bfd/elf32-fr30.c

   1 /* FR30-specific support for 32-bit ELF.
   2    Copyright 1998, 1999, 2000, 2001 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 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libbfd.h"
  23 #include "elf-bfd.h"
  24 #include "elf/fr30.h"
  25
  26 /* Forward declarations.  */
  27 static bfd_reloc_status_type fr30_elf_i20_reloc
  28   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  29 static bfd_reloc_status_type fr30_elf_i32_reloc
  30   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  31 static reloc_howto_type * fr30_reloc_type_lookup
  32   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  33 static void fr30_info_to_howto_rela
  34   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
  35 static boolean fr30_elf_relocate_section
  36   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  37            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  38 static bfd_reloc_status_type fr30_final_link_relocate
  39   PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
  40            Elf_Internal_Rela *, bfd_vma));
  41 static boolean fr30_elf_gc_sweep_hook
  42   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  43            const Elf_Internal_Rela *));
  44 static asection * fr30_elf_gc_mark_hook
  45   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
  46            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  47 static boolean fr30_elf_check_relocs
  48   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  49            const Elf_Internal_Rela *));
  50
  51 static reloc_howto_type fr30_elf_howto_table [] =
  52 {
  53   /* This reloc does nothing.  */
  54   HOWTO (R_FR30_NONE,           /* type */
  55          0,                     /* rightshift */
  56          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  57          32,                    /* bitsize */
  58          false,                 /* pc_relative */
  59          0,                     /* bitpos */
  60          complain_overflow_bitfield, /* complain_on_overflow */
  61          bfd_elf_generic_reloc, /* special_function */
  62          "R_FR30_NONE",         /* name */
  63          false,                 /* partial_inplace */
  64          0,                     /* src_mask */
  65          0,                     /* dst_mask */
  66          false),                /* pcrel_offset */
  67
  68   /* An 8 bit absolute relocation.  */
  69   HOWTO (R_FR30_8,              /* type */
  70          0,                     /* rightshift */
  71          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  72          8,                     /* bitsize */
  73          false,                 /* pc_relative */
  74          4,                     /* bitpos */
  75          complain_overflow_bitfield, /* complain_on_overflow */
  76          bfd_elf_generic_reloc, /* special_function */
  77          "R_FR30_8",            /* name */
  78          true,                  /* partial_inplace */
  79          0x0000,                /* src_mask */
  80          0x0ff0,                /* dst_mask */
  81          false),                /* pcrel_offset */
  82
  83   /* A 20 bit absolute relocation.  */
  84   HOWTO (R_FR30_20,             /* type */
  85          0,                     /* rightshift */
  86          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  87          20,                    /* bitsize */
  88          false,                 /* pc_relative */
  89          0,                     /* bitpos */
  90          complain_overflow_bitfield, /* complain_on_overflow */
  91          fr30_elf_i20_reloc,    /* special_function */
  92          "R_FR30_20",           /* name */
  93          true,                  /* partial_inplace */
  94          0x00000000,            /* src_mask */
  95          0x00f0ffff,            /* dst_mask */
  96          false),                /* pcrel_offset */
  97
  98   /* A 32 bit absolute relocation.  */
  99   HOWTO (R_FR30_32,             /* type */
 100          0,                     /* rightshift */
 101          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 102          32,                    /* bitsize */
 103          false,                 /* pc_relative */
 104          0,                     /* bitpos */
 105          complain_overflow_bitfield, /* complain_on_overflow */
 106          bfd_elf_generic_reloc, /* special_function */
 107          "R_FR30_32",           /* name */
 108          true,                  /* partial_inplace */
 109          0x00000000,            /* src_mask */
 110          0xffffffff,            /* dst_mask */
 111          false),                /* pcrel_offset */
 112
 113   /* A 32 bit into 48 bits absolute relocation.  */
 114   HOWTO (R_FR30_48,             /* type */
 115          0,                     /* rightshift */
 116          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 117          32,                    /* bitsize */
 118          false,                 /* pc_relative */
 119          0,                     /* bitpos */
 120          complain_overflow_bitfield, /* complain_on_overflow */
 121          fr30_elf_i32_reloc,    /* special_function */
 122          "R_FR30_48",           /* name */
 123          true,                  /* partial_inplace */
 124          0x00000000,            /* src_mask */
 125          0xffffffff,            /* dst_mask */
 126          false),                /* pcrel_offset */
 127
 128   /* A 6 bit absolute relocation.  */
 129   HOWTO (R_FR30_6_IN_4,         /* type */
 130          2,                     /* rightshift */
 131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 132          6,                     /* bitsize */
 133          false,                 /* pc_relative */
 134          4,                     /* bitpos */
 135          complain_overflow_unsigned, /* complain_on_overflow */
 136          bfd_elf_generic_reloc, /* special_function */
 137          "R_FR30_6_IN_4",       /* name */
 138          true,                  /* partial_inplace */
 139          0x0000,                /* src_mask */
 140          0x00f0,                /* dst_mask */
 141          false),                /* pcrel_offset */
 142
 143   /* An 8 bit absolute relocation.  */
 144   HOWTO (R_FR30_8_IN_8,         /* type */
 145          0,                     /* rightshift */
 146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 147          8,                     /* bitsize */
 148          false,                 /* pc_relative */
 149          4,                     /* bitpos */
 150          complain_overflow_signed, /* complain_on_overflow */
 151          bfd_elf_generic_reloc,/* special_function */
 152          "R_FR30_8_IN_8",       /* name */
 153          true,                  /* partial_inplace */
 154          0x0000,                /* src_mask */
 155          0x0ff0,                /* dst_mask */
 156          false),                /* pcrel_offset */
 157
 158   /* A 9 bit absolute relocation.  */
 159   HOWTO (R_FR30_9_IN_8,         /* type */
 160          1,                     /* rightshift */
 161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 162          9,                     /* bitsize */
 163          false,                 /* pc_relative */
 164          4,                     /* bitpos */
 165          complain_overflow_signed, /* complain_on_overflow */
 166          bfd_elf_generic_reloc,/* special_function */
 167          "R_FR30_9_IN_8",       /* name */
 168          true,                  /* partial_inplace */
 169          0x0000,                /* src_mask */
 170          0x0ff0,                /* dst_mask */
 171          false),                /* pcrel_offset */
 172
 173   /* A 10 bit absolute relocation.  */
 174   HOWTO (R_FR30_10_IN_8,        /* type */
 175          2,                     /* rightshift */
 176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 177          10,                    /* bitsize */
 178          false,                 /* pc_relative */
 179          4,                     /* bitpos */
 180          complain_overflow_signed, /* complain_on_overflow */
 181          bfd_elf_generic_reloc,/* special_function */
 182          "R_FR30_10_IN_8",      /* name */
 183          true,                  /* partial_inplace */
 184          0x0000,                /* src_mask */
 185          0x0ff0,                /* dst_mask */
 186          false),                /* pcrel_offset */
 187
 188   /* A PC relative 9 bit relocation, right shifted by 1.  */
 189   HOWTO (R_FR30_9_PCREL,        /* type */
 190          1,                     /* rightshift */
 191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 192          9,                     /* bitsize */
 193          true,                  /* pc_relative */
 194          0,                     /* bitpos */
 195          complain_overflow_signed, /* complain_on_overflow */
 196          bfd_elf_generic_reloc, /* special_function */
 197          "R_FR30_9_PCREL",      /* name */
 198          false,                 /* partial_inplace */
 199          0x0000,                /* src_mask */
 200          0x00ff,                /* dst_mask */
 201          false),                /* pcrel_offset */
 202
 203   /* A PC relative 12 bit relocation, right shifted by 1.  */
 204   HOWTO (R_FR30_12_PCREL,       /* type */
 205          1,                     /* rightshift */
 206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 207          12,                    /* bitsize */
 208          true,                  /* pc_relative */
 209          0,                     /* bitpos */
 210          complain_overflow_signed, /* complain_on_overflow */
 211          bfd_elf_generic_reloc, /* special_function */
 212          "R_FR30_12_PCREL",     /* name */
 213          false,                 /* partial_inplace */
 214          0x0000,                /* src_mask */
 215          0x07ff,                /* dst_mask */
 216          false),                /* pcrel_offset */
 217   /* GNU extension to record C++ vtable hierarchy */
 218   HOWTO (R_FR30_GNU_VTINHERIT, /* type */
 219          0,                     /* rightshift */
 220          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 221          0,                     /* bitsize */
 222          false,                 /* pc_relative */
 223          0,                     /* bitpos */
 224          complain_overflow_dont, /* complain_on_overflow */
 225          NULL,                  /* special_function */
 226          "R_FR30_GNU_VTINHERIT", /* name */
 227          false,                 /* partial_inplace */
 228          0,                     /* src_mask */
 229          0,                     /* dst_mask */
 230          false),                /* pcrel_offset */
 231
 232   /* GNU extension to record C++ vtable member usage */
 233   HOWTO (R_FR30_GNU_VTENTRY,     /* type */
 234          0,                     /* rightshift */
 235          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 236          0,                     /* bitsize */
 237          false,                 /* pc_relative */
 238          0,                     /* bitpos */
 239          complain_overflow_dont, /* complain_on_overflow */
 240          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 241          "R_FR30_GNU_VTENTRY",   /* name */
 242          false,                 /* partial_inplace */
 243          0,                     /* src_mask */
 244          0,                     /* dst_mask */
 245          false),                /* pcrel_offset */
 246 };
 247 \f
 248 /* Utility to actually perform an R_FR30_20 reloc.  */
 249
 250 static bfd_reloc_status_type
 251 fr30_elf_i20_reloc (abfd, reloc_entry, symbol, data,
 252                     input_section, output_bfd, error_message)
 253      bfd *      abfd;
 254      arelent *  reloc_entry;
 255      asymbol *  symbol;
 256      PTR        data;
 257      asection * input_section;
 258      bfd *      output_bfd;
 259      char **    error_message ATTRIBUTE_UNUSED;
 260 {
 261   bfd_vma       relocation;
 262   unsigned long x;
 263
 264   /* This part is from bfd_elf_generic_reloc.  */
 265   if (output_bfd != (bfd *) NULL
 266       && (symbol->flags & BSF_SECTION_SYM) == 0
 267       && (! reloc_entry->howto->partial_inplace
 268           || reloc_entry->addend == 0))
 269     {
 270       reloc_entry->address += input_section->output_offset;
 271       return bfd_reloc_ok;
 272     }
 273
 274   if (output_bfd != NULL)
 275     /* FIXME: See bfd_perform_relocation.  Is this right?  */
 276     return bfd_reloc_ok;
 277
 278   relocation =
 279     symbol->value
 280     + symbol->section->output_section->vma
 281     + symbol->section->output_offset
 282     + reloc_entry->addend;
 283
 284   if (relocation > (((bfd_vma) 1 << 20) - 1))
 285     return bfd_reloc_overflow;
 286
 287   x = bfd_get_32 (abfd, (char *) data + reloc_entry->address);
 288   x = (x & 0xff0f0000) | (relocation & 0x0000ffff) | ((relocation & 0x000f0000) << 4);
 289   bfd_put_32 (abfd, (bfd_vma) x, (char *) data + reloc_entry->address);
 290
 291   return bfd_reloc_ok;
 292 }
 293 \f
 294 /* Utility to actually perform a R_FR30_48 reloc.  */
 295
 296 static bfd_reloc_status_type
 297 fr30_elf_i32_reloc (abfd, reloc_entry, symbol, data,
 298                     input_section, output_bfd, error_message)
 299      bfd *      abfd;
 300      arelent *  reloc_entry;
 301      asymbol *  symbol;
 302      PTR        data;
 303      asection * input_section;
 304      bfd *      output_bfd;
 305      char **    error_message ATTRIBUTE_UNUSED;
 306 {
 307   bfd_vma       relocation;
 308
 309   /* This part is from bfd_elf_generic_reloc.  */
 310   if (output_bfd != (bfd *) NULL
 311       && (symbol->flags & BSF_SECTION_SYM) == 0
 312       && (! reloc_entry->howto->partial_inplace
 313           || reloc_entry->addend == 0))
 314     {
 315       reloc_entry->address += input_section->output_offset;
 316       return bfd_reloc_ok;
 317     }
 318
 319   if (output_bfd != NULL)
 320     /* FIXME: See bfd_perform_relocation.  Is this right?  */
 321     return bfd_reloc_ok;
 322
 323   relocation =
 324     symbol->value
 325     + symbol->section->output_section->vma
 326     + symbol->section->output_offset
 327     + reloc_entry->addend;
 328
 329   bfd_put_32 (abfd, relocation, (char *) data + reloc_entry->address + 2);
 330
 331   return bfd_reloc_ok;
 332 }
 333 \f
 334 /* Map BFD reloc types to FR30 ELF reloc types.  */
 335
 336 struct fr30_reloc_map
 337 {
 338   bfd_reloc_code_real_type bfd_reloc_val;
 339   unsigned int fr30_reloc_val;
 340 };
 341
 342 static const struct fr30_reloc_map fr30_reloc_map [] =
 343 {
 344   { BFD_RELOC_NONE,           R_FR30_NONE },
 345   { BFD_RELOC_8,              R_FR30_8 },
 346   { BFD_RELOC_FR30_20,        R_FR30_20 },
 347   { BFD_RELOC_32,             R_FR30_32 },
 348   { BFD_RELOC_FR30_48,        R_FR30_48 },
 349   { BFD_RELOC_FR30_6_IN_4,    R_FR30_6_IN_4 },
 350   { BFD_RELOC_FR30_8_IN_8,    R_FR30_8_IN_8 },
 351   { BFD_RELOC_FR30_9_IN_8,    R_FR30_9_IN_8 },
 352   { BFD_RELOC_FR30_10_IN_8,   R_FR30_10_IN_8 },
 353   { BFD_RELOC_FR30_9_PCREL,   R_FR30_9_PCREL },
 354   { BFD_RELOC_FR30_12_PCREL,  R_FR30_12_PCREL },
 355   { BFD_RELOC_VTABLE_INHERIT, R_FR30_GNU_VTINHERIT },
 356   { BFD_RELOC_VTABLE_ENTRY,   R_FR30_GNU_VTENTRY },
 357 };
 358
 359 static reloc_howto_type *
 360 fr30_reloc_type_lookup (abfd, code)
 361      bfd * abfd ATTRIBUTE_UNUSED;
 362      bfd_reloc_code_real_type code;
 363 {
 364   unsigned int i;
 365
 366   for (i = sizeof (fr30_reloc_map) / sizeof (fr30_reloc_map[0]);
 367        --i;)
 368     if (fr30_reloc_map [i].bfd_reloc_val == code)
 369       return & fr30_elf_howto_table [fr30_reloc_map[i].fr30_reloc_val];
 370
 371   return NULL;
 372 }
 373
 374 /* Set the howto pointer for an FR30 ELF reloc.  */
 375
 376 static void
 377 fr30_info_to_howto_rela (abfd, cache_ptr, dst)
 378      bfd * abfd ATTRIBUTE_UNUSED;
 379      arelent * cache_ptr;
 380      Elf32_Internal_Rela * dst;
 381 {
 382   unsigned int r_type;
 383
 384   r_type = ELF32_R_TYPE (dst->r_info);
 385   BFD_ASSERT (r_type < (unsigned int) R_FR30_max);
 386   cache_ptr->howto = & fr30_elf_howto_table [r_type];
 387 }
 388 \f
 389 /* Perform a single relocation.  By default we use the standard BFD
 390    routines, but a few relocs, we have to do them ourselves.  */
 391
 392 static bfd_reloc_status_type
 393 fr30_final_link_relocate (howto, input_bfd, input_section, contents, rel, relocation)
 394      reloc_howto_type *  howto;
 395      bfd *               input_bfd;
 396      asection *          input_section;
 397      bfd_byte *          contents;
 398      Elf_Internal_Rela * rel;
 399      bfd_vma             relocation;
 400 {
 401   bfd_reloc_status_type r = bfd_reloc_ok;
 402   bfd_vma               x;
 403   bfd_signed_vma        srel;
 404
 405   switch (howto->type)
 406     {
 407     case R_FR30_20:
 408       contents   += rel->r_offset;
 409       relocation += rel->r_addend;
 410
 411       if (relocation > ((1 << 20) - 1))
 412         return bfd_reloc_overflow;
 413
 414       x = bfd_get_32 (input_bfd, contents);
 415       x = (x & 0xff0f0000) | (relocation & 0x0000ffff) | ((relocation & 0x000f0000) << 4);
 416       bfd_put_32 (input_bfd, x, contents);
 417       break;
 418
 419     case R_FR30_48:
 420       contents   += rel->r_offset + 2;
 421       relocation += rel->r_addend;
 422       bfd_put_32 (input_bfd, relocation, contents);
 423       break;
 424
 425     case R_FR30_9_PCREL:
 426       contents   += rel->r_offset + 1;
 427       srel = (bfd_signed_vma) relocation;
 428       srel += rel->r_addend;
 429       srel -= rel->r_offset;
 430       srel -= 2;  /* Branch instructions add 2 to the PC...  */
 431       srel -= (input_section->output_section->vma +
 432                      input_section->output_offset);
 433
 434       if (srel & 1)
 435         return bfd_reloc_outofrange;
 436       if (srel > ((1 << 8) - 1) || (srel < - (1 << 8)))
 437         return bfd_reloc_overflow;
 438
 439       bfd_put_8 (input_bfd, srel >> 1, contents);
 440       break;
 441
 442     case R_FR30_12_PCREL:
 443       contents   += rel->r_offset;
 444       srel = (bfd_signed_vma) relocation;
 445       srel += rel->r_addend;
 446       srel -= rel->r_offset;
 447       srel -= 2; /* Branch instructions add 2 to the PC...  */
 448       srel -= (input_section->output_section->vma +
 449                      input_section->output_offset);
 450
 451       if (srel & 1)
 452         return bfd_reloc_outofrange;
 453       if (srel > ((1 << 11) - 1) || (srel < - (1 << 11)))
 454           return bfd_reloc_overflow;
 455
 456       x = bfd_get_16 (input_bfd, contents);
 457       x = (x & 0xf800) | ((srel >> 1) & 0x7ff);
 458       bfd_put_16 (input_bfd, x, contents);
 459       break;
 460
 461     default:
 462       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 463                                     contents, rel->r_offset,
 464                                     relocation, rel->r_addend);
 465     }
 466
 467   return r;
 468 }
 469 \f
 470 /* Relocate an FR30 ELF section.
 471    There is some attempt to make this function usable for many architectures,
 472    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 473    if only to serve as a learning tool.
 474
 475    The RELOCATE_SECTION function is called by the new ELF backend linker
 476    to handle the relocations for a section.
 477
 478    The relocs are always passed as Rela structures; if the section
 479    actually uses Rel structures, the r_addend field will always be
 480    zero.
 481
 482    This function is responsible for adjusting the section contents as
 483    necessary, and (if using Rela relocs and generating a relocateable
 484    output file) adjusting the reloc addend as necessary.
 485
 486    This function does not have to worry about setting the reloc
 487    address or the reloc symbol index.
 488
 489    LOCAL_SYMS is a pointer to the swapped in local symbols.
 490
 491    LOCAL_SECTIONS is an array giving the section in the input file
 492    corresponding to the st_shndx field of each local symbol.
 493
 494    The global hash table entry for the global symbols can be found
 495    via elf_sym_hashes (input_bfd).
 496
 497    When generating relocateable output, this function must handle
 498    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 499    going to be the section symbol corresponding to the output
 500    section, which means that the addend must be adjusted
 501    accordingly.  */
 502
 503 static boolean
 504 fr30_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 505                            contents, relocs, local_syms, local_sections)
 506      bfd *                   output_bfd;
 507      struct bfd_link_info *  info;
 508      bfd *                   input_bfd;
 509      asection *              input_section;
 510      bfd_byte *              contents;
 511      Elf_Internal_Rela *     relocs;
 512      Elf_Internal_Sym *      local_syms;
 513      asection **             local_sections;
 514 {
 515   Elf_Internal_Shdr *           symtab_hdr;
 516   struct elf_link_hash_entry ** sym_hashes;
 517   Elf_Internal_Rela *           rel;
 518   Elf_Internal_Rela *           relend;
 519
 520   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 521   sym_hashes = elf_sym_hashes (input_bfd);
 522   relend     = relocs + input_section->reloc_count;
 523
 524   for (rel = relocs; rel < relend; rel ++)
 525     {
 526       reloc_howto_type *           howto;
 527       unsigned long                r_symndx;
 528       Elf_Internal_Sym *           sym;
 529       asection *                   sec;
 530       struct elf_link_hash_entry * h;
 531       bfd_vma                      relocation;
 532       bfd_reloc_status_type        r;
 533       const char *                 name = NULL;
 534       int                          r_type;
 535
 536       r_type = ELF32_R_TYPE (rel->r_info);
 537
 538       if (   r_type == R_FR30_GNU_VTINHERIT
 539           || r_type == R_FR30_GNU_VTENTRY)
 540         continue;
 541
 542       r_symndx = ELF32_R_SYM (rel->r_info);
 543
 544       if (info->relocateable)
 545         {
 546           /* This is a relocateable link.  We don't have to change
 547              anything, unless the reloc is against a section symbol,
 548              in which case we have to adjust according to where the
 549              section symbol winds up in the output section.  */
 550           if (r_symndx < symtab_hdr->sh_info)
 551             {
 552               sym = local_syms + r_symndx;
 553
 554               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 555                 {
 556                   sec = local_sections [r_symndx];
 557                   rel->r_addend += sec->output_offset + sym->st_value;
 558                 }
 559             }
 560
 561           continue;
 562         }
 563
 564       /* This is a final link.  */
 565       howto  = fr30_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 566       h      = NULL;
 567       sym    = NULL;
 568       sec    = NULL;
 569
 570       if (r_symndx < symtab_hdr->sh_info)
 571         {
 572           sym = local_syms + r_symndx;
 573           sec = local_sections [r_symndx];
 574           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
 575
 576           name = bfd_elf_string_from_elf_section
 577             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 578           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 579 #if 0
 580           fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
 581                    sec->name, name, sym->st_name,
 582                    sec->output_section->vma, sec->output_offset,
 583                    sym->st_value, rel->r_addend);
 584 #endif
 585         }
 586       else
 587         {
 588           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
 589
 590           while (h->root.type == bfd_link_hash_indirect
 591                  || h->root.type == bfd_link_hash_warning)
 592             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 593
 594           name = h->root.root.string;
 595
 596           if (h->root.type == bfd_link_hash_defined
 597               || h->root.type == bfd_link_hash_defweak)
 598             {
 599               sec = h->root.u.def.section;
 600               relocation = (h->root.u.def.value
 601                             + sec->output_section->vma
 602                             + sec->output_offset);
 603 #if 0
 604               fprintf (stderr,
 605                        "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
 606                        sec->name, name, h->root.u.def.value,
 607                        sec->output_section->vma, sec->output_offset, relocation);
 608 #endif
 609             }
 610           else if (h->root.type == bfd_link_hash_undefweak)
 611             {
 612 #if 0
 613               fprintf (stderr, "undefined: sec: %s, name: %s\n",
 614                        sec->name, name);
 615 #endif
 616               relocation = 0;
 617             }
 618           else
 619             {
 620               if (! ((*info->callbacks->undefined_symbol)
 621                      (info, h->root.root.string, input_bfd,
 622                       input_section, rel->r_offset, true)))
 623                 return false;
 624 #if 0
 625               fprintf (stderr, "unknown: name: %s\n", name);
 626 #endif
 627               relocation = 0;
 628             }
 629         }
 630
 631       r = fr30_final_link_relocate (howto, input_bfd, input_section,
 632                                      contents, rel, relocation);
 633
 634       if (r != bfd_reloc_ok)
 635         {
 636           const char * msg = (const char *) NULL;
 637
 638           switch (r)
 639             {
 640             case bfd_reloc_overflow:
 641               r = info->callbacks->reloc_overflow
 642                 (info, name, howto->name, (bfd_vma) 0,
 643                  input_bfd, input_section, rel->r_offset);
 644               break;
 645
 646             case bfd_reloc_undefined:
 647               r = info->callbacks->undefined_symbol
 648                 (info, name, input_bfd, input_section, rel->r_offset,
 649                  true);
 650               break;
 651
 652             case bfd_reloc_outofrange:
 653               msg = _("internal error: out of range error");
 654               break;
 655
 656             case bfd_reloc_notsupported:
 657               msg = _("internal error: unsupported relocation error");
 658               break;
 659
 660             case bfd_reloc_dangerous:
 661               msg = _("internal error: dangerous relocation");
 662               break;
 663
 664             default:
 665               msg = _("internal error: unknown error");
 666               break;
 667             }
 668
 669           if (msg)
 670             r = info->callbacks->warning
 671               (info, msg, name, input_bfd, input_section, rel->r_offset);
 672
 673           if (! r)
 674             return false;
 675         }
 676     }
 677
 678   return true;
 679 }
 680 \f
 681 /* Return the section that should be marked against GC for a given
 682    relocation.  */
 683
 684 static asection *
 685 fr30_elf_gc_mark_hook (abfd, info, rel, h, sym)
 686      bfd *                        abfd;
 687      struct bfd_link_info *       info ATTRIBUTE_UNUSED;
 688      Elf_Internal_Rela *          rel;
 689      struct elf_link_hash_entry * h;
 690      Elf_Internal_Sym *           sym;
 691 {
 692   if (h != NULL)
 693     {
 694       switch (ELF32_R_TYPE (rel->r_info))
 695         {
 696         case R_FR30_GNU_VTINHERIT:
 697         case R_FR30_GNU_VTENTRY:
 698           break;
 699
 700         default:
 701           switch (h->root.type)
 702             {
 703             case bfd_link_hash_defined:
 704             case bfd_link_hash_defweak:
 705               return h->root.u.def.section;
 706
 707             case bfd_link_hash_common:
 708               return h->root.u.c.p->section;
 709
 710             default:
 711               break;
 712             }
 713         }
 714     }
 715   else
 716     {
 717       if (!(elf_bad_symtab (abfd)
 718             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
 719           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
 720                 && sym->st_shndx != SHN_COMMON))
 721         {
 722           return bfd_section_from_elf_index (abfd, sym->st_shndx);
 723         }
 724     }
 725
 726   return NULL;
 727 }
 728
 729 /* Update the got entry reference counts for the section being removed.  */
 730
 731 static boolean
 732 fr30_elf_gc_sweep_hook (abfd, info, sec, relocs)
 733      bfd *                     abfd ATTRIBUTE_UNUSED;
 734      struct bfd_link_info *    info ATTRIBUTE_UNUSED;
 735      asection *                sec ATTRIBUTE_UNUSED;
 736      const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
 737 {
 738   return true;
 739 }
 740
 741 /* Look through the relocs for a section during the first phase.
 742    Since we don't do .gots or .plts, we just need to consider the
 743    virtual table relocs for gc.  */
 744
 745 static boolean
 746 fr30_elf_check_relocs (abfd, info, sec, relocs)
 747      bfd *abfd;
 748      struct bfd_link_info *info;
 749      asection *sec;
 750      const Elf_Internal_Rela *relocs;
 751 {
 752   Elf_Internal_Shdr *symtab_hdr;
 753   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 754   const Elf_Internal_Rela *rel;
 755   const Elf_Internal_Rela *rel_end;
 756
 757   if (info->relocateable)
 758     return true;
 759
 760   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 761   sym_hashes = elf_sym_hashes (abfd);
 762   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
 763   if (!elf_bad_symtab (abfd))
 764     sym_hashes_end -= symtab_hdr->sh_info;
 765
 766   rel_end = relocs + sec->reloc_count;
 767   for (rel = relocs; rel < rel_end; rel++)
 768     {
 769       struct elf_link_hash_entry *h;
 770       unsigned long r_symndx;
 771
 772       r_symndx = ELF32_R_SYM (rel->r_info);
 773       if (r_symndx < symtab_hdr->sh_info)
 774         h = NULL;
 775       else
 776         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 777
 778       switch (ELF32_R_TYPE (rel->r_info))
 779         {
 780         /* This relocation describes the C++ object vtable hierarchy.
 781            Reconstruct it for later use during GC.  */
 782         case R_FR30_GNU_VTINHERIT:
 783           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 784             return false;
 785           break;
 786
 787         /* This relocation describes which C++ vtable entries are actually
 788            used.  Record for later use during GC.  */
 789         case R_FR30_GNU_VTENTRY:
 790           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 791             return false;
 792           break;
 793         }
 794     }
 795
 796   return true;
 797 }
 798 \f
 799 #define ELF_ARCH                bfd_arch_fr30
 800 #define ELF_MACHINE_CODE        EM_FR30
 801 #define ELF_MACHINE_ALT1        EM_CYGNUS_FR30
 802 #define ELF_MAXPAGESIZE         0x1000
 803
 804 #define TARGET_BIG_SYM          bfd_elf32_fr30_vec
 805 #define TARGET_BIG_NAME         "elf32-fr30"
 806
 807 #define elf_info_to_howto_rel                   NULL
 808 #define elf_info_to_howto                       fr30_info_to_howto_rela
 809 #define elf_backend_relocate_section            fr30_elf_relocate_section
 810 #define elf_backend_gc_mark_hook                fr30_elf_gc_mark_hook
 811 #define elf_backend_gc_sweep_hook               fr30_elf_gc_sweep_hook
 812 #define elf_backend_check_relocs                fr30_elf_check_relocs
 813
 814 #define elf_backend_can_gc_sections             1
 815
 816 #define bfd_elf32_bfd_reloc_type_lookup         fr30_reloc_type_lookup
 817
 818 #include "elf32-target.h"