bfd/elf32-v850.c

   1 /* V850-specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* XXX FIXME: This code is littered with 32bit int, 16bit short, 8bit char
  22    dependencies.  As is the gas & simulator code or 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) ^ (~ 0x7fffff)) + 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 *, Elf32_Internal_Rel *));
  39 static void v850_elf_info_to_howto_rela
  40   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
  41 static bfd_reloc_status_type v850_elf_reloc
  42   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  43 static boolean v850_elf_is_local_label_name
  44   PARAMS ((bfd *, const char *));
  45 static 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 *, int, bfd_vma, bfd_byte *));
  50 static 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, 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 boolean v850_elf_object_p
  60   PARAMS ((bfd *));
  61 static boolean v850_elf_fake_sections
  62   PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
  63 static void v850_elf_final_write_processing
  64   PARAMS ((bfd *, boolean));
  65 static boolean v850_elf_set_private_flags
  66   PARAMS ((bfd *, flagword));
  67 static boolean v850_elf_copy_private_bfd_data
  68   PARAMS ((bfd *, bfd *));
  69 static boolean v850_elf_merge_private_bfd_data
  70   PARAMS ((bfd *, bfd *));
  71 static boolean v850_elf_print_private_bfd_data
  72   PARAMS ((bfd *, PTR));
  73 static boolean v850_elf_section_from_bfd_section
  74   PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *, int *));
  75 static void v850_elf_symbol_processing
  76   PARAMS ((bfd *, asymbol *));
  77 static boolean v850_elf_add_symbol_hook
  78   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
  79            const char **, flagword *, asection **, bfd_vma *));
  80 static boolean v850_elf_link_output_symbol_hook
  81   PARAMS ((bfd *, struct bfd_link_info *, const char *,
  82            Elf_Internal_Sym *, asection *));
  83 static boolean v850_elf_section_from_shdr
  84   PARAMS ((bfd *, Elf_Internal_Shdr *, char *));
  85 static boolean v850_elf_gc_sweep_hook
  86   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  87            const Elf_Internal_Rela *));
  88 static asection * v850_elf_gc_mark_hook
  89   PARAMS ((bfd *, struct bfd_link_info *,
  90            Elf_Internal_Rela *, struct elf_link_hash_entry *,
  91            Elf_Internal_Sym *));
  92
  93 /* Note: It is REQUIRED that the 'type' value of each entry
  94    in this array match the index of the entry in the array.  */
  95 static reloc_howto_type v850_elf_howto_table[] =
  96 {
  97   /* This reloc does nothing.  */
  98   HOWTO (R_V850_NONE,                   /* type */
  99          0,                             /* rightshift */
 100          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 101          32,                            /* bitsize */
 102          false,                         /* pc_relative */
 103          0,                             /* bitpos */
 104          complain_overflow_bitfield,    /* complain_on_overflow */
 105          bfd_elf_generic_reloc,         /* special_function */
 106          "R_V850_NONE",                 /* name */
 107          false,                         /* partial_inplace */
 108          0,                             /* src_mask */
 109          0,                             /* dst_mask */
 110          false),                        /* pcrel_offset */
 111
 112   /* A PC relative 9 bit branch.  */
 113   HOWTO (R_V850_9_PCREL,                /* type */
 114          2,                             /* rightshift */
 115          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 116          26,                            /* bitsize */
 117          true,                          /* pc_relative */
 118          0,                             /* bitpos */
 119          complain_overflow_bitfield,    /* complain_on_overflow */
 120          v850_elf_reloc,                /* special_function */
 121          "R_V850_9_PCREL",              /* name */
 122          false,                         /* partial_inplace */
 123          0x00ffffff,                    /* src_mask */
 124          0x00ffffff,                    /* dst_mask */
 125          true),                         /* pcrel_offset */
 126
 127   /* A PC relative 22 bit branch.  */
 128   HOWTO (R_V850_22_PCREL,               /* type */
 129          2,                             /* rightshift */
 130          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 131          22,                            /* bitsize */
 132          true,                          /* pc_relative */
 133          7,                             /* bitpos */
 134          complain_overflow_signed,      /* complain_on_overflow */
 135          v850_elf_reloc,                /* special_function */
 136          "R_V850_22_PCREL",             /* name */
 137          false,                         /* partial_inplace */
 138          0x07ffff80,                    /* src_mask */
 139          0x07ffff80,                    /* dst_mask */
 140          true),                         /* pcrel_offset */
 141
 142   /* High 16 bits of symbol value.  */
 143   HOWTO (R_V850_HI16_S,                 /* type */
 144          0,                             /* rightshift */
 145          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 146          16,                            /* bitsize */
 147          false,                         /* pc_relative */
 148          0,                             /* bitpos */
 149          complain_overflow_dont,        /* complain_on_overflow */
 150          v850_elf_reloc,                /* special_function */
 151          "R_V850_HI16_S",               /* name */
 152          false,                         /* partial_inplace */
 153          0xffff,                        /* src_mask */
 154          0xffff,                        /* dst_mask */
 155          false),                        /* pcrel_offset */
 156
 157   /* High 16 bits of symbol value.  */
 158   HOWTO (R_V850_HI16,                   /* type */
 159          0,                             /* rightshift */
 160          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 161          16,                            /* bitsize */
 162          false,                         /* pc_relative */
 163          0,                             /* bitpos */
 164          complain_overflow_dont,        /* complain_on_overflow */
 165          v850_elf_reloc,                /* special_function */
 166          "R_V850_HI16",                 /* name */
 167          false,                         /* partial_inplace */
 168          0xffff,                        /* src_mask */
 169          0xffff,                        /* dst_mask */
 170          false),                        /* pcrel_offset */
 171
 172   /* Low 16 bits of symbol value.  */
 173   HOWTO (R_V850_LO16,                   /* type */
 174          0,                             /* rightshift */
 175          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 176          16,                            /* bitsize */
 177          false,                         /* pc_relative */
 178          0,                             /* bitpos */
 179          complain_overflow_dont,        /* complain_on_overflow */
 180          v850_elf_reloc,                /* special_function */
 181          "R_V850_LO16",                 /* name */
 182          false,                         /* partial_inplace */
 183          0xffff,                        /* src_mask */
 184          0xffff,                        /* dst_mask */
 185          false),                        /* pcrel_offset */
 186
 187   /* Simple 32bit reloc.  */
 188   HOWTO (R_V850_32,                     /* type */
 189          0,                             /* rightshift */
 190          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 191          32,                            /* bitsize */
 192          false,                         /* pc_relative */
 193          0,                             /* bitpos */
 194          complain_overflow_dont,        /* complain_on_overflow */
 195          v850_elf_reloc,                /* special_function */
 196          "R_V850_32",                   /* name */
 197          false,                         /* partial_inplace */
 198          0xffffffff,                    /* src_mask */
 199          0xffffffff,                    /* dst_mask */
 200          false),                        /* pcrel_offset */
 201
 202   /* Simple 16bit reloc.  */
 203   HOWTO (R_V850_16,                     /* type */
 204          0,                             /* rightshift */
 205          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 206          16,                            /* bitsize */
 207          false,                         /* pc_relative */
 208          0,                             /* bitpos */
 209          complain_overflow_dont,        /* complain_on_overflow */
 210          bfd_elf_generic_reloc,         /* special_function */
 211          "R_V850_16",                   /* name */
 212          false,                         /* partial_inplace */
 213          0xffff,                        /* src_mask */
 214          0xffff,                        /* dst_mask */
 215          false),                        /* pcrel_offset */
 216
 217   /* Simple 8bit reloc.  */
 218   HOWTO (R_V850_8,                      /* type */
 219          0,                             /* rightshift */
 220          0,                             /* size (0 = byte, 1 = short, 2 = long) */
 221          8,                             /* bitsize */
 222          false,                         /* pc_relative */
 223          0,                             /* bitpos */
 224          complain_overflow_dont,        /* complain_on_overflow */
 225          bfd_elf_generic_reloc,         /* special_function */
 226          "R_V850_8",                    /* name */
 227          false,                         /* partial_inplace */
 228          0xff,                          /* src_mask */
 229          0xff,                          /* dst_mask */
 230          false),                        /* pcrel_offset */
 231
 232   /* 16 bit offset from the short data area pointer.  */
 233   HOWTO (R_V850_SDA_16_16_OFFSET,       /* type */
 234          0,                             /* rightshift */
 235          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 236          16,                            /* bitsize */
 237          false,                         /* pc_relative */
 238          0,                             /* bitpos */
 239          complain_overflow_dont,        /* complain_on_overflow */
 240          v850_elf_reloc,                /* special_function */
 241          "R_V850_SDA_16_16_OFFSET",     /* name */
 242          false,                         /* partial_inplace */
 243          0xffff,                        /* src_mask */
 244          0xffff,                        /* dst_mask */
 245          false),                        /* pcrel_offset */
 246
 247   /* 15 bit offset from the short data area pointer.  */
 248   HOWTO (R_V850_SDA_15_16_OFFSET,       /* type */
 249          1,                             /* rightshift */
 250          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 251          16,                            /* bitsize */
 252          false,                         /* pc_relative */
 253          1,                             /* bitpos */
 254          complain_overflow_dont,        /* complain_on_overflow */
 255          v850_elf_reloc,                /* special_function */
 256          "R_V850_SDA_15_16_OFFSET",     /* name */
 257          false,                         /* partial_inplace */
 258          0xfffe,                        /* src_mask */
 259          0xfffe,                        /* dst_mask */
 260          false),                        /* pcrel_offset */
 261
 262   /* 16 bit offset from the zero data area pointer.  */
 263   HOWTO (R_V850_ZDA_16_16_OFFSET,       /* type */
 264          0,                             /* rightshift */
 265          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 266          16,                            /* bitsize */
 267          false,                         /* pc_relative */
 268          0,                             /* bitpos */
 269          complain_overflow_dont,        /* complain_on_overflow */
 270          v850_elf_reloc,                /* special_function */
 271          "R_V850_ZDA_16_16_OFFSET",     /* name */
 272          false,                         /* partial_inplace */
 273          0xffff,                        /* src_mask */
 274          0xffff,                        /* dst_mask */
 275          false),                        /* pcrel_offset */
 276
 277   /* 15 bit offset from the zero data area pointer.  */
 278   HOWTO (R_V850_ZDA_15_16_OFFSET,       /* type */
 279          1,                             /* rightshift */
 280          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 281          16,                            /* bitsize */
 282          false,                         /* pc_relative */
 283          1,                             /* bitpos */
 284          complain_overflow_dont,        /* complain_on_overflow */
 285          v850_elf_reloc,                /* special_function */
 286          "R_V850_ZDA_15_16_OFFSET",     /* name */
 287          false,                         /* partial_inplace */
 288          0xfffe,                        /* src_mask */
 289          0xfffe,                        /* dst_mask */
 290          false),                        /* pcrel_offset */
 291
 292   /* 6 bit offset from the tiny data area pointer.  */
 293   HOWTO (R_V850_TDA_6_8_OFFSET,         /* type */
 294          2,                             /* rightshift */
 295          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 296          8,                             /* bitsize */
 297          false,                         /* pc_relative */
 298          1,                             /* bitpos */
 299          complain_overflow_dont,        /* complain_on_overflow */
 300          v850_elf_reloc,                /* special_function */
 301          "R_V850_TDA_6_8_OFFSET",       /* name */
 302          false,                         /* partial_inplace */
 303          0x7e,                          /* src_mask */
 304          0x7e,                          /* dst_mask */
 305          false),                        /* pcrel_offset */
 306
 307   /* 8 bit offset from the tiny data area pointer.  */
 308   HOWTO (R_V850_TDA_7_8_OFFSET,         /* type */
 309          1,                             /* rightshift */
 310          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 311          8,                             /* bitsize */
 312          false,                         /* pc_relative */
 313          0,                             /* bitpos */
 314          complain_overflow_dont,        /* complain_on_overflow */
 315          v850_elf_reloc,                /* special_function */
 316          "R_V850_TDA_7_8_OFFSET",       /* name */
 317          false,                         /* partial_inplace */
 318          0x7f,                          /* src_mask */
 319          0x7f,                          /* dst_mask */
 320          false),                        /* pcrel_offset */
 321
 322   /* 7 bit offset from the tiny data area pointer.  */
 323   HOWTO (R_V850_TDA_7_7_OFFSET,         /* type */
 324          0,                             /* rightshift */
 325          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 326          7,                             /* bitsize */
 327          false,                         /* pc_relative */
 328          0,                             /* bitpos */
 329          complain_overflow_dont,        /* complain_on_overflow */
 330          v850_elf_reloc,                /* special_function */
 331          "R_V850_TDA_7_7_OFFSET",       /* name */
 332          false,                         /* partial_inplace */
 333          0x7f,                          /* src_mask */
 334          0x7f,                          /* dst_mask */
 335          false),                        /* pcrel_offset */
 336
 337   /* 16 bit offset from the tiny data area pointer!  */
 338   HOWTO (R_V850_TDA_16_16_OFFSET,       /* type */
 339          0,                             /* rightshift */
 340          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                            /* bitsize */
 342          false,                         /* pc_relative */
 343          0,                             /* bitpos */
 344          complain_overflow_dont,        /* complain_on_overflow */
 345          v850_elf_reloc,                /* special_function */
 346          "R_V850_TDA_16_16_OFFSET",     /* name */
 347          false,                         /* partial_inplace */
 348          0xffff,                        /* src_mask */
 349          0xfff,                         /* dst_mask */
 350          false),                        /* pcrel_offset */
 351
 352   /* 5 bit offset from the tiny data area pointer.  */
 353   HOWTO (R_V850_TDA_4_5_OFFSET,         /* type */
 354          1,                             /* rightshift */
 355          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 356          5,                             /* bitsize */
 357          false,                         /* pc_relative */
 358          0,                             /* bitpos */
 359          complain_overflow_dont,        /* complain_on_overflow */
 360          v850_elf_reloc,                /* special_function */
 361          "R_V850_TDA_4_5_OFFSET",       /* name */
 362          false,                         /* partial_inplace */
 363          0x0f,                          /* src_mask */
 364          0x0f,                          /* dst_mask */
 365          false),                        /* pcrel_offset */
 366
 367   /* 4 bit offset from the tiny data area pointer.  */
 368   HOWTO (R_V850_TDA_4_4_OFFSET,         /* type */
 369          0,                             /* rightshift */
 370          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 371          4,                             /* bitsize */
 372          false,                         /* pc_relative */
 373          0,                             /* bitpos */
 374          complain_overflow_dont,        /* complain_on_overflow */
 375          v850_elf_reloc,                /* special_function */
 376          "R_V850_TDA_4_4_OFFSET",       /* name */
 377          false,                         /* partial_inplace */
 378          0x0f,                          /* src_mask */
 379          0x0f,                          /* dst_mask */
 380          false),                        /* pcrel_offset */
 381
 382   /* 16 bit offset from the short data area pointer.  */
 383   HOWTO (R_V850_SDA_16_16_SPLIT_OFFSET, /* type */
 384          0,                             /* rightshift */
 385          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 386          16,                            /* bitsize */
 387          false,                         /* pc_relative */
 388          0,                             /* bitpos */
 389          complain_overflow_dont,        /* complain_on_overflow */
 390          v850_elf_reloc,                /* special_function */
 391          "R_V850_SDA_16_16_SPLIT_OFFSET",/* name */
 392          false,                         /* partial_inplace */
 393          0xfffe0020,                    /* src_mask */
 394          0xfffe0020,                    /* dst_mask */
 395          false),                        /* pcrel_offset */
 396
 397   /* 16 bit offset from the zero data area pointer.  */
 398   HOWTO (R_V850_ZDA_16_16_SPLIT_OFFSET, /* type */
 399          0,                             /* rightshift */
 400          2,                             /* size (0 = byte, 1 = short, 2 = long) */
 401          16,                            /* bitsize */
 402          false,                         /* pc_relative */
 403          0,                             /* bitpos */
 404          complain_overflow_dont,        /* complain_on_overflow */
 405          v850_elf_reloc,                /* special_function */
 406          "R_V850_ZDA_16_16_SPLIT_OFFSET",/* name */
 407          false,                         /* partial_inplace */
 408          0xfffe0020,                    /* src_mask */
 409          0xfffe0020,                    /* dst_mask */
 410          false),                        /* pcrel_offset */
 411
 412   /* 6 bit offset from the call table base pointer.  */
 413   HOWTO (R_V850_CALLT_6_7_OFFSET,       /* type */
 414          0,                             /* rightshift */
 415          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 416          7,                             /* bitsize */
 417          false,                         /* pc_relative */
 418          0,                             /* bitpos */
 419          complain_overflow_dont,        /* complain_on_overflow */
 420          v850_elf_reloc,                /* special_function */
 421          "R_V850_CALLT_6_7_OFFSET",     /* name */
 422          false,                         /* partial_inplace */
 423          0x3f,                          /* src_mask */
 424          0x3f,                          /* dst_mask */
 425          false),                        /* pcrel_offset */
 426
 427   /* 16 bit offset from the call table base pointer.  */
 428   HOWTO (R_V850_CALLT_16_16_OFFSET,     /* type */
 429          0,                             /* rightshift */
 430          1,                             /* size (0 = byte, 1 = short, 2 = long) */
 431          16,                            /* bitsize */
 432          false,                         /* pc_relative */
 433          0,                             /* bitpos */
 434          complain_overflow_dont,        /* complain_on_overflow */
 435          v850_elf_reloc,                /* special_function */
 436          "R_V850_CALLT_16_16_OFFSET",   /* name */
 437          false,                         /* partial_inplace */
 438          0xffff,                        /* src_mask */
 439          0xffff,                        /* dst_mask */
 440          false),                        /* pcrel_offset */
 441
 442   /* GNU extension to record C++ vtable hierarchy */
 443   HOWTO (R_V850_GNU_VTINHERIT, /* type */
 444          0,                     /* rightshift */
 445          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 446          0,                     /* bitsize */
 447          false,                 /* pc_relative */
 448          0,                     /* bitpos */
 449          complain_overflow_dont, /* complain_on_overflow */
 450          NULL,                  /* special_function */
 451          "R_V850_GNU_VTINHERIT", /* name */
 452          false,                 /* partial_inplace */
 453          0,                     /* src_mask */
 454          0,                     /* dst_mask */
 455          false),                /* pcrel_offset */
 456
 457   /* GNU extension to record C++ vtable member usage */
 458   HOWTO (R_V850_GNU_VTENTRY,     /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          0,                     /* bitsize */
 462          false,                 /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_dont, /* complain_on_overflow */
 465          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 466          "R_V850_GNU_VTENTRY",   /* name */
 467          false,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0,                     /* dst_mask */
 470          false),                /* pcrel_offset */
 471
 472 };
 473
 474 /* Map BFD reloc types to V850 ELF reloc types.  */
 475
 476 struct v850_elf_reloc_map
 477 {
 478   /* BFD_RELOC_V850_CALLT_16_16_OFFSET is 258, which will not fix in an
 479      unsigned char.  */
 480   bfd_reloc_code_real_type bfd_reloc_val;
 481   unsigned char elf_reloc_val;
 482 };
 483
 484 static const struct v850_elf_reloc_map v850_elf_reloc_map[] =
 485 {
 486   { BFD_RELOC_NONE,             R_V850_NONE },
 487   { BFD_RELOC_V850_9_PCREL,     R_V850_9_PCREL },
 488   { BFD_RELOC_V850_22_PCREL,    R_V850_22_PCREL },
 489   { BFD_RELOC_HI16_S,           R_V850_HI16_S },
 490   { BFD_RELOC_HI16,             R_V850_HI16 },
 491   { BFD_RELOC_LO16,             R_V850_LO16 },
 492   { BFD_RELOC_32,               R_V850_32 },
 493   { BFD_RELOC_16,               R_V850_16 },
 494   { BFD_RELOC_8,                R_V850_8 },
 495   { BFD_RELOC_V850_SDA_16_16_OFFSET, R_V850_SDA_16_16_OFFSET },
 496   { BFD_RELOC_V850_SDA_15_16_OFFSET, R_V850_SDA_15_16_OFFSET },
 497   { BFD_RELOC_V850_ZDA_16_16_OFFSET, R_V850_ZDA_16_16_OFFSET },
 498   { BFD_RELOC_V850_ZDA_15_16_OFFSET, R_V850_ZDA_15_16_OFFSET },
 499   { BFD_RELOC_V850_TDA_6_8_OFFSET,   R_V850_TDA_6_8_OFFSET   },
 500   { BFD_RELOC_V850_TDA_7_8_OFFSET,   R_V850_TDA_7_8_OFFSET   },
 501   { BFD_RELOC_V850_TDA_7_7_OFFSET,   R_V850_TDA_7_7_OFFSET   },
 502   { BFD_RELOC_V850_TDA_16_16_OFFSET, R_V850_TDA_16_16_OFFSET },
 503   { BFD_RELOC_V850_TDA_4_5_OFFSET,         R_V850_TDA_4_5_OFFSET         },
 504   { BFD_RELOC_V850_TDA_4_4_OFFSET,         R_V850_TDA_4_4_OFFSET         },
 505   { BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, R_V850_SDA_16_16_SPLIT_OFFSET },
 506   { BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, R_V850_ZDA_16_16_SPLIT_OFFSET },
 507   { BFD_RELOC_V850_CALLT_6_7_OFFSET,       R_V850_CALLT_6_7_OFFSET       },
 508   { BFD_RELOC_V850_CALLT_16_16_OFFSET,     R_V850_CALLT_16_16_OFFSET     },
 509   { BFD_RELOC_VTABLE_INHERIT,               R_V850_GNU_VTINHERIT },
 510   { BFD_RELOC_VTABLE_ENTRY,                 R_V850_GNU_VTENTRY },
 511
 512 };
 513 \f
 514 /* Map a bfd relocation into the appropriate howto structure.  */
 515
 516 static reloc_howto_type *
 517 v850_elf_reloc_type_lookup (abfd, code)
 518      bfd *                     abfd ATTRIBUTE_UNUSED;
 519      bfd_reloc_code_real_type  code;
 520 {
 521   unsigned int i;
 522
 523   for (i = ARRAY_SIZE (v850_elf_reloc_map); i --;)
 524     if (v850_elf_reloc_map[i].bfd_reloc_val == code)
 525       {
 526         BFD_ASSERT (v850_elf_howto_table[code].type == v850_elf_reloc_map[i].elf_reloc_val);
 527
 528         return v850_elf_howto_table + code;
 529       }
 530
 531   return NULL;
 532 }
 533 \f
 534 /* Set the howto pointer for an V850 ELF reloc.  */
 535
 536 static void
 537 v850_elf_info_to_howto_rel (abfd, cache_ptr, dst)
 538      bfd *                 abfd ATTRIBUTE_UNUSED;
 539      arelent *             cache_ptr;
 540      Elf32_Internal_Rel *  dst;
 541 {
 542   unsigned int r_type;
 543
 544   r_type = ELF32_R_TYPE (dst->r_info);
 545   BFD_ASSERT (r_type < (unsigned int) R_V850_max);
 546   cache_ptr->howto = &v850_elf_howto_table[r_type];
 547 }
 548
 549 /* Set the howto pointer for a V850 ELF reloc (type RELA).  */
 550 static void
 551 v850_elf_info_to_howto_rela (abfd, cache_ptr, dst)
 552      bfd *                 abfd ATTRIBUTE_UNUSED;
 553      arelent *             cache_ptr;
 554      Elf32_Internal_Rela   *dst;
 555 {
 556   unsigned int r_type;
 557
 558   r_type = ELF32_R_TYPE (dst->r_info);
 559   BFD_ASSERT (r_type < (unsigned int) R_V850_max);
 560   cache_ptr->howto = &v850_elf_howto_table[r_type];
 561 }
 562 \f
 563 /* Look through the relocs for a section during the first phase, and
 564    allocate space in the global offset table or procedure linkage
 565    table.  */
 566
 567 static boolean
 568 v850_elf_check_relocs (abfd, info, sec, relocs)
 569      bfd *                      abfd;
 570      struct bfd_link_info *     info;
 571      asection *                 sec;
 572      const Elf_Internal_Rela *  relocs;
 573 {
 574   boolean ret = true;
 575   bfd *dynobj;
 576   Elf_Internal_Shdr *symtab_hdr;
 577   struct elf_link_hash_entry **sym_hashes;
 578   const Elf_Internal_Rela *rel;
 579   const Elf_Internal_Rela *rel_end;
 580   asection *sreloc;
 581   enum v850_reloc_type r_type;
 582   int other = 0;
 583   const char *common = (const char *)0;
 584
 585   if (info->relocateable)
 586     return true;
 587
 588 #ifdef DEBUG
 589   fprintf (stderr, "v850_elf_check_relocs called for section %s in %s\n",
 590            bfd_get_section_name (abfd, sec),
 591            bfd_get_filename (abfd));
 592 #endif
 593
 594   dynobj = elf_hash_table (info)->dynobj;
 595   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 596   sym_hashes = elf_sym_hashes (abfd);
 597   sreloc = NULL;
 598
 599   rel_end = relocs + sec->reloc_count;
 600   for (rel = relocs; rel < rel_end; rel++)
 601     {
 602       unsigned long r_symndx;
 603       struct elf_link_hash_entry *h;
 604
 605       r_symndx = ELF32_R_SYM (rel->r_info);
 606       if (r_symndx < symtab_hdr->sh_info)
 607         h = NULL;
 608       else
 609         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 610
 611       r_type = (enum v850_reloc_type) ELF32_R_TYPE (rel->r_info);
 612       switch (r_type)
 613         {
 614         default:
 615         case R_V850_NONE:
 616         case R_V850_9_PCREL:
 617         case R_V850_22_PCREL:
 618         case R_V850_HI16_S:
 619         case R_V850_HI16:
 620         case R_V850_LO16:
 621         case R_V850_32:
 622         case R_V850_16:
 623         case R_V850_8:
 624         case R_V850_CALLT_6_7_OFFSET:
 625         case R_V850_CALLT_16_16_OFFSET:
 626           break;
 627
 628         /* This relocation describes the C++ object vtable hierarchy.
 629            Reconstruct it for later use during GC.  */
 630         case R_V850_GNU_VTINHERIT:
 631           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 632             return false;
 633           break;
 634
 635         /* This relocation describes which C++ vtable entries
 636            are actually used.  Record for later use during GC.  */
 637         case R_V850_GNU_VTENTRY:
 638           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 639             return false;
 640           break;
 641
 642         case R_V850_SDA_16_16_SPLIT_OFFSET:
 643         case R_V850_SDA_16_16_OFFSET:
 644         case R_V850_SDA_15_16_OFFSET:
 645           other = V850_OTHER_SDA;
 646           common = ".scommon";
 647           goto small_data_common;
 648
 649         case R_V850_ZDA_16_16_SPLIT_OFFSET:
 650         case R_V850_ZDA_16_16_OFFSET:
 651         case R_V850_ZDA_15_16_OFFSET:
 652           other = V850_OTHER_ZDA;
 653           common = ".zcommon";
 654           goto small_data_common;
 655
 656         case R_V850_TDA_4_5_OFFSET:
 657         case R_V850_TDA_4_4_OFFSET:
 658         case R_V850_TDA_6_8_OFFSET:
 659         case R_V850_TDA_7_8_OFFSET:
 660         case R_V850_TDA_7_7_OFFSET:
 661         case R_V850_TDA_16_16_OFFSET:
 662           other = V850_OTHER_TDA;
 663           common = ".tcommon";
 664           /* fall through */
 665
 666 #define V850_OTHER_MASK (V850_OTHER_TDA | V850_OTHER_SDA | V850_OTHER_ZDA)
 667
 668         small_data_common:
 669           if (h)
 670             {
 671               /* Flag which type of relocation was used.  */
 672               h->other |= other;
 673               if ((h->other & V850_OTHER_MASK) != (other & V850_OTHER_MASK)
 674                   && (h->other & V850_OTHER_ERROR) == 0)
 675                 {
 676                   const char * msg;
 677                   static char  buff[200]; /* XXX */
 678
 679                   switch (h->other & V850_OTHER_MASK)
 680                     {
 681                     default:
 682                       msg = _("Variable `%s' cannot occupy in multiple small data regions");
 683                       break;
 684                     case V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA:
 685                       msg = _("Variable `%s' can only be in one of the small, zero, and tiny data regions");
 686                       break;
 687                     case V850_OTHER_SDA | V850_OTHER_ZDA:
 688                       msg = _("Variable `%s' cannot be in both small and zero data regions simultaneously");
 689                       break;
 690                     case V850_OTHER_SDA | V850_OTHER_TDA:
 691                       msg = _("Variable `%s' cannot be in both small and tiny data regions simultaneously");
 692                       break;
 693                     case V850_OTHER_ZDA | V850_OTHER_TDA:
 694                       msg = _("Variable `%s' cannot be in both zero and tiny data regions simultaneously");
 695                       break;
 696                     }
 697
 698                   sprintf (buff, msg, h->root.root.string);
 699                   info->callbacks->warning (info, buff, h->root.root.string,
 700                                             abfd, h->root.u.def.section, 0);
 701
 702                   bfd_set_error (bfd_error_bad_value);
 703                   h->other |= V850_OTHER_ERROR;
 704                   ret = false;
 705                 }
 706             }
 707
 708           if (h && h->root.type == bfd_link_hash_common
 709               && h->root.u.c.p
 710               && !strcmp (bfd_get_section_name (abfd, h->root.u.c.p->section), "COMMON"))
 711             {
 712               asection * section;
 713
 714               section = h->root.u.c.p->section = bfd_make_section_old_way (abfd, common);
 715               section->flags |= SEC_IS_COMMON;
 716             }
 717
 718 #ifdef DEBUG
 719           fprintf (stderr, "v850_elf_check_relocs, found %s relocation for %s%s\n",
 720                    v850_elf_howto_table[ (int)r_type ].name,
 721                    (h && h->root.root.string) ? h->root.root.string : "<unknown>",
 722                    (h->root.type == bfd_link_hash_common) ? ", symbol is common" : "");
 723 #endif
 724           break;
 725         }
 726     }
 727
 728   return ret;
 729 }
 730
 731 /* In the old version, when an entry was checked out from the table,
 732    it was deleted.  This produced an error if the entry was needed
 733    more than once, as the second attempted retry failed.
 734
 735    In the current version, the entry is not deleted, instead we set
 736    the field 'found' to true.  If a second lookup matches the same
 737    entry, then we know that the hi16s reloc has already been updated
 738    and does not need to be updated a second time.
 739
 740    TODO - TOFIX: If it is possible that we need to restore 2 different
 741    addresses from the same table entry, where the first generates an
 742    overflow, whilst the second do not, then this code will fail.  */
 743
 744 typedef struct hi16s_location
 745 {
 746   bfd_vma       addend;
 747   bfd_byte *    address;
 748   unsigned long counter;
 749   boolean       found;
 750   struct hi16s_location * next;
 751 }
 752 hi16s_location;
 753
 754 static hi16s_location *  previous_hi16s;
 755 static hi16s_location *  free_hi16s;
 756 static unsigned long     hi16s_counter;
 757
 758 static void
 759 remember_hi16s_reloc (abfd, addend, address)
 760      bfd *      abfd;
 761      bfd_vma    addend;
 762      bfd_byte * address;
 763 {
 764   hi16s_location * entry = NULL;
 765
 766   /* Find a free structure.  */
 767   if (free_hi16s == NULL)
 768     free_hi16s = (hi16s_location *) bfd_zalloc (abfd, sizeof (* free_hi16s));
 769
 770   entry      = free_hi16s;
 771   free_hi16s = free_hi16s->next;
 772
 773   entry->addend  = addend;
 774   entry->address = address;
 775   entry->counter = hi16s_counter ++;
 776   entry->found   = false;
 777   entry->next    = previous_hi16s;
 778   previous_hi16s = entry;
 779
 780   /* Cope with wrap around of our counter.  */
 781   if (hi16s_counter == 0)
 782     {
 783       /* XXX - Assume that all counter entries differ only in their low 16 bits.  */
 784       for (entry = previous_hi16s; entry != NULL; entry = entry->next)
 785         entry->counter &= 0xffff;
 786
 787       hi16s_counter = 0x10000;
 788     }
 789
 790   return;
 791 }
 792
 793 static bfd_byte *
 794 find_remembered_hi16s_reloc (addend, already_found)
 795      bfd_vma   addend;
 796      boolean * already_found;
 797 {
 798   hi16s_location * match = NULL;
 799   hi16s_location * entry;
 800   hi16s_location * previous = NULL;
 801   hi16s_location * prev;
 802   bfd_byte *       addr;
 803
 804   /* Search the table.  Record the most recent entry that matches.  */
 805   for (entry = previous_hi16s; entry; entry = entry->next)
 806     {
 807       if (entry->addend == addend
 808           && (match == NULL || match->counter < entry->counter))
 809         {
 810           previous = prev;
 811           match    = entry;
 812         }
 813
 814       prev = entry;
 815     }
 816
 817   if (match == NULL)
 818     return NULL;
 819
 820   /* Extract the address.  */
 821   addr = match->address;
 822
 823   /* Remeber if this entry has already been used before.  */
 824   if (already_found)
 825     * already_found = match->found;
 826
 827   /* Note that this entry has now been used.  */
 828   match->found = true;
 829
 830   return addr;
 831 }
 832
 833 /* FIXME:  The code here probably ought to be removed and the code in reloc.c
 834    allowed to do its  stuff instead.  At least for most of the relocs, anwyay.  */
 835
 836 static bfd_reloc_status_type
 837 v850_elf_perform_relocation (abfd, r_type, addend, address)
 838      bfd *      abfd;
 839      int        r_type;
 840      bfd_vma    addend;
 841      bfd_byte * address;
 842 {
 843   unsigned long insn;
 844   bfd_signed_vma saddend = (bfd_signed_vma) addend;
 845
 846   switch (r_type)
 847     {
 848     default:
 849       /* fprintf (stderr, "reloc type %d not SUPPORTED\n", r_type ); */
 850       return bfd_reloc_notsupported;
 851
 852     case R_V850_32:
 853       bfd_put_32 (abfd, addend, address);
 854       return bfd_reloc_ok;
 855
 856     case R_V850_22_PCREL:
 857       if (saddend > 0x1fffff || saddend < -0x200000)
 858         return bfd_reloc_overflow;
 859
 860       if ((addend % 2) != 0)
 861         return bfd_reloc_dangerous;
 862
 863       insn  = bfd_get_32 (abfd, address);
 864       insn &= ~0xfffe003f;
 865       insn |= (((addend & 0xfffe) << 16) | ((addend & 0x3f0000) >> 16));
 866       bfd_put_32 (abfd, insn, address);
 867       return bfd_reloc_ok;
 868
 869     case R_V850_9_PCREL:
 870       if (saddend > 0xff || saddend < -0x100)
 871         return bfd_reloc_overflow;
 872
 873       if ((addend % 2) != 0)
 874         return bfd_reloc_dangerous;
 875
 876       insn  = bfd_get_16 (abfd, address);
 877       insn &= ~ 0xf870;
 878       insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3);
 879       break;
 880
 881     case R_V850_HI16:
 882       addend += (bfd_get_16 (abfd, address) << 16);
 883       addend = (addend >> 16);
 884       insn = addend;
 885       break;
 886
 887     case R_V850_HI16_S:
 888       /* Remember where this relocation took place.  */
 889       remember_hi16s_reloc (abfd, addend, address);
 890
 891       addend += (bfd_get_16 (abfd, address) << 16);
 892       addend = (addend >> 16) + ((addend & 0x8000) != 0);
 893
 894       /* This relocation cannot overflow.  */
 895       if (addend > 0x7fff)
 896         addend = 0;
 897
 898       insn = addend;
 899       break;
 900
 901     case R_V850_LO16:
 902       /* Calculate the sum of the value stored in the instruction and the
 903          addend and check for overflow from the low 16 bits into the high
 904          16 bits.  The assembler has already done some of this:  If the
 905          value stored in the instruction has its 15th bit set, (counting
 906          from zero) then the assembler will have added 1 to the value
 907          stored in the associated HI16S reloc.  So for example, these
 908          relocations:
 909
 910              movhi hi( fred ), r0, r1
 911              movea lo( fred ), r1, r1
 912
 913          will store 0 in the value fields for the MOVHI and MOVEA instructions
 914          and addend will be the address of fred, but for these instructions:
 915
 916              movhi hi( fred + 0x123456), r0, r1
 917              movea lo( fred + 0x123456), r1, r1
 918
 919          the value stored in the MOVHI instruction will be 0x12 and the value
 920          stored in the MOVEA instruction will be 0x3456.  If however the
 921          instructions were:
 922
 923              movhi hi( fred + 0x10ffff), r0, r1
 924              movea lo( fred + 0x10ffff), r1, r1
 925
 926          then the value stored in the MOVHI instruction would be 0x11 (not
 927          0x10) and the value stored in the MOVEA instruction would be 0xffff.
 928          Thus (assuming for the moment that the addend is 0), at run time the
 929          MOVHI instruction loads 0x110000 into r1, then the MOVEA instruction
 930          adds 0xffffffff (sign extension!) producing 0x10ffff.  Similarly if
 931          the instructions were:
 932
 933              movhi hi( fred - 1), r0, r1
 934              movea lo( fred - 1), r1, r1
 935
 936          then 0 is stored in the MOVHI instruction and -1 is stored in the
 937          MOVEA instruction.
 938
 939          Overflow can occur if the addition of the value stored in the
 940          instruction plus the addend sets the 15th bit when before it was clear.
 941          This is because the 15th bit will be sign extended into the high part,
 942          thus reducing its value by one, but since the 15th bit was originally
 943          clear, the assembler will not have added 1 to the previous HI16S reloc
 944          to compensate for this effect.  For example:
 945
 946             movhi hi( fred + 0x123456), r0, r1
 947             movea lo( fred + 0x123456), r1, r1
 948
 949          The value stored in HI16S reloc is 0x12, the value stored in the LO16
 950          reloc is 0x3456.  If we assume that the address of fred is 0x00007000
 951          then the relocations become:
 952
 953            HI16S: 0x0012 + (0x00007000 >> 16)    = 0x12
 954            LO16:  0x3456 + (0x00007000 & 0xffff) = 0xa456
 955
 956          but when the instructions are executed, the MOVEA instruction's value
 957          is signed extended, so the sum becomes:
 958
 959               0x00120000
 960             + 0xffffa456
 961             ------------
 962               0x0011a456    but 'fred + 0x123456' = 0x0012a456
 963
 964          Note that if the 15th bit was set in the value stored in the LO16
 965          reloc, then we do not have to do anything:
 966
 967             movhi hi( fred + 0x10ffff), r0, r1
 968             movea lo( fred + 0x10ffff), r1, r1
 969
 970             HI16S:  0x0011 + (0x00007000 >> 16)    = 0x11
 971             LO16:   0xffff + (0x00007000 & 0xffff) = 0x6fff
 972
 973               0x00110000
 974             + 0x00006fff
 975             ------------
 976               0x00116fff  = fred + 0x10ffff = 0x7000 + 0x10ffff
 977
 978          Overflow can also occur if the computation carries into the 16th bit
 979          and it also results in the 15th bit having the same value as the 15th
 980          bit of the original value.   What happens is that the HI16S reloc
 981          will have already examined the 15th bit of the original value and
 982          added 1 to the high part if the bit is set.  This compensates for the
 983          sign extension of 15th bit of the result of the computation.  But now
 984          there is a carry into the 16th bit, and this has not been allowed for.
 985
 986          So, for example if fred is at address 0xf000:
 987
 988            movhi hi( fred + 0xffff), r0, r1    [bit 15 of the offset is set]
 989            movea lo( fred + 0xffff), r1, r1
 990
 991            HI16S: 0x0001 + (0x0000f000 >> 16)    = 0x0001
 992            LO16:  0xffff + (0x0000f000 & 0xffff) = 0xefff   (carry into bit 16 is lost)
 993
 994              0x00010000
 995            + 0xffffefff
 996            ------------
 997              0x0000efff   but 'fred + 0xffff' = 0x0001efff
 998
 999          Similarly, if the 15th bit remains clear, but overflow occurs into
1000          the 16th bit then (assuming the address of fred is 0xf000):
1001
1002            movhi hi( fred + 0x7000), r0, r1    [bit 15 of the offset is clear]
1003            movea lo( fred + 0x7000), r1, r1
1004
1005            HI16S: 0x0000 + (0x0000f000 >> 16)    = 0x0000
1006            LO16:  0x7000 + (0x0000f000 & 0xffff) = 0x6fff  (carry into bit 16 is lost)
1007
1008              0x00000000
1009            + 0x00006fff
1010            ------------
1011              0x00006fff   but 'fred + 0x7000' = 0x00016fff
1012
1013          Note - there is no need to change anything if a carry occurs, and the
1014          15th bit changes its value from being set to being clear, as the HI16S
1015          reloc will have already added in 1 to the high part for us:
1016
1017            movhi hi( fred + 0xffff), r0, r1     [bit 15 of the offset is set]
1018            movea lo( fred + 0xffff), r1, r1
1019
1020            HI16S: 0x0001 + (0x00007000 >> 16)
1021            LO16:  0xffff + (0x00007000 & 0xffff) = 0x6fff  (carry into bit 16 is lost)
1022
1023              0x00010000
1024            + 0x00006fff   (bit 15 not set, so the top half is zero)
1025            ------------
1026              0x00016fff   which is right (assuming that fred is at 0x7000)
1027
1028          but if the 15th bit goes from being clear to being set, then we must
1029          once again handle overflow:
1030
1031            movhi hi( fred + 0x7000), r0, r1     [bit 15 of the offset is clear]
1032            movea lo( fred + 0x7000), r1, r1
1033
1034            HI16S: 0x0000 + (0x0000ffff >> 16)
1035            LO16:  0x7000 + (0x0000ffff & 0xffff) = 0x6fff  (carry into bit 16)
1036
1037              0x00000000
1038            + 0x00006fff   (bit 15 not set, so the top half is zero)
1039            ------------
1040              0x00006fff   which is wrong (assuming that fred is at 0xffff).  */
1041       {
1042         long result;
1043
1044         insn   = bfd_get_16 (abfd, address);
1045         result = insn + addend;
1046
1047 #define BIT15_SET(x) ((x) & 0x8000)
1048 #define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff)
1049
1050         if ((BIT15_SET (result) && ! BIT15_SET (addend))
1051             || (OVERFLOWS (addend, insn)
1052                 && ((! BIT15_SET (insn)) || (BIT15_SET (addend)))))
1053           {
1054             boolean already_updated;
1055             bfd_byte * hi16s_address = find_remembered_hi16s_reloc
1056               (addend, & already_updated);
1057
1058             /* Amend the matching HI16_S relocation.  */
1059             if (hi16s_address != NULL)
1060               {
1061                 if (! already_updated)
1062                   {
1063                     insn = bfd_get_16 (abfd, hi16s_address);
1064                     insn += 1;
1065                     bfd_put_16 (abfd, insn, hi16s_address);
1066                   }
1067               }
1068             else
1069               {
1070                 fprintf (stderr, _("FAILED to find previous HI16 reloc\n"));
1071                 return bfd_reloc_overflow;
1072               }
1073           }
1074
1075         /* Do not complain if value has top bit set, as this has been anticipated.  */
1076         insn = result & 0xffff;
1077         break;
1078       }
1079
1080     case R_V850_8:
1081       addend += (char) bfd_get_8 (abfd, address);
1082
1083       saddend = (bfd_signed_vma) addend;
1084
1085       if (saddend > 0x7f || saddend < -0x80)
1086         return bfd_reloc_overflow;
1087
1088       bfd_put_8 (abfd, addend, address);
1089       return bfd_reloc_ok;
1090
1091     case R_V850_CALLT_16_16_OFFSET:
1092       addend += bfd_get_16 (abfd, address);
1093
1094       saddend = (bfd_signed_vma) addend;
1095
1096       if (saddend > 0xffff || saddend < 0)
1097         return bfd_reloc_overflow;
1098
1099       insn = addend;
1100       break;
1101
1102     case R_V850_16:
1103
1104       /* drop through */
1105     case R_V850_SDA_16_16_OFFSET:
1106     case R_V850_ZDA_16_16_OFFSET:
1107     case R_V850_TDA_16_16_OFFSET:
1108       addend += bfd_get_16 (abfd, address);
1109
1110       saddend = (bfd_signed_vma) addend;
1111
1112       if (saddend > 0x7fff || saddend < -0x8000)
1113         return bfd_reloc_overflow;
1114
1115       insn = addend;
1116       break;
1117
1118     case R_V850_SDA_15_16_OFFSET:
1119     case R_V850_ZDA_15_16_OFFSET:
1120       insn = bfd_get_16 (abfd, address);
1121       addend += (insn & 0xfffe);
1122
1123       saddend = (bfd_signed_vma) addend;
1124
1125       if (saddend > 0x7ffe || saddend < -0x8000)
1126         return bfd_reloc_overflow;
1127
1128       if (addend & 1)
1129         return bfd_reloc_dangerous;
1130
1131       insn = (addend & ~1) | (insn & 1);
1132       break;
1133
1134     case R_V850_TDA_6_8_OFFSET:
1135       insn = bfd_get_16 (abfd, address);
1136       addend += ((insn & 0x7e) << 1);
1137
1138       saddend = (bfd_signed_vma) addend;
1139
1140       if (saddend > 0xfc || saddend < 0)
1141         return bfd_reloc_overflow;
1142
1143       if (addend & 3)
1144         return bfd_reloc_dangerous;
1145
1146       insn &= 0xff81;
1147       insn |= (addend >> 1);
1148       break;
1149
1150     case R_V850_TDA_7_8_OFFSET:
1151       insn = bfd_get_16 (abfd, address);
1152       addend += ((insn & 0x7f) << 1);
1153
1154       saddend = (bfd_signed_vma) addend;
1155
1156       if (saddend > 0xfe || saddend < 0)
1157         return bfd_reloc_overflow;
1158
1159       if (addend & 1)
1160         return bfd_reloc_dangerous;
1161
1162       insn &= 0xff80;
1163       insn |= (addend >> 1);
1164       break;
1165
1166     case R_V850_TDA_7_7_OFFSET:
1167       insn = bfd_get_16 (abfd, address);
1168       addend += insn & 0x7f;
1169
1170       saddend = (bfd_signed_vma) addend;
1171
1172       if (saddend > 0x7f || saddend < 0)
1173         return bfd_reloc_overflow;
1174
1175       insn &= 0xff80;
1176       insn |= addend;
1177       break;
1178
1179     case R_V850_TDA_4_5_OFFSET:
1180       insn = bfd_get_16 (abfd, address);
1181       addend += ((insn & 0xf) << 1);
1182
1183       saddend = (bfd_signed_vma) addend;
1184
1185       if (saddend > 0x1e || saddend < 0)
1186         return bfd_reloc_overflow;
1187
1188       if (addend & 1)
1189         return bfd_reloc_dangerous;
1190
1191       insn &= 0xfff0;
1192       insn |= (addend >> 1);
1193       break;
1194
1195     case R_V850_TDA_4_4_OFFSET:
1196       insn = bfd_get_16 (abfd, address);
1197       addend += insn & 0xf;
1198
1199       saddend = (bfd_signed_vma) addend;
1200
1201       if (saddend > 0xf || saddend < 0)
1202         return bfd_reloc_overflow;
1203
1204       insn &= 0xfff0;
1205       insn |= addend;
1206       break;
1207
1208     case R_V850_ZDA_16_16_SPLIT_OFFSET:
1209     case R_V850_SDA_16_16_SPLIT_OFFSET:
1210       insn = bfd_get_32 (abfd, address);
1211       addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5);
1212
1213       saddend = (bfd_signed_vma) addend;
1214
1215       if (saddend > 0x7fff || saddend < -0x8000)
1216         return bfd_reloc_overflow;
1217
1218       insn &= 0x0001ffdf;
1219       insn |= (addend & 1) << 5;
1220       insn |= (addend & ~1) << 16;
1221
1222       bfd_put_32 (abfd, insn, address);
1223       return bfd_reloc_ok;
1224
1225     case R_V850_CALLT_6_7_OFFSET:
1226       insn = bfd_get_16 (abfd, address);
1227       addend += ((insn & 0x3f) << 1);
1228
1229       saddend = (bfd_signed_vma) addend;
1230
1231       if (saddend > 0x7e || saddend < 0)
1232         return bfd_reloc_overflow;
1233
1234       if (addend & 1)
1235         return bfd_reloc_dangerous;
1236
1237       insn &= 0xff80;
1238       insn |= (addend >> 1);
1239       break;
1240
1241     case R_V850_GNU_VTINHERIT:
1242     case R_V850_GNU_VTENTRY:
1243       return bfd_reloc_ok;
1244
1245     }
1246
1247   bfd_put_16 (abfd, insn, address);
1248   return bfd_reloc_ok;
1249 }
1250 \f
1251 /* Insert the addend into the instruction.  */
1252
1253 static bfd_reloc_status_type
1254 v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
1255      bfd *       abfd ATTRIBUTE_UNUSED;
1256      arelent *   reloc;
1257      asymbol *   symbol;
1258      PTR         data ATTRIBUTE_UNUSED;
1259      asection *  isection;
1260      bfd *       obfd;
1261      char **     err ATTRIBUTE_UNUSED;
1262 {
1263   long relocation;
1264
1265   /* If there is an output BFD,
1266      and the symbol is not a section name (which is only defined at final link time),
1267      and either we are not putting the addend into the instruction
1268       or the addend is zero, so there is nothing to add into the instruction
1269      then just fixup the address and return.  */
1270   if (obfd != (bfd *) NULL
1271       && (symbol->flags & BSF_SECTION_SYM) == 0
1272       && (! reloc->howto->partial_inplace
1273           || reloc->addend == 0))
1274     {
1275       reloc->address += isection->output_offset;
1276       return bfd_reloc_ok;
1277     }
1278 #if 0
1279   else if (obfd != NULL)
1280     return bfd_reloc_continue;
1281 #endif
1282
1283   /* Catch relocs involving undefined symbols.  */
1284   if (bfd_is_und_section (symbol->section)
1285       && (symbol->flags & BSF_WEAK) == 0
1286       && obfd == NULL)
1287     return bfd_reloc_undefined;
1288
1289   /* We handle final linking of some relocs ourselves.  */
1290
1291   /* Is the address of the relocation really within the section?  */
1292   if (reloc->address > isection->_cooked_size)
1293     return bfd_reloc_outofrange;
1294
1295   /* Work out which section the relocation is targetted at and the
1296      initial relocation command value.  */
1297
1298   /* Get symbol value.  (Common symbols are special.)  */
1299   if (bfd_is_com_section (symbol->section))
1300     relocation = 0;
1301   else
1302     relocation = symbol->value;
1303
1304   /* Convert input-section-relative symbol value to absolute + addend.  */
1305   relocation += symbol->section->output_section->vma;
1306   relocation += symbol->section->output_offset;
1307   relocation += reloc->addend;
1308
1309 #if 0 /* Since this reloc is going to be processed later on, we should
1310          not make it pc-relative here.  To test this, try assembling and
1311          linking this program:
1312
1313                 .text
1314                 .globl _start
1315                 nop
1316         _start:
1317                 jr foo
1318
1319                 .section ".foo","ax"
1320                 nop
1321         foo:
1322                 nop      */
1323   if (reloc->howto->pc_relative == true)
1324     {
1325       /* Here the variable relocation holds the final address of the
1326          symbol we are relocating against, plus any addend.  */
1327       relocation -= isection->output_section->vma + isection->output_offset;
1328
1329       /* Deal with pcrel_offset.  */
1330       relocation -= reloc->address;
1331     }
1332 #endif
1333   reloc->addend = relocation;
1334   return bfd_reloc_ok;
1335 }
1336 \f
1337 static boolean
1338 v850_elf_is_local_label_name (abfd, name)
1339      bfd *         abfd ATTRIBUTE_UNUSED;
1340      const char *  name;
1341 {
1342   return (   (name[0] == '.' && (name[1] == 'L' || name[1] == '.'))
1343           || (name[0] == '_' &&  name[1] == '.' && name[2] == 'L' && name[3] == '_'));
1344 }
1345 \f
1346 /* Perform a relocation as part of a final link.  */
1347
1348 static bfd_reloc_status_type
1349 v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1350                                     input_section, contents, offset, value,
1351                                     addend, info, sym_sec, is_local)
1352      reloc_howto_type *      howto;
1353      bfd *                   input_bfd;
1354      bfd *                   output_bfd ATTRIBUTE_UNUSED;
1355      asection *              input_section;
1356      bfd_byte *              contents;
1357      bfd_vma                 offset;
1358      bfd_vma                 value;
1359      bfd_vma                 addend;
1360      struct bfd_link_info *  info;
1361      asection *              sym_sec;
1362      int                     is_local ATTRIBUTE_UNUSED;
1363 {
1364   unsigned long  r_type   = howto->type;
1365   bfd_byte *     hit_data = contents + offset;
1366
1367   /* Adjust the value according to the relocation.  */
1368   switch (r_type)
1369     {
1370     case R_V850_9_PCREL:
1371       value -= (input_section->output_section->vma
1372                 + input_section->output_offset);
1373       value -= offset;
1374       break;
1375
1376     case R_V850_22_PCREL:
1377       value -= (input_section->output_section->vma
1378                 + input_section->output_offset
1379                 + offset);
1380
1381       /* If the sign extension will corrupt the value then we have overflowed.  */
1382       if (((value & 0xff000000) != 0x0) && ((value & 0xff000000) != 0xff000000))
1383         return bfd_reloc_overflow;
1384
1385       /* Only the bottom 24 bits of the PC are valid */
1386       value = SEXT24 (value);
1387       break;
1388
1389     case R_V850_HI16_S:
1390     case R_V850_HI16:
1391     case R_V850_LO16:
1392     case R_V850_16:
1393     case R_V850_32:
1394     case R_V850_8:
1395       break;
1396
1397     case R_V850_ZDA_15_16_OFFSET:
1398     case R_V850_ZDA_16_16_OFFSET:
1399     case R_V850_ZDA_16_16_SPLIT_OFFSET:
1400       if (sym_sec == NULL)
1401         return bfd_reloc_undefined;
1402
1403       value -= sym_sec->output_section->vma;
1404       break;
1405
1406     case R_V850_SDA_15_16_OFFSET:
1407     case R_V850_SDA_16_16_OFFSET:
1408     case R_V850_SDA_16_16_SPLIT_OFFSET:
1409       {
1410         unsigned long                gp;
1411         struct bfd_link_hash_entry * h;
1412
1413         if (sym_sec == NULL)
1414           return bfd_reloc_undefined;
1415
1416         /* Get the value of __gp.  */
1417         h = bfd_link_hash_lookup (info->hash, "__gp", false, false, true);
1418         if (h == (struct bfd_link_hash_entry *) NULL
1419             || h->type != bfd_link_hash_defined)
1420           return bfd_reloc_other;
1421
1422         gp = (h->u.def.value
1423               + h->u.def.section->output_section->vma
1424               + h->u.def.section->output_offset);
1425
1426         value -= sym_sec->output_section->vma;
1427         value -= (gp - sym_sec->output_section->vma);
1428       }
1429     break;
1430
1431     case R_V850_TDA_4_4_OFFSET:
1432     case R_V850_TDA_4_5_OFFSET:
1433     case R_V850_TDA_16_16_OFFSET:
1434     case R_V850_TDA_7_7_OFFSET:
1435     case R_V850_TDA_7_8_OFFSET:
1436     case R_V850_TDA_6_8_OFFSET:
1437       {
1438         unsigned long                ep;
1439         struct bfd_link_hash_entry * h;
1440
1441         /* Get the value of __ep.  */
1442         h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1443         if (h == (struct bfd_link_hash_entry *) NULL
1444             || h->type != bfd_link_hash_defined)
1445           /* Actually this indicates that __ep could not be found.  */
1446           return bfd_reloc_continue;
1447
1448         ep = (h->u.def.value
1449               + h->u.def.section->output_section->vma
1450               + h->u.def.section->output_offset);
1451
1452         value -= ep;
1453       }
1454     break;
1455
1456     case R_V850_CALLT_6_7_OFFSET:
1457       {
1458         unsigned long                ctbp;
1459         struct bfd_link_hash_entry * h;
1460
1461         /* Get the value of __ctbp.  */
1462         h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
1463         if (h == (struct bfd_link_hash_entry *) NULL
1464             || h->type != bfd_link_hash_defined)
1465           /* Actually this indicates that __ctbp could not be found.  */
1466           return bfd_reloc_dangerous + 1;
1467
1468         ctbp = (h->u.def.value
1469               + h->u.def.section->output_section->vma
1470               + h->u.def.section->output_offset);
1471         value -= ctbp;
1472       }
1473     break;
1474
1475     case R_V850_CALLT_16_16_OFFSET:
1476       {
1477         unsigned long                ctbp;
1478         struct bfd_link_hash_entry * h;
1479
1480         if (sym_sec == NULL)
1481           return bfd_reloc_undefined;
1482
1483         /* Get the value of __ctbp.  */
1484         h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
1485         if (h == (struct bfd_link_hash_entry *) NULL
1486             || h->type != bfd_link_hash_defined)
1487           return (bfd_reloc_dangerous + 1);
1488
1489         ctbp = (h->u.def.value
1490               + h->u.def.section->output_section->vma
1491               + h->u.def.section->output_offset);
1492
1493         value -= sym_sec->output_section->vma;
1494         value -= (ctbp - sym_sec->output_section->vma);
1495       }
1496     break;
1497
1498     case R_V850_NONE:
1499     case R_V850_GNU_VTINHERIT:
1500     case R_V850_GNU_VTENTRY:
1501       return bfd_reloc_ok;
1502
1503     default:
1504       return bfd_reloc_notsupported;
1505     }
1506
1507   /* Perform the relocation.  */
1508   return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
1509 }
1510 \f
1511 /* Relocate an V850 ELF section.  */
1512
1513 static boolean
1514 v850_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1515                            contents, relocs, local_syms, local_sections)
1516      bfd *                  output_bfd;
1517      struct bfd_link_info * info;
1518      bfd *                  input_bfd;
1519      asection *             input_section;
1520      bfd_byte *             contents;
1521      Elf_Internal_Rela *    relocs;
1522      Elf_Internal_Sym *     local_syms;
1523      asection **            local_sections;
1524 {
1525   Elf_Internal_Shdr *           symtab_hdr;
1526   struct elf_link_hash_entry ** sym_hashes;
1527   Elf_Internal_Rela *           rel;
1528   Elf_Internal_Rela *           relend;
1529
1530   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1531   sym_hashes = elf_sym_hashes (input_bfd);
1532
1533   if (sym_hashes == NULL)
1534     {
1535       info->callbacks->warning
1536         (info, "no hash table available", NULL, input_bfd, input_section, 0);
1537
1538       return false;
1539     }
1540
1541   /* Reset the list of remembered HI16S relocs to empty.  */
1542   free_hi16s     = previous_hi16s;
1543   previous_hi16s = NULL;
1544   hi16s_counter  = 0;
1545
1546   rel    = relocs;
1547   relend = relocs + input_section->reloc_count;
1548   for (; rel < relend; rel++)
1549     {
1550       int                          r_type;
1551       reloc_howto_type *           howto;
1552       unsigned long                r_symndx;
1553       Elf_Internal_Sym *           sym;
1554       asection *                   sec;
1555       struct elf_link_hash_entry * h;
1556       bfd_vma                      relocation;
1557       bfd_reloc_status_type        r;
1558
1559       r_symndx = ELF32_R_SYM (rel->r_info);
1560       r_type   = ELF32_R_TYPE (rel->r_info);
1561
1562       if (r_type == R_V850_GNU_VTENTRY
1563           || r_type == R_V850_GNU_VTINHERIT)
1564         continue;
1565
1566       howto = v850_elf_howto_table + r_type;
1567
1568       if (info->relocateable)
1569         {
1570           /* This is a relocateable link.  We don't have to change
1571              anything, unless the reloc is against a section symbol,
1572              in which case we have to adjust according to where the
1573              section symbol winds up in the output section.  */
1574           if (r_symndx < symtab_hdr->sh_info)
1575             {
1576               sym = local_syms + r_symndx;
1577               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1578                 {
1579                   sec = local_sections[r_symndx];
1580                   rel->r_addend += sec->output_offset + sym->st_value;
1581                 }
1582             }
1583
1584           continue;
1585         }
1586
1587       /* This is a final link.  */
1588       h = NULL;
1589       sym = NULL;
1590       sec = NULL;
1591       if (r_symndx < symtab_hdr->sh_info)
1592         {
1593           sym = local_syms + r_symndx;
1594           sec = local_sections[r_symndx];
1595           relocation = (sec->output_section->vma
1596                         + sec->output_offset
1597                         + sym->st_value);
1598 #if 0
1599           {
1600             char * name;
1601
1602             name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name);
1603             name = (name == NULL) ? "<none>" : name;
1604             fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
1605                      sec->name, name, sym->st_name,
1606                      sec->output_section->vma, sec->output_offset, sym->st_value, rel->r_addend);
1607           }
1608 #endif
1609         }
1610       else
1611         {
1612           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1613
1614           while (h->root.type == bfd_link_hash_indirect
1615                  || h->root.type == bfd_link_hash_warning)
1616             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1617
1618           if (h->root.type == bfd_link_hash_defined
1619               || h->root.type == bfd_link_hash_defweak)
1620             {
1621               sec = h->root.u.def.section;
1622               relocation = (h->root.u.def.value
1623                             + sec->output_section->vma
1624                             + sec->output_offset);
1625 #if 0
1626               fprintf (stderr, "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
1627                        sec->name, h->root.root.string, h->root.u.def.value, sec->output_section->vma, sec->output_offset, relocation);
1628 #endif
1629             }
1630           else if (h->root.type == bfd_link_hash_undefweak)
1631             {
1632 #if 0
1633               fprintf (stderr, "undefined: sec: %s, name: %s\n",
1634                        sec->name, h->root.root.string);
1635 #endif
1636               relocation = 0;
1637             }
1638           else
1639             {
1640               if (! ((*info->callbacks->undefined_symbol)
1641                      (info, h->root.root.string, input_bfd,
1642                       input_section, rel->r_offset, true)))
1643                 return false;
1644 #if 0
1645               fprintf (stderr, "unknown: name: %s\n", h->root.root.string);
1646 #endif
1647               relocation = 0;
1648             }
1649         }
1650
1651       /* FIXME: We should use the addend, but the COFF relocations don't.  */
1652       r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1653                                         input_section,
1654                                         contents, rel->r_offset,
1655                                         relocation, rel->r_addend,
1656                                         info, sec, h == NULL);
1657
1658       if (r != bfd_reloc_ok)
1659         {
1660           const char * name;
1661           const char * msg = (const char *)0;
1662
1663           if (h != NULL)
1664             name = h->root.root.string;
1665           else
1666             {
1667               name = (bfd_elf_string_from_elf_section
1668                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1669               if (name == NULL || *name == '\0')
1670                 name = bfd_section_name (input_bfd, sec);
1671             }
1672
1673           switch (r)
1674             {
1675             case bfd_reloc_overflow:
1676               if (! ((*info->callbacks->reloc_overflow)
1677                      (info, name, howto->name, (bfd_vma) 0,
1678                       input_bfd, input_section, rel->r_offset)))
1679                 return false;
1680               break;
1681
1682             case bfd_reloc_undefined:
1683               if (! ((*info->callbacks->undefined_symbol)
1684                      (info, name, input_bfd, input_section,
1685                       rel->r_offset, true)))
1686                 return false;
1687               break;
1688
1689             case bfd_reloc_outofrange:
1690               msg = _("internal error: out of range error");
1691               goto common_error;
1692
1693             case bfd_reloc_notsupported:
1694               msg = _("internal error: unsupported relocation error");
1695               goto common_error;
1696
1697             case bfd_reloc_dangerous:
1698               msg = _("internal error: dangerous relocation");
1699               goto common_error;
1700
1701             case bfd_reloc_other:
1702               msg = _("could not locate special linker symbol __gp");
1703               goto common_error;
1704
1705             case bfd_reloc_continue:
1706               msg = _("could not locate special linker symbol __ep");
1707               goto common_error;
1708
1709             case (bfd_reloc_dangerous + 1):
1710               msg = _("could not locate special linker symbol __ctbp");
1711               goto common_error;
1712
1713             default:
1714               msg = _("internal error: unknown error");
1715               /* fall through */
1716
1717             common_error:
1718               if (!((*info->callbacks->warning)
1719                     (info, msg, name, input_bfd, input_section,
1720                      rel->r_offset)))
1721                 return false;
1722               break;
1723             }
1724         }
1725     }
1726
1727   return true;
1728 }
1729
1730 static boolean
1731 v850_elf_gc_sweep_hook (abfd, info, sec, relocs)
1732      bfd *abfd ATTRIBUTE_UNUSED;
1733      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1734      asection *sec ATTRIBUTE_UNUSED;
1735      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
1736 {
1737   /* No got and plt entries for v850-elf.  */
1738   return true;
1739 }
1740
1741 static asection *
1742 v850_elf_gc_mark_hook (abfd, info, rel, h, sym)
1743        bfd *abfd;
1744        struct bfd_link_info *info ATTRIBUTE_UNUSED;
1745        Elf_Internal_Rela *rel;
1746        struct elf_link_hash_entry *h;
1747        Elf_Internal_Sym *sym;
1748 {
1749   if (h != NULL)
1750     {
1751       switch (ELF32_R_TYPE (rel->r_info))
1752       {
1753       case R_V850_GNU_VTINHERIT:
1754       case R_V850_GNU_VTENTRY:
1755         break;
1756
1757       default:
1758         switch (h->root.type)
1759           {
1760           case bfd_link_hash_defined:
1761           case bfd_link_hash_defweak:
1762             return h->root.u.def.section;
1763
1764           case bfd_link_hash_common:
1765             return h->root.u.c.p->section;
1766
1767           default:
1768             break;
1769           }
1770        }
1771      }
1772    else
1773      {
1774        if (!(elf_bad_symtab (abfd)
1775            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1776          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1777                 && sym->st_shndx != SHN_COMMON))
1778           {
1779             return bfd_section_from_elf_index (abfd, sym->st_shndx);
1780           }
1781       }
1782   return NULL;
1783 }
1784
1785 /* Set the right machine number.  */
1786
1787 static boolean
1788 v850_elf_object_p (abfd)
1789      bfd *abfd;
1790 {
1791   switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1792     {
1793     default:
1794     case E_V850_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, 0); break;
1795     case E_V850E_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e); break;
1796     case E_V850EA_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850ea); break;
1797     }
1798   return true;
1799 }
1800
1801 /* Store the machine number in the flags field.  */
1802
1803 static void
1804 v850_elf_final_write_processing (abfd, linker)
1805      bfd *   abfd;
1806      boolean linker ATTRIBUTE_UNUSED;
1807 {
1808   unsigned long val;
1809
1810   switch (bfd_get_mach (abfd))
1811     {
1812     default:
1813     case 0: val = E_V850_ARCH; break;
1814     case bfd_mach_v850e:  val = E_V850E_ARCH; break;
1815     case bfd_mach_v850ea: val = E_V850EA_ARCH;  break;
1816     }
1817
1818   elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH;
1819   elf_elfheader (abfd)->e_flags |= val;
1820 }
1821
1822 /* Function to keep V850 specific file flags.  */
1823
1824 static boolean
1825 v850_elf_set_private_flags (abfd, flags)
1826      bfd *    abfd;
1827      flagword flags;
1828 {
1829   BFD_ASSERT (!elf_flags_init (abfd)
1830               || elf_elfheader (abfd)->e_flags == flags);
1831
1832   elf_elfheader (abfd)->e_flags = flags;
1833   elf_flags_init (abfd) = true;
1834   return true;
1835 }
1836
1837 /* Copy backend specific data from one object module to another.  */
1838
1839 static boolean
1840 v850_elf_copy_private_bfd_data (ibfd, obfd)
1841      bfd * ibfd;
1842      bfd * obfd;
1843 {
1844   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1845       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1846     return true;
1847
1848   BFD_ASSERT (!elf_flags_init (obfd)
1849               || (elf_elfheader (obfd)->e_flags
1850                   == elf_elfheader (ibfd)->e_flags));
1851
1852   elf_gp (obfd) = elf_gp (ibfd);
1853   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1854   elf_flags_init (obfd) = true;
1855
1856   return true;
1857 }
1858
1859 /* Merge backend specific data from an object file
1860    to the output object file when linking.  */
1861 static boolean
1862 v850_elf_merge_private_bfd_data (ibfd, obfd)
1863      bfd * ibfd;
1864      bfd * obfd;
1865 {
1866   flagword out_flags;
1867   flagword in_flags;
1868
1869   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1870       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1871     return true;
1872
1873   in_flags = elf_elfheader (ibfd)->e_flags;
1874   out_flags = elf_elfheader (obfd)->e_flags;
1875
1876   if (! elf_flags_init (obfd))
1877     {
1878       /* If the input is the default architecture then do not
1879          bother setting the flags for the output architecture,
1880          instead allow future merges to do this.  If no future
1881          merges ever set these flags then they will retain their
1882          unitialised values, which surprise surprise, correspond
1883          to the default values.  */
1884       if (bfd_get_arch_info (ibfd)->the_default)
1885         return true;
1886
1887       elf_flags_init (obfd) = true;
1888       elf_elfheader (obfd)->e_flags = in_flags;
1889
1890       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1891           && bfd_get_arch_info (obfd)->the_default)
1892         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1893
1894       return true;
1895     }
1896
1897   /* Check flag compatibility.  */
1898   if (in_flags == out_flags)
1899     return true;
1900
1901   if ((in_flags & EF_V850_ARCH) != (out_flags & EF_V850_ARCH)
1902       && (in_flags & EF_V850_ARCH) != E_V850_ARCH)
1903     _bfd_error_handler (_("%s: Architecture mismatch with previous modules"),
1904                         bfd_get_filename (ibfd));
1905
1906   return true;
1907 }
1908
1909 /* Display the flags field.  */
1910
1911 static boolean
1912 v850_elf_print_private_bfd_data (abfd, ptr)
1913      bfd *   abfd;
1914      PTR     ptr;
1915 {
1916   FILE * file = (FILE *) ptr;
1917
1918   BFD_ASSERT (abfd != NULL && ptr != NULL);
1919
1920   _bfd_elf_print_private_bfd_data (abfd, ptr);
1921
1922   /* xgettext:c-format */
1923   fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags);
1924
1925   switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1926     {
1927     default:
1928     case E_V850_ARCH: fprintf (file, _("v850 architecture")); break;
1929     case E_V850E_ARCH:  fprintf (file, _("v850e architecture")); break;
1930     case E_V850EA_ARCH: fprintf (file, _("v850ea architecture")); break;
1931     }
1932
1933   fputc ('\n', file);
1934
1935   return true;
1936 }
1937
1938 /* V850 ELF uses four common sections.  One is the usual one, and the
1939    others are for (small) objects in one of the special data areas:
1940    small, tiny and zero.  All the objects are kept together, and then
1941    referenced via the gp register, the ep register or the r0 register
1942    respectively, which yields smaller, faster assembler code.  This
1943    approach is copied from elf32-mips.c.  */
1944
1945 static asection  v850_elf_scom_section;
1946 static asymbol   v850_elf_scom_symbol;
1947 static asymbol * v850_elf_scom_symbol_ptr;
1948 static asection  v850_elf_tcom_section;
1949 static asymbol   v850_elf_tcom_symbol;
1950 static asymbol * v850_elf_tcom_symbol_ptr;
1951 static asection  v850_elf_zcom_section;
1952 static asymbol   v850_elf_zcom_symbol;
1953 static asymbol * v850_elf_zcom_symbol_ptr;
1954
1955 /* Given a BFD section, try to locate the
1956    corresponding ELF section index.  */
1957
1958 static boolean
1959 v850_elf_section_from_bfd_section (abfd, hdr, sec, retval)
1960      bfd *                 abfd ATTRIBUTE_UNUSED;
1961      Elf32_Internal_Shdr * hdr ATTRIBUTE_UNUSED;
1962      asection *            sec;
1963      int *                 retval;
1964 {
1965   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1966     *retval = SHN_V850_SCOMMON;
1967   else if (strcmp (bfd_get_section_name (abfd, sec), ".tcommon") == 0)
1968     *retval = SHN_V850_TCOMMON;
1969   else if (strcmp (bfd_get_section_name (abfd, sec), ".zcommon") == 0)
1970     *retval = SHN_V850_ZCOMMON;
1971   else
1972     return false;
1973
1974   return true;
1975 }
1976
1977 /* Handle the special V850 section numbers that a symbol may use.  */
1978
1979 static void
1980 v850_elf_symbol_processing (abfd, asym)
1981      bfd *     abfd;
1982      asymbol * asym;
1983 {
1984   elf_symbol_type * elfsym = (elf_symbol_type *) asym;
1985   unsigned short index;
1986
1987   index = elfsym->internal_elf_sym.st_shndx;
1988
1989   /* If the section index is an "ordinary" index, then it may
1990      refer to a v850 specific section created by the assembler.
1991      Check the section's type and change the index it matches.
1992
1993      FIXME: Should we alter the st_shndx field as well ?  */
1994
1995   if (index < elf_elfheader(abfd)[0].e_shnum)
1996     switch (elf_elfsections(abfd)[index]->sh_type)
1997       {
1998       case SHT_V850_SCOMMON:
1999         index = SHN_V850_SCOMMON;
2000         break;
2001
2002       case SHT_V850_TCOMMON:
2003         index = SHN_V850_TCOMMON;
2004         break;
2005
2006       case SHT_V850_ZCOMMON:
2007         index = SHN_V850_ZCOMMON;
2008         break;
2009
2010       default:
2011         break;
2012       }
2013
2014   switch (index)
2015     {
2016     case SHN_V850_SCOMMON:
2017       if (v850_elf_scom_section.name == NULL)
2018         {
2019           /* Initialize the small common section.  */
2020           v850_elf_scom_section.name           = ".scommon";
2021           v850_elf_scom_section.flags          = SEC_IS_COMMON | SEC_ALLOC | SEC_DATA;
2022           v850_elf_scom_section.output_section = & v850_elf_scom_section;
2023           v850_elf_scom_section.symbol         = & v850_elf_scom_symbol;
2024           v850_elf_scom_section.symbol_ptr_ptr = & v850_elf_scom_symbol_ptr;
2025           v850_elf_scom_symbol.name            = ".scommon";
2026           v850_elf_scom_symbol.flags           = BSF_SECTION_SYM;
2027           v850_elf_scom_symbol.section         = & v850_elf_scom_section;
2028           v850_elf_scom_symbol_ptr             = & v850_elf_scom_symbol;
2029         }
2030       asym->section = & v850_elf_scom_section;
2031       asym->value = elfsym->internal_elf_sym.st_size;
2032       break;
2033
2034     case SHN_V850_TCOMMON:
2035       if (v850_elf_tcom_section.name == NULL)
2036         {
2037           /* Initialize the tcommon section.  */
2038           v850_elf_tcom_section.name           = ".tcommon";
2039           v850_elf_tcom_section.flags          = SEC_IS_COMMON;
2040           v850_elf_tcom_section.output_section = & v850_elf_tcom_section;
2041           v850_elf_tcom_section.symbol         = & v850_elf_tcom_symbol;
2042           v850_elf_tcom_section.symbol_ptr_ptr = & v850_elf_tcom_symbol_ptr;
2043           v850_elf_tcom_symbol.name            = ".tcommon";
2044           v850_elf_tcom_symbol.flags           = BSF_SECTION_SYM;
2045           v850_elf_tcom_symbol.section         = & v850_elf_tcom_section;
2046           v850_elf_tcom_symbol_ptr             = & v850_elf_tcom_symbol;
2047         }
2048       asym->section = & v850_elf_tcom_section;
2049       asym->value = elfsym->internal_elf_sym.st_size;
2050       break;
2051
2052     case SHN_V850_ZCOMMON:
2053       if (v850_elf_zcom_section.name == NULL)
2054         {
2055           /* Initialize the zcommon section.  */
2056           v850_elf_zcom_section.name           = ".zcommon";
2057           v850_elf_zcom_section.flags          = SEC_IS_COMMON;
2058           v850_elf_zcom_section.output_section = & v850_elf_zcom_section;
2059           v850_elf_zcom_section.symbol         = & v850_elf_zcom_symbol;
2060           v850_elf_zcom_section.symbol_ptr_ptr = & v850_elf_zcom_symbol_ptr;
2061           v850_elf_zcom_symbol.name            = ".zcommon";
2062           v850_elf_zcom_symbol.flags           = BSF_SECTION_SYM;
2063           v850_elf_zcom_symbol.section         = & v850_elf_zcom_section;
2064           v850_elf_zcom_symbol_ptr             = & v850_elf_zcom_symbol;
2065         }
2066       asym->section = & v850_elf_zcom_section;
2067       asym->value = elfsym->internal_elf_sym.st_size;
2068       break;
2069     }
2070 }
2071
2072 /* Hook called by the linker routine which adds symbols from an object
2073    file.  We must handle the special v850 section numbers here.  */
2074
2075 static boolean
2076 v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2077      bfd *                    abfd;
2078      struct bfd_link_info *   info ATTRIBUTE_UNUSED;
2079      const Elf_Internal_Sym * sym;
2080      const char **            namep ATTRIBUTE_UNUSED;
2081      flagword *               flagsp ATTRIBUTE_UNUSED;
2082      asection **              secp;
2083      bfd_vma *                valp;
2084 {
2085   int index = sym->st_shndx;
2086
2087   /* If the section index is an "ordinary" index, then it may
2088      refer to a v850 specific section created by the assembler.
2089      Check the section's type and change the index it matches.
2090
2091      FIXME: Should we alter the st_shndx field as well ?  */
2092
2093   if (index < elf_elfheader(abfd)[0].e_shnum)
2094     switch (elf_elfsections(abfd)[index]->sh_type)
2095       {
2096       case SHT_V850_SCOMMON:
2097         index = SHN_V850_SCOMMON;
2098         break;
2099
2100       case SHT_V850_TCOMMON:
2101         index = SHN_V850_TCOMMON;
2102         break;
2103
2104       case SHT_V850_ZCOMMON:
2105         index = SHN_V850_ZCOMMON;
2106         break;
2107
2108       default:
2109         break;
2110       }
2111
2112   switch (index)
2113     {
2114     case SHN_V850_SCOMMON:
2115       *secp = bfd_make_section_old_way (abfd, ".scommon");
2116       (*secp)->flags |= SEC_IS_COMMON;
2117       *valp = sym->st_size;
2118       break;
2119
2120     case SHN_V850_TCOMMON:
2121       *secp = bfd_make_section_old_way (abfd, ".tcommon");
2122       (*secp)->flags |= SEC_IS_COMMON;
2123       *valp = sym->st_size;
2124       break;
2125
2126     case SHN_V850_ZCOMMON:
2127       *secp = bfd_make_section_old_way (abfd, ".zcommon");
2128       (*secp)->flags |= SEC_IS_COMMON;
2129       *valp = sym->st_size;
2130       break;
2131     }
2132
2133   return true;
2134 }
2135
2136 static boolean
2137 v850_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
2138      bfd *                  abfd ATTRIBUTE_UNUSED;
2139      struct bfd_link_info * info ATTRIBUTE_UNUSED;
2140      const char *           name ATTRIBUTE_UNUSED;
2141      Elf_Internal_Sym *     sym;
2142      asection *             input_sec;
2143 {
2144   /* If we see a common symbol, which implies a relocatable link, then
2145      if a symbol was in a special common section in an input file, mark
2146      it as a special common in the output file.  */
2147
2148   if (sym->st_shndx == SHN_COMMON)
2149     {
2150       if (strcmp (input_sec->name, ".scommon") == 0)
2151         sym->st_shndx = SHN_V850_SCOMMON;
2152       else if (strcmp (input_sec->name, ".tcommon") == 0)
2153         sym->st_shndx = SHN_V850_TCOMMON;
2154       else if (strcmp (input_sec->name, ".zcommon") == 0)
2155         sym->st_shndx = SHN_V850_ZCOMMON;
2156     }
2157
2158   return true;
2159 }
2160
2161 static boolean
2162 v850_elf_section_from_shdr (abfd, hdr, name)
2163      bfd *               abfd;
2164      Elf_Internal_Shdr * hdr;
2165      char *              name;
2166 {
2167   /* There ought to be a place to keep ELF backend specific flags, but
2168      at the moment there isn't one.  We just keep track of the
2169      sections by their name, instead.  */
2170
2171   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2172     return false;
2173
2174   switch (hdr->sh_type)
2175     {
2176     case SHT_V850_SCOMMON:
2177     case SHT_V850_TCOMMON:
2178     case SHT_V850_ZCOMMON:
2179       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2180                                    (bfd_get_section_flags (abfd,
2181                                                            hdr->bfd_section)
2182                                     | SEC_IS_COMMON)))
2183         return false;
2184     }
2185
2186   return true;
2187 }
2188
2189 /* Set the correct type for a V850 ELF section.  We do this
2190    by the section name, which is a hack, but ought to work.  */
2191
2192 static boolean
2193 v850_elf_fake_sections (abfd, hdr, sec)
2194      bfd *                 abfd ATTRIBUTE_UNUSED;
2195      Elf32_Internal_Shdr * hdr;
2196      asection *            sec;
2197 {
2198   register const char * name;
2199
2200   name = bfd_get_section_name (abfd, sec);
2201
2202   if (strcmp (name, ".scommon") == 0)
2203     {
2204       hdr->sh_type = SHT_V850_SCOMMON;
2205     }
2206   else if (strcmp (name, ".tcommon") == 0)
2207     {
2208       hdr->sh_type = SHT_V850_TCOMMON;
2209     }
2210   else if (strcmp (name, ".zcommon") == 0)
2211     hdr->sh_type = SHT_V850_ZCOMMON;
2212
2213   return true;
2214 }
2215 \f
2216 #define TARGET_LITTLE_SYM                       bfd_elf32_v850_vec
2217 #define TARGET_LITTLE_NAME                      "elf32-v850"
2218 #define ELF_ARCH                                bfd_arch_v850
2219 #define ELF_MACHINE_CODE                        EM_CYGNUS_V850
2220 #define ELF_MAXPAGESIZE                         0x1000
2221
2222 #define elf_info_to_howto                       v850_elf_info_to_howto_rela
2223 #define elf_info_to_howto_rel                   v850_elf_info_to_howto_rel
2224
2225 #define elf_backend_check_relocs                v850_elf_check_relocs
2226 #define elf_backend_relocate_section            v850_elf_relocate_section
2227 #define elf_backend_object_p                    v850_elf_object_p
2228 #define elf_backend_final_write_processing      v850_elf_final_write_processing
2229 #define elf_backend_section_from_bfd_section    v850_elf_section_from_bfd_section
2230 #define elf_backend_symbol_processing           v850_elf_symbol_processing
2231 #define elf_backend_add_symbol_hook             v850_elf_add_symbol_hook
2232 #define elf_backend_link_output_symbol_hook     v850_elf_link_output_symbol_hook
2233 #define elf_backend_section_from_shdr           v850_elf_section_from_shdr
2234 #define elf_backend_fake_sections               v850_elf_fake_sections
2235 #define elf_backend_gc_mark_hook                v850_elf_gc_mark_hook
2236 #define elf_backend_gc_sweep_hook               v850_elf_gc_sweep_hook
2237
2238 #define elf_backend_can_gc_sections 1
2239
2240 #define bfd_elf32_bfd_is_local_label_name       v850_elf_is_local_label_name
2241 #define bfd_elf32_bfd_reloc_type_lookup         v850_elf_reloc_type_lookup
2242 #define bfd_elf32_bfd_copy_private_bfd_data     v850_elf_copy_private_bfd_data
2243 #define bfd_elf32_bfd_merge_private_bfd_data    v850_elf_merge_private_bfd_data
2244 #define bfd_elf32_bfd_set_private_flags         v850_elf_set_private_flags
2245 #define bfd_elf32_bfd_print_private_bfd_data    v850_elf_print_private_bfd_data
2246
2247 #define elf_symbol_leading_char                 '_'
2248
2249 #include "elf32-target.h"