bfd/elf32-mcore.c

   1 /* Motorola MCore specific support for 32-bit ELF
   2    Copyright 1994, 1995, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   3    2007 Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
  20    USA.  */
  21
  22 /* This file is based on a preliminary RCE ELF ABI.  The
  23    information may not match the final RCE ELF ABI.   */
  24
  25 #include "bfd.h"
  26 #include "sysdep.h"
  27 #include "bfdlink.h"
  28 #include "libbfd.h"
  29 #include "elf-bfd.h"
  30 #include "elf/mcore.h"
  31 #include <assert.h>
  32
  33 /* RELA relocs are used here...  */
  34
  35 /* Function to set whether a module needs the -mrelocatable bit set.  */
  36
  37 static bfd_boolean
  38 mcore_elf_set_private_flags (bfd * abfd, flagword flags)
  39 {
  40   BFD_ASSERT (! elf_flags_init (abfd)
  41               || elf_elfheader (abfd)->e_flags == flags);
  42
  43   elf_elfheader (abfd)->e_flags = flags;
  44   elf_flags_init (abfd) = TRUE;
  45   return TRUE;
  46 }
  47
  48 /* Merge backend specific data from an object file to the output
  49    object file when linking.  */
  50
  51 static bfd_boolean
  52 mcore_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
  53 {
  54   flagword old_flags;
  55   flagword new_flags;
  56
  57   /* Check if we have the same endianess.  */
  58   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
  59     return FALSE;
  60
  61   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
  62       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
  63     return TRUE;
  64
  65   new_flags = elf_elfheader (ibfd)->e_flags;
  66   old_flags = elf_elfheader (obfd)->e_flags;
  67
  68   if (! elf_flags_init (obfd))
  69     {
  70         /* First call, no flags set.  */
  71       elf_flags_init (obfd) = TRUE;
  72       elf_elfheader (obfd)->e_flags = new_flags;
  73     }
  74   else if (new_flags == old_flags)
  75     /* Compatible flags are OK.  */
  76     ;
  77   else
  78     {
  79       /* FIXME */
  80     }
  81
  82   return TRUE;
  83 }
  84 \f
  85 /* Don't pretend we can deal with unsupported relocs.  */
  86
  87 static bfd_reloc_status_type
  88 mcore_elf_unsupported_reloc (bfd * abfd,
  89                              arelent * reloc_entry,
  90                              asymbol * symbol ATTRIBUTE_UNUSED,
  91                              PTR data ATTRIBUTE_UNUSED,
  92                              asection * input_section ATTRIBUTE_UNUSED,
  93                              bfd * output_bfd ATTRIBUTE_UNUSED,
  94                              char ** error_message ATTRIBUTE_UNUSED)
  95 {
  96   BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
  97
  98   _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"),
  99                       abfd,
 100                       reloc_entry->howto->name,
 101                       reloc_entry->howto->type);
 102
 103   return bfd_reloc_notsupported;
 104 }
 105
 106 static reloc_howto_type * mcore_elf_howto_table [(int) R_MCORE_max];
 107
 108 static reloc_howto_type mcore_elf_howto_raw[] =
 109 {
 110   /* This reloc does nothing.  */
 111   HOWTO (R_MCORE_NONE,          /* type */
 112          0,                     /* rightshift */
 113          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 114          32,                    /* bitsize */
 115          FALSE,                 /* pc_relative */
 116          0,                     /* bitpos */
 117          complain_overflow_bitfield,  /* complain_on_overflow */
 118          NULL,                  /* special_function */
 119          "R_MCORE_NONE",        /* name */
 120          FALSE,                 /* partial_inplace */
 121          0,                     /* src_mask */
 122          0,                     /* dst_mask */
 123          FALSE),                /* pcrel_offset */
 124
 125   /* A standard 32 bit relocation.  */
 126   HOWTO (R_MCORE_ADDR32,        /* type */
 127          0,                     /* rightshift */
 128          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 129          32,                    /* bitsize */
 130          FALSE,                 /* pc_relative */
 131          0,                     /* bitpos */
 132          complain_overflow_bitfield, /* complain_on_overflow */
 133          bfd_elf_generic_reloc, /* special_function */
 134          "ADDR32",              /* name *//* For compatibility with coff/pe port.  */
 135          FALSE,                 /* partial_inplace */
 136          0x0,                   /* src_mask */
 137          0xffffffff,            /* dst_mask */
 138          FALSE),                /* pcrel_offset */
 139
 140   /* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions.
 141      Should not appear in object files.  */
 142   HOWTO (R_MCORE_PCRELIMM8BY4,  /* type */
 143          2,                     /* rightshift */
 144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 145          8,                     /* bitsize */
 146          TRUE,                  /* pc_relative */
 147          0,                     /* bitpos */
 148          complain_overflow_bitfield, /* complain_on_overflow */
 149          mcore_elf_unsupported_reloc,   /* special_function */
 150          "R_MCORE_PCRELIMM8BY4",/* name */
 151          FALSE,                 /* partial_inplace */
 152          0,                     /* src_mask */
 153          0,                     /* dst_mask */
 154          TRUE),                 /* pcrel_offset */
 155
 156   /* bsr/bt/bf/br instructions; 11 bits + 1 zero bit
 157      Span 2k instructions == 4k bytes.
 158      Only useful pieces at the relocated address are the opcode (5 bits) */
 159   HOWTO (R_MCORE_PCRELIMM11BY2,/* type */
 160          1,                     /* rightshift */
 161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 162          11,                    /* bitsize */
 163          TRUE,                  /* pc_relative */
 164          0,                     /* bitpos */
 165          complain_overflow_signed, /* complain_on_overflow */
 166          bfd_elf_generic_reloc, /* special_function */
 167          "R_MCORE_PCRELIMM11BY2",/* name */
 168          FALSE,                 /* partial_inplace */
 169          0x0,                   /* src_mask */
 170          0x7ff,                 /* dst_mask */
 171          TRUE),                 /* pcrel_offset */
 172
 173   /* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported.  */
 174   HOWTO (R_MCORE_PCRELIMM4BY2,  /* type */
 175          1,                     /* rightshift */
 176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 177          4,                     /* bitsize */
 178          TRUE,                  /* pc_relative */
 179          0,                     /* bitpos */
 180          complain_overflow_bitfield, /* complain_on_overflow */
 181          mcore_elf_unsupported_reloc,/* special_function */
 182          "R_MCORE_PCRELIMM4BY2",/* name */
 183          FALSE,                 /* partial_inplace */
 184          0,                     /* src_mask */
 185          0,                     /* dst_mask */
 186          TRUE),                 /* pcrel_offset */
 187
 188   /* 32-bit pc-relative. Eventually this will help support PIC code.  */
 189   HOWTO (R_MCORE_PCREL32,       /* type */
 190          0,                     /* rightshift */
 191          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 192          32,                    /* bitsize */
 193          TRUE,                  /* pc_relative */
 194          0,                     /* bitpos */
 195          complain_overflow_bitfield, /* complain_on_overflow */
 196          bfd_elf_generic_reloc, /* special_function */
 197          "R_MCORE_PCREL32",     /* name */
 198          FALSE,                 /* partial_inplace */
 199          0x0,                   /* src_mask */
 200          0xffffffff,            /* dst_mask */
 201          TRUE),                 /* pcrel_offset */
 202
 203   /* Like PCRELIMM11BY2, this relocation indicates that there is a
 204      'jsri' at the specified address. There is a separate relocation
 205      entry for the literal pool entry that it references, but we
 206      might be able to change the jsri to a bsr if the target turns out
 207      to be close enough [even though we won't reclaim the literal pool
 208      entry, we'll get some runtime efficiency back]. Note that this
 209      is a relocation that we are allowed to safely ignore.  */
 210   HOWTO (R_MCORE_PCRELJSR_IMM11BY2,/* type */
 211          1,                     /* rightshift */
 212          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 213          11,                    /* bitsize */
 214          TRUE,                  /* pc_relative */
 215          0,                     /* bitpos */
 216          complain_overflow_signed, /* complain_on_overflow */
 217          bfd_elf_generic_reloc, /* special_function */
 218          "R_MCORE_PCRELJSR_IMM11BY2", /* name */
 219          FALSE,                 /* partial_inplace */
 220          0x0,                   /* src_mask */
 221          0x7ff,                 /* dst_mask */
 222          TRUE),                 /* pcrel_offset */
 223
 224   /* GNU extension to record C++ vtable hierarchy.  */
 225   HOWTO (R_MCORE_GNU_VTINHERIT, /* type */
 226          0,                     /* rightshift */
 227          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 228          0,                     /* bitsize */
 229          FALSE,                 /* pc_relative */
 230          0,                     /* bitpos */
 231          complain_overflow_dont, /* complain_on_overflow */
 232          NULL,                  /* special_function */
 233          "R_MCORE_GNU_VTINHERIT", /* name */
 234          FALSE,                 /* partial_inplace */
 235          0,                     /* src_mask */
 236          0,                     /* dst_mask */
 237          FALSE),                /* pcrel_offset */
 238
 239   /* GNU extension to record C++ vtable member usage.  */
 240   HOWTO (R_MCORE_GNU_VTENTRY,   /* type */
 241          0,                     /* rightshift */
 242          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 243          0,                     /* bitsize */
 244          FALSE,                 /* pc_relative */
 245          0,                     /* bitpos */
 246          complain_overflow_dont,/* complain_on_overflow */
 247          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 248          "R_MCORE_GNU_VTENTRY", /* name */
 249          FALSE,                 /* partial_inplace */
 250          0,                     /* src_mask */
 251          0,                     /* dst_mask */
 252          FALSE),                /* pcrel_offset */
 253
 254   HOWTO (R_MCORE_RELATIVE,      /* type */
 255          0,                     /* rightshift */
 256          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 257          32,                    /* bitsize */
 258          FALSE,                 /* pc_relative */
 259          0,                     /* bitpos */
 260          complain_overflow_signed, /* complain_on_overflow */
 261          NULL,                  /* special_function */
 262          "R_MCORE_RELATIVE",    /* name */
 263          TRUE,                  /* partial_inplace */
 264          0xffffffff,            /* src_mask */
 265          0xffffffff,            /* dst_mask */
 266          FALSE)                 /* pcrel_offset */
 267 };
 268
 269 #ifndef NUM_ELEM
 270 #define NUM_ELEM(a) (sizeof (a) / sizeof (a)[0])
 271 #endif
 272 \f
 273 /* Initialize the mcore_elf_howto_table, so that linear accesses can be done.  */
 274 static void
 275 mcore_elf_howto_init (void)
 276 {
 277   unsigned int i;
 278
 279   for (i = NUM_ELEM (mcore_elf_howto_raw); i--;)
 280     {
 281       unsigned int type;
 282
 283       type = mcore_elf_howto_raw[i].type;
 284
 285       BFD_ASSERT (type < NUM_ELEM (mcore_elf_howto_table));
 286
 287       mcore_elf_howto_table [type] = & mcore_elf_howto_raw [i];
 288     }
 289 }
 290 \f
 291 static reloc_howto_type *
 292 mcore_elf_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 293                              bfd_reloc_code_real_type code)
 294 {
 295   enum elf_mcore_reloc_type mcore_reloc = R_MCORE_NONE;
 296
 297   switch (code)
 298     {
 299     case BFD_RELOC_NONE:                     mcore_reloc = R_MCORE_NONE; break;
 300     case BFD_RELOC_32:                       mcore_reloc = R_MCORE_ADDR32; break;
 301     case BFD_RELOC_MCORE_PCREL_IMM8BY4:      mcore_reloc = R_MCORE_PCRELIMM8BY4; break;
 302     case BFD_RELOC_MCORE_PCREL_IMM11BY2:     mcore_reloc = R_MCORE_PCRELIMM11BY2; break;
 303     case BFD_RELOC_MCORE_PCREL_IMM4BY2:      mcore_reloc = R_MCORE_PCRELIMM4BY2; break;
 304     case BFD_RELOC_32_PCREL:                 mcore_reloc = R_MCORE_PCREL32; break;
 305     case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2: mcore_reloc = R_MCORE_PCRELJSR_IMM11BY2; break;
 306     case BFD_RELOC_VTABLE_INHERIT:           mcore_reloc = R_MCORE_GNU_VTINHERIT; break;
 307     case BFD_RELOC_VTABLE_ENTRY:             mcore_reloc = R_MCORE_GNU_VTENTRY; break;
 308     case BFD_RELOC_RVA:                      mcore_reloc = R_MCORE_RELATIVE; break;
 309     default:
 310       return NULL;
 311     }
 312
 313   if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4])
 314     /* Initialize howto table if needed.  */
 315     mcore_elf_howto_init ();
 316
 317   return mcore_elf_howto_table [(int) mcore_reloc];
 318 };
 319
 320 /* Set the howto pointer for a RCE ELF reloc.  */
 321
 322 static void
 323 mcore_elf_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED,
 324                          arelent * cache_ptr,
 325                          Elf_Internal_Rela * dst)
 326 {
 327   if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4])
 328     /* Initialize howto table if needed.  */
 329     mcore_elf_howto_init ();
 330
 331   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_MCORE_max);
 332
 333   cache_ptr->howto = mcore_elf_howto_table [ELF32_R_TYPE (dst->r_info)];
 334 }
 335 \f
 336 /* The RELOCATE_SECTION function is called by the ELF backend linker
 337    to handle the relocations for a section.
 338
 339    The relocs are always passed as Rela structures; if the section
 340    actually uses Rel structures, the r_addend field will always be
 341    zero.
 342
 343    This function is responsible for adjust the section contents as
 344    necessary, and (if using Rela relocs and generating a
 345    relocatable output file) adjusting the reloc addend as
 346    necessary.
 347
 348    This function does not have to worry about setting the reloc
 349    address or the reloc symbol index.
 350
 351    LOCAL_SYMS is a pointer to the swapped in local symbols.
 352
 353    LOCAL_SECTIONS is an array giving the section in the input file
 354    corresponding to the st_shndx field of each local symbol.
 355
 356    The global hash table entry for the global symbols can be found
 357    via elf_sym_hashes (input_bfd).
 358
 359    When generating relocatable output, this function must handle
 360    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 361    going to be the section symbol corresponding to the output
 362    section, which means that the addend must be adjusted
 363    accordingly.  */
 364
 365 static bfd_boolean
 366 mcore_elf_relocate_section (bfd * output_bfd,
 367                             struct bfd_link_info * info,
 368                             bfd * input_bfd,
 369                             asection * input_section,
 370                             bfd_byte * contents,
 371                             Elf_Internal_Rela * relocs,
 372                             Elf_Internal_Sym * local_syms,
 373                             asection ** local_sections)
 374 {
 375   Elf_Internal_Shdr * symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 376   struct elf_link_hash_entry ** sym_hashes = elf_sym_hashes (input_bfd);
 377   Elf_Internal_Rela * rel = relocs;
 378   Elf_Internal_Rela * relend = relocs + input_section->reloc_count;
 379   bfd_boolean ret = TRUE;
 380
 381 #ifdef DEBUG
 382   _bfd_error_handler
 383     ("mcore_elf_relocate_section called for %B section %A, %ld relocations%s",
 384      input_bfd,
 385      input_section,
 386      (long) input_section->reloc_count,
 387      (info->relocatable) ? " (relocatable)" : "");
 388 #endif
 389
 390   if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4])   /* Initialize howto table if needed */
 391     mcore_elf_howto_init ();
 392
 393   for (; rel < relend; rel++)
 394     {
 395       enum elf_mcore_reloc_type    r_type = (enum elf_mcore_reloc_type) ELF32_R_TYPE (rel->r_info);
 396       bfd_vma                      offset = rel->r_offset;
 397       bfd_vma                      addend = rel->r_addend;
 398       bfd_reloc_status_type        r = bfd_reloc_other;
 399       asection *                   sec = NULL;
 400       reloc_howto_type *           howto;
 401       bfd_vma                      relocation;
 402       Elf_Internal_Sym *           sym = NULL;
 403       unsigned long                r_symndx;
 404       struct elf_link_hash_entry * h = NULL;
 405       unsigned short               oldinst = 0;
 406
 407       /* Unknown relocation handling.  */
 408       if ((unsigned) r_type >= (unsigned) R_MCORE_max
 409           || ! mcore_elf_howto_table [(int)r_type])
 410         {
 411           _bfd_error_handler (_("%B: Unknown relocation type %d\n"),
 412                               input_bfd, (int) r_type);
 413
 414           bfd_set_error (bfd_error_bad_value);
 415           ret = FALSE;
 416           continue;
 417         }
 418
 419       howto = mcore_elf_howto_table [(int) r_type];
 420       r_symndx = ELF32_R_SYM (rel->r_info);
 421
 422       /* Complain about known relocation that are not yet supported.  */
 423       if (howto->special_function == mcore_elf_unsupported_reloc)
 424         {
 425           _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"),
 426                               input_bfd,
 427                               howto->name,
 428                               (int)r_type);
 429
 430           bfd_set_error (bfd_error_bad_value);
 431           ret = FALSE;
 432           continue;
 433         }
 434
 435       if (r_symndx < symtab_hdr->sh_info)
 436         {
 437           sym = local_syms + r_symndx;
 438           sec = local_sections [r_symndx];
 439           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 440           addend = rel->r_addend;
 441         }
 442       else
 443         {
 444           bfd_boolean unresolved_reloc, warned;
 445
 446           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 447                                    r_symndx, symtab_hdr, sym_hashes,
 448                                    h, sec, relocation,
 449                                    unresolved_reloc, warned);
 450         }
 451
 452       if (sec != NULL && elf_discarded_section (sec))
 453         {
 454           /* For relocs against symbols from removed linkonce sections,
 455              or sections discarded by a linker script, we just want the
 456              section contents zeroed.  Avoid any special processing.  */
 457           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
 458           rel->r_info = 0;
 459           rel->r_addend = 0;
 460           continue;
 461         }
 462
 463       if (info->relocatable)
 464         continue;
 465
 466       switch (r_type)
 467         {
 468         default:
 469           break;
 470
 471         case R_MCORE_PCRELJSR_IMM11BY2:
 472           oldinst = bfd_get_16 (input_bfd, contents + offset);
 473 #define MCORE_INST_BSR  0xF800
 474           bfd_put_16 (input_bfd, (bfd_vma) MCORE_INST_BSR, contents + offset);
 475           break;
 476         }
 477
 478 #ifdef DEBUG
 479       fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
 480                howto->name, r_type, r_symndx, (long) offset, (long) addend);
 481 #endif
 482
 483       r = _bfd_final_link_relocate
 484         (howto, input_bfd, input_section, contents, offset, relocation, addend);
 485
 486       if (r != bfd_reloc_ok && r_type == R_MCORE_PCRELJSR_IMM11BY2)
 487         {
 488           /* Wasn't ok, back it out and give up.  */
 489           bfd_put_16 (input_bfd, (bfd_vma) oldinst, contents + offset);
 490           r = bfd_reloc_ok;
 491         }
 492
 493       if (r != bfd_reloc_ok)
 494         {
 495           ret = FALSE;
 496
 497           switch (r)
 498             {
 499             default:
 500               break;
 501
 502             case bfd_reloc_overflow:
 503               {
 504                 const char * name;
 505
 506                 if (h != NULL)
 507                   name = NULL;
 508                 else
 509                   {
 510                     name = bfd_elf_string_from_elf_section
 511                       (input_bfd, symtab_hdr->sh_link, sym->st_name);
 512
 513                     if (name == NULL)
 514                       break;
 515
 516                     if (* name == '\0')
 517                       name = bfd_section_name (input_bfd, sec);
 518                   }
 519
 520                 (*info->callbacks->reloc_overflow)
 521                   (info, (h ? &h->root : NULL), name, howto->name,
 522                    (bfd_vma) 0, input_bfd, input_section, offset);
 523               }
 524               break;
 525             }
 526         }
 527     }
 528
 529 #ifdef DEBUG
 530   fprintf (stderr, "\n");
 531 #endif
 532
 533   return ret;
 534 }
 535 \f
 536 /* Return the section that should be marked against GC for a given
 537    relocation.  */
 538
 539 static asection *
 540 mcore_elf_gc_mark_hook (asection *sec,
 541                         struct bfd_link_info *info,
 542                         Elf_Internal_Rela *rel,
 543                         struct elf_link_hash_entry *h,
 544                         Elf_Internal_Sym *sym)
 545 {
 546   if (h != NULL)
 547     switch (ELF32_R_TYPE (rel->r_info))
 548       {
 549       case R_MCORE_GNU_VTINHERIT:
 550       case R_MCORE_GNU_VTENTRY:
 551         return NULL;
 552       }
 553
 554   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
 555 }
 556
 557 /* Update the got entry reference counts for the section being removed.  */
 558
 559 static bfd_boolean
 560 mcore_elf_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED,
 561                          struct bfd_link_info * info ATTRIBUTE_UNUSED,
 562                          asection * sec ATTRIBUTE_UNUSED,
 563                          const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
 564 {
 565   return TRUE;
 566 }
 567
 568 /* Look through the relocs for a section during the first phase.
 569    Since we don't do .gots or .plts, we just need to consider the
 570    virtual table relocs for gc.  */
 571
 572 static bfd_boolean
 573 mcore_elf_check_relocs (bfd * abfd,
 574                         struct bfd_link_info * info,
 575                         asection * sec,
 576                         const Elf_Internal_Rela * relocs)
 577 {
 578   Elf_Internal_Shdr * symtab_hdr;
 579   struct elf_link_hash_entry ** sym_hashes;
 580   struct elf_link_hash_entry ** sym_hashes_end;
 581   const Elf_Internal_Rela * rel;
 582   const Elf_Internal_Rela * rel_end;
 583
 584   if (info->relocatable)
 585     return TRUE;
 586
 587   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 588   sym_hashes = elf_sym_hashes (abfd);
 589   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
 590   if (!elf_bad_symtab (abfd))
 591     sym_hashes_end -= symtab_hdr->sh_info;
 592
 593   rel_end = relocs + sec->reloc_count;
 594
 595   for (rel = relocs; rel < rel_end; rel++)
 596     {
 597       struct elf_link_hash_entry * h;
 598       unsigned long r_symndx;
 599
 600       r_symndx = ELF32_R_SYM (rel->r_info);
 601
 602       if (r_symndx < symtab_hdr->sh_info)
 603         h = NULL;
 604       else
 605         {
 606           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
 607           while (h->root.type == bfd_link_hash_indirect
 608                  || h->root.type == bfd_link_hash_warning)
 609             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 610         }
 611
 612       switch (ELF32_R_TYPE (rel->r_info))
 613         {
 614         /* This relocation describes the C++ object vtable hierarchy.
 615            Reconstruct it for later use during GC.  */
 616         case R_MCORE_GNU_VTINHERIT:
 617           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 618             return FALSE;
 619           break;
 620
 621         /* This relocation describes which C++ vtable entries are actually
 622            used.  Record for later use during GC.  */
 623         case R_MCORE_GNU_VTENTRY:
 624           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 625             return FALSE;
 626           break;
 627         }
 628     }
 629
 630   return TRUE;
 631 }
 632
 633 static const struct bfd_elf_special_section mcore_elf_special_sections[]=
 634 {
 635   { STRING_COMMA_LEN (".ctors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
 636   { STRING_COMMA_LEN (".dtors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
 637   { NULL,                     0,  0, 0,            0 }
 638 };
 639
 640 #define TARGET_BIG_SYM          bfd_elf32_mcore_big_vec
 641 #define TARGET_BIG_NAME         "elf32-mcore-big"
 642 #define TARGET_LITTLE_SYM       bfd_elf32_mcore_little_vec
 643 #define TARGET_LITTLE_NAME      "elf32-mcore-little"
 644
 645 #define ELF_ARCH                bfd_arch_mcore
 646 #define ELF_MACHINE_CODE        EM_MCORE
 647 #define ELF_MAXPAGESIZE         0x1000          /* 4k, if we ever have 'em */
 648 #define elf_info_to_howto       mcore_elf_info_to_howto
 649 #define elf_info_to_howto_rel   NULL
 650
 651 #define bfd_elf32_bfd_merge_private_bfd_data    mcore_elf_merge_private_bfd_data
 652 #define bfd_elf32_bfd_set_private_flags         mcore_elf_set_private_flags
 653 #define bfd_elf32_bfd_reloc_type_lookup         mcore_elf_reloc_type_lookup
 654 #define elf_backend_relocate_section            mcore_elf_relocate_section
 655 #define elf_backend_gc_mark_hook                mcore_elf_gc_mark_hook
 656 #define elf_backend_gc_sweep_hook               mcore_elf_gc_sweep_hook
 657 #define elf_backend_check_relocs                mcore_elf_check_relocs
 658 #define elf_backend_special_sections            mcore_elf_special_sections
 659
 660 #define elf_backend_can_gc_sections             1
 661 #define elf_backend_rela_normal                 1
 662
 663 #include "elf32-target.h"