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 "sysdep.h"
  26 #include "bfd.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 static reloc_howto_type *
 321 mcore_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 322                              const char *r_name)
 323 {
 324   unsigned int i;
 325
 326   for (i = 0;
 327        i < sizeof (mcore_elf_howto_raw) / sizeof (mcore_elf_howto_raw[0]);
 328        i++)
 329     if (mcore_elf_howto_raw[i].name != NULL
 330         && strcasecmp (mcore_elf_howto_raw[i].name, r_name) == 0)
 331       return &mcore_elf_howto_raw[i];
 332
 333   return NULL;
 334 }
 335
 336 /* Set the howto pointer for a RCE ELF reloc.  */
 337
 338 static void
 339 mcore_elf_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED,
 340                          arelent * cache_ptr,
 341                          Elf_Internal_Rela * dst)
 342 {
 343   if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4])
 344     /* Initialize howto table if needed.  */
 345     mcore_elf_howto_init ();
 346
 347   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_MCORE_max);
 348
 349   cache_ptr->howto = mcore_elf_howto_table [ELF32_R_TYPE (dst->r_info)];
 350 }
 351 \f
 352 /* The RELOCATE_SECTION function is called by the ELF backend linker
 353    to handle the relocations for a section.
 354
 355    The relocs are always passed as Rela structures; if the section
 356    actually uses Rel structures, the r_addend field will always be
 357    zero.
 358
 359    This function is responsible for adjust the section contents as
 360    necessary, and (if using Rela relocs and generating a
 361    relocatable output file) adjusting the reloc addend as
 362    necessary.
 363
 364    This function does not have to worry about setting the reloc
 365    address or the reloc symbol index.
 366
 367    LOCAL_SYMS is a pointer to the swapped in local symbols.
 368
 369    LOCAL_SECTIONS is an array giving the section in the input file
 370    corresponding to the st_shndx field of each local symbol.
 371
 372    The global hash table entry for the global symbols can be found
 373    via elf_sym_hashes (input_bfd).
 374
 375    When generating relocatable output, this function must handle
 376    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 377    going to be the section symbol corresponding to the output
 378    section, which means that the addend must be adjusted
 379    accordingly.  */
 380
 381 static bfd_boolean
 382 mcore_elf_relocate_section (bfd * output_bfd,
 383                             struct bfd_link_info * info,
 384                             bfd * input_bfd,
 385                             asection * input_section,
 386                             bfd_byte * contents,
 387                             Elf_Internal_Rela * relocs,
 388                             Elf_Internal_Sym * local_syms,
 389                             asection ** local_sections)
 390 {
 391   Elf_Internal_Shdr * symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 392   struct elf_link_hash_entry ** sym_hashes = elf_sym_hashes (input_bfd);
 393   Elf_Internal_Rela * rel = relocs;
 394   Elf_Internal_Rela * relend = relocs + input_section->reloc_count;
 395   bfd_boolean ret = TRUE;
 396
 397 #ifdef DEBUG
 398   _bfd_error_handler
 399     ("mcore_elf_relocate_section called for %B section %A, %ld relocations%s",
 400      input_bfd,
 401      input_section,
 402      (long) input_section->reloc_count,
 403      (info->relocatable) ? " (relocatable)" : "");
 404 #endif
 405
 406   if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4])   /* Initialize howto table if needed */
 407     mcore_elf_howto_init ();
 408
 409   for (; rel < relend; rel++)
 410     {
 411       enum elf_mcore_reloc_type    r_type = (enum elf_mcore_reloc_type) ELF32_R_TYPE (rel->r_info);
 412       bfd_vma                      offset = rel->r_offset;
 413       bfd_vma                      addend = rel->r_addend;
 414       bfd_reloc_status_type        r = bfd_reloc_other;
 415       asection *                   sec = NULL;
 416       reloc_howto_type *           howto;
 417       bfd_vma                      relocation;
 418       Elf_Internal_Sym *           sym = NULL;
 419       unsigned long                r_symndx;
 420       struct elf_link_hash_entry * h = NULL;
 421       unsigned short               oldinst = 0;
 422
 423       /* Unknown relocation handling.  */
 424       if ((unsigned) r_type >= (unsigned) R_MCORE_max
 425           || ! mcore_elf_howto_table [(int)r_type])
 426         {
 427           _bfd_error_handler (_("%B: Unknown relocation type %d\n"),
 428                               input_bfd, (int) r_type);
 429
 430           bfd_set_error (bfd_error_bad_value);
 431           ret = FALSE;
 432           continue;
 433         }
 434
 435       howto = mcore_elf_howto_table [(int) r_type];
 436       r_symndx = ELF32_R_SYM (rel->r_info);
 437
 438       /* Complain about known relocation that are not yet supported.  */
 439       if (howto->special_function == mcore_elf_unsupported_reloc)
 440         {
 441           _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"),
 442                               input_bfd,
 443                               howto->name,
 444                               (int)r_type);
 445
 446           bfd_set_error (bfd_error_bad_value);
 447           ret = FALSE;
 448           continue;
 449         }
 450
 451       if (r_symndx < symtab_hdr->sh_info)
 452         {
 453           sym = local_syms + r_symndx;
 454           sec = local_sections [r_symndx];
 455           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 456           addend = rel->r_addend;
 457         }
 458       else
 459         {
 460           bfd_boolean unresolved_reloc, warned;
 461
 462           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 463                                    r_symndx, symtab_hdr, sym_hashes,
 464                                    h, sec, relocation,
 465                                    unresolved_reloc, warned);
 466         }
 467
 468       if (sec != NULL && elf_discarded_section (sec))
 469         {
 470           /* For relocs against symbols from removed linkonce sections,
 471              or sections discarded by a linker script, we just want the
 472              section contents zeroed.  Avoid any special processing.  */
 473           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
 474           rel->r_info = 0;
 475           rel->r_addend = 0;
 476           continue;
 477         }
 478
 479       if (info->relocatable)
 480         continue;
 481
 482       switch (r_type)
 483         {
 484         default:
 485           break;
 486
 487         case R_MCORE_PCRELJSR_IMM11BY2:
 488           oldinst = bfd_get_16 (input_bfd, contents + offset);
 489 #define MCORE_INST_BSR  0xF800
 490           bfd_put_16 (input_bfd, (bfd_vma) MCORE_INST_BSR, contents + offset);
 491           break;
 492         }
 493
 494 #ifdef DEBUG
 495       fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
 496                howto->name, r_type, r_symndx, (long) offset, (long) addend);
 497 #endif
 498
 499       r = _bfd_final_link_relocate
 500         (howto, input_bfd, input_section, contents, offset, relocation, addend);
 501
 502       if (r != bfd_reloc_ok && r_type == R_MCORE_PCRELJSR_IMM11BY2)
 503         {
 504           /* Wasn't ok, back it out and give up.  */
 505           bfd_put_16 (input_bfd, (bfd_vma) oldinst, contents + offset);
 506           r = bfd_reloc_ok;
 507         }
 508
 509       if (r != bfd_reloc_ok)
 510         {
 511           ret = FALSE;
 512
 513           switch (r)
 514             {
 515             default:
 516               break;
 517
 518             case bfd_reloc_overflow:
 519               {
 520                 const char * name;
 521
 522                 if (h != NULL)
 523                   name = NULL;
 524                 else
 525                   {
 526                     name = bfd_elf_string_from_elf_section
 527                       (input_bfd, symtab_hdr->sh_link, sym->st_name);
 528
 529                     if (name == NULL)
 530                       break;
 531
 532                     if (* name == '\0')
 533                       name = bfd_section_name (input_bfd, sec);
 534                   }
 535
 536                 (*info->callbacks->reloc_overflow)
 537                   (info, (h ? &h->root : NULL), name, howto->name,
 538                    (bfd_vma) 0, input_bfd, input_section, offset);
 539               }
 540               break;
 541             }
 542         }
 543     }
 544
 545 #ifdef DEBUG
 546   fprintf (stderr, "\n");
 547 #endif
 548
 549   return ret;
 550 }
 551 \f
 552 /* Return the section that should be marked against GC for a given
 553    relocation.  */
 554
 555 static asection *
 556 mcore_elf_gc_mark_hook (asection *sec,
 557                         struct bfd_link_info *info,
 558                         Elf_Internal_Rela *rel,
 559                         struct elf_link_hash_entry *h,
 560                         Elf_Internal_Sym *sym)
 561 {
 562   if (h != NULL)
 563     switch (ELF32_R_TYPE (rel->r_info))
 564       {
 565       case R_MCORE_GNU_VTINHERIT:
 566       case R_MCORE_GNU_VTENTRY:
 567         return NULL;
 568       }
 569
 570   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
 571 }
 572
 573 /* Update the got entry reference counts for the section being removed.  */
 574
 575 static bfd_boolean
 576 mcore_elf_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED,
 577                          struct bfd_link_info * info ATTRIBUTE_UNUSED,
 578                          asection * sec ATTRIBUTE_UNUSED,
 579                          const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
 580 {
 581   return TRUE;
 582 }
 583
 584 /* Look through the relocs for a section during the first phase.
 585    Since we don't do .gots or .plts, we just need to consider the
 586    virtual table relocs for gc.  */
 587
 588 static bfd_boolean
 589 mcore_elf_check_relocs (bfd * abfd,
 590                         struct bfd_link_info * info,
 591                         asection * sec,
 592                         const Elf_Internal_Rela * relocs)
 593 {
 594   Elf_Internal_Shdr * symtab_hdr;
 595   struct elf_link_hash_entry ** sym_hashes;
 596   struct elf_link_hash_entry ** sym_hashes_end;
 597   const Elf_Internal_Rela * rel;
 598   const Elf_Internal_Rela * rel_end;
 599
 600   if (info->relocatable)
 601     return TRUE;
 602
 603   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 604   sym_hashes = elf_sym_hashes (abfd);
 605   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
 606   if (!elf_bad_symtab (abfd))
 607     sym_hashes_end -= symtab_hdr->sh_info;
 608
 609   rel_end = relocs + sec->reloc_count;
 610
 611   for (rel = relocs; rel < rel_end; rel++)
 612     {
 613       struct elf_link_hash_entry * h;
 614       unsigned long r_symndx;
 615
 616       r_symndx = ELF32_R_SYM (rel->r_info);
 617
 618       if (r_symndx < symtab_hdr->sh_info)
 619         h = NULL;
 620       else
 621         {
 622           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
 623           while (h->root.type == bfd_link_hash_indirect
 624                  || h->root.type == bfd_link_hash_warning)
 625             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 626         }
 627
 628       switch (ELF32_R_TYPE (rel->r_info))
 629         {
 630         /* This relocation describes the C++ object vtable hierarchy.
 631            Reconstruct it for later use during GC.  */
 632         case R_MCORE_GNU_VTINHERIT:
 633           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 634             return FALSE;
 635           break;
 636
 637         /* This relocation describes which C++ vtable entries are actually
 638            used.  Record for later use during GC.  */
 639         case R_MCORE_GNU_VTENTRY:
 640           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 641             return FALSE;
 642           break;
 643         }
 644     }
 645
 646   return TRUE;
 647 }
 648
 649 static const struct bfd_elf_special_section mcore_elf_special_sections[]=
 650 {
 651   { STRING_COMMA_LEN (".ctors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
 652   { STRING_COMMA_LEN (".dtors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
 653   { NULL,                     0,  0, 0,            0 }
 654 };
 655
 656 #define TARGET_BIG_SYM          bfd_elf32_mcore_big_vec
 657 #define TARGET_BIG_NAME         "elf32-mcore-big"
 658 #define TARGET_LITTLE_SYM       bfd_elf32_mcore_little_vec
 659 #define TARGET_LITTLE_NAME      "elf32-mcore-little"
 660
 661 #define ELF_ARCH                bfd_arch_mcore
 662 #define ELF_MACHINE_CODE        EM_MCORE
 663 #define ELF_MAXPAGESIZE         0x1000          /* 4k, if we ever have 'em */
 664 #define elf_info_to_howto       mcore_elf_info_to_howto
 665 #define elf_info_to_howto_rel   NULL
 666
 667 #define bfd_elf32_bfd_merge_private_bfd_data    mcore_elf_merge_private_bfd_data
 668 #define bfd_elf32_bfd_set_private_flags         mcore_elf_set_private_flags
 669 #define bfd_elf32_bfd_reloc_type_lookup         mcore_elf_reloc_type_lookup
 670 #define bfd_elf32_bfd_reloc_name_lookup mcore_elf_reloc_name_lookup
 671 #define elf_backend_relocate_section            mcore_elf_relocate_section
 672 #define elf_backend_gc_mark_hook                mcore_elf_gc_mark_hook
 673 #define elf_backend_gc_sweep_hook               mcore_elf_gc_sweep_hook
 674 #define elf_backend_check_relocs                mcore_elf_check_relocs
 675 #define elf_backend_special_sections            mcore_elf_special_sections
 676
 677 #define elf_backend_can_gc_sections             1
 678 #define elf_backend_rela_normal                 1
 679
 680 #include "elf32-target.h"