bfd/elf32-v850.c

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