bfd/elf32-mcore.c

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