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