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