bfd/elf32-v850.c

   1 /* V850-specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* XXX FIXME: This code is littered with 32bit int, 16bit short, 8bit char
  22    dependencies.  As is the gas & simulator code for the v850.  */
  23
  24 #include "bfd.h"
  25 #include "sysdep.h"
  26 #include "bfdlink.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29 #include "elf/v850.h"
  30 #include "libiberty.h"
  31
  32 /* Sign-extend a 24-bit number.  */
  33 #define SEXT24(x)       ((((x) & 0xffffff) ^ 0x800000) - 0x800000)
  34
  35 static reloc_howto_type *v850_elf_reloc_type_lookup
  36   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  37 static void v850_elf_info_to_howto_rel
  38   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  39 static void v850_elf_info_to_howto_rela
  40   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  41 static bfd_reloc_status_type v850_elf_reloc
  42   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  43 static bfd_boolean v850_elf_is_local_label_name
  44   PARAMS ((bfd *, const char *));
  45 static bfd_boolean v850_elf_relocate_section
  46   PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  47           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  48 static bfd_reloc_status_type v850_elf_perform_relocation
  49   PARAMS ((bfd *, unsigned int, bfd_vma, bfd_byte *));
  50 static bfd_boolean v850_elf_check_relocs
  51   PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));
  52 static void remember_hi16s_reloc
  53   PARAMS ((bfd *, bfd_vma, bfd_byte *));
  54 static bfd_byte * find_remembered_hi16s_reloc
  55   PARAMS ((bfd_vma, bfd_boolean *));
  56 static bfd_reloc_status_type v850_elf_final_link_relocate
  57   PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *, bfd_vma,
  58            bfd_vma, bfd_vma, struct bfd_link_info *, asection *, int));
  59 static bfd_boolean v850_elf_object_p
  60   PARAMS ((bfd *));
  61 static bfd_boolean v850_elf_fake_sections
  62   PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
  63 static void v850_elf_final_write_processing
  64   PARAMS ((bfd *, bfd_boolean));
  65 static bfd_boolean v850_elf_set_private_flags
  66   PARAMS ((bfd *, flagword));
  67 static bfd_boolean v850_elf_merge_private_bfd_data
  68   PARAMS ((bfd *, bfd *));
  69 static bfd_boolean v850_elf_print_private_bfd_data
  70   PARAMS ((bfd *, PTR));
  71 static bfd_boolean v850_elf_section_from_bfd_section
  72   PARAMS ((bfd *, asection *, int *));
  73 static void v850_elf_symbol_processing
  74   PARAMS ((bfd *, asymbol *));
  75 static bfd_boolean v850_elf_add_symbol_hook
  76   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Sym *,
  77            const char **, flagword *, asection **, bfd_vma *));
  78 static bfd_boolean v850_elf_link_output_symbol_hook
  79   PARAMS ((struct bfd_link_info *, const char *, Elf_Internal_Sym *,
  80            asection *, struct elf_link_hash_entry *));
  81 static bfd_boolean v850_elf_section_from_shdr
  82   PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
  83 static bfd_boolean v850_elf_gc_sweep_hook
  84   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  85            const Elf_Internal_Rela *));
  86 static asection * v850_elf_gc_mark_hook
  87   PARAMS ((asection *, struct bfd_link_info *,
  88            Elf_Internal_Rela *, struct elf_link_hash_entry *,
  89            Elf_Internal_Sym *));
  90 static bfd_reloc_status_type v850_elf_ignore_reloc
  91   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  92 static bfd_boolean v850_elf_relax_delete_bytes
  93   PARAMS ((bfd *, asection *, bfd_vma, bfd_vma, int));
  94 static bfd_boolean v850_elf_relax_section
  95   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
  96
  97 /* Note: It is REQUIRED that the 'type' value of each entry
  98    in this array match the index of the entry in the array.  */
  99 static reloc_howto_type v850_elf_howto_table[] =
 100 {
 101   /* This reloc does nothing.  */
 102   HOWTO (R_V850_NONE,                   /* type */
 103          0,                             /* rightshift */
 104          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 105          32,                            /* bitsize */
 106          FALSE,                         /* pc_relative */
 107          0,                             /* bitpos */
 108          complain_overflow_bitfield,    /* complain_on_overflow */
 109          bfd_elf_generic_reloc,         /* special_function */
 110          "R_V850_NONE",                 /* name */
 111          FALSE,                         /* partial_inplace */
 112          0,                             /* src_mask */
 113          0,                             /* dst_mask */
 114          FALSE),                        /* pcrel_offset */
 115
 116   /* A PC relative 9 bit branch.  */
 117   HOWTO (R_V850_9_PCREL,                /* type */
 118          2,                             /* rightshift */
 119          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 120          26,                            /* bitsize */
 121          TRUE,                          /* pc_relative */
 122          0,                             /* bitpos */
 123          complain_overflow_bitfield,    /* complain_on_overflow */
 124          v850_elf_reloc,                /* special_function */
 125          "R_V850_9_PCREL",              /* name */
 126          FALSE,                         /* partial_inplace */
 127          0x00ffffff,                    /* src_mask */
 128          0x00ffffff,                    /* dst_mask */
 129          TRUE),                         /* pcrel_offset */
 130
 131   /* A PC relative 22 bit branch.  */
 132   HOWTO (R_V850_22_PCREL,               /* type */
 133          2,                             /* rightshift */
 134          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 135          22,                            /* bitsize */
 136          TRUE,                          /* pc_relative */
 137          7,                             /* bitpos */
 138          complain_overflow_signed,      /* complain_on_overflow */
 139          v850_elf_reloc,                /* special_function */
 140          "R_V850_22_PCREL",             /* name */
 141          FALSE,                         /* partial_inplace */
 142          0x07ffff80,                    /* src_mask */
 143          0x07ffff80,                    /* dst_mask */
 144          TRUE),                         /* pcrel_offset */
 145
 146   /* High 16 bits of symbol value.  */
 147   HOWTO (R_V850_HI16_S,                 /* type */
 148          0,                             /* rightshift */
 149          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 150          16,                            /* bitsize */
 151          FALSE,                         /* pc_relative */
 152          0,                             /* bitpos */
 153          complain_overflow_dont,        /* complain_on_overflow */
 154          v850_elf_reloc,                /* special_function */
 155          "R_V850_HI16_S",               /* name */
 156          FALSE,                         /* partial_inplace */
 157          0xffff,                        /* src_mask */
 158          0xffff,                        /* dst_mask */
 159          FALSE),                        /* pcrel_offset */
 160
 161   /* High 16 bits of symbol value.  */
 162   HOWTO (R_V850_HI16,                   /* type */
 163          0,                             /* rightshift */
 164          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 165          16,                            /* bitsize */
 166          FALSE,                         /* pc_relative */
 167          0,                             /* bitpos */
 168          complain_overflow_dont,        /* complain_on_overflow */
 169          v850_elf_reloc,                /* special_function */
 170          "R_V850_HI16",                 /* name */
 171          FALSE,                         /* partial_inplace */
 172          0xffff,                        /* src_mask */
 173          0xffff,                        /* dst_mask */
 174          FALSE),                        /* pcrel_offset */
 175
 176   /* Low 16 bits of symbol value.  */
 177   HOWTO (R_V850_LO16,                   /* type */
 178          0,                             /* rightshift */
 179          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 180          16,                            /* bitsize */
 181          FALSE,                         /* pc_relative */
 182          0,                             /* bitpos */
 183          complain_overflow_dont,        /* complain_on_overflow */
 184          v850_elf_reloc,                /* special_function */
 185          "R_V850_LO16",                 /* name */
 186          FALSE,                         /* partial_inplace */
 187          0xffff,                        /* src_mask */
 188          0xffff,                        /* dst_mask */
 189          FALSE),                        /* pcrel_offset */
 190
 191   /* Simple 32bit reloc.  */
 192   HOWTO (R_V850_ABS32,                  /* type */
 193          0,                             /* rightshift */
 194          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 195          32,                            /* bitsize */
 196          FALSE,                         /* pc_relative */
 197          0,                             /* bitpos */
 198          complain_overflow_dont,        /* complain_on_overflow */
 199          v850_elf_reloc,                /* special_function */
 200          "R_V850_ABS32",                /* name */
 201          FALSE,                         /* partial_inplace */
 202          0xffffffff,                    /* src_mask */
 203          0xffffffff,                    /* dst_mask */
 204          FALSE),                        /* pcrel_offset */
 205
 206   /* Simple 16bit reloc.  */
 207   HOWTO (R_V850_16,                     /* type */
 208          0,                             /* rightshift */
 209          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 210          16,                            /* bitsize */
 211          FALSE,                         /* pc_relative */
 212          0,                             /* bitpos */
 213          complain_overflow_dont,        /* complain_on_overflow */
 214          bfd_elf_generic_reloc,         /* special_function */
 215          "R_V850_16",                   /* name */
 216          FALSE,                         /* partial_inplace */
 217          0xffff,                        /* src_mask */
 218          0xffff,                        /* dst_mask */
 219          FALSE),                        /* pcrel_offset */
 220
 221   /* Simple 8bit reloc.  */
 222   HOWTO (R_V850_8,                      /* type */
 223          0,                             /* rightshift */
 224          0,                             /* size (0 = byte, 1 = short, 2 = long) */
 225          8,                             /* bitsize */
 226          FALSE,                         /* pc_relative */
 227          0,                             /* bitpos */
 228          complain_overflow_dont,        /* complain_on_overflow */
 229          bfd_elf_generic_reloc,         /* special_function */
 230          "R_V850_8",                    /* name */
 231          FALSE,                         /* partial_inplace */
 232          0xff,                          /* src_mask */
 233          0xff,                          /* dst_mask */
 234          FALSE),                        /* pcrel_offset */
 235
 236   /* 16 bit offset from the short data area pointer.  */
 237   HOWTO (R_V850_SDA_16_16_OFFSET,       /* type */
 238          0,                             /* rightshift */
 239          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 240          16,                            /* bitsize */
 241          FALSE,                         /* pc_relative */
 242          0,                             /* bitpos */
 243          complain_overflow_dont,        /* complain_on_overflow */
 244          v850_elf_reloc,                /* special_function */
 245          "R_V850_SDA_16_16_OFFSET",     /* name */
 246          FALSE,                         /* partial_inplace */
 247          0xffff,                        /* src_mask */
 248          0xffff,                        /* dst_mask */
 249          FALSE),                        /* pcrel_offset */
 250
 251   /* 15 bit offset from the short data area pointer.  */
 252   HOWTO (R_V850_SDA_15_16_OFFSET,       /* type */
 253          1,                             /* rightshift */
 254          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 255          16,                            /* bitsize */
 256          FALSE,                         /* pc_relative */
 257          1,                             /* bitpos */
 258          complain_overflow_dont,        /* complain_on_overflow */
 259          v850_elf_reloc,                /* special_function */
 260          "R_V850_SDA_15_16_OFFSET",     /* name */
 261          FALSE,                         /* partial_inplace */
 262          0xfffe,                        /* src_mask */
 263          0xfffe,                        /* dst_mask */
 264          FALSE),                        /* pcrel_offset */
 265
 266   /* 16 bit offset from the zero data area pointer.  */
 267   HOWTO (R_V850_ZDA_16_16_OFFSET,       /* type */
 268          0,                             /* rightshift */
 269          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 270          16,                            /* bitsize */
 271          FALSE,                         /* pc_relative */
 272          0,                             /* bitpos */
 273          complain_overflow_dont,        /* complain_on_overflow */
 274          v850_elf_reloc,                /* special_function */
 275          "R_V850_ZDA_16_16_OFFSET",     /* name */
 276          FALSE,                         /* partial_inplace */
 277          0xffff,                        /* src_mask */
 278          0xffff,                        /* dst_mask */
 279          FALSE),                        /* pcrel_offset */
 280
 281   /* 15 bit offset from the zero data area pointer.  */
 282   HOWTO (R_V850_ZDA_15_16_OFFSET,       /* type */
 283          1,                             /* rightshift */
 284          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 285          16,                            /* bitsize */
 286          FALSE,                         /* pc_relative */
 287          1,                             /* bitpos */
 288          complain_overflow_dont,        /* complain_on_overflow */
 289          v850_elf_reloc,                /* special_function */
 290          "R_V850_ZDA_15_16_OFFSET",     /* name */
 291          FALSE,                         /* partial_inplace */
 292          0xfffe,                        /* src_mask */
 293          0xfffe,                        /* dst_mask */
 294          FALSE),                        /* pcrel_offset */
 295
 296   /* 6 bit offset from the tiny data area pointer.  */
 297   HOWTO (R_V850_TDA_6_8_OFFSET,         /* type */
 298          2,                             /* rightshift */
 299          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 300          8,                             /* bitsize */
 301          FALSE,                         /* pc_relative */
 302          1,                             /* bitpos */
 303          complain_overflow_dont,        /* complain_on_overflow */
 304          v850_elf_reloc,                /* special_function */
 305          "R_V850_TDA_6_8_OFFSET",       /* name */
 306          FALSE,                         /* partial_inplace */
 307          0x7e,                          /* src_mask */
 308          0x7e,                          /* dst_mask */
 309          FALSE),                        /* pcrel_offset */
 310
 311   /* 8 bit offset from the tiny data area pointer.  */
 312   HOWTO (R_V850_TDA_7_8_OFFSET,         /* type */
 313          1,                             /* rightshift */
 314          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 315          8,                             /* bitsize */
 316          FALSE,                         /* pc_relative */
 317          0,                             /* bitpos */
 318          complain_overflow_dont,        /* complain_on_overflow */
 319          v850_elf_reloc,                /* special_function */
 320          "R_V850_TDA_7_8_OFFSET",       /* name */
 321          FALSE,                         /* partial_inplace */
 322          0x7f,                          /* src_mask */
 323          0x7f,                          /* dst_mask */
 324          FALSE),                        /* pcrel_offset */
 325
 326   /* 7 bit offset from the tiny data area pointer.  */
 327   HOWTO (R_V850_TDA_7_7_OFFSET,         /* type */
 328          0,                             /* rightshift */
 329          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 330          7,                             /* bitsize */
 331          FALSE,                         /* pc_relative */
 332          0,                             /* bitpos */
 333          complain_overflow_dont,        /* complain_on_overflow */
 334          v850_elf_reloc,                /* special_function */
 335          "R_V850_TDA_7_7_OFFSET",       /* name */
 336          FALSE,                         /* partial_inplace */
 337          0x7f,                          /* src_mask */
 338          0x7f,                          /* dst_mask */
 339          FALSE),                        /* pcrel_offset */
 340
 341   /* 16 bit offset from the tiny data area pointer!  */
 342   HOWTO (R_V850_TDA_16_16_OFFSET,       /* type */
 343          0,                             /* rightshift */
 344          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 345          16,                            /* bitsize */
 346          FALSE,                         /* pc_relative */
 347          0,                             /* bitpos */
 348          complain_overflow_dont,        /* complain_on_overflow */
 349          v850_elf_reloc,                /* special_function */
 350          "R_V850_TDA_16_16_OFFSET",     /* name */
 351          FALSE,                         /* partial_inplace */
 352          0xffff,                        /* src_mask */
 353          0xfff,                         /* dst_mask */
 354          FALSE),                        /* pcrel_offset */
 355
 356   /* 5 bit offset from the tiny data area pointer.  */
 357   HOWTO (R_V850_TDA_4_5_OFFSET,         /* type */
 358          1,                             /* rightshift */
 359          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 360          5,                             /* bitsize */
 361          FALSE,                         /* pc_relative */
 362          0,                             /* bitpos */
 363          complain_overflow_dont,        /* complain_on_overflow */
 364          v850_elf_reloc,                /* special_function */
 365          "R_V850_TDA_4_5_OFFSET",       /* name */
 366          FALSE,                         /* partial_inplace */
 367          0x0f,                          /* src_mask */
 368          0x0f,                          /* dst_mask */
 369          FALSE),                        /* pcrel_offset */
 370
 371   /* 4 bit offset from the tiny data area pointer.  */
 372   HOWTO (R_V850_TDA_4_4_OFFSET,         /* type */
 373          0,                             /* rightshift */
 374          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 375          4,                             /* bitsize */
 376          FALSE,                         /* pc_relative */
 377          0,                             /* bitpos */
 378          complain_overflow_dont,        /* complain_on_overflow */
 379          v850_elf_reloc,                /* special_function */
 380          "R_V850_TDA_4_4_OFFSET",       /* name */
 381          FALSE,                         /* partial_inplace */
 382          0x0f,                          /* src_mask */
 383          0x0f,                          /* dst_mask */
 384          FALSE),                        /* pcrel_offset */
 385
 386   /* 16 bit offset from the short data area pointer.  */
 387   HOWTO (R_V850_SDA_16_16_SPLIT_OFFSET, /* type */
 388          0,                             /* rightshift */
 389          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 390          16,                            /* bitsize */
 391          FALSE,                         /* pc_relative */
 392          0,                             /* bitpos */
 393          complain_overflow_dont,        /* complain_on_overflow */
 394          v850_elf_reloc,                /* special_function */
 395          "R_V850_SDA_16_16_SPLIT_OFFSET",/* name */
 396          FALSE,                         /* partial_inplace */
 397          0xfffe0020,                    /* src_mask */
 398          0xfffe0020,                    /* dst_mask */
 399          FALSE),                        /* pcrel_offset */
 400
 401   /* 16 bit offset from the zero data area pointer.  */
 402   HOWTO (R_V850_ZDA_16_16_SPLIT_OFFSET, /* type */
 403          0,                             /* rightshift */
 404          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 405          16,                            /* bitsize */
 406          FALSE,                         /* pc_relative */
 407          0,                             /* bitpos */
 408          complain_overflow_dont,        /* complain_on_overflow */
 409          v850_elf_reloc,                /* special_function */
 410          "R_V850_ZDA_16_16_SPLIT_OFFSET",/* name */
 411          FALSE,                         /* partial_inplace */
 412          0xfffe0020,                    /* src_mask */
 413          0xfffe0020,                    /* dst_mask */
 414          FALSE),                        /* pcrel_offset */
 415
 416   /* 6 bit offset from the call table base pointer.  */
 417   HOWTO (R_V850_CALLT_6_7_OFFSET,       /* type */
 418          0,                             /* rightshift */
 419          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 420          7,                             /* bitsize */
 421          FALSE,                         /* pc_relative */
 422          0,                             /* bitpos */
 423          complain_overflow_dont,        /* complain_on_overflow */
 424          v850_elf_reloc,                /* special_function */
 425          "R_V850_CALLT_6_7_OFFSET",     /* name */
 426          FALSE,                         /* partial_inplace */
 427          0x3f,                          /* src_mask */
 428          0x3f,                          /* dst_mask */
 429          FALSE),                        /* pcrel_offset */
 430
 431   /* 16 bit offset from the call table base pointer.  */
 432   HOWTO (R_V850_CALLT_16_16_OFFSET,     /* type */
 433          0,                             /* rightshift */
 434          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 435          16,                            /* bitsize */
 436          FALSE,                         /* pc_relative */
 437          0,                             /* bitpos */
 438          complain_overflow_dont,        /* complain_on_overflow */
 439          v850_elf_reloc,                /* special_function */
 440          "R_V850_CALLT_16_16_OFFSET",   /* name */
 441          FALSE,                         /* partial_inplace */
 442          0xffff,                        /* src_mask */
 443          0xffff,                        /* dst_mask */
 444          FALSE),                        /* pcrel_offset */
 445
 446   /* GNU extension to record C++ vtable hierarchy */
 447   HOWTO (R_V850_GNU_VTINHERIT, /* type */
 448          0,                     /* rightshift */
 449          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 450          0,                     /* bitsize */
 451          FALSE,                 /* pc_relative */
 452          0,                     /* bitpos */
 453          complain_overflow_dont, /* complain_on_overflow */
 454          NULL,                  /* special_function */
 455          "R_V850_GNU_VTINHERIT", /* name */
 456          FALSE,                 /* partial_inplace */
 457          0,                     /* src_mask */
 458          0,                     /* dst_mask */
 459          FALSE),                /* pcrel_offset */
 460
 461   /* GNU extension to record C++ vtable member usage */
 462   HOWTO (R_V850_GNU_VTENTRY,     /* type */
 463          0,                     /* rightshift */
 464          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 465          0,                     /* bitsize */
 466          FALSE,                 /* pc_relative */
 467          0,                     /* bitpos */
 468          complain_overflow_dont, /* complain_on_overflow */
 469          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 470          "R_V850_GNU_VTENTRY",   /* name */
 471          FALSE,                 /* partial_inplace */
 472          0,                     /* src_mask */
 473          0,                     /* dst_mask */
 474          FALSE),                /* pcrel_offset */
 475
 476   /* Indicates a .longcall pseudo-op.  The compiler will generate a .longcall
 477      pseudo-op when it finds a function call which can be relaxed.  */
 478   HOWTO (R_V850_LONGCALL,     /* type */
 479        0,                     /* rightshift */
 480        2,                     /* size (0 = byte, 1 = short, 2 = long) */
 481        32,                    /* bitsize */
 482        TRUE,                  /* pc_relative */
 483        0,                     /* bitpos */
 484        complain_overflow_signed, /* complain_on_overflow */
 485        v850_elf_ignore_reloc, /* special_function */
 486        "R_V850_LONGCALL",     /* name */
 487        FALSE,                 /* partial_inplace */
 488        0,                     /* src_mask */
 489        0,                     /* dst_mask */
 490        TRUE),                 /* pcrel_offset */
 491
 492   /* Indicates a .longjump pseudo-op.  The compiler will generate a
 493      .longjump pseudo-op when it finds a branch which can be relaxed.  */
 494   HOWTO (R_V850_LONGJUMP,     /* type */
 495        0,                     /* rightshift */
 496        2,                     /* size (0 = byte, 1 = short, 2 = long) */
 497        32,                    /* bitsize */
 498        TRUE,                  /* pc_relative */
 499        0,                     /* bitpos */
 500        complain_overflow_signed, /* complain_on_overflow */
 501        v850_elf_ignore_reloc, /* special_function */
 502        "R_V850_LONGJUMP",     /* name */
 503        FALSE,                 /* partial_inplace */
 504        0,                     /* src_mask */
 505        0,                     /* dst_mask */
 506        TRUE),                 /* pcrel_offset */
 507
 508   HOWTO (R_V850_ALIGN,        /* type */
 509        0,                     /* rightshift */
 510        1,                     /* size (0 = byte, 1 = short, 2 = long) */
 511        0,                     /* bitsize */
 512        FALSE,                 /* pc_relative */
 513        0,                     /* bitpos */
 514        complain_overflow_unsigned, /* complain_on_overflow */
 515        v850_elf_ignore_reloc, /* special_function */
 516        "R_V850_ALIGN",        /* name */
 517        FALSE,                 /* partial_inplace */
 518        0,                     /* src_mask */
 519        0,                     /* dst_mask */
 520        TRUE),                 /* pcrel_offset */
 521
 522   /* Simple pc-relative 32bit reloc.  */
 523   HOWTO (R_V850_REL32,                  /* type */
 524          0,                             /* rightshift */
 525          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 526          32,                            /* bitsize */
 527          TRUE,                          /* pc_relative */
 528          0,                             /* bitpos */
 529          complain_overflow_dont,        /* complain_on_overflow */
 530          v850_elf_reloc,                /* special_function */
 531          "R_V850_REL32",                /* name */
 532          FALSE,                         /* partial_inplace */
 533          0xffffffff,                    /* src_mask */
 534          0xffffffff,                    /* dst_mask */
 535          FALSE),                        /* pcrel_offset */
 536 };
 537
 538 /* Map BFD reloc types to V850 ELF reloc types.  */
 539
 540 struct v850_elf_reloc_map
 541 {
 542   /* BFD_RELOC_V850_CALLT_16_16_OFFSET is 258, which will not fix in an
 543      unsigned char.  */
 544   bfd_reloc_code_real_type bfd_reloc_val;
 545   unsigned int elf_reloc_val;
 546 };
 547
 548 static const struct v850_elf_reloc_map v850_elf_reloc_map[] =
 549 {
 550   { BFD_RELOC_NONE,                        R_V850_NONE                   },
 551   { BFD_RELOC_V850_9_PCREL,                R_V850_9_PCREL                },
 552   { BFD_RELOC_V850_22_PCREL,               R_V850_22_PCREL               },
 553   { BFD_RELOC_HI16_S,                      R_V850_HI16_S                 },
 554   { BFD_RELOC_HI16,                        R_V850_HI16                   },
 555   { BFD_RELOC_LO16,                        R_V850_LO16                   },
 556   { BFD_RELOC_32,                          R_V850_ABS32                  },
 557   { BFD_RELOC_32_PCREL,                    R_V850_REL32                  },
 558   { BFD_RELOC_16,                          R_V850_16                     },
 559   { BFD_RELOC_8,                           R_V850_8                      },
 560   { BFD_RELOC_V850_SDA_16_16_OFFSET,       R_V850_SDA_16_16_OFFSET       },
 561   { BFD_RELOC_V850_SDA_15_16_OFFSET,       R_V850_SDA_15_16_OFFSET       },
 562   { BFD_RELOC_V850_ZDA_16_16_OFFSET,       R_V850_ZDA_16_16_OFFSET       },
 563   { BFD_RELOC_V850_ZDA_15_16_OFFSET,       R_V850_ZDA_15_16_OFFSET       },
 564   { BFD_RELOC_V850_TDA_6_8_OFFSET,         R_V850_TDA_6_8_OFFSET         },
 565   { BFD_RELOC_V850_TDA_7_8_OFFSET,         R_V850_TDA_7_8_OFFSET         },
 566   { BFD_RELOC_V850_TDA_7_7_OFFSET,         R_V850_TDA_7_7_OFFSET         },
 567   { BFD_RELOC_V850_TDA_16_16_OFFSET,       R_V850_TDA_16_16_OFFSET       },
 568   { BFD_RELOC_V850_TDA_4_5_OFFSET,         R_V850_TDA_4_5_OFFSET         },
 569   { BFD_RELOC_V850_TDA_4_4_OFFSET,         R_V850_TDA_4_4_OFFSET         },
 570   { BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, R_V850_SDA_16_16_SPLIT_OFFSET },
 571   { BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, R_V850_ZDA_16_16_SPLIT_OFFSET },
 572   { BFD_RELOC_V850_CALLT_6_7_OFFSET,       R_V850_CALLT_6_7_OFFSET       },
 573   { BFD_RELOC_V850_CALLT_16_16_OFFSET,     R_V850_CALLT_16_16_OFFSET     },
 574   { BFD_RELOC_VTABLE_INHERIT,              R_V850_GNU_VTINHERIT          },
 575   { BFD_RELOC_VTABLE_ENTRY,                R_V850_GNU_VTENTRY            },
 576   { BFD_RELOC_V850_LONGCALL,               R_V850_LONGCALL               },
 577   { BFD_RELOC_V850_LONGJUMP,               R_V850_LONGJUMP               },
 578   { BFD_RELOC_V850_ALIGN,                  R_V850_ALIGN                  },
 579
 580 };
 581 \f
 582 /* Map a bfd relocation into the appropriate howto structure.  */
 583
 584 static reloc_howto_type *
 585 v850_elf_reloc_type_lookup (abfd, code)
 586      bfd *abfd ATTRIBUTE_UNUSED;
 587      bfd_reloc_code_real_type code;
 588 {
 589   unsigned int i;
 590
 591   for (i = ARRAY_SIZE (v850_elf_reloc_map); i --;)
 592     if (v850_elf_reloc_map[i].bfd_reloc_val == code)
 593       {
 594         unsigned int elf_reloc_val = v850_elf_reloc_map[i].elf_reloc_val;
 595
 596         BFD_ASSERT (v850_elf_howto_table[elf_reloc_val].type == elf_reloc_val);
 597
 598         return v850_elf_howto_table + elf_reloc_val;
 599       }
 600
 601   return NULL;
 602 }
 603 \f
 604 /* Set the howto pointer for an V850 ELF reloc.  */
 605
 606 static void
 607 v850_elf_info_to_howto_rel (abfd, cache_ptr, dst)
 608      bfd *abfd ATTRIBUTE_UNUSED;
 609      arelent *cache_ptr;
 610      Elf_Internal_Rela *dst;
 611 {
 612   unsigned int r_type;
 613
 614   r_type = ELF32_R_TYPE (dst->r_info);
 615   BFD_ASSERT (r_type < (unsigned int) R_V850_max);
 616   cache_ptr->howto = &v850_elf_howto_table[r_type];
 617 }
 618
 619 /* Set the howto pointer for a V850 ELF reloc (type RELA).  */
 620 static void
 621 v850_elf_info_to_howto_rela (abfd, cache_ptr, dst)
 622      bfd *abfd ATTRIBUTE_UNUSED;
 623      arelent * cache_ptr;
 624      Elf_Internal_Rela *dst;
 625 {
 626   unsigned int r_type;
 627
 628   r_type = ELF32_R_TYPE (dst->r_info);
 629   BFD_ASSERT (r_type < (unsigned int) R_V850_max);
 630   cache_ptr->howto = &v850_elf_howto_table[r_type];
 631 }
 632 \f
 633 /* Look through the relocs for a section during the first phase, and
 634    allocate space in the global offset table or procedure linkage
 635    table.  */
 636
 637 static bfd_boolean
 638 v850_elf_check_relocs (abfd, info, sec, relocs)
 639      bfd *abfd;
 640      struct bfd_link_info *info;
 641      asection *sec;
 642      const Elf_Internal_Rela *relocs;
 643 {
 644   bfd_boolean ret = TRUE;
 645   bfd *dynobj;
 646   Elf_Internal_Shdr *symtab_hdr;
 647   struct elf_link_hash_entry **sym_hashes;
 648   const Elf_Internal_Rela *rel;
 649   const Elf_Internal_Rela *rel_end;
 650   asection *sreloc;
 651   enum v850_reloc_type r_type;
 652   int other = 0;
 653   const char *common = (const char *)0;
 654
 655   if (info->relocatable)
 656     return TRUE;
 657
 658 #ifdef DEBUG
 659   fprintf (stderr, "v850_elf_check_relocs called for section %s in %s\n",
 660            bfd_get_section_name (abfd, sec),
 661            bfd_archive_filename (abfd));
 662 #endif
 663
 664   dynobj = elf_hash_table (info)->dynobj;
 665   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 666   sym_hashes = elf_sym_hashes (abfd);
 667   sreloc = NULL;
 668
 669   rel_end = relocs + sec->reloc_count;
 670   for (rel = relocs; rel < rel_end; rel++)
 671     {
 672       unsigned long r_symndx;
 673       struct elf_link_hash_entry *h;
 674
 675       r_symndx = ELF32_R_SYM (rel->r_info);
 676       if (r_symndx < symtab_hdr->sh_info)
 677         h = NULL;
 678       else
 679         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 680
 681       r_type = (enum v850_reloc_type) ELF32_R_TYPE (rel->r_info);
 682       switch (r_type)
 683         {
 684         default:
 685         case R_V850_NONE:
 686         case R_V850_9_PCREL:
 687         case R_V850_22_PCREL:
 688         case R_V850_HI16_S:
 689         case R_V850_HI16:
 690         case R_V850_LO16:
 691         case R_V850_ABS32:
 692         case R_V850_REL32:
 693         case R_V850_16:
 694         case R_V850_8:
 695         case R_V850_CALLT_6_7_OFFSET:
 696         case R_V850_CALLT_16_16_OFFSET:
 697           break;
 698
 699         /* This relocation describes the C++ object vtable hierarchy.
 700            Reconstruct it for later use during GC.  */
 701         case R_V850_GNU_VTINHERIT:
 702           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 703             return FALSE;
 704           break;
 705
 706         /* This relocation describes which C++ vtable entries
 707            are actually used.  Record for later use during GC.  */
 708         case R_V850_GNU_VTENTRY:
 709           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 710             return FALSE;
 711           break;
 712
 713         case R_V850_SDA_16_16_SPLIT_OFFSET:
 714         case R_V850_SDA_16_16_OFFSET:
 715         case R_V850_SDA_15_16_OFFSET:
 716           other = V850_OTHER_SDA;
 717           common = ".scommon";
 718           goto small_data_common;
 719
 720         case R_V850_ZDA_16_16_SPLIT_OFFSET:
 721         case R_V850_ZDA_16_16_OFFSET:
 722         case R_V850_ZDA_15_16_OFFSET:
 723           other = V850_OTHER_ZDA;
 724           common = ".zcommon";
 725           goto small_data_common;
 726
 727         case R_V850_TDA_4_5_OFFSET:
 728         case R_V850_TDA_4_4_OFFSET:
 729         case R_V850_TDA_6_8_OFFSET:
 730         case R_V850_TDA_7_8_OFFSET:
 731         case R_V850_TDA_7_7_OFFSET:
 732         case R_V850_TDA_16_16_OFFSET:
 733           other = V850_OTHER_TDA;
 734           common = ".tcommon";
 735           /* fall through */
 736
 737 #define V850_OTHER_MASK (V850_OTHER_TDA | V850_OTHER_SDA | V850_OTHER_ZDA)
 738
 739         small_data_common:
 740           if (h)
 741             {
 742               /* Flag which type of relocation was used.  */
 743               h->other |= other;
 744               if ((h->other & V850_OTHER_MASK) != (other & V850_OTHER_MASK)
 745                   && (h->other & V850_OTHER_ERROR) == 0)
 746                 {
 747                   const char * msg;
 748                   static char  buff[200]; /* XXX */
 749
 750                   switch (h->other & V850_OTHER_MASK)
 751                     {
 752                     default:
 753                       msg = _("Variable `%s' cannot occupy in multiple small data regions");
 754                       break;
 755                     case V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA:
 756                       msg = _("Variable `%s' can only be in one of the small, zero, and tiny data regions");
 757                       break;
 758                     case V850_OTHER_SDA | V850_OTHER_ZDA:
 759                       msg = _("Variable `%s' cannot be in both small and zero data regions simultaneously");
 760                       break;
 761                     case V850_OTHER_SDA | V850_OTHER_TDA:
 762                       msg = _("Variable `%s' cannot be in both small and tiny data regions simultaneously");
 763                       break;
 764                     case V850_OTHER_ZDA | V850_OTHER_TDA:
 765                       msg = _("Variable `%s' cannot be in both zero and tiny data regions simultaneously");
 766                       break;
 767                     }
 768
 769                   sprintf (buff, msg, h->root.root.string);
 770                   info->callbacks->warning (info, buff, h->root.root.string,
 771                                             abfd, h->root.u.def.section,
 772                                             (bfd_vma) 0);
 773
 774                   bfd_set_error (bfd_error_bad_value);
 775                   h->other |= V850_OTHER_ERROR;
 776                   ret = FALSE;
 777                 }
 778             }
 779
 780           if (h && h->root.type == bfd_link_hash_common
 781               && h->root.u.c.p
 782               && !strcmp (bfd_get_section_name (abfd, h->root.u.c.p->section), "COMMON"))
 783             {
 784               asection * section;
 785
 786               section = h->root.u.c.p->section = bfd_make_section_old_way (abfd, common);
 787               section->flags |= SEC_IS_COMMON;
 788             }
 789
 790 #ifdef DEBUG
 791           fprintf (stderr, "v850_elf_check_relocs, found %s relocation for %s%s\n",
 792                    v850_elf_howto_table[ (int)r_type ].name,
 793                    (h && h->root.root.string) ? h->root.root.string : "<unknown>",
 794                    (h->root.type == bfd_link_hash_common) ? ", symbol is common" : "");
 795 #endif
 796           break;
 797         }
 798     }
 799
 800   return ret;
 801 }
 802
 803 /* In the old version, when an entry was checked out from the table,
 804    it was deleted.  This produced an error if the entry was needed
 805    more than once, as the second attempted retry failed.
 806
 807    In the current version, the entry is not deleted, instead we set
 808    the field 'found' to TRUE.  If a second lookup matches the same
 809    entry, then we know that the hi16s reloc has already been updated
 810    and does not need to be updated a second time.
 811
 812    TODO - TOFIX: If it is possible that we need to restore 2 different
 813    addresses from the same table entry, where the first generates an
 814    overflow, whilst the second do not, then this code will fail.  */
 815
 816 typedef struct hi16s_location
 817 {
 818   bfd_vma addend;
 819   bfd_byte *address;
 820   unsigned long counter;
 821   bfd_boolean found;
 822   struct hi16s_location *next;
 823 }
 824 hi16s_location;
 825
 826 static hi16s_location *previous_hi16s;
 827 static hi16s_location *free_hi16s;
 828 static unsigned long hi16s_counter;
 829
 830 static void
 831 remember_hi16s_reloc (abfd, addend, address)
 832      bfd *abfd;
 833      bfd_vma addend;
 834      bfd_byte *address;
 835 {
 836   hi16s_location * entry = NULL;
 837   bfd_size_type amt = sizeof (* free_hi16s);
 838
 839   /* Find a free structure.  */
 840   if (free_hi16s == NULL)
 841     free_hi16s = (hi16s_location *) bfd_zalloc (abfd, amt);
 842
 843   entry      = free_hi16s;
 844   free_hi16s = free_hi16s->next;
 845
 846   entry->addend  = addend;
 847   entry->address = address;
 848   entry->counter = hi16s_counter ++;
 849   entry->found   = FALSE;
 850   entry->next    = previous_hi16s;
 851   previous_hi16s = entry;
 852
 853   /* Cope with wrap around of our counter.  */
 854   if (hi16s_counter == 0)
 855     {
 856       /* XXX - Assume that all counter entries differ only in their low 16 bits.  */
 857       for (entry = previous_hi16s; entry != NULL; entry = entry->next)
 858         entry->counter &= 0xffff;
 859
 860       hi16s_counter = 0x10000;
 861     }
 862
 863   return;
 864 }
 865
 866 static bfd_byte *
 867 find_remembered_hi16s_reloc (addend, already_found)
 868      bfd_vma addend;
 869      bfd_boolean *already_found;
 870 {
 871   hi16s_location *match = NULL;
 872   hi16s_location *entry;
 873   hi16s_location *previous = NULL;
 874   hi16s_location *prev;
 875   bfd_byte *addr;
 876
 877   /* Search the table.  Record the most recent entry that matches.  */
 878   for (entry = previous_hi16s; entry; entry = entry->next)
 879     {
 880       if (entry->addend == addend
 881           && (match == NULL || match->counter < entry->counter))
 882         {
 883           previous = prev;
 884           match    = entry;
 885         }
 886
 887       prev = entry;
 888     }
 889
 890   if (match == NULL)
 891     return NULL;
 892
 893   /* Extract the address.  */
 894   addr = match->address;
 895
 896   /* Remember if this entry has already been used before.  */
 897   if (already_found)
 898     * already_found = match->found;
 899
 900   /* Note that this entry has now been used.  */
 901   match->found = TRUE;
 902
 903   return addr;
 904 }
 905
 906 /* FIXME:  The code here probably ought to be removed and the code in reloc.c
 907    allowed to do its stuff instead.  At least for most of the relocs, anyway.  */
 908
 909 static bfd_reloc_status_type
 910 v850_elf_perform_relocation (abfd, r_type, addend, address)
 911      bfd *abfd;
 912      unsigned int r_type;
 913      bfd_vma addend;
 914      bfd_byte *address;
 915 {
 916   unsigned long insn;
 917   bfd_signed_vma saddend = (bfd_signed_vma) addend;
 918
 919   switch (r_type)
 920     {
 921     default:
 922       /* fprintf (stderr, "reloc type %d not SUPPORTED\n", r_type ); */
 923       return bfd_reloc_notsupported;
 924
 925     case R_V850_REL32:
 926     case R_V850_ABS32:
 927       bfd_put_32 (abfd, addend, address);
 928       return bfd_reloc_ok;
 929
 930     case R_V850_22_PCREL:
 931       if (saddend > 0x1fffff || saddend < -0x200000)
 932         return bfd_reloc_overflow;
 933
 934       if ((addend % 2) != 0)
 935         return bfd_reloc_dangerous;
 936
 937       insn  = bfd_get_32 (abfd, address);
 938       insn &= ~0xfffe003f;
 939       insn |= (((addend & 0xfffe) << 16) | ((addend & 0x3f0000) >> 16));
 940       bfd_put_32 (abfd, (bfd_vma) insn, address);
 941       return bfd_reloc_ok;
 942
 943     case R_V850_9_PCREL:
 944       if (saddend > 0xff || saddend < -0x100)
 945         return bfd_reloc_overflow;
 946
 947       if ((addend % 2) != 0)
 948         return bfd_reloc_dangerous;
 949
 950       insn  = bfd_get_16 (abfd, address);
 951       insn &= ~ 0xf870;
 952       insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3);
 953       break;
 954
 955     case R_V850_HI16:
 956       addend += (bfd_get_16 (abfd, address) << 16);
 957       addend = (addend >> 16);
 958       insn = addend;
 959       break;
 960
 961     case R_V850_HI16_S:
 962       /* Remember where this relocation took place.  */
 963       remember_hi16s_reloc (abfd, addend, address);
 964
 965       addend += (bfd_get_16 (abfd, address) << 16);
 966       addend = (addend >> 16) + ((addend & 0x8000) != 0);
 967
 968       /* This relocation cannot overflow.  */
 969       if (addend > 0x7fff)
 970         addend = 0;
 971
 972       insn = addend;
 973       break;
 974
 975     case R_V850_LO16:
 976       /* Calculate the sum of the value stored in the instruction and the
 977          addend and check for overflow from the low 16 bits into the high
 978          16 bits.  The assembler has already done some of this:  If the
 979          value stored in the instruction has its 15th bit set, (counting
 980          from zero) then the assembler will have added 1 to the value
 981          stored in the associated HI16S reloc.  So for example, these
 982          relocations:
 983
 984              movhi hi( fred ), r0, r1
 985              movea lo( fred ), r1, r1
 986
 987          will store 0 in the value fields for the MOVHI and MOVEA instructions
 988          and addend will be the address of fred, but for these instructions:
 989
 990              movhi hi( fred + 0x123456), r0, r1
 991              movea lo( fred + 0x123456), r1, r1
 992
 993          the value stored in the MOVHI instruction will be 0x12 and the value
 994          stored in the MOVEA instruction will be 0x3456.  If however the
 995          instructions were:
 996
 997              movhi hi( fred + 0x10ffff), r0, r1
 998              movea lo( fred + 0x10ffff), r1, r1
 999
1000          then the value stored in the MOVHI instruction would be 0x11 (not
1001          0x10) and the value stored in the MOVEA instruction would be 0xffff.
1002          Thus (assuming for the moment that the addend is 0), at run time the
1003          MOVHI instruction loads 0x110000 into r1, then the MOVEA instruction
1004          adds 0xffffffff (sign extension!) producing 0x10ffff.  Similarly if
1005          the instructions were:
1006
1007              movhi hi( fred - 1), r0, r1
1008              movea lo( fred - 1), r1, r1
1009
1010          then 0 is stored in the MOVHI instruction and -1 is stored in the
1011          MOVEA instruction.
1012
1013          Overflow can occur if the addition of the value stored in the
1014          instruction plus the addend sets the 15th bit when before it was clear.
1015          This is because the 15th bit will be sign extended into the high part,
1016          thus reducing its value by one, but since the 15th bit was originally
1017          clear, the assembler will not have added 1 to the previous HI16S reloc
1018          to compensate for this effect.  For example:
1019
1020             movhi hi( fred + 0x123456), r0, r1
1021             movea lo( fred + 0x123456), r1, r1
1022
1023          The value stored in HI16S reloc is 0x12, the value stored in the LO16
1024          reloc is 0x3456.  If we assume that the address of fred is 0x00007000
1025          then the relocations become:
1026
1027            HI16S: 0x0012 + (0x00007000 >> 16)    = 0x12
1028            LO16:  0x3456 + (0x00007000 & 0xffff) = 0xa456
1029
1030          but when the instructions are executed, the MOVEA instruction's value
1031          is signed extended, so the sum becomes:
1032
1033               0x00120000
1034             + 0xffffa456
1035             ------------
1036               0x0011a456    but 'fred + 0x123456' = 0x0012a456
1037
1038          Note that if the 15th bit was set in the value stored in the LO16
1039          reloc, then we do not have to do anything:
1040
1041             movhi hi( fred + 0x10ffff), r0, r1
1042             movea lo( fred + 0x10ffff), r1, r1
1043
1044             HI16S:  0x0011 + (0x00007000 >> 16)    = 0x11
1045             LO16:   0xffff + (0x00007000 & 0xffff) = 0x6fff
1046
1047               0x00110000
1048             + 0x00006fff
1049             ------------
1050               0x00116fff  = fred + 0x10ffff = 0x7000 + 0x10ffff
1051
1052          Overflow can also occur if the computation carries into the 16th bit
1053          and it also results in the 15th bit having the same value as the 15th
1054          bit of the original value.   What happens is that the HI16S reloc
1055          will have already examined the 15th bit of the original value and
1056          added 1 to the high part if the bit is set.  This compensates for the
1057          sign extension of 15th bit of the result of the computation.  But now
1058          there is a carry into the 16th bit, and this has not been allowed for.
1059
1060          So, for example if fred is at address 0xf000:
1061
1062            movhi hi( fred + 0xffff), r0, r1    [bit 15 of the offset is set]
1063            movea lo( fred + 0xffff), r1, r1
1064
1065            HI16S: 0x0001 + (0x0000f000 >> 16)    = 0x0001
1066            LO16:  0xffff + (0x0000f000 & 0xffff) = 0xefff   (carry into bit 16 is lost)
1067
1068              0x00010000
1069            + 0xffffefff
1070            ------------
1071              0x0000efff   but 'fred + 0xffff' = 0x0001efff
1072
1073          Similarly, if the 15th bit remains clear, but overflow occurs into
1074          the 16th bit then (assuming the address of fred is 0xf000):
1075
1076            movhi hi( fred + 0x7000), r0, r1    [bit 15 of the offset is clear]
1077            movea lo( fred + 0x7000), r1, r1
1078
1079            HI16S: 0x0000 + (0x0000f000 >> 16)    = 0x0000
1080            LO16:  0x7000 + (0x0000f000 & 0xffff) = 0x6fff  (carry into bit 16 is lost)
1081
1082              0x00000000
1083            + 0x00006fff
1084            ------------
1085              0x00006fff   but 'fred + 0x7000' = 0x00016fff
1086
1087          Note - there is no need to change anything if a carry occurs, and the
1088          15th bit changes its value from being set to being clear, as the HI16S
1089          reloc will have already added in 1 to the high part for us:
1090
1091            movhi hi( fred + 0xffff), r0, r1     [bit 15 of the offset is set]
1092            movea lo( fred + 0xffff), r1, r1
1093
1094            HI16S: 0x0001 + (0x00007000 >> 16)
1095            LO16:  0xffff + (0x00007000 & 0xffff) = 0x6fff  (carry into bit 16 is lost)
1096
1097              0x00010000
1098            + 0x00006fff   (bit 15 not set, so the top half is zero)
1099            ------------
1100              0x00016fff   which is right (assuming that fred is at 0x7000)
1101
1102          but if the 15th bit goes from being clear to being set, then we must
1103          once again handle overflow:
1104
1105            movhi hi( fred + 0x7000), r0, r1     [bit 15 of the offset is clear]
1106            movea lo( fred + 0x7000), r1, r1
1107
1108            HI16S: 0x0000 + (0x0000ffff >> 16)
1109            LO16:  0x7000 + (0x0000ffff & 0xffff) = 0x6fff  (carry into bit 16)
1110
1111              0x00000000
1112            + 0x00006fff   (bit 15 not set, so the top half is zero)
1113            ------------
1114              0x00006fff   which is wrong (assuming that fred is at 0xffff).  */
1115       {
1116         long result;
1117
1118         insn   = bfd_get_16 (abfd, address);
1119         result = insn + addend;
1120
1121 #define BIT15_SET(x) ((x) & 0x8000)
1122 #define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff)
1123
1124         if ((BIT15_SET (result) && ! BIT15_SET (addend))
1125             || (OVERFLOWS (addend, insn)
1126                 && ((! BIT15_SET (insn)) || (BIT15_SET (addend)))))
1127           {
1128             bfd_boolean already_updated;
1129             bfd_byte *hi16s_address = find_remembered_hi16s_reloc
1130               (addend, & already_updated);
1131
1132             /* Amend the matching HI16_S relocation.  */
1133             if (hi16s_address != NULL)
1134               {
1135                 if (! already_updated)
1136                   {
1137                     insn = bfd_get_16 (abfd, hi16s_address);
1138                     insn += 1;
1139                     bfd_put_16 (abfd, (bfd_vma) insn, hi16s_address);
1140                   }
1141               }
1142             else
1143               {
1144                 fprintf (stderr, _("FAILED to find previous HI16 reloc\n"));
1145                 return bfd_reloc_overflow;
1146               }
1147           }
1148
1149         /* Do not complain if value has top bit set, as this has been anticipated.  */
1150         insn = result & 0xffff;
1151         break;
1152       }
1153
1154     case R_V850_8:
1155       addend += (char) bfd_get_8 (abfd, address);
1156
1157       saddend = (bfd_signed_vma) addend;
1158
1159       if (saddend > 0x7f || saddend < -0x80)
1160         return bfd_reloc_overflow;
1161
1162       bfd_put_8 (abfd, addend, address);
1163       return bfd_reloc_ok;
1164
1165     case R_V850_CALLT_16_16_OFFSET:
1166       addend += bfd_get_16 (abfd, address);
1167
1168       saddend = (bfd_signed_vma) addend;
1169
1170       if (saddend > 0xffff || saddend < 0)
1171         return bfd_reloc_overflow;
1172
1173       insn = addend;
1174       break;
1175
1176     case R_V850_16:
1177
1178       /* drop through */
1179     case R_V850_SDA_16_16_OFFSET:
1180     case R_V850_ZDA_16_16_OFFSET:
1181     case R_V850_TDA_16_16_OFFSET:
1182       addend += bfd_get_16 (abfd, address);
1183
1184       saddend = (bfd_signed_vma) addend;
1185
1186       if (saddend > 0x7fff || saddend < -0x8000)
1187         return bfd_reloc_overflow;
1188
1189       insn = addend;
1190       break;
1191
1192     case R_V850_SDA_15_16_OFFSET:
1193     case R_V850_ZDA_15_16_OFFSET:
1194       insn = bfd_get_16 (abfd, address);
1195       addend += (insn & 0xfffe);
1196
1197       saddend = (bfd_signed_vma) addend;
1198
1199       if (saddend > 0x7ffe || saddend < -0x8000)
1200         return bfd_reloc_overflow;
1201
1202       if (addend & 1)
1203         return bfd_reloc_dangerous;
1204
1205       insn = (addend &~ (bfd_vma) 1) | (insn & 1);
1206       break;
1207
1208     case R_V850_TDA_6_8_OFFSET:
1209       insn = bfd_get_16 (abfd, address);
1210       addend += ((insn & 0x7e) << 1);
1211
1212       saddend = (bfd_signed_vma) addend;
1213
1214       if (saddend > 0xfc || saddend < 0)
1215         return bfd_reloc_overflow;
1216
1217       if (addend & 3)
1218         return bfd_reloc_dangerous;
1219
1220       insn &= 0xff81;
1221       insn |= (addend >> 1);
1222       break;
1223
1224     case R_V850_TDA_7_8_OFFSET:
1225       insn = bfd_get_16 (abfd, address);
1226       addend += ((insn & 0x7f) << 1);
1227
1228       saddend = (bfd_signed_vma) addend;
1229
1230       if (saddend > 0xfe || saddend < 0)
1231         return bfd_reloc_overflow;
1232
1233       if (addend & 1)
1234         return bfd_reloc_dangerous;
1235
1236       insn &= 0xff80;
1237       insn |= (addend >> 1);
1238       break;
1239
1240     case R_V850_TDA_7_7_OFFSET:
1241       insn = bfd_get_16 (abfd, address);
1242       addend += insn & 0x7f;
1243
1244       saddend = (bfd_signed_vma) addend;
1245
1246       if (saddend > 0x7f || saddend < 0)
1247         return bfd_reloc_overflow;
1248
1249       insn &= 0xff80;
1250       insn |= addend;
1251       break;
1252
1253     case R_V850_TDA_4_5_OFFSET:
1254       insn = bfd_get_16 (abfd, address);
1255       addend += ((insn & 0xf) << 1);
1256
1257       saddend = (bfd_signed_vma) addend;
1258
1259       if (saddend > 0x1e || saddend < 0)
1260         return bfd_reloc_overflow;
1261
1262       if (addend & 1)
1263         return bfd_reloc_dangerous;
1264
1265       insn &= 0xfff0;
1266       insn |= (addend >> 1);
1267       break;
1268
1269     case R_V850_TDA_4_4_OFFSET:
1270       insn = bfd_get_16 (abfd, address);
1271       addend += insn & 0xf;
1272
1273       saddend = (bfd_signed_vma) addend;
1274
1275       if (saddend > 0xf || saddend < 0)
1276         return bfd_reloc_overflow;
1277
1278       insn &= 0xfff0;
1279       insn |= addend;
1280       break;
1281
1282     case R_V850_ZDA_16_16_SPLIT_OFFSET:
1283     case R_V850_SDA_16_16_SPLIT_OFFSET:
1284       insn = bfd_get_32 (abfd, address);
1285       addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5);
1286
1287       saddend = (bfd_signed_vma) addend;
1288
1289       if (saddend > 0x7fff || saddend < -0x8000)
1290         return bfd_reloc_overflow;
1291
1292       insn &= 0x0001ffdf;
1293       insn |= (addend & 1) << 5;
1294       insn |= (addend &~ (bfd_vma) 1) << 16;
1295
1296       bfd_put_32 (abfd, (bfd_vma) insn, address);
1297       return bfd_reloc_ok;
1298
1299     case R_V850_CALLT_6_7_OFFSET:
1300       insn = bfd_get_16 (abfd, address);
1301       addend += ((insn & 0x3f) << 1);
1302
1303       saddend = (bfd_signed_vma) addend;
1304
1305       if (saddend > 0x7e || saddend < 0)
1306         return bfd_reloc_overflow;
1307
1308       if (addend & 1)
1309         return bfd_reloc_dangerous;
1310
1311       insn &= 0xff80;
1312       insn |= (addend >> 1);
1313       break;
1314
1315     case R_V850_GNU_VTINHERIT:
1316     case R_V850_GNU_VTENTRY:
1317       return bfd_reloc_ok;
1318
1319     }
1320
1321   bfd_put_16 (abfd, (bfd_vma) insn, address);
1322   return bfd_reloc_ok;
1323 }
1324 \f
1325 /* Insert the addend into the instruction.  */
1326
1327 static bfd_reloc_status_type
1328 v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
1329      bfd *abfd ATTRIBUTE_UNUSED;
1330      arelent *reloc;
1331      asymbol *symbol;
1332      PTR data ATTRIBUTE_UNUSED;
1333      asection *isection;
1334      bfd *obfd;
1335      char **err ATTRIBUTE_UNUSED;
1336 {
1337   bfd_size_type sz;
1338   long relocation;
1339
1340   /* If there is an output BFD,
1341      and the symbol is not a section name (which is only defined at final link time),
1342      and either we are not putting the addend into the instruction
1343       or the addend is zero, so there is nothing to add into the instruction
1344      then just fixup the address and return.  */
1345   if (obfd != (bfd *) NULL
1346       && (symbol->flags & BSF_SECTION_SYM) == 0
1347       && (! reloc->howto->partial_inplace
1348           || reloc->addend == 0))
1349     {
1350       reloc->address += isection->output_offset;
1351       return bfd_reloc_ok;
1352     }
1353
1354   /* Catch relocs involving undefined symbols.  */
1355   if (bfd_is_und_section (symbol->section)
1356       && (symbol->flags & BSF_WEAK) == 0
1357       && obfd == NULL)
1358     return bfd_reloc_undefined;
1359
1360   /* We handle final linking of some relocs ourselves.  */
1361
1362   /* Is the address of the relocation really within the section?  */
1363   sz = isection->rawsize ? isection->rawsize : isection->size;
1364   if (reloc->address > sz)
1365     return bfd_reloc_outofrange;
1366
1367   /* Work out which section the relocation is targeted at and the
1368      initial relocation command value.  */
1369
1370   if (reloc->howto->pc_relative)
1371     return bfd_reloc_ok;
1372
1373   /* Get symbol value.  (Common symbols are special.)  */
1374   if (bfd_is_com_section (symbol->section))
1375     relocation = 0;
1376   else
1377     relocation = symbol->value;
1378
1379   /* Convert input-section-relative symbol value to absolute + addend.  */
1380   relocation += symbol->section->output_section->vma;
1381   relocation += symbol->section->output_offset;
1382   relocation += reloc->addend;
1383
1384 #if 0 /* Since this reloc is going to be processed later on, we should
1385          not make it pc-relative here.  To test this, try assembling and
1386          linking this program:
1387
1388                 .text
1389                 .globl _start
1390                 nop
1391         _start:
1392                 jr foo
1393
1394                 .section ".foo","ax"
1395                 nop
1396         foo:
1397                 nop      */
1398   if (reloc->howto->pc_relative)
1399     {
1400       /* Here the variable relocation holds the final address of the
1401          symbol we are relocating against, plus any addend.  */
1402       relocation -= isection->output_section->vma + isection->output_offset;
1403
1404       /* Deal with pcrel_offset.  */
1405       relocation -= reloc->address;
1406     }
1407 #endif
1408   reloc->addend = relocation;
1409   return bfd_reloc_ok;
1410 }
1411
1412 /* This function is used for relocs which are only used
1413    for relaxing, which the linker should otherwise ignore.  */
1414
1415 static bfd_reloc_status_type
1416 v850_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
1417                        output_bfd, error_message)
1418      bfd *abfd ATTRIBUTE_UNUSED;
1419      arelent *reloc_entry;
1420      asymbol *symbol ATTRIBUTE_UNUSED;
1421      PTR data ATTRIBUTE_UNUSED;
1422      asection *input_section;
1423      bfd *output_bfd;
1424      char **error_message ATTRIBUTE_UNUSED;
1425 {
1426   if (output_bfd != NULL)
1427     reloc_entry->address += input_section->output_offset;
1428
1429   return bfd_reloc_ok;
1430 }
1431 \f
1432 static bfd_boolean
1433 v850_elf_is_local_label_name (abfd, name)
1434      bfd *abfd ATTRIBUTE_UNUSED;
1435      const char *name;
1436 {
1437   return (   (name[0] == '.' && (name[1] == 'L' || name[1] == '.'))
1438           || (name[0] == '_' &&  name[1] == '.' && name[2] == 'L' && name[3] == '_'));
1439 }
1440 \f
1441 /* We overload some of the bfd_reloc error codes for own purposes.  */
1442 #define bfd_reloc_gp_not_found          bfd_reloc_other
1443 #define bfd_reloc_ep_not_found          bfd_reloc_continue
1444 #define bfd_reloc_ctbp_not_found        (bfd_reloc_dangerous + 1)
1445
1446 /* Perform a relocation as part of a final link.  */
1447
1448 static bfd_reloc_status_type
1449 v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1450                               input_section, contents, offset, value,
1451                               addend, info, sym_sec, is_local)
1452      reloc_howto_type *howto;
1453      bfd *input_bfd;
1454      bfd *output_bfd ATTRIBUTE_UNUSED;
1455      asection *input_section;
1456      bfd_byte *contents;
1457      bfd_vma offset;
1458      bfd_vma value;
1459      bfd_vma addend;
1460      struct bfd_link_info *info;
1461      asection *sym_sec;
1462      int is_local ATTRIBUTE_UNUSED;
1463 {
1464   unsigned int r_type = howto->type;
1465   bfd_byte *hit_data = contents + offset;
1466
1467   /* Adjust the value according to the relocation.  */
1468   switch (r_type)
1469     {
1470     case R_V850_9_PCREL:
1471       value -= (input_section->output_section->vma
1472                 + input_section->output_offset);
1473       value -= offset;
1474       break;
1475
1476     case R_V850_22_PCREL:
1477       value -= (input_section->output_section->vma
1478                 + input_section->output_offset
1479                 + offset);
1480
1481       /* If the sign extension will corrupt the value then we have overflowed.  */
1482       if (((value & 0xff000000) != 0x0) && ((value & 0xff000000) != 0xff000000))
1483         return bfd_reloc_overflow;
1484
1485       /* Only the bottom 24 bits of the PC are valid */
1486       value = SEXT24 (value);
1487       break;
1488
1489     case R_V850_REL32:
1490       value -= (input_section->output_section->vma
1491                 + input_section->output_offset
1492                 + offset);
1493       break;
1494
1495     case R_V850_HI16_S:
1496     case R_V850_HI16:
1497     case R_V850_LO16:
1498     case R_V850_16:
1499     case R_V850_ABS32:
1500     case R_V850_8:
1501       break;
1502
1503     case R_V850_ZDA_15_16_OFFSET:
1504     case R_V850_ZDA_16_16_OFFSET:
1505     case R_V850_ZDA_16_16_SPLIT_OFFSET:
1506       if (sym_sec == NULL)
1507         return bfd_reloc_undefined;
1508
1509       value -= sym_sec->output_section->vma;
1510       break;
1511
1512     case R_V850_SDA_15_16_OFFSET:
1513     case R_V850_SDA_16_16_OFFSET:
1514     case R_V850_SDA_16_16_SPLIT_OFFSET:
1515       {
1516         unsigned long                gp;
1517         struct bfd_link_hash_entry * h;
1518
1519         if (sym_sec == NULL)
1520           return bfd_reloc_undefined;
1521
1522         /* Get the value of __gp.  */
1523         h = bfd_link_hash_lookup (info->hash, "__gp", FALSE, FALSE, TRUE);
1524         if (h == (struct bfd_link_hash_entry *) NULL
1525             || h->type != bfd_link_hash_defined)
1526           return bfd_reloc_gp_not_found;
1527
1528         gp = (h->u.def.value
1529               + h->u.def.section->output_section->vma
1530               + h->u.def.section->output_offset);
1531
1532         value -= sym_sec->output_section->vma;
1533         value -= (gp - sym_sec->output_section->vma);
1534       }
1535     break;
1536
1537     case R_V850_TDA_4_4_OFFSET:
1538     case R_V850_TDA_4_5_OFFSET:
1539     case R_V850_TDA_16_16_OFFSET:
1540     case R_V850_TDA_7_7_OFFSET:
1541     case R_V850_TDA_7_8_OFFSET:
1542     case R_V850_TDA_6_8_OFFSET:
1543       {
1544         unsigned long                ep;
1545         struct bfd_link_hash_entry * h;
1546
1547         /* Get the value of __ep.  */
1548         h = bfd_link_hash_lookup (info->hash, "__ep", FALSE, FALSE, TRUE);
1549         if (h == (struct bfd_link_hash_entry *) NULL
1550             || h->type != bfd_link_hash_defined)
1551           return bfd_reloc_ep_not_found;
1552
1553         ep = (h->u.def.value
1554               + h->u.def.section->output_section->vma
1555               + h->u.def.section->output_offset);
1556
1557         value -= ep;
1558       }
1559     break;
1560
1561     case R_V850_CALLT_6_7_OFFSET:
1562       {
1563         unsigned long                ctbp;
1564         struct bfd_link_hash_entry * h;
1565
1566         /* Get the value of __ctbp.  */
1567         h = bfd_link_hash_lookup (info->hash, "__ctbp", FALSE, FALSE, TRUE);
1568         if (h == (struct bfd_link_hash_entry *) NULL
1569             || h->type != bfd_link_hash_defined)
1570           return bfd_reloc_ctbp_not_found;
1571
1572         ctbp = (h->u.def.value
1573               + h->u.def.section->output_section->vma
1574               + h->u.def.section->output_offset);
1575         value -= ctbp;
1576       }
1577     break;
1578
1579     case R_V850_CALLT_16_16_OFFSET:
1580       {
1581         unsigned long                ctbp;
1582         struct bfd_link_hash_entry * h;
1583
1584         if (sym_sec == NULL)
1585           return bfd_reloc_undefined;
1586
1587         /* Get the value of __ctbp.  */
1588         h = bfd_link_hash_lookup (info->hash, "__ctbp", FALSE, FALSE, TRUE);
1589         if (h == (struct bfd_link_hash_entry *) NULL
1590             || h->type != bfd_link_hash_defined)
1591           return bfd_reloc_ctbp_not_found;
1592
1593         ctbp = (h->u.def.value
1594               + h->u.def.section->output_section->vma
1595               + h->u.def.section->output_offset);
1596
1597         value -= sym_sec->output_section->vma;
1598         value -= (ctbp - sym_sec->output_section->vma);
1599       }
1600     break;
1601
1602     case R_V850_NONE:
1603     case R_V850_GNU_VTINHERIT:
1604     case R_V850_GNU_VTENTRY:
1605     case R_V850_LONGCALL:
1606     case R_V850_LONGJUMP:
1607     case R_V850_ALIGN:
1608       return bfd_reloc_ok;
1609
1610     default:
1611       return bfd_reloc_notsupported;
1612     }
1613
1614   /* Perform the relocation.  */
1615   return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
1616 }
1617 \f
1618 /* Relocate an V850 ELF section.  */
1619
1620 static bfd_boolean
1621 v850_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1622                            contents, relocs, local_syms, local_sections)
1623      bfd *output_bfd;
1624      struct bfd_link_info *info;
1625      bfd *input_bfd;
1626      asection *input_section;
1627      bfd_byte *contents;
1628      Elf_Internal_Rela *relocs;
1629      Elf_Internal_Sym *local_syms;
1630      asection **local_sections;
1631 {
1632   Elf_Internal_Shdr *symtab_hdr;
1633   struct elf_link_hash_entry **sym_hashes;
1634   Elf_Internal_Rela *rel;
1635   Elf_Internal_Rela *relend;
1636
1637   if (info->relocatable)
1638     return TRUE;
1639
1640   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1641   sym_hashes = elf_sym_hashes (input_bfd);
1642
1643   if (sym_hashes == NULL)
1644     {
1645       info->callbacks->warning
1646         (info, "no hash table available",
1647          NULL, input_bfd, input_section, (bfd_vma) 0);
1648
1649       return FALSE;
1650     }
1651
1652   /* Reset the list of remembered HI16S relocs to empty.  */
1653   free_hi16s     = previous_hi16s;
1654   previous_hi16s = NULL;
1655   hi16s_counter  = 0;
1656
1657   rel    = relocs;
1658   relend = relocs + input_section->reloc_count;
1659   for (; rel < relend; rel++)
1660     {
1661       int r_type;
1662       reloc_howto_type *howto;
1663       unsigned long r_symndx;
1664       Elf_Internal_Sym *sym;
1665       asection *sec;
1666       struct elf_link_hash_entry *h;
1667       bfd_vma relocation;
1668       bfd_reloc_status_type r;
1669
1670       r_symndx = ELF32_R_SYM (rel->r_info);
1671       r_type   = ELF32_R_TYPE (rel->r_info);
1672
1673       if (r_type == R_V850_GNU_VTENTRY
1674           || r_type == R_V850_GNU_VTINHERIT)
1675         continue;
1676
1677       /* This is a final link.  */
1678       howto = v850_elf_howto_table + r_type;
1679       h = NULL;
1680       sym = NULL;
1681       sec = NULL;
1682       if (r_symndx < symtab_hdr->sh_info)
1683         {
1684           sym = local_syms + r_symndx;
1685           sec = local_sections[r_symndx];
1686           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1687 #if 0
1688           {
1689             char * name;
1690
1691             name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name);
1692             name = (name == NULL) ? "<none>" : name;
1693             fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
1694                      sec->name, name, sym->st_name,
1695                      sec->output_section->vma, sec->output_offset, sym->st_value, rel->r_addend);
1696           }
1697 #endif
1698         }
1699       else
1700         {
1701           bfd_boolean unresolved_reloc, warned;
1702
1703           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1704                                    r_symndx, symtab_hdr, sym_hashes,
1705                                    h, sec, relocation,
1706                                    unresolved_reloc, warned);
1707         }
1708
1709       /* FIXME: We should use the addend, but the COFF relocations don't.  */
1710       r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1711                                         input_section,
1712                                         contents, rel->r_offset,
1713                                         relocation, rel->r_addend,
1714                                         info, sec, h == NULL);
1715
1716       if (r != bfd_reloc_ok)
1717         {
1718           const char * name;
1719           const char * msg = (const char *)0;
1720
1721           if (h != NULL)
1722             name = h->root.root.string;
1723           else
1724             {
1725               name = (bfd_elf_string_from_elf_section
1726                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1727               if (name == NULL || *name == '\0')
1728                 name = bfd_section_name (input_bfd, sec);
1729             }
1730
1731           switch (r)
1732             {
1733             case bfd_reloc_overflow:
1734               if (! ((*info->callbacks->reloc_overflow)
1735                      (info, name, howto->name, (bfd_vma) 0,
1736                       input_bfd, input_section, rel->r_offset)))
1737                 return FALSE;
1738               break;
1739
1740             case bfd_reloc_undefined:
1741               if (! ((*info->callbacks->undefined_symbol)
1742                      (info, name, input_bfd, input_section,
1743                       rel->r_offset, TRUE)))
1744                 return FALSE;
1745               break;
1746
1747             case bfd_reloc_outofrange:
1748               msg = _("internal error: out of range error");
1749               goto common_error;
1750
1751             case bfd_reloc_notsupported:
1752               msg = _("internal error: unsupported relocation error");
1753               goto common_error;
1754
1755             case bfd_reloc_dangerous:
1756               msg = _("internal error: dangerous relocation");
1757               goto common_error;
1758
1759             case bfd_reloc_gp_not_found:
1760               msg = _("could not locate special linker symbol __gp");
1761               goto common_error;
1762
1763             case bfd_reloc_ep_not_found:
1764               msg = _("could not locate special linker symbol __ep");
1765               goto common_error;
1766
1767             case bfd_reloc_ctbp_not_found:
1768               msg = _("could not locate special linker symbol __ctbp");
1769               goto common_error;
1770
1771             default:
1772               msg = _("internal error: unknown error");
1773               /* fall through */
1774
1775             common_error:
1776               if (!((*info->callbacks->warning)
1777                     (info, msg, name, input_bfd, input_section,
1778                      rel->r_offset)))
1779                 return FALSE;
1780               break;
1781             }
1782         }
1783     }
1784
1785   return TRUE;
1786 }
1787
1788 static bfd_boolean
1789 v850_elf_gc_sweep_hook (abfd, info, sec, relocs)
1790      bfd *abfd ATTRIBUTE_UNUSED;
1791      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1792      asection *sec ATTRIBUTE_UNUSED;
1793      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
1794 {
1795   /* No got and plt entries for v850-elf.  */
1796   return TRUE;
1797 }
1798
1799 static asection *
1800 v850_elf_gc_mark_hook (sec, info, rel, h, sym)
1801        asection *sec;
1802        struct bfd_link_info *info ATTRIBUTE_UNUSED;
1803        Elf_Internal_Rela *rel;
1804        struct elf_link_hash_entry *h;
1805        Elf_Internal_Sym *sym;
1806 {
1807   if (h != NULL)
1808     {
1809       switch (ELF32_R_TYPE (rel->r_info))
1810       {
1811       case R_V850_GNU_VTINHERIT:
1812       case R_V850_GNU_VTENTRY:
1813         break;
1814
1815       default:
1816         switch (h->root.type)
1817           {
1818           case bfd_link_hash_defined:
1819           case bfd_link_hash_defweak:
1820             return h->root.u.def.section;
1821
1822           case bfd_link_hash_common:
1823             return h->root.u.c.p->section;
1824
1825           default:
1826             break;
1827           }
1828        }
1829      }
1830    else
1831      return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1832
1833   return NULL;
1834 }
1835
1836 /* Set the right machine number.  */
1837
1838 static bfd_boolean
1839 v850_elf_object_p (abfd)
1840      bfd *abfd;
1841 {
1842   switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1843     {
1844     default:
1845     case E_V850_ARCH:
1846       bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850);
1847       break;
1848     case E_V850E_ARCH:
1849       bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e);
1850       break;
1851     case E_V850E1_ARCH:
1852       bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e1);
1853       break;
1854     }
1855   return TRUE;
1856 }
1857
1858 /* Store the machine number in the flags field.  */
1859
1860 static void
1861 v850_elf_final_write_processing (abfd, linker)
1862      bfd *abfd;
1863      bfd_boolean linker ATTRIBUTE_UNUSED;
1864 {
1865   unsigned long val;
1866
1867   switch (bfd_get_mach (abfd))
1868     {
1869     default:
1870     case bfd_mach_v850:  val = E_V850_ARCH; break;
1871     case bfd_mach_v850e: val = E_V850E_ARCH; break;
1872     case bfd_mach_v850e1: val = E_V850E1_ARCH;  break;
1873     }
1874
1875   elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH;
1876   elf_elfheader (abfd)->e_flags |= val;
1877 }
1878
1879 /* Function to keep V850 specific file flags.  */
1880
1881 static bfd_boolean
1882 v850_elf_set_private_flags (abfd, flags)
1883      bfd *abfd;
1884      flagword flags;
1885 {
1886   BFD_ASSERT (!elf_flags_init (abfd)
1887               || elf_elfheader (abfd)->e_flags == flags);
1888
1889   elf_elfheader (abfd)->e_flags = flags;
1890   elf_flags_init (abfd) = TRUE;
1891   return TRUE;
1892 }
1893
1894 /* Merge backend specific data from an object file
1895    to the output object file when linking.  */
1896 static bfd_boolean
1897 v850_elf_merge_private_bfd_data (ibfd, obfd)
1898      bfd *ibfd;
1899      bfd *obfd;
1900 {
1901   flagword out_flags;
1902   flagword in_flags;
1903
1904   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1905       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1906     return TRUE;
1907
1908   in_flags = elf_elfheader (ibfd)->e_flags;
1909   out_flags = elf_elfheader (obfd)->e_flags;
1910
1911   if (! elf_flags_init (obfd))
1912     {
1913       /* If the input is the default architecture then do not
1914          bother setting the flags for the output architecture,
1915          instead allow future merges to do this.  If no future
1916          merges ever set these flags then they will retain their
1917          unitialised values, which surprise surprise, correspond
1918          to the default values.  */
1919       if (bfd_get_arch_info (ibfd)->the_default)
1920         return TRUE;
1921
1922       elf_flags_init (obfd) = TRUE;
1923       elf_elfheader (obfd)->e_flags = in_flags;
1924
1925       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1926           && bfd_get_arch_info (obfd)->the_default)
1927         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1928
1929       return TRUE;
1930     }
1931
1932   /* Check flag compatibility.  */
1933   if (in_flags == out_flags)
1934     return TRUE;
1935
1936   if ((in_flags & EF_V850_ARCH) != (out_flags & EF_V850_ARCH)
1937       && (in_flags & EF_V850_ARCH) != E_V850_ARCH)
1938     {
1939       /* Allow v850e1 binaries to be linked with v850e binaries.
1940          Set the output binary to v850e.  */
1941       if ((in_flags & EF_V850_ARCH) == E_V850E1_ARCH
1942           && (out_flags & EF_V850_ARCH) == E_V850E_ARCH)
1943         return TRUE;
1944
1945       if ((in_flags & EF_V850_ARCH) == E_V850E_ARCH
1946           && (out_flags & EF_V850_ARCH) == E_V850E1_ARCH)
1947         {
1948           elf_elfheader (obfd)->e_flags =
1949             ((out_flags & ~ EF_V850_ARCH) | E_V850E_ARCH);
1950           return TRUE;
1951         }
1952
1953       _bfd_error_handler (_("%s: Architecture mismatch with previous modules"),
1954                           bfd_archive_filename (ibfd));
1955     }
1956
1957   return TRUE;
1958 }
1959
1960 /* Display the flags field.  */
1961
1962 static bfd_boolean
1963 v850_elf_print_private_bfd_data (abfd, ptr)
1964      bfd *abfd;
1965      PTR ptr;
1966 {
1967   FILE * file = (FILE *) ptr;
1968
1969   BFD_ASSERT (abfd != NULL && ptr != NULL);
1970
1971   _bfd_elf_print_private_bfd_data (abfd, ptr);
1972
1973   /* xgettext:c-format */
1974   fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags);
1975
1976   switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1977     {
1978     default:
1979     case E_V850_ARCH: fprintf (file, _("v850 architecture")); break;
1980     case E_V850E_ARCH:  fprintf (file, _("v850e architecture")); break;
1981     case E_V850E1_ARCH: fprintf (file, _("v850e1 architecture")); break;
1982     }
1983
1984   fputc ('\n', file);
1985
1986   return TRUE;
1987 }
1988
1989 /* V850 ELF uses four common sections.  One is the usual one, and the
1990    others are for (small) objects in one of the special data areas:
1991    small, tiny and zero.  All the objects are kept together, and then
1992    referenced via the gp register, the ep register or the r0 register
1993    respectively, which yields smaller, faster assembler code.  This
1994    approach is copied from elf32-mips.c.  */
1995
1996 static asection  v850_elf_scom_section;
1997 static asymbol   v850_elf_scom_symbol;
1998 static asymbol * v850_elf_scom_symbol_ptr;
1999 static asection  v850_elf_tcom_section;
2000 static asymbol   v850_elf_tcom_symbol;
2001 static asymbol * v850_elf_tcom_symbol_ptr;
2002 static asection  v850_elf_zcom_section;
2003 static asymbol   v850_elf_zcom_symbol;
2004 static asymbol * v850_elf_zcom_symbol_ptr;
2005
2006 /* Given a BFD section, try to locate the
2007    corresponding ELF section index.  */
2008
2009 static bfd_boolean
2010 v850_elf_section_from_bfd_section (abfd, sec, retval)
2011      bfd *abfd ATTRIBUTE_UNUSED;
2012      asection *sec;
2013      int *retval;
2014 {
2015   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
2016     *retval = SHN_V850_SCOMMON;
2017   else if (strcmp (bfd_get_section_name (abfd, sec), ".tcommon") == 0)
2018     *retval = SHN_V850_TCOMMON;
2019   else if (strcmp (bfd_get_section_name (abfd, sec), ".zcommon") == 0)
2020     *retval = SHN_V850_ZCOMMON;
2021   else
2022     return FALSE;
2023
2024   return TRUE;
2025 }
2026
2027 /* Handle the special V850 section numbers that a symbol may use.  */
2028
2029 static void
2030 v850_elf_symbol_processing (abfd, asym)
2031      bfd *abfd;
2032      asymbol *asym;
2033 {
2034   elf_symbol_type * elfsym = (elf_symbol_type *) asym;
2035   unsigned int indx;
2036
2037   indx = elfsym->internal_elf_sym.st_shndx;
2038
2039   /* If the section index is an "ordinary" index, then it may
2040      refer to a v850 specific section created by the assembler.
2041      Check the section's type and change the index it matches.
2042
2043      FIXME: Should we alter the st_shndx field as well ?  */
2044
2045   if (indx < elf_numsections (abfd))
2046     switch (elf_elfsections(abfd)[indx]->sh_type)
2047       {
2048       case SHT_V850_SCOMMON:
2049         indx = SHN_V850_SCOMMON;
2050         break;
2051
2052       case SHT_V850_TCOMMON:
2053         indx = SHN_V850_TCOMMON;
2054         break;
2055
2056       case SHT_V850_ZCOMMON:
2057         indx = SHN_V850_ZCOMMON;
2058         break;
2059
2060       default:
2061         break;
2062       }
2063
2064   switch (indx)
2065     {
2066     case SHN_V850_SCOMMON:
2067       if (v850_elf_scom_section.name == NULL)
2068         {
2069           /* Initialize the small common section.  */
2070           v850_elf_scom_section.name           = ".scommon";
2071           v850_elf_scom_section.flags          = SEC_IS_COMMON | SEC_ALLOC | SEC_DATA;
2072           v850_elf_scom_section.output_section = & v850_elf_scom_section;
2073           v850_elf_scom_section.symbol         = & v850_elf_scom_symbol;
2074           v850_elf_scom_section.symbol_ptr_ptr = & v850_elf_scom_symbol_ptr;
2075           v850_elf_scom_symbol.name            = ".scommon";
2076           v850_elf_scom_symbol.flags           = BSF_SECTION_SYM;
2077           v850_elf_scom_symbol.section         = & v850_elf_scom_section;
2078           v850_elf_scom_symbol_ptr             = & v850_elf_scom_symbol;
2079         }
2080       asym->section = & v850_elf_scom_section;
2081       asym->value = elfsym->internal_elf_sym.st_size;
2082       break;
2083
2084     case SHN_V850_TCOMMON:
2085       if (v850_elf_tcom_section.name == NULL)
2086         {
2087           /* Initialize the tcommon section.  */
2088           v850_elf_tcom_section.name           = ".tcommon";
2089           v850_elf_tcom_section.flags          = SEC_IS_COMMON;
2090           v850_elf_tcom_section.output_section = & v850_elf_tcom_section;
2091           v850_elf_tcom_section.symbol         = & v850_elf_tcom_symbol;
2092           v850_elf_tcom_section.symbol_ptr_ptr = & v850_elf_tcom_symbol_ptr;
2093           v850_elf_tcom_symbol.name            = ".tcommon";
2094           v850_elf_tcom_symbol.flags           = BSF_SECTION_SYM;
2095           v850_elf_tcom_symbol.section         = & v850_elf_tcom_section;
2096           v850_elf_tcom_symbol_ptr             = & v850_elf_tcom_symbol;
2097         }
2098       asym->section = & v850_elf_tcom_section;
2099       asym->value = elfsym->internal_elf_sym.st_size;
2100       break;
2101
2102     case SHN_V850_ZCOMMON:
2103       if (v850_elf_zcom_section.name == NULL)
2104         {
2105           /* Initialize the zcommon section.  */
2106           v850_elf_zcom_section.name           = ".zcommon";
2107           v850_elf_zcom_section.flags          = SEC_IS_COMMON;
2108           v850_elf_zcom_section.output_section = & v850_elf_zcom_section;
2109           v850_elf_zcom_section.symbol         = & v850_elf_zcom_symbol;
2110           v850_elf_zcom_section.symbol_ptr_ptr = & v850_elf_zcom_symbol_ptr;
2111           v850_elf_zcom_symbol.name            = ".zcommon";
2112           v850_elf_zcom_symbol.flags           = BSF_SECTION_SYM;
2113           v850_elf_zcom_symbol.section         = & v850_elf_zcom_section;
2114           v850_elf_zcom_symbol_ptr             = & v850_elf_zcom_symbol;
2115         }
2116       asym->section = & v850_elf_zcom_section;
2117       asym->value = elfsym->internal_elf_sym.st_size;
2118       break;
2119     }
2120 }
2121
2122 /* Hook called by the linker routine which adds symbols from an object
2123    file.  We must handle the special v850 section numbers here.  */
2124
2125 static bfd_boolean
2126 v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2127      bfd *abfd;
2128      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2129      Elf_Internal_Sym *sym;
2130      const char **namep ATTRIBUTE_UNUSED;
2131      flagword *flagsp ATTRIBUTE_UNUSED;
2132      asection **secp;
2133      bfd_vma *valp;
2134 {
2135   unsigned int indx = sym->st_shndx;
2136
2137   /* If the section index is an "ordinary" index, then it may
2138      refer to a v850 specific section created by the assembler.
2139      Check the section's type and change the index it matches.
2140
2141      FIXME: Should we alter the st_shndx field as well ?  */
2142
2143   if (indx < elf_numsections (abfd))
2144     switch (elf_elfsections(abfd)[indx]->sh_type)
2145       {
2146       case SHT_V850_SCOMMON:
2147         indx = SHN_V850_SCOMMON;
2148         break;
2149
2150       case SHT_V850_TCOMMON:
2151         indx = SHN_V850_TCOMMON;
2152         break;
2153
2154       case SHT_V850_ZCOMMON:
2155         indx = SHN_V850_ZCOMMON;
2156         break;
2157
2158       default:
2159         break;
2160       }
2161
2162   switch (indx)
2163     {
2164     case SHN_V850_SCOMMON:
2165       *secp = bfd_make_section_old_way (abfd, ".scommon");
2166       (*secp)->flags |= SEC_IS_COMMON;
2167       *valp = sym->st_size;
2168       break;
2169
2170     case SHN_V850_TCOMMON:
2171       *secp = bfd_make_section_old_way (abfd, ".tcommon");
2172       (*secp)->flags |= SEC_IS_COMMON;
2173       *valp = sym->st_size;
2174       break;
2175
2176     case SHN_V850_ZCOMMON:
2177       *secp = bfd_make_section_old_way (abfd, ".zcommon");
2178       (*secp)->flags |= SEC_IS_COMMON;
2179       *valp = sym->st_size;
2180       break;
2181     }
2182
2183   return TRUE;
2184 }
2185
2186 static bfd_boolean
2187 v850_elf_link_output_symbol_hook (info, name, sym, input_sec, h)
2188      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2189      const char *name ATTRIBUTE_UNUSED;
2190      Elf_Internal_Sym *sym;
2191      asection *input_sec;
2192      struct elf_link_hash_entry *h ATTRIBUTE_UNUSED;
2193 {
2194   /* If we see a common symbol, which implies a relocatable link, then
2195      if a symbol was in a special common section in an input file, mark
2196      it as a special common in the output file.  */
2197
2198   if (sym->st_shndx == SHN_COMMON)
2199     {
2200       if (strcmp (input_sec->name, ".scommon") == 0)
2201         sym->st_shndx = SHN_V850_SCOMMON;
2202       else if (strcmp (input_sec->name, ".tcommon") == 0)
2203         sym->st_shndx = SHN_V850_TCOMMON;
2204       else if (strcmp (input_sec->name, ".zcommon") == 0)
2205         sym->st_shndx = SHN_V850_ZCOMMON;
2206     }
2207
2208   return TRUE;
2209 }
2210
2211 static bfd_boolean
2212 v850_elf_section_from_shdr (abfd, hdr, name)
2213      bfd *abfd;
2214      Elf_Internal_Shdr *hdr;
2215      const char *name;
2216 {
2217   /* There ought to be a place to keep ELF backend specific flags, but
2218      at the moment there isn't one.  We just keep track of the
2219      sections by their name, instead.  */
2220
2221   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2222     return FALSE;
2223
2224   switch (hdr->sh_type)
2225     {
2226     case SHT_V850_SCOMMON:
2227     case SHT_V850_TCOMMON:
2228     case SHT_V850_ZCOMMON:
2229       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2230                                    (bfd_get_section_flags (abfd,
2231                                                            hdr->bfd_section)
2232                                     | SEC_IS_COMMON)))
2233         return FALSE;
2234     }
2235
2236   return TRUE;
2237 }
2238
2239 /* Set the correct type for a V850 ELF section.  We do this
2240    by the section name, which is a hack, but ought to work.  */
2241
2242 static bfd_boolean
2243 v850_elf_fake_sections (abfd, hdr, sec)
2244      bfd *abfd ATTRIBUTE_UNUSED;
2245      Elf_Internal_Shdr *hdr;
2246      asection *sec;
2247 {
2248   register const char * name;
2249
2250   name = bfd_get_section_name (abfd, sec);
2251
2252   if (strcmp (name, ".scommon") == 0)
2253     {
2254       hdr->sh_type = SHT_V850_SCOMMON;
2255     }
2256   else if (strcmp (name, ".tcommon") == 0)
2257     {
2258       hdr->sh_type = SHT_V850_TCOMMON;
2259     }
2260   else if (strcmp (name, ".zcommon") == 0)
2261     hdr->sh_type = SHT_V850_ZCOMMON;
2262
2263   return TRUE;
2264 }
2265
2266 /* Delete some bytes from a section while relaxing.  */
2267
2268 static bfd_boolean
2269 v850_elf_relax_delete_bytes (abfd, sec, addr, toaddr, count)
2270      bfd *abfd;
2271      asection *sec;
2272      bfd_vma addr;
2273      bfd_vma toaddr;
2274      int count;
2275 {
2276   Elf_Internal_Shdr *symtab_hdr;
2277   Elf32_External_Sym *extsyms;
2278   Elf32_External_Sym *esym;
2279   Elf32_External_Sym *esymend;
2280   int index;
2281   unsigned int sec_shndx;
2282   bfd_byte *contents;
2283   Elf_Internal_Rela *irel;
2284   Elf_Internal_Rela *irelend;
2285   struct elf_link_hash_entry *sym_hash;
2286   Elf_Internal_Shdr *shndx_hdr;
2287   Elf_External_Sym_Shndx *shndx;
2288
2289   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2290   extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2291
2292   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2293
2294   contents = elf_section_data (sec)->this_hdr.contents;
2295
2296   /* The deletion must stop at the next ALIGN reloc for an alignment
2297      power larger than the number of bytes we are deleting.  */
2298
2299   /* Actually delete the bytes.  */
2300 #if (DEBUG_RELAX & 2)
2301   fprintf (stderr, "relax_delete: contents: sec: %s  %p .. %p %x\n",
2302            sec->name, addr, toaddr, count );
2303 #endif
2304   memmove (contents + addr, contents + addr + count,
2305            toaddr - addr - count);
2306   memset (contents + toaddr-count, 0, count);
2307
2308   /* Adjust all the relocs.  */
2309   irel = elf_section_data (sec)->relocs;
2310   irelend = irel + sec->reloc_count;
2311   shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2312   shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
2313
2314   for (; irel < irelend; irel++)
2315     {
2316       bfd_vma raddr, paddr, symval;
2317       Elf_Internal_Sym isym;
2318
2319       /* Get the new reloc address.  */
2320       raddr = irel->r_offset;
2321       if ((raddr >= (addr + count) && raddr < toaddr))
2322         irel->r_offset -= count;
2323
2324       if (raddr >= addr && raddr < addr + count)
2325         {
2326           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2327                                        (int) R_V850_NONE);
2328           continue;
2329         }
2330
2331       if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN)
2332         continue;
2333
2334       bfd_elf32_swap_symbol_in (abfd,
2335                                 extsyms + ELF32_R_SYM (irel->r_info),
2336                                 shndx ? shndx + ELF32_R_SYM (irel->r_info) : NULL,
2337                                 & isym);
2338
2339       if (isym.st_shndx != sec_shndx)
2340         continue;
2341
2342       /* Get the value of the symbol referred to by the reloc.  */
2343       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2344         {
2345           symval = isym.st_value;
2346 #if (DEBUG_RELAX & 2)
2347           {
2348             char * name = bfd_elf_string_from_elf_section
2349                            (abfd, symtab_hdr->sh_link, isym.st_name);
2350             fprintf (stderr,
2351                "relax_delete: local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
2352                sec->name, name, isym.st_name,
2353                sec->output_section->vma, sec->output_offset,
2354                isym.st_value, irel->r_addend);
2355           }
2356 #endif
2357         }
2358       else
2359         {
2360           unsigned long indx;
2361           struct elf_link_hash_entry * h;
2362
2363           /* An external symbol.  */
2364           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2365
2366           h = elf_sym_hashes (abfd) [indx];
2367           BFD_ASSERT (h != NULL);
2368
2369           symval = h->root.u.def.value;
2370 #if (DEBUG_RELAX & 2)
2371           fprintf (stderr,
2372                    "relax_delete: defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n",
2373                    sec->name, h->root.root.string, h->root.u.def.value,
2374                    sec->output_section->vma, sec->output_offset, irel->r_addend);
2375 #endif
2376         }
2377
2378       paddr = symval + irel->r_addend;
2379
2380       if ( (symval >= addr + count && symval < toaddr)
2381           && (paddr < addr + count || paddr >= toaddr))
2382         irel->r_addend += count;
2383       else if (    (symval < addr + count || symval >= toaddr)
2384                 && (paddr >= addr + count && paddr < toaddr))
2385         irel->r_addend -= count;
2386     }
2387
2388   /* Adjust the local symbols defined in this section.  */
2389   esym = extsyms;
2390   esymend = esym + symtab_hdr->sh_info;
2391
2392   for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL))
2393     {
2394       Elf_Internal_Sym isym;
2395
2396       bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym);
2397
2398       if (isym.st_shndx == sec_shndx
2399           && isym.st_value >= addr + count
2400           && isym.st_value < toaddr)
2401         {
2402           isym.st_value -= count;
2403
2404           if (isym.st_value + isym.st_size >= toaddr)
2405             isym.st_size += count;
2406
2407           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
2408         }
2409       else if (isym.st_shndx == sec_shndx
2410                && isym.st_value < addr + count)
2411         {
2412           if (isym.st_value+isym.st_size >= addr + count
2413               && isym.st_value+isym.st_size < toaddr)
2414             isym.st_size -= count;
2415
2416           if (isym.st_value >= addr
2417               && isym.st_value <  addr + count)
2418             isym.st_value = addr;
2419
2420           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
2421         }
2422     }
2423
2424   /* Now adjust the global symbols defined in this section.  */
2425   esym = extsyms + symtab_hdr->sh_info;
2426   esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2427
2428   for (index = 0; esym < esymend; esym ++, index ++)
2429     {
2430       Elf_Internal_Sym isym;
2431
2432       bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym);
2433       sym_hash = elf_sym_hashes (abfd) [index];
2434
2435       if (isym.st_shndx == sec_shndx
2436           && ((sym_hash)->root.type == bfd_link_hash_defined
2437               || (sym_hash)->root.type == bfd_link_hash_defweak)
2438           && (sym_hash)->root.u.def.section == sec
2439           && (sym_hash)->root.u.def.value >= addr + count
2440           && (sym_hash)->root.u.def.value < toaddr)
2441         {
2442           if ((sym_hash)->root.u.def.value + isym.st_size >= toaddr)
2443             {
2444               isym.st_size += count;
2445               bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
2446             }
2447
2448           (sym_hash)->root.u.def.value -= count;
2449         }
2450       else if (isym.st_shndx == sec_shndx
2451                && ((sym_hash)->root.type == bfd_link_hash_defined
2452                    || (sym_hash)->root.type == bfd_link_hash_defweak)
2453                && (sym_hash)->root.u.def.section == sec
2454                && (sym_hash)->root.u.def.value < addr + count)
2455         {
2456           if ((sym_hash)->root.u.def.value+isym.st_size >= addr + count
2457               && (sym_hash)->root.u.def.value+isym.st_size < toaddr)
2458             isym.st_size -= count;
2459
2460           if ((sym_hash)->root.u.def.value >= addr
2461               && (sym_hash)->root.u.def.value < addr + count)
2462             (sym_hash)->root.u.def.value = addr;
2463
2464           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
2465         }
2466
2467       if (shndx)
2468         ++ shndx;
2469     }
2470
2471   return TRUE;
2472 }
2473
2474 #define NOP_OPCODE      (0x0000)
2475 #define MOVHI           0x0640                          /* 4byte */
2476 #define MOVHI_MASK      0x07e0
2477 #define MOVHI_R1(insn)  ((insn) & 0x1f)                 /* 4byte */
2478 #define MOVHI_R2(insn)  ((insn) >> 11)
2479 #define MOVEA           0x0620                          /* 2byte */
2480 #define MOVEA_MASK      0x07e0
2481 #define MOVEA_R1(insn)  ((insn) & 0x1f)
2482 #define MOVEA_R2(insn)  ((insn) >> 11)
2483 #define JARL_4          0x00040780                              /* 4byte */
2484 #define JARL_4_MASK     0xFFFF07FF
2485 #define JARL_R2(insn)   (int)(((insn) & (~JARL_4_MASK)) >> 11)
2486 #define ADD_I           0x0240                                  /* 2byte */
2487 #define ADD_I_MASK      0x07e0
2488 #define ADD_I5(insn)    ((((insn) & 0x001f) << 11) >> 11)       /* 2byte */
2489 #define ADD_R2(insn)    ((insn) >> 11)
2490 #define JMP_R           0x0060                                  /* 2byte */
2491 #define JMP_R_MASK      0xFFE0
2492 #define JMP_R1(insn)    ((insn) & 0x1f)
2493
2494 static bfd_boolean
2495 v850_elf_relax_section (abfd, sec, link_info, again)
2496      bfd *abfd;
2497      asection *sec;
2498      struct bfd_link_info *link_info;
2499      bfd_boolean *again;
2500 {
2501   Elf_Internal_Shdr *symtab_hdr;
2502   Elf_Internal_Rela *internal_relocs;
2503   Elf_Internal_Rela *irel;
2504   Elf_Internal_Rela *irelend;
2505   Elf_Internal_Rela *irelalign = NULL;
2506   Elf_Internal_Sym *isymbuf = NULL;
2507   bfd_byte *contents = NULL;
2508   bfd_vma addr = 0;
2509   bfd_vma toaddr;
2510   int align_pad_size = 0;
2511   bfd_boolean result = TRUE;
2512
2513   *again = FALSE;
2514
2515   if (link_info->relocatable
2516       || (sec->flags & SEC_RELOC) == 0
2517       || sec->reloc_count == 0)
2518     return TRUE;
2519
2520   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2521
2522   internal_relocs = (_bfd_elf_link_read_relocs
2523                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2524                       link_info->keep_memory));
2525   if (internal_relocs == NULL)
2526     goto error_return;
2527
2528   irelend = internal_relocs + sec->reloc_count;
2529
2530   while (addr < sec->size)
2531     {
2532       toaddr = sec->size;
2533
2534       for (irel = internal_relocs; irel < irelend; irel ++)
2535         if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN
2536             && irel->r_offset > addr
2537             && irel->r_offset < toaddr)
2538           toaddr = irel->r_offset;
2539
2540 #ifdef DEBUG_RELAX
2541       fprintf (stderr, "relax region 0x%x to 0x%x align pad %d\n",
2542                addr, toaddr, align_pad_size);
2543 #endif
2544       if (irelalign)
2545         {
2546           bfd_vma alignto;
2547           bfd_vma alignmoveto;
2548
2549           alignmoveto = BFD_ALIGN (addr - align_pad_size, 1 << irelalign->r_addend);
2550           alignto = BFD_ALIGN (addr, 1 << irelalign->r_addend);
2551
2552           if (alignmoveto < alignto)
2553             {
2554               unsigned int i;
2555
2556               align_pad_size = alignto - alignmoveto;
2557 #ifdef DEBUG_RELAX
2558               fprintf (stderr, "relax move region 0x%x to 0x%x delete size 0x%x\n",
2559                        alignmoveto, toaddr, align_pad_size);
2560 #endif
2561               if (!v850_elf_relax_delete_bytes (abfd, sec, alignmoveto,
2562                                                 toaddr, align_pad_size))
2563                 goto error_return;
2564
2565               for (i  = BFD_ALIGN (toaddr - align_pad_size, 1);
2566                    (i + 1) < toaddr; i += 2)
2567                 bfd_put_16 (abfd, NOP_OPCODE, contents + i);
2568
2569               addr = alignmoveto;
2570             }
2571           else
2572             align_pad_size = 0;
2573         }
2574
2575       for (irel = internal_relocs; irel < irelend; irel++)
2576         {
2577           bfd_vma laddr;
2578           bfd_vma addend;
2579           bfd_vma symval;
2580           int insn[5];
2581           int no_match = -1;
2582           Elf_Internal_Rela *hi_irelfn;
2583           Elf_Internal_Rela *lo_irelfn;
2584           Elf_Internal_Rela *irelcall;
2585           bfd_signed_vma foff;
2586
2587           if (! (irel->r_offset >= addr && irel->r_offset < toaddr
2588                  && (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL
2589                      || ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP)))
2590             continue;
2591
2592 #ifdef DEBUG_RELAX
2593           fprintf (stderr, "relax check r_info 0x%x r_offset 0x%x r_addend 0x%x\n",
2594                    irel->r_info,
2595                    irel->r_offset,
2596                    irel->r_addend );
2597 #endif
2598
2599           /* Get the section contents.  */
2600           if (contents == NULL)
2601             {
2602               if (elf_section_data (sec)->this_hdr.contents != NULL)
2603                 contents = elf_section_data (sec)->this_hdr.contents;
2604               else
2605                 {
2606                   if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2607                     goto error_return;
2608                 }
2609             }
2610
2611           /* Read this BFD's local symbols if we haven't done so already.  */
2612           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2613             {
2614               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2615               if (isymbuf == NULL)
2616                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2617                                                 symtab_hdr->sh_info, 0,
2618                                                 NULL, NULL, NULL);
2619               if (isymbuf == NULL)
2620                 goto error_return;
2621             }
2622
2623           laddr = irel->r_offset;
2624
2625           if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL)
2626             {
2627               /* Check code for -mlong-calls output. */
2628               if (laddr + 16 <= (bfd_vma) sec->size)
2629                 {
2630                   insn[0] = bfd_get_16 (abfd, contents + laddr);
2631                   insn[1] = bfd_get_16 (abfd, contents + laddr + 4);
2632                   insn[2] = bfd_get_32 (abfd, contents + laddr + 8);
2633                   insn[3] = bfd_get_16 (abfd, contents + laddr + 12);
2634                   insn[4] = bfd_get_16 (abfd, contents + laddr + 14);
2635
2636                   if ((insn[0] & MOVHI_MASK) != MOVHI
2637                        || MOVHI_R1 (insn[0]) != 0)
2638                     no_match = 0;
2639
2640                   if (no_match < 0
2641                       && ((insn[1] & MOVEA_MASK) != MOVEA
2642                            || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1])))
2643                     no_match = 1;
2644
2645                   if (no_match < 0
2646                       && (insn[2] & JARL_4_MASK) != JARL_4)
2647                     no_match = 2;
2648
2649                   if (no_match < 0
2650                       && ((insn[3] & ADD_I_MASK) != ADD_I
2651                            || ADD_I5 (insn[3]) != 4
2652                            || JARL_R2 (insn[2]) != ADD_R2 (insn[3])))
2653                     no_match = 3;
2654
2655                   if (no_match < 0
2656                       && ((insn[4] & JMP_R_MASK) != JMP_R
2657                            || MOVEA_R2 (insn[1]) != JMP_R1 (insn[4])))
2658                     no_match = 4;
2659                 }
2660               else
2661                 {
2662                   ((*_bfd_error_handler)
2663                    ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insns",
2664                     bfd_get_filename (abfd), (unsigned long) irel->r_offset));
2665
2666                   continue;
2667                 }
2668
2669               if (no_match >= 0)
2670                 {
2671                   ((*_bfd_error_handler)
2672                    ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insn 0x%x",
2673                     bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match]));
2674
2675                   continue;
2676                 }
2677
2678               /* Get the reloc for the address from which the register is
2679                  being loaded.  This reloc will tell us which function is
2680                  actually being called.  */
2681               for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++)
2682                 if (hi_irelfn->r_offset == laddr + 2
2683                     && ELF32_R_TYPE (hi_irelfn->r_info)
2684                         == (int) R_V850_HI16_S)
2685                   break;
2686
2687               for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++)
2688                 if (lo_irelfn->r_offset == laddr + 6
2689                     && ELF32_R_TYPE (lo_irelfn->r_info)
2690                         == (int) R_V850_LO16)
2691                   break;
2692
2693               for (irelcall = internal_relocs; irelcall < irelend; irelcall ++)
2694                 if (irelcall->r_offset == laddr + 8
2695                     && ELF32_R_TYPE (irelcall->r_info)
2696                         == (int) R_V850_22_PCREL)
2697                   break;
2698
2699               if (   hi_irelfn == irelend
2700                   || lo_irelfn == irelend
2701                   || irelcall  == irelend)
2702                 {
2703                   ((*_bfd_error_handler)
2704                    ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc",
2705                     bfd_get_filename (abfd), (unsigned long) irel->r_offset ));
2706
2707                   continue;
2708                 }
2709
2710               if (ELF32_R_SYM (irelcall->r_info) < symtab_hdr->sh_info)
2711                 {
2712                   Elf_Internal_Sym *  isym;
2713
2714                   /* A local symbol.  */
2715                   isym = isymbuf + ELF32_R_SYM (irelcall->r_info);
2716
2717                   symval = isym->st_value;
2718                 }
2719               else
2720                 {
2721                   unsigned long indx;
2722                   struct elf_link_hash_entry * h;
2723
2724                   /* An external symbol.  */
2725                   indx = ELF32_R_SYM (irelcall->r_info) - symtab_hdr->sh_info;
2726                   h = elf_sym_hashes (abfd)[indx];
2727                   BFD_ASSERT (h != NULL);
2728
2729                   if (   h->root.type != bfd_link_hash_defined
2730                       && h->root.type != bfd_link_hash_defweak)
2731                     /* This appears to be a reference to an undefined
2732                        symbol.  Just ignore it--it will be caught by the
2733                        regular reloc processing.  */
2734                     continue;
2735
2736                   symval = h->root.u.def.value;
2737                 }
2738
2739               if (symval + irelcall->r_addend != irelcall->r_offset + 4)
2740                 {
2741                   ((*_bfd_error_handler)
2742                    ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc 0x%lx",
2743                     bfd_get_filename (abfd), (unsigned long) irel->r_offset, irelcall->r_offset ));
2744
2745                   continue;
2746                 }
2747
2748               /* Get the value of the symbol referred to by the reloc.  */
2749               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2750                 {
2751                   Elf_Internal_Sym *isym;
2752                   asection *sym_sec;
2753
2754                   /* A local symbol.  */
2755                   isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info);
2756
2757                   if (isym->st_shndx == SHN_UNDEF)
2758                     sym_sec = bfd_und_section_ptr;
2759                   else if (isym->st_shndx == SHN_ABS)
2760                     sym_sec = bfd_abs_section_ptr;
2761                   else if (isym->st_shndx == SHN_COMMON)
2762                     sym_sec = bfd_com_section_ptr;
2763                   else
2764                     sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2765                   symval = (isym->st_value
2766                             + sym_sec->output_section->vma
2767                             + sym_sec->output_offset);
2768                 }
2769               else
2770                 {
2771                   unsigned long indx;
2772                   struct elf_link_hash_entry *h;
2773
2774                   /* An external symbol.  */
2775                   indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
2776                   h = elf_sym_hashes (abfd)[indx];
2777                   BFD_ASSERT (h != NULL);
2778
2779                   if (   h->root.type != bfd_link_hash_defined
2780                       && h->root.type != bfd_link_hash_defweak)
2781                     /* This appears to be a reference to an undefined
2782                        symbol.  Just ignore it--it will be caught by the
2783                        regular reloc processing.  */
2784                     continue;
2785
2786                   symval = (h->root.u.def.value
2787                             + h->root.u.def.section->output_section->vma
2788                             + h->root.u.def.section->output_offset);
2789                 }
2790
2791               addend = irel->r_addend;
2792
2793               foff = (symval + addend
2794                       - (irel->r_offset
2795                          + sec->output_section->vma
2796                          + sec->output_offset
2797                          + 4));
2798 #ifdef DEBUG_RELAX
2799               fprintf (stderr, "relax longcall r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n",
2800                        irel->r_offset,
2801                        (irel->r_offset
2802                         + sec->output_section->vma
2803                         + sec->output_offset),
2804                        symval, addend, foff);
2805 #endif
2806
2807               if (foff < -0x100000 || foff >= 0x100000)
2808                 /* After all that work, we can't shorten this function call.  */
2809                 continue;
2810
2811               /* For simplicity of coding, we are going to modify the section
2812                  contents, the section relocs, and the BFD symbol table.  We
2813                  must tell the rest of the code not to free up this
2814                  information.  It would be possible to instead create a table
2815                  of changes which have to be made, as is done in coff-mips.c;
2816                  that would be more work, but would require less memory when
2817                  the linker is run.  */
2818               elf_section_data (sec)->relocs = internal_relocs;
2819               elf_section_data (sec)->this_hdr.contents = contents;
2820               symtab_hdr->contents = (bfd_byte *) isymbuf;
2821
2822               /* Replace the long call with a jarl.  */
2823               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_22_PCREL);
2824
2825               addend = 0;
2826
2827               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2828                 /* If this needs to be changed because of future relaxing,
2829                    it will be handled here like other internal IND12W
2830                    relocs.  */
2831                 bfd_put_32 (abfd,
2832                             0x00000780 | (JARL_R2 (insn[2])<<11) | ((addend << 16) & 0xffff) | ((addend >> 16) & 0xf),
2833                             contents + irel->r_offset);
2834               else
2835                 /* We can't fully resolve this yet, because the external
2836                    symbol value may be changed by future relaxing.
2837                    We let the final link phase handle it.  */
2838                 bfd_put_32 (abfd, 0x00000780 | (JARL_R2 (insn[2])<<11),
2839                             contents + irel->r_offset);
2840
2841               hi_irelfn->r_info =
2842                 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
2843               lo_irelfn->r_info =
2844                 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
2845               irelcall->r_info =
2846                 ELF32_R_INFO (ELF32_R_SYM (irelcall->r_info), R_V850_NONE);
2847
2848               if (! v850_elf_relax_delete_bytes (abfd, sec,
2849                                                  irel->r_offset + 4, toaddr, 12))
2850                 goto error_return;
2851
2852               align_pad_size += 12;
2853             }
2854           else if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP)
2855             {
2856               /* Check code for -mlong-jumps output.  */
2857               if (laddr + 10 <= (bfd_vma) sec->size)
2858                 {
2859                   insn[0] = bfd_get_16 (abfd, contents + laddr);
2860                   insn[1] = bfd_get_16 (abfd, contents + laddr + 4);
2861                   insn[2] = bfd_get_16 (abfd, contents + laddr + 8);
2862
2863                   if ((insn[0] & MOVHI_MASK) != MOVHI
2864                        || MOVHI_R1 (insn[0]) != 0)
2865                     no_match = 0;
2866
2867                   if (no_match < 0
2868                       && ((insn[1] & MOVEA_MASK) != MOVEA
2869                            || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1])))
2870                     no_match = 1;
2871
2872                   if (no_match < 0
2873                       && ((insn[2] & JMP_R_MASK) != JMP_R
2874                            || MOVEA_R2 (insn[1]) != JMP_R1 (insn[2])))
2875                     no_match = 4;
2876                 }
2877               else
2878                 {
2879                   ((*_bfd_error_handler)
2880                    ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insns",
2881                     bfd_get_filename (abfd), (unsigned long) irel->r_offset));
2882
2883                   continue;
2884                 }
2885
2886               if (no_match >= 0)
2887                 {
2888                   ((*_bfd_error_handler)
2889                    ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insn 0x%x",
2890                     bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match]));
2891
2892                   continue;
2893                 }
2894
2895               /* Get the reloc for the address from which the register is
2896                  being loaded.  This reloc will tell us which function is
2897                  actually being called.  */
2898               for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++)
2899                 if (hi_irelfn->r_offset == laddr + 2
2900                     && ELF32_R_TYPE (hi_irelfn->r_info) == (int) R_V850_HI16_S)
2901                   break;
2902
2903               for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++)
2904                 if (lo_irelfn->r_offset == laddr + 6
2905                     && ELF32_R_TYPE (lo_irelfn->r_info) == (int) R_V850_LO16)
2906                   break;
2907
2908               if (   hi_irelfn == irelend
2909                   || lo_irelfn == irelend)
2910                 {
2911                   ((*_bfd_error_handler)
2912                    ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized reloc",
2913                     bfd_get_filename (abfd), (unsigned long) irel->r_offset ));
2914
2915                   continue;
2916                 }
2917
2918               /* Get the value of the symbol referred to by the reloc.  */
2919               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2920                 {
2921                   Elf_Internal_Sym *  isym;
2922                   asection *          sym_sec;
2923
2924                   /* A local symbol.  */
2925                   isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info);
2926
2927                   if (isym->st_shndx == SHN_UNDEF)
2928                     sym_sec = bfd_und_section_ptr;
2929                   else if (isym->st_shndx == SHN_ABS)
2930                     sym_sec = bfd_abs_section_ptr;
2931                   else if (isym->st_shndx == SHN_COMMON)
2932                     sym_sec = bfd_com_section_ptr;
2933                   else
2934                     sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2935                   symval = (isym->st_value
2936                             + sym_sec->output_section->vma
2937                             + sym_sec->output_offset);
2938 #ifdef DEBUG_RELAX
2939                   {
2940                     char * name = bfd_elf_string_from_elf_section
2941                       (abfd, symtab_hdr->sh_link, isym->st_name);
2942
2943                     fprintf (stderr, "relax long jump local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
2944                              sym_sec->name, name, isym->st_name,
2945                              sym_sec->output_section->vma,
2946                              sym_sec->output_offset,
2947                              isym->st_value, irel->r_addend);
2948                   }
2949 #endif
2950                 }
2951               else
2952                 {
2953                   unsigned long indx;
2954                   struct elf_link_hash_entry * h;
2955
2956                   /* An external symbol.  */
2957                   indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2958                   h = elf_sym_hashes (abfd)[indx];
2959                   BFD_ASSERT (h != NULL);
2960
2961                   if (   h->root.type != bfd_link_hash_defined
2962                       && h->root.type != bfd_link_hash_defweak)
2963                     /* This appears to be a reference to an undefined
2964                        symbol.  Just ignore it--it will be caught by the
2965                        regular reloc processing.  */
2966                     continue;
2967
2968                   symval = (h->root.u.def.value
2969                             + h->root.u.def.section->output_section->vma
2970                             + h->root.u.def.section->output_offset);
2971 #ifdef DEBUG_RELAX
2972                   fprintf (stderr,
2973                            "relax longjump defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n",
2974                            sec->name, h->root.root.string, h->root.u.def.value,
2975                            sec->output_section->vma, sec->output_offset, irel->r_addend);
2976 #endif
2977                 }
2978
2979               addend = irel->r_addend;
2980
2981               foff = (symval + addend
2982                       - (irel->r_offset
2983                          + sec->output_section->vma
2984                          + sec->output_offset
2985                          + 4));
2986 #ifdef DEBUG_RELAX
2987               fprintf (stderr, "relax longjump r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n",
2988                        irel->r_offset,
2989                        (irel->r_offset
2990                         + sec->output_section->vma
2991                         + sec->output_offset),
2992                        symval, addend, foff);
2993 #endif
2994               if (foff < -0x100000 || foff >= 0x100000)
2995                 /* After all that work, we can't shorten this function call.  */
2996                 continue;
2997
2998               /* For simplicity of coding, we are going to modify the section
2999                  contents, the section relocs, and the BFD symbol table.  We
3000                  must tell the rest of the code not to free up this
3001                  information.  It would be possible to instead create a table
3002                  of changes which have to be made, as is done in coff-mips.c;
3003                  that would be more work, but would require less memory when
3004                  the linker is run.  */
3005               elf_section_data (sec)->relocs = internal_relocs;
3006               elf_section_data (sec)->this_hdr.contents = contents;
3007               symtab_hdr->contents = (bfd_byte *) isymbuf;
3008
3009               if (foff < -0x100 || foff >= 0x100)
3010                 {
3011                   /* Replace the long jump with a jr.  */
3012
3013                   irel->r_info =
3014                     ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_22_PCREL);
3015
3016                   irel->r_addend = addend;
3017                   addend = 0;
3018
3019                   if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
3020                     /* If this needs to be changed because of future relaxing,
3021                        it will be handled here like other internal IND12W
3022                        relocs.  */
3023                     bfd_put_32 (abfd,
3024                                 0x00000780 | ((addend << 15) & 0xffff0000) | ((addend >> 17) & 0xf),
3025                                 contents + irel->r_offset);
3026                   else
3027                     /* We can't fully resolve this yet, because the external
3028                        symbol value may be changed by future relaxing.
3029                        We let the final link phase handle it.  */
3030                     bfd_put_32 (abfd, 0x00000780, contents + irel->r_offset);
3031
3032                   hi_irelfn->r_info =
3033                         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
3034                   lo_irelfn->r_info =
3035                         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
3036                   if (!v850_elf_relax_delete_bytes (abfd, sec,
3037                                                     irel->r_offset + 4, toaddr, 6))
3038                     goto error_return;
3039
3040                   align_pad_size += 6;
3041                 }
3042               else
3043                 {
3044                   /* Replace the long jump with a br.  */
3045
3046                   irel->r_info =
3047                         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_9_PCREL);
3048
3049                   irel->r_addend = addend;
3050                   addend = 0;
3051
3052                   if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
3053                     /* If this needs to be changed because of future relaxing,
3054                        it will be handled here like other internal IND12W
3055                        relocs.  */
3056                     bfd_put_16 (abfd,
3057                                 0x0585 | ((addend << 10) & 0xf800) | ((addend << 3) & 0x0070),
3058                                 contents + irel->r_offset);
3059                   else
3060                     /* We can't fully resolve this yet, because the external
3061                        symbol value may be changed by future relaxing.
3062                        We let the final link phase handle it.  */
3063                     bfd_put_16 (abfd, 0x0585, contents + irel->r_offset);
3064
3065                   hi_irelfn->r_info =
3066                         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
3067                   lo_irelfn->r_info =
3068                         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
3069                   if (!v850_elf_relax_delete_bytes (abfd, sec,
3070                                                     irel->r_offset + 2, toaddr, 8))
3071                     goto error_return;
3072
3073                   align_pad_size += 8;
3074                 }
3075             }
3076         }
3077
3078       irelalign = NULL;
3079       for (irel = internal_relocs; irel < irelend; irel++)
3080         {
3081           if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN
3082               && irel->r_offset == toaddr)
3083             {
3084               irel->r_offset -= align_pad_size;
3085
3086               if (irelalign == NULL || irelalign->r_addend > irel->r_addend)
3087                 irelalign = irel;
3088             }
3089         }
3090
3091       addr = toaddr;
3092     }
3093
3094   if (!irelalign)
3095     {
3096 #ifdef DEBUG_RELAX
3097       fprintf (stderr, "relax pad %d shorten %d -> %d\n",
3098                align_pad_size,
3099                sec->size,
3100                sec->size - align_pad_size);
3101 #endif
3102       sec->size -= align_pad_size;
3103     }
3104
3105  finish:
3106   if (internal_relocs != NULL
3107       && elf_section_data (sec)->relocs != internal_relocs)
3108     free (internal_relocs);
3109
3110   if (contents != NULL
3111       && elf_section_data (sec)->this_hdr.contents != (unsigned char *) contents)
3112     free (contents);
3113
3114   if (isymbuf != NULL
3115       && symtab_hdr->contents != (bfd_byte *) isymbuf)
3116     free (isymbuf);
3117
3118   return result;
3119
3120  error_return:
3121   result = FALSE;
3122   goto finish;
3123 }
3124
3125 static struct bfd_elf_special_section const v850_elf_special_sections[]=
3126 {
3127   { ".sdata",            6, -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
3128                                                    + SHF_V850_GPREL) },
3129   { ".rosdata",          8, -2, SHT_PROGBITS,     (SHF_ALLOC
3130                                                    + SHF_V850_GPREL) },
3131   { ".sbss",             5, -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
3132                                                    + SHF_V850_GPREL) },
3133   { ".scommon",          8, -2, SHT_V850_SCOMMON, (SHF_ALLOC + SHF_WRITE
3134                                                    + SHF_V850_GPREL) },
3135   { ".tdata",            6, -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
3136                                                    + SHF_V850_EPREL) },
3137   { ".tbss",             5, -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
3138                                                    + SHF_V850_EPREL) },
3139   { ".tcommon",          8, -2, SHT_V850_TCOMMON, (SHF_ALLOC + SHF_WRITE
3140                                                    + SHF_V850_R0REL) },
3141   { ".zdata",            6, -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
3142                                                    + SHF_V850_R0REL) },
3143   { ".rozdata",          8, -2, SHT_PROGBITS,     (SHF_ALLOC
3144                                                    + SHF_V850_R0REL) },
3145   { ".zbss",             5, -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
3146                                                    + SHF_V850_R0REL) },
3147   { ".zcommon",          8, -2, SHT_V850_ZCOMMON, (SHF_ALLOC + SHF_WRITE
3148                                                    + SHF_V850_R0REL) },
3149   { ".call_table_data", 16,  0, SHT_PROGBITS,     (SHF_ALLOC
3150                                                    + SHF_WRITE) },
3151   { ".call_table_text", 16,  0, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
3152                                                    + SHF_EXECINSTR) },
3153   { NULL,               0,   0, 0,                0 }
3154 };
3155 \f
3156 #define TARGET_LITTLE_SYM                       bfd_elf32_v850_vec
3157 #define TARGET_LITTLE_NAME                      "elf32-v850"
3158 #define ELF_ARCH                                bfd_arch_v850
3159 #define ELF_MACHINE_CODE                        EM_V850
3160 #define ELF_MACHINE_ALT1                        EM_CYGNUS_V850
3161 #define ELF_MAXPAGESIZE                         0x1000
3162
3163 #define elf_info_to_howto                       v850_elf_info_to_howto_rela
3164 #define elf_info_to_howto_rel                   v850_elf_info_to_howto_rel
3165
3166 #define elf_backend_check_relocs                v850_elf_check_relocs
3167 #define elf_backend_relocate_section            v850_elf_relocate_section
3168 #define elf_backend_object_p                    v850_elf_object_p
3169 #define elf_backend_final_write_processing      v850_elf_final_write_processing
3170 #define elf_backend_section_from_bfd_section    v850_elf_section_from_bfd_section
3171 #define elf_backend_symbol_processing           v850_elf_symbol_processing
3172 #define elf_backend_add_symbol_hook             v850_elf_add_symbol_hook
3173 #define elf_backend_link_output_symbol_hook     v850_elf_link_output_symbol_hook
3174 #define elf_backend_section_from_shdr           v850_elf_section_from_shdr
3175 #define elf_backend_fake_sections               v850_elf_fake_sections
3176 #define elf_backend_gc_mark_hook                v850_elf_gc_mark_hook
3177 #define elf_backend_gc_sweep_hook               v850_elf_gc_sweep_hook
3178 #define elf_backend_special_sections            v850_elf_special_sections
3179
3180 #define elf_backend_can_gc_sections 1
3181 #define elf_backend_rela_normal 1
3182
3183 #define bfd_elf32_bfd_is_local_label_name       v850_elf_is_local_label_name
3184 #define bfd_elf32_bfd_reloc_type_lookup         v850_elf_reloc_type_lookup
3185 #define bfd_elf32_bfd_merge_private_bfd_data    v850_elf_merge_private_bfd_data
3186 #define bfd_elf32_bfd_set_private_flags         v850_elf_set_private_flags
3187 #define bfd_elf32_bfd_print_private_bfd_data    v850_elf_print_private_bfd_data
3188 #define bfd_elf32_bfd_relax_section             v850_elf_relax_section
3189
3190 #define elf_symbol_leading_char                 '_'
3191
3192 #include "elf32-target.h"