bfd/elf32-v850.c

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