bfd/elf32-fr30.c

   1 /* FR30-specific support for 32-bit ELF.
   2    Copyright 1998, 1999, 2000, 2001, 2002 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 *, Elf_Internal_Rela *));
  35 static bfd_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 bfd_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 ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  46            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  47 static bfd_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      Elf_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,
 394                           relocation)
 395      reloc_howto_type *howto;
 396      bfd *input_bfd;
 397      asection *input_section;
 398      bfd_byte *contents;
 399      Elf_Internal_Rela *rel;
 400      bfd_vma relocation;
 401 {
 402   bfd_reloc_status_type r = bfd_reloc_ok;
 403   bfd_vma x;
 404   bfd_signed_vma srel;
 405
 406   switch (howto->type)
 407     {
 408     case R_FR30_20:
 409       contents   += rel->r_offset;
 410       relocation += rel->r_addend;
 411
 412       if (relocation > ((1 << 20) - 1))
 413         return bfd_reloc_overflow;
 414
 415       x = bfd_get_32 (input_bfd, contents);
 416       x = (x & 0xff0f0000) | (relocation & 0x0000ffff) | ((relocation & 0x000f0000) << 4);
 417       bfd_put_32 (input_bfd, x, contents);
 418       break;
 419
 420     case R_FR30_48:
 421       contents   += rel->r_offset + 2;
 422       relocation += rel->r_addend;
 423       bfd_put_32 (input_bfd, relocation, contents);
 424       break;
 425
 426     case R_FR30_9_PCREL:
 427       contents   += rel->r_offset + 1;
 428       srel = (bfd_signed_vma) relocation;
 429       srel += rel->r_addend;
 430       srel -= rel->r_offset;
 431       srel -= 2;  /* Branch instructions add 2 to the PC...  */
 432       srel -= (input_section->output_section->vma +
 433                      input_section->output_offset);
 434
 435       if (srel & 1)
 436         return bfd_reloc_outofrange;
 437       if (srel > ((1 << 8) - 1) || (srel < - (1 << 8)))
 438         return bfd_reloc_overflow;
 439
 440       bfd_put_8 (input_bfd, srel >> 1, contents);
 441       break;
 442
 443     case R_FR30_12_PCREL:
 444       contents   += rel->r_offset;
 445       srel = (bfd_signed_vma) relocation;
 446       srel += rel->r_addend;
 447       srel -= rel->r_offset;
 448       srel -= 2; /* Branch instructions add 2 to the PC...  */
 449       srel -= (input_section->output_section->vma +
 450                      input_section->output_offset);
 451
 452       if (srel & 1)
 453         return bfd_reloc_outofrange;
 454       if (srel > ((1 << 11) - 1) || (srel < - (1 << 11)))
 455           return bfd_reloc_overflow;
 456
 457       x = bfd_get_16 (input_bfd, contents);
 458       x = (x & 0xf800) | ((srel >> 1) & 0x7ff);
 459       bfd_put_16 (input_bfd, x, contents);
 460       break;
 461
 462     default:
 463       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 464                                     contents, rel->r_offset,
 465                                     relocation, rel->r_addend);
 466     }
 467
 468   return r;
 469 }
 470 \f
 471 /* Relocate an FR30 ELF section.
 472
 473    The RELOCATE_SECTION function is called by the new ELF backend linker
 474    to handle the relocations for a section.
 475
 476    The relocs are always passed as Rela structures; if the section
 477    actually uses Rel structures, the r_addend field will always be
 478    zero.
 479
 480    This function is responsible for adjusting the section contents as
 481    necessary, and (if using Rela relocs and generating a relocateable
 482    output file) adjusting the reloc addend as necessary.
 483
 484    This function does not have to worry about setting the reloc
 485    address or the reloc symbol index.
 486
 487    LOCAL_SYMS is a pointer to the swapped in local symbols.
 488
 489    LOCAL_SECTIONS is an array giving the section in the input file
 490    corresponding to the st_shndx field of each local symbol.
 491
 492    The global hash table entry for the global symbols can be found
 493    via elf_sym_hashes (input_bfd).
 494
 495    When generating relocateable output, this function must handle
 496    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 497    going to be the section symbol corresponding to the output
 498    section, which means that the addend must be adjusted
 499    accordingly.  */
 500
 501 static bfd_boolean
 502 fr30_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 503                            contents, relocs, local_syms, local_sections)
 504      bfd *output_bfd;
 505      struct bfd_link_info *info;
 506      bfd *input_bfd;
 507      asection *input_section;
 508      bfd_byte *contents;
 509      Elf_Internal_Rela *relocs;
 510      Elf_Internal_Sym *local_syms;
 511      asection **local_sections;
 512 {
 513   Elf_Internal_Shdr *symtab_hdr;
 514   struct elf_link_hash_entry **sym_hashes;
 515   Elf_Internal_Rela *rel;
 516   Elf_Internal_Rela *relend;
 517
 518   if (info->relocateable)
 519     return TRUE;
 520
 521   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 522   sym_hashes = elf_sym_hashes (input_bfd);
 523   relend     = relocs + input_section->reloc_count;
 524
 525   for (rel = relocs; rel < relend; rel ++)
 526     {
 527       reloc_howto_type *howto;
 528       unsigned long r_symndx;
 529       Elf_Internal_Sym *sym;
 530       asection *sec;
 531       struct elf_link_hash_entry *h;
 532       bfd_vma relocation;
 533       bfd_reloc_status_type r;
 534       const char *name = NULL;
 535       int r_type;
 536
 537       r_type = ELF32_R_TYPE (rel->r_info);
 538
 539       if (   r_type == R_FR30_GNU_VTINHERIT
 540           || r_type == R_FR30_GNU_VTENTRY)
 541         continue;
 542
 543       r_symndx = ELF32_R_SYM (rel->r_info);
 544
 545       howto  = fr30_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 546       h      = NULL;
 547       sym    = NULL;
 548       sec    = NULL;
 549
 550       if (r_symndx < symtab_hdr->sh_info)
 551         {
 552           sym = local_syms + r_symndx;
 553           sec = local_sections [r_symndx];
 554           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
 555
 556           name = bfd_elf_string_from_elf_section
 557             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 558           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 559 #if 0
 560           fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
 561                    sec->name, name, sym->st_name,
 562                    sec->output_section->vma, sec->output_offset,
 563                    sym->st_value, rel->r_addend);
 564 #endif
 565         }
 566       else
 567         {
 568           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
 569
 570           while (h->root.type == bfd_link_hash_indirect
 571                  || h->root.type == bfd_link_hash_warning)
 572             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 573
 574           name = h->root.root.string;
 575
 576           if (h->root.type == bfd_link_hash_defined
 577               || h->root.type == bfd_link_hash_defweak)
 578             {
 579               sec = h->root.u.def.section;
 580               relocation = (h->root.u.def.value
 581                             + sec->output_section->vma
 582                             + sec->output_offset);
 583 #if 0
 584               fprintf (stderr,
 585                        "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
 586                        sec->name, name, h->root.u.def.value,
 587                        sec->output_section->vma, sec->output_offset, relocation);
 588 #endif
 589             }
 590           else if (h->root.type == bfd_link_hash_undefweak)
 591             {
 592 #if 0
 593               fprintf (stderr, "undefined: sec: %s, name: %s\n",
 594                        sec->name, name);
 595 #endif
 596               relocation = 0;
 597             }
 598           else
 599             {
 600               if (! ((*info->callbacks->undefined_symbol)
 601                      (info, h->root.root.string, input_bfd,
 602                       input_section, rel->r_offset, TRUE)))
 603                 return FALSE;
 604 #if 0
 605               fprintf (stderr, "unknown: name: %s\n", name);
 606 #endif
 607               relocation = 0;
 608             }
 609         }
 610
 611       r = fr30_final_link_relocate (howto, input_bfd, input_section,
 612                                      contents, rel, relocation);
 613
 614       if (r != bfd_reloc_ok)
 615         {
 616           const char * msg = (const char *) NULL;
 617
 618           switch (r)
 619             {
 620             case bfd_reloc_overflow:
 621               r = info->callbacks->reloc_overflow
 622                 (info, name, howto->name, (bfd_vma) 0,
 623                  input_bfd, input_section, rel->r_offset);
 624               break;
 625
 626             case bfd_reloc_undefined:
 627               r = info->callbacks->undefined_symbol
 628                 (info, name, input_bfd, input_section, rel->r_offset,
 629                  TRUE);
 630               break;
 631
 632             case bfd_reloc_outofrange:
 633               msg = _("internal error: out of range error");
 634               break;
 635
 636             case bfd_reloc_notsupported:
 637               msg = _("internal error: unsupported relocation error");
 638               break;
 639
 640             case bfd_reloc_dangerous:
 641               msg = _("internal error: dangerous relocation");
 642               break;
 643
 644             default:
 645               msg = _("internal error: unknown error");
 646               break;
 647             }
 648
 649           if (msg)
 650             r = info->callbacks->warning
 651               (info, msg, name, input_bfd, input_section, rel->r_offset);
 652
 653           if (! r)
 654             return FALSE;
 655         }
 656     }
 657
 658   return TRUE;
 659 }
 660 \f
 661 /* Return the section that should be marked against GC for a given
 662    relocation.  */
 663
 664 static asection *
 665 fr30_elf_gc_mark_hook (sec, info, rel, h, sym)
 666      asection *sec;
 667      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 668      Elf_Internal_Rela *rel;
 669      struct elf_link_hash_entry *h;
 670      Elf_Internal_Sym * sym;
 671 {
 672   if (h != NULL)
 673     {
 674       switch (ELF32_R_TYPE (rel->r_info))
 675         {
 676         case R_FR30_GNU_VTINHERIT:
 677         case R_FR30_GNU_VTENTRY:
 678           break;
 679
 680         default:
 681           switch (h->root.type)
 682             {
 683             case bfd_link_hash_defined:
 684             case bfd_link_hash_defweak:
 685               return h->root.u.def.section;
 686
 687             case bfd_link_hash_common:
 688               return h->root.u.c.p->section;
 689
 690             default:
 691               break;
 692             }
 693         }
 694     }
 695   else
 696     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 697
 698   return NULL;
 699 }
 700
 701 /* Update the got entry reference counts for the section being removed.  */
 702
 703 static bfd_boolean
 704 fr30_elf_gc_sweep_hook (abfd, info, sec, relocs)
 705      bfd *abfd ATTRIBUTE_UNUSED;
 706      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 707      asection *sec ATTRIBUTE_UNUSED;
 708      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
 709 {
 710   return TRUE;
 711 }
 712
 713 /* Look through the relocs for a section during the first phase.
 714    Since we don't do .gots or .plts, we just need to consider the
 715    virtual table relocs for gc.  */
 716
 717 static bfd_boolean
 718 fr30_elf_check_relocs (abfd, info, sec, relocs)
 719      bfd *abfd;
 720      struct bfd_link_info *info;
 721      asection *sec;
 722      const Elf_Internal_Rela *relocs;
 723 {
 724   Elf_Internal_Shdr *symtab_hdr;
 725   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 726   const Elf_Internal_Rela *rel;
 727   const Elf_Internal_Rela *rel_end;
 728
 729   if (info->relocateable)
 730     return TRUE;
 731
 732   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 733   sym_hashes = elf_sym_hashes (abfd);
 734   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
 735   if (!elf_bad_symtab (abfd))
 736     sym_hashes_end -= symtab_hdr->sh_info;
 737
 738   rel_end = relocs + sec->reloc_count;
 739   for (rel = relocs; rel < rel_end; rel++)
 740     {
 741       struct elf_link_hash_entry *h;
 742       unsigned long r_symndx;
 743
 744       r_symndx = ELF32_R_SYM (rel->r_info);
 745       if (r_symndx < symtab_hdr->sh_info)
 746         h = NULL;
 747       else
 748         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 749
 750       switch (ELF32_R_TYPE (rel->r_info))
 751         {
 752         /* This relocation describes the C++ object vtable hierarchy.
 753            Reconstruct it for later use during GC.  */
 754         case R_FR30_GNU_VTINHERIT:
 755           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 756             return FALSE;
 757           break;
 758
 759         /* This relocation describes which C++ vtable entries are actually
 760            used.  Record for later use during GC.  */
 761         case R_FR30_GNU_VTENTRY:
 762           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 763             return FALSE;
 764           break;
 765         }
 766     }
 767
 768   return TRUE;
 769 }
 770 \f
 771 #define ELF_ARCH                bfd_arch_fr30
 772 #define ELF_MACHINE_CODE        EM_FR30
 773 #define ELF_MACHINE_ALT1        EM_CYGNUS_FR30
 774 #define ELF_MAXPAGESIZE         0x1000
 775
 776 #define TARGET_BIG_SYM          bfd_elf32_fr30_vec
 777 #define TARGET_BIG_NAME         "elf32-fr30"
 778
 779 #define elf_info_to_howto_rel                   NULL
 780 #define elf_info_to_howto                       fr30_info_to_howto_rela
 781 #define elf_backend_relocate_section            fr30_elf_relocate_section
 782 #define elf_backend_gc_mark_hook                fr30_elf_gc_mark_hook
 783 #define elf_backend_gc_sweep_hook               fr30_elf_gc_sweep_hook
 784 #define elf_backend_check_relocs                fr30_elf_check_relocs
 785
 786 #define elf_backend_can_gc_sections             1
 787 #define elf_backend_rela_normal                 1
 788
 789 #define bfd_elf32_bfd_reloc_type_lookup         fr30_reloc_type_lookup
 790
 791 #include "elf32-target.h"