bfd/elf32-v850.c

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