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