1/* M16C/M32C specific support for 32-bit ELF. 2 Copyright (C) 2005, 2006 3 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#include "bfd.h" 22#include "sysdep.h" 23#include "libbfd.h" 24#include "elf-bfd.h" 25#include "elf/m32c.h" 26#include "libiberty.h" 27 28/* Forward declarations. */ 29static reloc_howto_type * m32c_reloc_type_lookup 30 (bfd *, bfd_reloc_code_real_type); 31static void m32c_info_to_howto_rela 32 (bfd *, arelent *, Elf_Internal_Rela *); 33static bfd_boolean m32c_elf_relocate_section 34 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **); 35static bfd_boolean m32c_elf_check_relocs 36 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *); 37static bfd_boolean m32c_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int); 38#ifdef DEBUG 39char * m32c_get_reloc (long reloc); 40void dump_symtab (bfd *, void *, void *); 41#endif 42static bfd_boolean m32c_elf_relax_section 43(bfd *abfd, asection *sec, struct bfd_link_info *link_info, bfd_boolean *again); 44 45 46static reloc_howto_type m32c_elf_howto_table [] = 47{ 48 /* This reloc does nothing. */ 49 HOWTO (R_M32C_NONE, /* type */ 50 0, /* rightshift */ 51 0, /* size (0 = byte, 1 = short, 2 = long) */ 52 32, /* bitsize */ 53 FALSE, /* pc_relative */ 54 0, /* bitpos */ 55 complain_overflow_bitfield, /* complain_on_overflow */ 56 bfd_elf_generic_reloc, /* special_function */ 57 "R_M32C_NONE", /* name */ 58 FALSE, /* partial_inplace */ 59 0, /* src_mask */ 60 0, /* dst_mask */ 61 FALSE), /* pcrel_offset */ 62 63 /* GCC intentionally overflows these next two in order to work 64 around limitations in the addressing modes, so don't complain 65 about overflow. */ 66 HOWTO (R_M32C_16, /* type */ 67 0, /* rightshift */ 68 1, /* size (0 = byte, 1 = short, 2 = long) */ 69 16, /* bitsize */ 70 FALSE, /* pc_relative */ 71 0, /* bitpos */ 72 complain_overflow_dont, /* complain_on_overflow */ 73 bfd_elf_generic_reloc, /* special_function */ 74 "R_M32C_16", /* name */ 75 FALSE, /* partial_inplace */ 76 0, /* src_mask */ 77 0xffff, /* dst_mask */ 78 FALSE), /* pcrel_offset */ 79 80 HOWTO (R_M32C_24, /* type */ 81 0, /* rightshift */ 82 2, /* size (0 = byte, 1 = short, 2 = long) */ 83 24, /* bitsize */ 84 FALSE, /* pc_relative */ 85 0, /* bitpos */ 86 complain_overflow_dont, /* complain_on_overflow */ 87 bfd_elf_generic_reloc, /* special_function */ 88 "R_M32C_24", /* name */ 89 FALSE, /* partial_inplace */ 90 0, /* src_mask */ 91 0xffffff, /* dst_mask */ 92 FALSE), /* pcrel_offset */ 93 94 HOWTO (R_M32C_32, /* type */ 95 0, /* rightshift */ 96 2, /* size (0 = byte, 1 = short, 2 = long) */ 97 32, /* bitsize */ 98 FALSE, /* pc_relative */ 99 0, /* bitpos */ 100 complain_overflow_bitfield, /* complain_on_overflow */ 101 bfd_elf_generic_reloc, /* special_function */ 102 "R_M32C_32", /* name */ 103 FALSE, /* partial_inplace */ 104 0, /* src_mask */ 105 0xffffffff, /* dst_mask */ 106 FALSE), /* pcrel_offset */ 107 108 HOWTO (R_M32C_8_PCREL, /* type */ 109 0, /* rightshift */ 110 0, /* size (0 = byte, 1 = short, 2 = long) */ 111 8, /* bitsize */ 112 TRUE, /* pc_relative */ 113 0, /* bitpos */ 114 complain_overflow_signed, /* complain_on_overflow */ 115 bfd_elf_generic_reloc, /* special_function */ 116 "R_M32C_8_PCREL", /* name */ 117 FALSE, /* partial_inplace */ 118 0, /* src_mask */ 119 0xff, /* dst_mask */ 120 TRUE), /* pcrel_offset */ 121 122 HOWTO (R_M32C_16_PCREL, /* type */ 123 0, /* rightshift */ 124 1, /* size (0 = byte, 1 = short, 2 = long) */ 125 16, /* bitsize */ 126 TRUE, /* pc_relative */ 127 0, /* bitpos */ 128 complain_overflow_signed, /* complain_on_overflow */ 129 bfd_elf_generic_reloc, /* special_function */ 130 "R_M32C_16_PCREL", /* name */ 131 FALSE, /* partial_inplace */ 132 0, /* src_mask */ 133 0xffff, /* dst_mask */ 134 TRUE), /* pcrel_offset */ 135 136 HOWTO (R_M32C_8, /* type */ 137 0, /* rightshift */ 138 0, /* size (0 = byte, 1 = short, 2 = long) */ 139 8, /* bitsize */ 140 FALSE, /* pc_relative */ 141 0, /* bitpos */ 142 complain_overflow_unsigned, /* complain_on_overflow */ 143 bfd_elf_generic_reloc, /* special_function */ 144 "R_M32C_8", /* name */ 145 FALSE, /* partial_inplace */ 146 0, /* src_mask */ 147 0xff, /* dst_mask */ 148 FALSE), /* pcrel_offset */ 149 150 HOWTO (R_M32C_LO16, /* type */ 151 0, /* rightshift */ 152 1, /* size (0 = byte, 1 = short, 2 = long) */ 153 16, /* bitsize */ 154 FALSE, /* pc_relative */ 155 0, /* bitpos */ 156 complain_overflow_dont, /* complain_on_overflow */ 157 bfd_elf_generic_reloc, /* special_function */ 158 "R_M32C_LO16", /* name */ 159 FALSE, /* partial_inplace */ 160 0, /* src_mask */ 161 0xffff, /* dst_mask */ 162 FALSE), /* pcrel_offset */ 163 164 HOWTO (R_M32C_HI8, /* type */ 165 0, /* rightshift */ 166 0, /* size (0 = byte, 1 = short, 2 = long) */ 167 8, /* bitsize */ 168 FALSE, /* pc_relative */ 169 0, /* bitpos */ 170 complain_overflow_dont, /* complain_on_overflow */ 171 bfd_elf_generic_reloc, /* special_function */ 172 "R_M32C_HI8", /* name */ 173 FALSE, /* partial_inplace */ 174 0, /* src_mask */ 175 0xff, /* dst_mask */ 176 FALSE), /* pcrel_offset */ 177 178 HOWTO (R_M32C_HI16, /* type */ 179 0, /* rightshift */ 180 1, /* size (0 = byte, 1 = short, 2 = long) */ 181 16, /* bitsize */ 182 FALSE, /* pc_relative */ 183 0, /* bitpos */ 184 complain_overflow_dont, /* complain_on_overflow */ 185 bfd_elf_generic_reloc, /* special_function */ 186 "R_M32C_HI16", /* name */ 187 FALSE, /* partial_inplace */ 188 0, /* src_mask */ 189 0xffff, /* dst_mask */ 190 FALSE), /* pcrel_offset */ 191 192 HOWTO (R_M32C_RL_JUMP, /* type */ 193 0, /* rightshift */ 194 0, /* size (0 = byte, 1 = short, 2 = long) */ 195 0, /* bitsize */ 196 FALSE, /* pc_relative */ 197 0, /* bitpos */ 198 complain_overflow_signed, /* complain_on_overflow */ 199 bfd_elf_generic_reloc, /* special_function */ 200 "R_M32C_RL_JUMP", /* name */ 201 FALSE, /* partial_inplace */ 202 0, /* src_mask */ 203 0, /* dst_mask */ 204 FALSE), /* pcrel_offset */ 205 206 HOWTO (R_M32C_RL_1ADDR, /* type */ 207 0, /* rightshift */ 208 0, /* size (0 = byte, 1 = short, 2 = long) */ 209 0, /* bitsize */ 210 FALSE, /* pc_relative */ 211 0, /* bitpos */ 212 complain_overflow_signed, /* complain_on_overflow */ 213 bfd_elf_generic_reloc, /* special_function */ 214 "R_M32C_RL_1ADDR", /* name */ 215 FALSE, /* partial_inplace */ 216 0, /* src_mask */ 217 0, /* dst_mask */ 218 FALSE), /* pcrel_offset */ 219 220 HOWTO (R_M32C_RL_2ADDR, /* type */ 221 0, /* rightshift */ 222 0, /* size (0 = byte, 1 = short, 2 = long) */ 223 0, /* bitsize */ 224 FALSE, /* pc_relative */ 225 0, /* bitpos */ 226 complain_overflow_signed, /* complain_on_overflow */ 227 bfd_elf_generic_reloc, /* special_function */ 228 "R_M32C_RL_2ADDR", /* name */ 229 FALSE, /* partial_inplace */ 230 0, /* src_mask */ 231 0, /* dst_mask */ 232 FALSE), /* pcrel_offset */ 233 234}; 235 236/* Map BFD reloc types to M32C ELF reloc types. */ 237 238struct m32c_reloc_map 239{ 240 bfd_reloc_code_real_type bfd_reloc_val; 241 unsigned int m32c_reloc_val; 242}; 243 244static const struct m32c_reloc_map m32c_reloc_map [] = 245{ 246 { BFD_RELOC_NONE, R_M32C_NONE }, 247 { BFD_RELOC_16, R_M32C_16 }, 248 { BFD_RELOC_24, R_M32C_24 }, 249 { BFD_RELOC_32, R_M32C_32 }, 250 { BFD_RELOC_8_PCREL, R_M32C_8_PCREL }, 251 { BFD_RELOC_16_PCREL, R_M32C_16_PCREL }, 252 { BFD_RELOC_8, R_M32C_8 }, 253 { BFD_RELOC_LO16, R_M32C_LO16 }, 254 { BFD_RELOC_HI16, R_M32C_HI16 }, 255 { BFD_RELOC_M32C_HI8, R_M32C_HI8 }, 256 { BFD_RELOC_M32C_RL_JUMP, R_M32C_RL_JUMP }, 257 { BFD_RELOC_M32C_RL_1ADDR, R_M32C_RL_1ADDR }, 258 { BFD_RELOC_M32C_RL_2ADDR, R_M32C_RL_2ADDR } 259}; 260 261static reloc_howto_type * 262m32c_reloc_type_lookup 263 (bfd * abfd ATTRIBUTE_UNUSED, 264 bfd_reloc_code_real_type code) 265{ 266 unsigned int i; 267 268 for (i = ARRAY_SIZE (m32c_reloc_map); --i;) 269 if (m32c_reloc_map [i].bfd_reloc_val == code) 270 return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val]; 271 272 return NULL; 273} 274 275/* Set the howto pointer for an M32C ELF reloc. */ 276 277static void 278m32c_info_to_howto_rela 279 (bfd * abfd ATTRIBUTE_UNUSED, 280 arelent * cache_ptr, 281 Elf_Internal_Rela * dst) 282{ 283 unsigned int r_type; 284 285 r_type = ELF32_R_TYPE (dst->r_info); 286 BFD_ASSERT (r_type < (unsigned int) R_M32C_max); 287 cache_ptr->howto = & m32c_elf_howto_table [r_type]; 288} 289 290 291 292/* Relocate an M32C ELF section. 293 There is some attempt to make this function usable for many architectures, 294 both USE_REL and USE_RELA ['twould be nice if such a critter existed], 295 if only to serve as a learning tool. 296 297 The RELOCATE_SECTION function is called by the new ELF backend linker 298 to handle the relocations for a section. 299 300 The relocs are always passed as Rela structures; if the section 301 actually uses Rel structures, the r_addend field will always be 302 zero. 303 304 This function is responsible for adjusting the section contents as 305 necessary, and (if using Rela relocs and generating a relocatable 306 output file) adjusting the reloc addend as necessary. 307 308 This function does not have to worry about setting the reloc 309 address or the reloc symbol index. 310 311 LOCAL_SYMS is a pointer to the swapped in local symbols. 312 313 LOCAL_SECTIONS is an array giving the section in the input file 314 corresponding to the st_shndx field of each local symbol. 315 316 The global hash table entry for the global symbols can be found 317 via elf_sym_hashes (input_bfd). 318 319 When generating relocatable output, this function must handle 320 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 321 going to be the section symbol corresponding to the output 322 section, which means that the addend must be adjusted 323 accordingly. */ 324 325static bfd_boolean 326m32c_elf_relocate_section 327 (bfd * output_bfd ATTRIBUTE_UNUSED, 328 struct bfd_link_info * info, 329 bfd * input_bfd, 330 asection * input_section, 331 bfd_byte * contents, 332 Elf_Internal_Rela * relocs, 333 Elf_Internal_Sym * local_syms, 334 asection ** local_sections) 335{ 336 Elf_Internal_Shdr * symtab_hdr; 337 struct elf_link_hash_entry ** sym_hashes; 338 Elf_Internal_Rela * rel; 339 Elf_Internal_Rela * relend; 340 bfd *dynobj; 341 asection *splt; 342 343 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 344 sym_hashes = elf_sym_hashes (input_bfd); 345 relend = relocs + input_section->reloc_count; 346 347 dynobj = elf_hash_table (info)->dynobj; 348 splt = NULL; 349 if (dynobj != NULL) 350 splt = bfd_get_section_by_name (dynobj, ".plt"); 351 352 for (rel = relocs; rel < relend; rel ++) 353 { 354 reloc_howto_type * howto; 355 unsigned long r_symndx; 356 Elf_Internal_Sym * sym; 357 asection * sec; 358 struct elf_link_hash_entry * h; 359 bfd_vma relocation; 360 bfd_reloc_status_type r; 361 const char * name = NULL; 362 int r_type; 363 364 r_type = ELF32_R_TYPE (rel->r_info); 365 366 /* These are only used for relaxing; we don't actually relocate 367 anything with them, so skip them. */ 368 if (r_type == R_M32C_RL_JUMP 369 || r_type == R_M32C_RL_1ADDR 370 || r_type == R_M32C_RL_2ADDR) 371 continue; 372 373 r_symndx = ELF32_R_SYM (rel->r_info); 374 375 if (info->relocatable) 376 { 377 /* This is a relocatable link. We don't have to change 378 anything, unless the reloc is against a section symbol, 379 in which case we have to adjust according to where the 380 section symbol winds up in the output section. */ 381 if (r_symndx < symtab_hdr->sh_info) 382 { 383 sym = local_syms + r_symndx; 384 385 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 386 { 387 sec = local_sections [r_symndx]; 388 rel->r_addend += sec->output_offset + sym->st_value; 389 } 390 } 391 392 continue; 393 } 394 395 /* This is a final link. */ 396 howto = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info); 397 h = NULL; 398 sym = NULL; 399 sec = NULL; 400 401 if (r_symndx < symtab_hdr->sh_info) 402 { 403 sym = local_syms + r_symndx; 404 sec = local_sections [r_symndx]; 405 relocation = (sec->output_section->vma 406 + sec->output_offset 407 + sym->st_value); 408 409 name = bfd_elf_string_from_elf_section 410 (input_bfd, symtab_hdr->sh_link, sym->st_name); 411 name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name; 412 } 413 else 414 { 415 h = sym_hashes [r_symndx - symtab_hdr->sh_info]; 416 417 while (h->root.type == bfd_link_hash_indirect 418 || h->root.type == bfd_link_hash_warning) 419 h = (struct elf_link_hash_entry *) h->root.u.i.link; 420 421 name = h->root.root.string; 422 423 if (h->root.type == bfd_link_hash_defined 424 || h->root.type == bfd_link_hash_defweak) 425 { 426 sec = h->root.u.def.section; 427 relocation = (h->root.u.def.value 428 + sec->output_section->vma 429 + sec->output_offset); 430 } 431 else if (h->root.type == bfd_link_hash_undefweak) 432 { 433 relocation = 0; 434 } 435 else 436 { 437 if (! ((*info->callbacks->undefined_symbol) 438 (info, h->root.root.string, input_bfd, 439 input_section, rel->r_offset, TRUE))) 440 return FALSE; 441 relocation = 0; 442 } 443 } 444 445 switch (ELF32_R_TYPE (rel->r_info)) 446 { 447 case R_M32C_16: 448 { 449 bfd_vma *plt_offset; 450 451 if (h != NULL) 452 plt_offset = &h->plt.offset; 453 else 454 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx; 455 456 /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)", 457 relocation, *plt_offset);*/ 458 if (relocation <= 0xffff) 459 { 460 /* If the symbol is in range for a 16-bit address, we should 461 have deallocated the plt entry in relax_section. */ 462 BFD_ASSERT (*plt_offset == (bfd_vma) -1); 463 } 464 else 465 { 466 /* If the symbol is out of range for a 16-bit address, 467 we must have allocated a plt entry. */ 468 BFD_ASSERT (*plt_offset != (bfd_vma) -1); 469 470 /* If this is the first time we've processed this symbol, 471 fill in the plt entry with the correct symbol address. */ 472 if ((*plt_offset & 1) == 0) 473 { 474 unsigned int x; 475 476 x = 0x000000fc; /* jmpf */ 477 x |= (relocation << 8) & 0xffffff00; 478 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset); 479 *plt_offset |= 1; 480 } 481 482 relocation = (splt->output_section->vma 483 + splt->output_offset 484 + (*plt_offset & -2)); 485 if (name) 486 { 487 char *newname = bfd_malloc (strlen(name)+5); 488 strcpy (newname, name); 489 strcat(newname, ".plt"); 490 _bfd_generic_link_add_one_symbol (info, 491 input_bfd, 492 newname, 493 BSF_FUNCTION | BSF_WEAK, 494 splt, 495 (*plt_offset & -2), 496 0, 497 1, 498 0, 499 0); 500 } 501 } 502 } 503 break; 504 505 case R_M32C_HI8: 506 case R_M32C_HI16: 507 relocation >>= 16; 508 break; 509 } 510 511#if 0 512 printf ("relocate %s at %06lx relocation %06lx addend %ld ", 513 m32c_elf_howto_table[ELF32_R_TYPE(rel->r_info)].name, 514 rel->r_offset + input_section->output_section->vma + input_section->output_offset, 515 relocation, rel->r_addend); 516 { 517 int i; 518 for (i=0; i<4; i++) 519 printf (" %02x", contents[rel->r_offset+i]); 520 printf ("\n"); 521 } 522#endif 523 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 524 contents, rel->r_offset, relocation, 525 rel->r_addend); 526 527 if (r != bfd_reloc_ok) 528 { 529 const char * msg = (const char *) NULL; 530 531 switch (r) 532 { 533 case bfd_reloc_overflow: 534 r = info->callbacks->reloc_overflow 535 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0, 536 input_bfd, input_section, rel->r_offset); 537 break; 538 539 case bfd_reloc_undefined: 540 r = info->callbacks->undefined_symbol 541 (info, name, input_bfd, input_section, rel->r_offset, 542 TRUE); 543 break; 544 545 case bfd_reloc_outofrange: 546 msg = _("internal error: out of range error"); 547 break; 548 549 case bfd_reloc_notsupported: 550 msg = _("internal error: unsupported relocation error"); 551 break; 552 553 case bfd_reloc_dangerous: 554 msg = _("internal error: dangerous relocation"); 555 break; 556 557 default: 558 msg = _("internal error: unknown error"); 559 break; 560 } 561 562 if (msg) 563 r = info->callbacks->warning 564 (info, msg, name, input_bfd, input_section, rel->r_offset); 565 566 if (! r) 567 return FALSE; 568 } 569 } 570 571 return TRUE; 572} 573 574/* We support 16-bit pointers to code above 64k by generating a thunk 575 below 64k containing a JMP instruction to the final address. */ 576 577static bfd_boolean 578m32c_elf_check_relocs 579 (bfd * abfd, 580 struct bfd_link_info * info, 581 asection * sec, 582 const Elf_Internal_Rela * relocs) 583{ 584 Elf_Internal_Shdr * symtab_hdr; 585 struct elf_link_hash_entry ** sym_hashes; 586 struct elf_link_hash_entry ** sym_hashes_end; 587 const Elf_Internal_Rela * rel; 588 const Elf_Internal_Rela * rel_end; 589 bfd_vma *local_plt_offsets; 590 asection *splt; 591 bfd *dynobj; 592 593 if (info->relocatable) 594 return TRUE; 595 596 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 597 sym_hashes = elf_sym_hashes (abfd); 598 local_plt_offsets = elf_local_got_offsets (abfd); 599 splt = NULL; 600 dynobj = elf_hash_table(info)->dynobj; 601 602 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym); 603 if (!elf_bad_symtab (abfd)) 604 sym_hashes_end -= symtab_hdr->sh_info; 605 606 rel_end = relocs + sec->reloc_count; 607 for (rel = relocs; rel < rel_end; rel++) 608 { 609 struct elf_link_hash_entry *h; 610 unsigned long r_symndx; 611 bfd_vma *offset; 612 613 r_symndx = ELF32_R_SYM (rel->r_info); 614 if (r_symndx < symtab_hdr->sh_info) 615 h = NULL; 616 else 617 { 618 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 619 while (h->root.type == bfd_link_hash_indirect 620 || h->root.type == bfd_link_hash_warning) 621 h = (struct elf_link_hash_entry *) h->root.u.i.link; 622 } 623 624 switch (ELF32_R_TYPE (rel->r_info)) 625 { 626 /* This relocation describes a 16-bit pointer to a function. 627 We may need to allocate a thunk in low memory; reserve memory 628 for it now. */ 629 case R_M32C_16: 630 if (dynobj == NULL) 631 elf_hash_table (info)->dynobj = dynobj = abfd; 632 if (splt == NULL) 633 { 634 splt = bfd_get_section_by_name (dynobj, ".plt"); 635 if (splt == NULL) 636 { 637 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 638 | SEC_IN_MEMORY | SEC_LINKER_CREATED 639 | SEC_READONLY | SEC_CODE); 640 splt = bfd_make_section_with_flags (dynobj, ".plt", flags); 641 if (splt == NULL 642 || ! bfd_set_section_alignment (dynobj, splt, 1)) 643 return FALSE; 644 } 645 } 646 647 if (h != NULL) 648 offset = &h->plt.offset; 649 else 650 { 651 if (local_plt_offsets == NULL) 652 { 653 size_t size; 654 unsigned int i; 655 656 size = symtab_hdr->sh_info * sizeof (bfd_vma); 657 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size); 658 if (local_plt_offsets == NULL) 659 return FALSE; 660 elf_local_got_offsets (abfd) = local_plt_offsets; 661 662 for (i = 0; i < symtab_hdr->sh_info; i++) 663 local_plt_offsets[i] = (bfd_vma) -1; 664 } 665 offset = &local_plt_offsets[r_symndx]; 666 } 667 668 if (*offset == (bfd_vma) -1) 669 { 670 *offset = splt->size; 671 splt->size += 4; 672 } 673 break; 674 } 675 } 676 677 return TRUE; 678} 679 680/* This must exist if dynobj is ever set. */ 681 682static bfd_boolean 683m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED, 684 struct bfd_link_info *info) 685{ 686 bfd *dynobj; 687 asection *splt; 688 689 /* As an extra sanity check, verify that all plt entries have 690 been filled in. */ 691 692 if ((dynobj = elf_hash_table (info)->dynobj) != NULL 693 && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL) 694 { 695 bfd_byte *contents = splt->contents; 696 unsigned int i, size = splt->size; 697 for (i = 0; i < size; i += 4) 698 { 699 unsigned int x = bfd_get_32 (dynobj, contents + i); 700 BFD_ASSERT (x != 0); 701 } 702 } 703 704 return TRUE; 705} 706 707static bfd_boolean 708m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 709 struct bfd_link_info *info) 710{ 711 bfd *dynobj; 712 asection *splt; 713 714 if (info->relocatable) 715 return TRUE; 716 717 dynobj = elf_hash_table (info)->dynobj; 718 if (dynobj == NULL) 719 return TRUE; 720 721 splt = bfd_get_section_by_name (dynobj, ".plt"); 722 BFD_ASSERT (splt != NULL); 723 724 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size); 725 if (splt->contents == NULL) 726 return FALSE; 727 728 return TRUE; 729} 730 731/* Function to set the ELF flag bits. */ 732 733static bfd_boolean 734m32c_elf_set_private_flags (bfd *abfd, flagword flags) 735{ 736 elf_elfheader (abfd)->e_flags = flags; 737 elf_flags_init (abfd) = TRUE; 738 return TRUE; 739} 740 741/* Merge backend specific data from an object file to the output 742 object file when linking. */ 743 744static bfd_boolean 745m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 746{ 747 flagword old_flags, old_partial; 748 flagword new_flags, new_partial; 749 bfd_boolean error = FALSE; 750 char new_opt[80]; 751 char old_opt[80]; 752 753 new_opt[0] = old_opt[0] = '\0'; 754 new_flags = elf_elfheader (ibfd)->e_flags; 755 old_flags = elf_elfheader (obfd)->e_flags; 756 757#ifdef DEBUG 758 (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s", 759 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no", 760 bfd_get_filename (ibfd)); 761#endif 762 763 if (!elf_flags_init (obfd)) 764 { 765 /* First call, no flags set. */ 766 elf_flags_init (obfd) = TRUE; 767 elf_elfheader (obfd)->e_flags = new_flags; 768 } 769 770 else if (new_flags == old_flags) 771 /* Compatible flags are ok. */ 772 ; 773 774 else /* Possibly incompatible flags. */ 775 { 776 /* Warn if different cpu is used (allow a specific cpu to override 777 the generic cpu). */ 778 new_partial = (new_flags & EF_M32C_CPU_MASK); 779 old_partial = (old_flags & EF_M32C_CPU_MASK); 780 if (new_partial == old_partial) 781 ; 782 783 else 784 { 785 switch (new_partial) 786 { 787 default: strcat (new_opt, " -m16c"); break; 788 case EF_M32C_CPU_M16C: strcat (new_opt, " -m16c"); break; 789 case EF_M32C_CPU_M32C: strcat (new_opt, " -m32c"); break; 790 } 791 792 switch (old_partial) 793 { 794 default: strcat (old_opt, " -m16c"); break; 795 case EF_M32C_CPU_M16C: strcat (old_opt, " -m16c"); break; 796 case EF_M32C_CPU_M32C: strcat (old_opt, " -m32c"); break; 797 } 798 } 799 800 /* Print out any mismatches from above. */ 801 if (new_opt[0]) 802 { 803 error = TRUE; 804 (*_bfd_error_handler) 805 (_("%s: compiled with %s and linked with modules compiled with %s"), 806 bfd_get_filename (ibfd), new_opt, old_opt); 807 } 808 809 new_flags &= ~ EF_M32C_ALL_FLAGS; 810 old_flags &= ~ EF_M32C_ALL_FLAGS; 811 812 /* Warn about any other mismatches. */ 813 if (new_flags != old_flags) 814 { 815 error = TRUE; 816 (*_bfd_error_handler) 817 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"), 818 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags); 819 } 820 } 821 822 if (error) 823 bfd_set_error (bfd_error_bad_value); 824 825 return !error; 826} 827 828 829static bfd_boolean 830m32c_elf_print_private_bfd_data (bfd *abfd, PTR ptr) 831{ 832 FILE *file = (FILE *) ptr; 833 flagword flags; 834 835 BFD_ASSERT (abfd != NULL && ptr != NULL); 836 837 /* Print normal ELF private data. */ 838 _bfd_elf_print_private_bfd_data (abfd, ptr); 839 840 flags = elf_elfheader (abfd)->e_flags; 841 fprintf (file, _("private flags = 0x%lx:"), (long)flags); 842 843 switch (flags & EF_M32C_CPU_MASK) 844 { 845 default: break; 846 case EF_M32C_CPU_M16C: fprintf (file, " -m16c"); break; 847 case EF_M32C_CPU_M32C: fprintf (file, " -m32c"); break; 848 } 849 850 fputc ('\n', file); 851 return TRUE; 852} 853 854/* Return the MACH for an e_flags value. */ 855 856static int 857elf32_m32c_machine (bfd *abfd) 858{ 859 switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK) 860 { 861 case EF_M32C_CPU_M16C: return bfd_mach_m16c; 862 case EF_M32C_CPU_M32C: return bfd_mach_m32c; 863 } 864 865 return bfd_mach_m16c; 866} 867 868static bfd_boolean 869m32c_elf_object_p (bfd *abfd) 870{ 871 bfd_default_set_arch_mach (abfd, bfd_arch_m32c, 872 elf32_m32c_machine (abfd)); 873 return TRUE; 874} 875 876 877#ifdef DEBUG 878void 879dump_symtab (bfd * abfd, void *internal_syms, void *external_syms) 880{ 881 size_t locsymcount; 882 Elf_Internal_Sym *isymbuf; 883 Elf_Internal_Sym *isymend; 884 Elf_Internal_Sym *isym; 885 Elf_Internal_Shdr *symtab_hdr; 886 bfd_boolean free_internal = 0, free_external = 0; 887 char * st_info_str; 888 char * st_info_stb_str; 889 char * st_other_str; 890 char * st_shndx_str; 891 892 if (! internal_syms) 893 { 894 internal_syms = bfd_malloc (1000); 895 free_internal = 1; 896 } 897 if (! external_syms) 898 { 899 external_syms = bfd_malloc (1000); 900 free_external = 1; 901 } 902 903 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 904 locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym; 905 if (free_internal) 906 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 907 symtab_hdr->sh_info, 0, 908 internal_syms, external_syms, NULL); 909 else 910 isymbuf = internal_syms; 911 isymend = isymbuf + locsymcount; 912 913 for (isym = isymbuf ; isym < isymend ; isym++) 914 { 915 switch (ELF_ST_TYPE (isym->st_info)) 916 { 917 case STT_FUNC: st_info_str = "STT_FUNC"; 918 case STT_SECTION: st_info_str = "STT_SECTION"; 919 case STT_FILE: st_info_str = "STT_FILE"; 920 case STT_OBJECT: st_info_str = "STT_OBJECT"; 921 case STT_TLS: st_info_str = "STT_TLS"; 922 default: st_info_str = ""; 923 } 924 switch (ELF_ST_BIND (isym->st_info)) 925 { 926 case STB_LOCAL: st_info_stb_str = "STB_LOCAL"; 927 case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL"; 928 default: st_info_stb_str = ""; 929 } 930 switch (ELF_ST_VISIBILITY (isym->st_other)) 931 { 932 case STV_DEFAULT: st_other_str = "STV_DEFAULT"; 933 case STV_INTERNAL: st_other_str = "STV_INTERNAL"; 934 case STV_PROTECTED: st_other_str = "STV_PROTECTED"; 935 default: st_other_str = ""; 936 } 937 switch (isym->st_shndx) 938 { 939 case SHN_ABS: st_shndx_str = "SHN_ABS"; 940 case SHN_COMMON: st_shndx_str = "SHN_COMMON"; 941 case SHN_UNDEF: st_shndx_str = "SHN_UNDEF"; 942 default: st_shndx_str = ""; 943 } 944 945 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s " 946 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n", 947 isym, 948 (unsigned long) isym->st_value, 949 (unsigned long) isym->st_size, 950 isym->st_name, 951 bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link, 952 isym->st_name), 953 isym->st_info, st_info_str, st_info_stb_str, 954 isym->st_other, st_other_str, 955 isym->st_shndx, st_shndx_str); 956 } 957 if (free_internal) 958 free (internal_syms); 959 if (free_external) 960 free (external_syms); 961} 962 963char * 964m32c_get_reloc (long reloc) 965{ 966 if (0 <= reloc && reloc < R_M32C_max) 967 return m32c_elf_howto_table[reloc].name; 968 else 969 return ""; 970} 971#endif /* DEBUG */ 972 973/* Handle relaxing. */ 974 975/* A subroutine of m32c_elf_relax_section. If the global symbol H 976 is within the low 64k, remove any entry for it in the plt. */ 977 978struct relax_plt_data 979{ 980 asection *splt; 981 bfd_boolean *again; 982}; 983 984static bfd_boolean 985m32c_relax_plt_check (struct elf_link_hash_entry *h, 986 PTR xdata) 987{ 988 struct relax_plt_data *data = (struct relax_plt_data *) xdata; 989 990 if (h->root.type == bfd_link_hash_warning) 991 h = (struct elf_link_hash_entry *) h->root.u.i.link; 992 993 if (h->plt.offset != (bfd_vma) -1) 994 { 995 bfd_vma address; 996 997 if (h->root.type == bfd_link_hash_undefined 998 || h->root.type == bfd_link_hash_undefweak) 999 address = 0; 1000 else 1001 address = (h->root.u.def.section->output_section->vma 1002 + h->root.u.def.section->output_offset 1003 + h->root.u.def.value); 1004 1005 if (address <= 0xffff) 1006 { 1007 h->plt.offset = -1; 1008 data->splt->size -= 4; 1009 *data->again = TRUE; 1010 } 1011 } 1012 1013 return TRUE; 1014} 1015 1016/* A subroutine of m32c_elf_relax_section. If the global symbol H 1017 previously had a plt entry, give it a new entry offset. */ 1018 1019static bfd_boolean 1020m32c_relax_plt_realloc (struct elf_link_hash_entry *h, 1021 PTR xdata) 1022{ 1023 bfd_vma *entry = (bfd_vma *) xdata; 1024 1025 if (h->root.type == bfd_link_hash_warning) 1026 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1027 1028 if (h->plt.offset != (bfd_vma) -1) 1029 { 1030 h->plt.offset = *entry; 1031 *entry += 4; 1032 } 1033 1034 return TRUE; 1035} 1036 1037static bfd_boolean 1038m32c_elf_relax_plt_section (bfd *dynobj, 1039 asection *splt, 1040 struct bfd_link_info *info, 1041 bfd_boolean *again) 1042{ 1043 struct relax_plt_data relax_plt_data; 1044 bfd *ibfd; 1045 1046 /* Assume nothing changes. */ 1047 *again = FALSE; 1048 1049 if (info->relocatable) 1050 return TRUE; 1051 1052 /* We only relax the .plt section at the moment. */ 1053 if (dynobj != elf_hash_table (info)->dynobj 1054 || strcmp (splt->name, ".plt") != 0) 1055 return TRUE; 1056 1057 /* Quick check for an empty plt. */ 1058 if (splt->size == 0) 1059 return TRUE; 1060 1061 /* Map across all global symbols; see which ones happen to 1062 fall in the low 64k. */ 1063 relax_plt_data.splt = splt; 1064 relax_plt_data.again = again; 1065 elf_link_hash_traverse (elf_hash_table (info), m32c_relax_plt_check, 1066 &relax_plt_data); 1067 1068 /* Likewise for local symbols, though that's somewhat less convenient 1069 as we have to walk the list of input bfds and swap in symbol data. */ 1070 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next) 1071 { 1072 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd); 1073 Elf_Internal_Shdr *symtab_hdr; 1074 Elf_Internal_Sym *isymbuf = NULL; 1075 unsigned int idx; 1076 1077 if (! local_plt_offsets) 1078 continue; 1079 1080 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 1081 if (symtab_hdr->sh_info != 0) 1082 { 1083 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1084 if (isymbuf == NULL) 1085 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr, 1086 symtab_hdr->sh_info, 0, 1087 NULL, NULL, NULL); 1088 if (isymbuf == NULL) 1089 return FALSE; 1090 } 1091 1092 for (idx = 0; idx < symtab_hdr->sh_info; ++idx) 1093 { 1094 Elf_Internal_Sym *isym; 1095 asection *tsec; 1096 bfd_vma address; 1097 1098 if (local_plt_offsets[idx] == (bfd_vma) -1) 1099 continue; 1100 1101 isym = &isymbuf[idx]; 1102 if (isym->st_shndx == SHN_UNDEF) 1103 continue; 1104 else if (isym->st_shndx == SHN_ABS) 1105 tsec = bfd_abs_section_ptr; 1106 else if (isym->st_shndx == SHN_COMMON) 1107 tsec = bfd_com_section_ptr; 1108 else 1109 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx); 1110 1111 address = (tsec->output_section->vma 1112 + tsec->output_offset 1113 + isym->st_value); 1114 if (address <= 0xffff) 1115 { 1116 local_plt_offsets[idx] = -1; 1117 splt->size -= 4; 1118 *again = TRUE; 1119 } 1120 } 1121 1122 if (isymbuf != NULL 1123 && symtab_hdr->contents != (unsigned char *) isymbuf) 1124 { 1125 if (! info->keep_memory) 1126 free (isymbuf); 1127 else 1128 { 1129 /* Cache the symbols for elf_link_input_bfd. */ 1130 symtab_hdr->contents = (unsigned char *) isymbuf; 1131 } 1132 } 1133 } 1134 1135 /* If we changed anything, walk the symbols again to reallocate 1136 .plt entry addresses. */ 1137 if (*again && splt->size > 0) 1138 { 1139 bfd_vma entry = 0; 1140 1141 elf_link_hash_traverse (elf_hash_table (info), 1142 m32c_relax_plt_realloc, &entry); 1143 1144 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next) 1145 { 1146 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd); 1147 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info; 1148 unsigned int idx; 1149 1150 if (! local_plt_offsets) 1151 continue; 1152 1153 for (idx = 0; idx < nlocals; ++idx) 1154 if (local_plt_offsets[idx] != (bfd_vma) -1) 1155 { 1156 local_plt_offsets[idx] = entry; 1157 entry += 4; 1158 } 1159 } 1160 } 1161 1162 return TRUE; 1163} 1164 1165static int 1166compare_reloc (const void *e1, const void *e2) 1167{ 1168 const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1; 1169 const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2; 1170 1171 if (i1->r_offset == i2->r_offset) 1172 return 0; 1173 else 1174 return i1->r_offset < i2->r_offset ? -1 : 1; 1175} 1176 1177#define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms) 1178static bfd_vma 1179m32c_offset_for_reloc (bfd *abfd, 1180 Elf_Internal_Rela *rel, 1181 Elf_Internal_Shdr *symtab_hdr, 1182 Elf_External_Sym_Shndx *shndx_buf, 1183 Elf_Internal_Sym *intsyms) 1184{ 1185 bfd_vma symval; 1186 1187 /* Get the value of the symbol referred to by the reloc. */ 1188 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info) 1189 { 1190 /* A local symbol. */ 1191 Elf_Internal_Sym *isym; 1192 Elf_External_Sym_Shndx *shndx; 1193 asection *ssec; 1194 1195 1196 isym = intsyms + ELF32_R_SYM (rel->r_info); 1197 ssec = bfd_section_from_elf_index (abfd, isym->st_shndx); 1198 shndx = shndx_buf + (shndx_buf ? ELF32_R_SYM (rel->r_info) : 0); 1199 1200 symval = isym->st_value; 1201 if (ssec) 1202 symval += ssec->output_section->vma 1203 + ssec->output_offset; 1204 } 1205 else 1206 { 1207 unsigned long indx; 1208 struct elf_link_hash_entry *h; 1209 1210 /* An external symbol. */ 1211 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info; 1212 h = elf_sym_hashes (abfd)[indx]; 1213 BFD_ASSERT (h != NULL); 1214 1215 if (h->root.type != bfd_link_hash_defined 1216 && h->root.type != bfd_link_hash_defweak) 1217 /* This appears to be a reference to an undefined 1218 symbol. Just ignore it--it will be caught by the 1219 regular reloc processing. */ 1220 return 0; 1221 1222 symval = (h->root.u.def.value 1223 + h->root.u.def.section->output_section->vma 1224 + h->root.u.def.section->output_offset); 1225 } 1226 return symval; 1227} 1228 1229static int bytes_saved = 0; 1230 1231static int bytes_to_reloc[] = { 1232 R_M32C_NONE, 1233 R_M32C_8, 1234 R_M32C_16, 1235 R_M32C_24, 1236 R_M32C_32 1237}; 1238 1239/* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */ 1240 1241/* Mask for the number of relocs associated with this insn. */ 1242#define RLA_RELOCS 0x0000000f 1243/* Number of bytes gas emitted (before gas's relaxing) */ 1244#define RLA_NBYTES 0x00000ff0 1245 1246/* If the displacement is within the given range and the new encoding 1247 differs from the old encoding (the index), then the insn can be 1248 relaxed to the new encoding. */ 1249typedef struct { 1250 int bytes; 1251 unsigned int max_disp; 1252 unsigned char new_encoding; 1253} EncodingTable; 1254 1255static EncodingTable m16c_addr_encodings[] = { 1256 { 0, 0, 0 }, /* R0 */ 1257 { 0, 0, 1 }, /* R1 */ 1258 { 0, 0, 2 }, /* R2 */ 1259 { 0, 0, 3 }, /* R3 */ 1260 { 0, 0, 4 }, /* A0 */ 1261 { 0, 0, 5 }, /* A1 */ 1262 { 0, 0, 6 }, /* [A0] */ 1263 { 0, 0, 7 }, /* [A1] */ 1264 { 1, 0, 6 }, /* udsp:8[A0] */ 1265 { 1, 0, 7 }, /* udsp:8[A1] */ 1266 { 1, 0, 10 }, /* udsp:8[SB] */ 1267 { 1, 0, 11 }, /* sdsp:8[FB] */ 1268 { 2, 255, 8 }, /* udsp:16[A0] */ 1269 { 2, 255, 9 }, /* udsp:16[A1] */ 1270 { 2, 255, 10 }, /* udsp:16[SB] */ 1271 { 2, 0, 15 }, /* abs:16 */ 1272}; 1273 1274static EncodingTable m16c_jmpaddr_encodings[] = { 1275 { 0, 0, 0 }, /* R0 */ 1276 { 0, 0, 1 }, /* R1 */ 1277 { 0, 0, 2 }, /* R2 */ 1278 { 0, 0, 3 }, /* R3 */ 1279 { 0, 0, 4 }, /* A0 */ 1280 { 0, 0, 5 }, /* A1 */ 1281 { 0, 0, 6 }, /* [A0] */ 1282 { 0, 0, 7 }, /* [A1] */ 1283 { 1, 0, 6 }, /* udsp:8[A0] */ 1284 { 1, 0, 7 }, /* udsp:8[A1] */ 1285 { 1, 0, 10 }, /* udsp:8[SB] */ 1286 { 1, 0, 11 }, /* sdsp:8[FB] */ 1287 { 3, 255, 8 }, /* udsp:20[A0] */ 1288 { 3, 255, 9 }, /* udsp:20[A1] */ 1289 { 2, 255, 10 }, /* udsp:16[SB] */ 1290 { 2, 0, 15 }, /* abs:16 */ 1291}; 1292 1293static EncodingTable m32c_addr_encodings[] = { 1294 { 0, 0, 0 }, /* [A0] */ 1295 { 0, 0, 1 }, /* [A1] */ 1296 { 0, 0, 2 }, /* A0 */ 1297 { 0, 0, 3 }, /* A1 */ 1298 { 1, 0, 0 }, /* udsp:8[A0] */ 1299 { 1, 0, 1 }, /* udsp:8[A1] */ 1300 { 1, 0, 6 }, /* udsp:8[SB] */ 1301 { 1, 0, 7 }, /* sdsp:8[FB] */ 1302 { 2, 255, 4 }, /* udsp:16[A0] */ 1303 { 2, 255, 5 }, /* udsp:16[A1] */ 1304 { 2, 255, 6 }, /* udsp:16[SB] */ 1305 { 2, 127, 7 }, /* sdsp:16[FB] */ 1306 { 3, 65535, 8 }, /* udsp:24[A0] */ 1307 { 3, 65535, 9 }, /* udsp:24[A1] */ 1308 { 3, 65535, 15 }, /* abs24 */ 1309 { 2, 0, 15 }, /* abs16 */ 1310 { 0, 0, 16 }, /* R2 */ 1311 { 0, 0, 17 }, /* R3 */ 1312 { 0, 0, 18 }, /* R0 */ 1313 { 0, 0, 19 }, /* R1 */ 1314 { 0, 0, 20 }, /* */ 1315 { 0, 0, 21 }, /* */ 1316 { 0, 0, 22 }, /* */ 1317 { 0, 0, 23 }, /* */ 1318 { 0, 0, 24 }, /* */ 1319 { 0, 0, 25 }, /* */ 1320 { 0, 0, 26 }, /* */ 1321 { 0, 0, 27 }, /* */ 1322 { 0, 0, 28 }, /* */ 1323 { 0, 0, 29 }, /* */ 1324 { 0, 0, 30 }, /* */ 1325 { 0, 0, 31 }, /* */ 1326}; 1327 1328static bfd_boolean 1329m32c_elf_relax_section 1330 (bfd * abfd, 1331 asection * sec, 1332 struct bfd_link_info * link_info, 1333 bfd_boolean * again) 1334{ 1335 Elf_Internal_Shdr *symtab_hdr; 1336 Elf_Internal_Shdr *shndx_hdr; 1337 Elf_Internal_Rela *internal_relocs; 1338 Elf_Internal_Rela *free_relocs = NULL; 1339 Elf_Internal_Rela *irel, *irelend, *srel; 1340 bfd_byte * contents = NULL; 1341 bfd_byte * free_contents = NULL; 1342 Elf_Internal_Sym *intsyms = NULL; 1343 Elf_Internal_Sym *free_intsyms = NULL; 1344 Elf_External_Sym_Shndx *shndx_buf = NULL; 1345 int machine; 1346 1347 if (abfd == elf_hash_table (link_info)->dynobj 1348 && strcmp (sec->name, ".plt") == 0) 1349 return m32c_elf_relax_plt_section (abfd, sec, link_info, again); 1350 1351 /* Assume nothing changes. */ 1352 *again = FALSE; 1353 1354 machine = elf32_m32c_machine (abfd); 1355 1356 /* We don't have to do anything for a relocatable link, if 1357 this section does not have relocs, or if this is not a 1358 code section. */ 1359 if (link_info->relocatable 1360 || (sec->flags & SEC_RELOC) == 0 1361 || sec->reloc_count == 0 1362 || (sec->flags & SEC_CODE) == 0) 1363 return TRUE; 1364 1365 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1366 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 1367 1368 /* Get the section contents. */ 1369 if (elf_section_data (sec)->this_hdr.contents != NULL) 1370 contents = elf_section_data (sec)->this_hdr.contents; 1371 /* Go get them off disk. */ 1372 else if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 1373 goto error_return; 1374 1375 /* Read this BFD's symbols. */ 1376 /* Get cached copy if it exists. */ 1377 if (symtab_hdr->contents != NULL) 1378 { 1379 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 1380 } 1381 else 1382 { 1383 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL); 1384 symtab_hdr->contents = (bfd_byte *) intsyms; 1385 } 1386 1387 if (shndx_hdr->sh_size != 0) 1388 { 1389 bfd_size_type amt; 1390 1391 amt = symtab_hdr->sh_info; 1392 amt *= sizeof (Elf_External_Sym_Shndx); 1393 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt); 1394 if (shndx_buf == NULL) 1395 goto error_return; 1396 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0 1397 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt) 1398 goto error_return; 1399 shndx_hdr->contents = (bfd_byte *) shndx_buf; 1400 } 1401 1402 /* Get a copy of the native relocations. */ 1403 internal_relocs = (_bfd_elf_link_read_relocs 1404 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 1405 link_info->keep_memory)); 1406 if (internal_relocs == NULL) 1407 goto error_return; 1408 if (! link_info->keep_memory) 1409 free_relocs = internal_relocs; 1410 1411 /* The RL_ relocs must be just before the operand relocs they go 1412 with, so we must sort them to guarantee this. */ 1413 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela), 1414 compare_reloc); 1415 1416 /* Walk through them looking for relaxing opportunities. */ 1417 irelend = internal_relocs + sec->reloc_count; 1418 1419 for (irel = internal_relocs; irel < irelend; irel++) 1420 { 1421 bfd_vma symval; 1422 unsigned char *insn, *gap, *einsn; 1423 bfd_vma pc; 1424 bfd_signed_vma pcrel; 1425 int relax_relocs; 1426 int gap_size; 1427 int new_type; 1428 int posn; 1429 int enc; 1430 EncodingTable *enctbl; 1431 EncodingTable *e; 1432 1433 if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP 1434 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR 1435 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR) 1436 continue; 1437 1438 srel = irel; 1439 1440 /* There will always be room for the relaxed insn, since it is smaller 1441 than the one it would replace. */ 1442 BFD_ASSERT (irel->r_offset < sec->size); 1443 1444 insn = contents + irel->r_offset; 1445 relax_relocs = irel->r_addend % 16; 1446 1447 /* Ok, we only have three relocs we care about, and they're all 1448 fake. The lower four bits of the addend is always the number 1449 of following relocs (hence the qsort above) that are assigned 1450 to this opcode. The next 8 bits of the addend indicates the 1451 number of bytes in the insn. We use the rest of them 1452 ourselves as flags for the more expensive operations (defines 1453 above). The three relocs are: 1454 1455 RL_JUMP: This marks all direct jump insns. We check the 1456 displacement and replace them with shorter jumps if 1457 they're in range. We also use this to find JMP.S 1458 insns and manually shorten them when we delete bytes. 1459 We have to decode these insns to figure out what to 1460 do. 1461 1462 RL_1ADDR: This is a :G or :Q insn, which has a single 1463 "standard" operand. We have to extract the type 1464 field, see if it's a wide displacement, then figure 1465 out if we can replace it with a narrow displacement. 1466 We don't have to decode these insns. 1467 1468 RL_2ADDR: Similarly, but two "standard" operands. Note that 1469 r_addend may still be 1, as standard operands don't 1470 always have displacements. Gas shouldn't give us one 1471 with zero operands, but since we don't know which one 1472 has the displacement, we check them both anyway. 1473 1474 These all point to the beginning of the insn itself, not the 1475 operands. 1476 1477 Note that we only relax one step at a time, relying on the 1478 linker to call us repeatedly. Thus, there is no code for 1479 JMP.A->JMP.B although that will happen in two steps. 1480 Likewise, for 2ADDR relaxes, we do one operand per cycle. 1481 */ 1482 1483 /* Get the value of the symbol referred to by the reloc. Just 1484 in case this is the last reloc in the list, use the RL's 1485 addend to choose between this reloc (no addend) or the next 1486 (yes addend, which means at least one following reloc). */ 1487 srel = irel + (relax_relocs ? 1 : 0); 1488 symval = OFFSET_FOR_RELOC (srel); 1489 1490 /* Setting gap_size nonzero is the flag which means "something 1491 shrunk". */ 1492 gap_size = 0; 1493 gap = NULL; 1494 new_type = ELF32_R_TYPE(srel->r_info); 1495 1496 pc = sec->output_section->vma + sec->output_offset 1497 + srel->r_offset; 1498 pcrel = symval - pc + srel->r_addend; 1499 1500 if (machine == bfd_mach_m16c) 1501 { 1502 /* R8C / M16C */ 1503 1504 switch (ELF32_R_TYPE(irel->r_info)) 1505 { 1506 1507 case R_M32C_RL_JUMP: 1508 switch (insn[0]) 1509 { 1510 case 0xfe: /* jmp.b */ 1511 if (pcrel >= 2 && pcrel <= 9) 1512 { 1513 /* Relax JMP.B -> JMP.S. We need to get rid of 1514 the following reloc though. */ 1515 insn[0] = 0x60 | (pcrel - 2); 1516 new_type = R_M32C_NONE; 1517 irel->r_addend = 0x10; 1518 gap_size = 1; 1519 gap = insn + 1; 1520 } 1521 break; 1522 1523 case 0xf4: /* jmp.w */ 1524 /* 128 is allowed because it will be one byte closer 1525 after relaxing. Likewise for all other pc-rel 1526 jumps. */ 1527 if (pcrel <= 128 && pcrel >= -128) 1528 { 1529 /* Relax JMP.W -> JMP.B */ 1530 insn[0] = 0xfe; 1531 insn[1] = 0; 1532 new_type = R_M32C_8_PCREL; 1533 gap_size = 1; 1534 gap = insn + 2; 1535 } 1536 break; 1537 1538 case 0xfc: /* jmp.a */ 1539 if (pcrel <= 32768 && pcrel >= -32768) 1540 { 1541 /* Relax JMP.A -> JMP.W */ 1542 insn[0] = 0xf4; 1543 insn[1] = 0; 1544 insn[2] = 0; 1545 new_type = R_M32C_16_PCREL; 1546 gap_size = 1; 1547 gap = insn + 3; 1548 } 1549 break; 1550 1551 case 0xfd: /* jsr.a */ 1552 if (pcrel <= 32768 && pcrel >= -32768) 1553 { 1554 /* Relax JSR.A -> JSR.W */ 1555 insn[0] = 0xf5; 1556 insn[1] = 0; 1557 insn[2] = 0; 1558 new_type = R_M32C_16_PCREL; 1559 gap_size = 1; 1560 gap = insn + 3; 1561 } 1562 break; 1563 } 1564 break; 1565 1566 case R_M32C_RL_2ADDR: 1567 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/ 1568 1569 enctbl = m16c_addr_encodings; 1570 posn = 2; 1571 enc = (insn[1] >> 4) & 0x0f; 1572 e = & enctbl[enc]; 1573 1574 if (srel->r_offset == irel->r_offset + posn 1575 && e->new_encoding != enc 1576 && symval <= e->max_disp) 1577 { 1578 insn[1] &= 0x0f; 1579 insn[1] |= e->new_encoding << 4; 1580 gap_size = e->bytes - enctbl[e->new_encoding].bytes; 1581 gap = insn + posn + enctbl[e->new_encoding].bytes; 1582 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes]; 1583 break; 1584 } 1585 if (relax_relocs == 2) 1586 srel ++; 1587 posn += e->bytes; 1588 1589 goto try_1addr_16; 1590 1591 case R_M32C_RL_1ADDR: 1592 /* xxxx xxxx xxxx dest [disp] */ 1593 1594 enctbl = m16c_addr_encodings; 1595 posn = 2; 1596 1597 /* Check the opcode for jumps. We know it's safe to 1598 do this because all 2ADDR insns are at least two 1599 bytes long. */ 1600 enc = insn[0] * 256 + insn[1]; 1601 enc &= 0xfff0; 1602 if (enc == 0x7d20 1603 || enc == 0x7d00 1604 || enc == 0x7d30 1605 || enc == 0x7d10) 1606 { 1607 enctbl = m16c_jmpaddr_encodings; 1608 } 1609 1610 try_1addr_16: 1611 /* srel, posn, and enc must be set here. */ 1612 1613 symval = OFFSET_FOR_RELOC (srel); 1614 enc = insn[1] & 0x0f; 1615 e = & enctbl[enc]; 1616 1617 if (srel->r_offset == irel->r_offset + posn 1618 && e->new_encoding != enc 1619 && symval <= e->max_disp) 1620 { 1621 insn[1] &= 0xf0; 1622 insn[1] |= e->new_encoding; 1623 gap_size = e->bytes - enctbl[e->new_encoding].bytes; 1624 gap = insn + posn + enctbl[e->new_encoding].bytes; 1625 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes]; 1626 break; 1627 } 1628 1629 break; 1630 1631 } /* Ends switch (reloc type) for m16c. */ 1632 } 1633 else /* machine == bfd_mach_m32c */ 1634 { 1635 /* M32CM / M32C */ 1636 1637 switch (ELF32_R_TYPE(irel->r_info)) 1638 { 1639 1640 case R_M32C_RL_JUMP: 1641 switch (insn[0]) 1642 { 1643 case 0xbb: /* jmp.b */ 1644 if (pcrel >= 2 && pcrel <= 9) 1645 { 1646 int p = pcrel - 2; 1647 /* Relax JMP.B -> JMP.S. We need to get rid of 1648 the following reloc though. */ 1649 insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1); 1650 new_type = R_M32C_NONE; 1651 irel->r_addend = 0x10; 1652 gap_size = 1; 1653 gap = insn + 1; 1654 } 1655 break; 1656 1657 case 0xce: /* jmp.w */ 1658 if (pcrel <= 128 && pcrel >= -128) 1659 { 1660 /* Relax JMP.W -> JMP.B */ 1661 insn[0] = 0xbb; 1662 insn[1] = 0; 1663 new_type = R_M32C_8_PCREL; 1664 gap_size = 1; 1665 gap = insn + 2; 1666 } 1667 break; 1668 1669 case 0xcc: /* jmp.a */ 1670 if (pcrel <= 32768 && pcrel >= -32768) 1671 { 1672 /* Relax JMP.A -> JMP.W */ 1673 insn[0] = 0xce; 1674 insn[1] = 0; 1675 insn[2] = 0; 1676 new_type = R_M32C_16_PCREL; 1677 gap_size = 1; 1678 gap = insn + 3; 1679 } 1680 break; 1681 1682 case 0xcd: /* jsr.a */ 1683 if (pcrel <= 32768 && pcrel >= -32768) 1684 { 1685 /* Relax JSR.A -> JSR.W */ 1686 insn[0] = 0xcf; 1687 insn[1] = 0; 1688 insn[2] = 0; 1689 new_type = R_M32C_16_PCREL; 1690 gap_size = 1; 1691 gap = insn + 3; 1692 } 1693 break; 1694 } 1695 break; 1696 1697 case R_M32C_RL_2ADDR: 1698 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/ 1699 1700 einsn = insn; 1701 posn = 2; 1702 if (einsn[0] == 1) 1703 { 1704 /* prefix; remove it as far as the RL reloc is concerned. */ 1705 einsn ++; 1706 posn ++; 1707 } 1708 1709 enctbl = m32c_addr_encodings; 1710 enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4); 1711 e = & enctbl[enc]; 1712 1713 if (srel->r_offset == irel->r_offset + posn 1714 && e->new_encoding != enc 1715 && symval <= e->max_disp) 1716 { 1717 einsn[0] &= 0x8f; 1718 einsn[0] |= (e->new_encoding & 0x1c) << 2; 1719 einsn[1] &= 0xcf; 1720 einsn[1] |= (e->new_encoding & 0x03) << 4; 1721 gap_size = e->bytes - enctbl[e->new_encoding].bytes; 1722 gap = insn + posn + enctbl[e->new_encoding].bytes; 1723 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes]; 1724 break; 1725 } 1726 if (relax_relocs == 2) 1727 srel ++; 1728 posn += e->bytes; 1729 1730 goto try_1addr_32; 1731 1732 case R_M32C_RL_1ADDR: 1733 /* xxxx DDDx DDxx xxxx [disp] */ 1734 1735 einsn = insn; 1736 posn = 2; 1737 if (einsn[0] == 1) 1738 { 1739 /* prefix; remove it as far as the RL reloc is concerned. */ 1740 einsn ++; 1741 posn ++; 1742 } 1743 1744 enctbl = m32c_addr_encodings; 1745 1746 try_1addr_32: 1747 /* srel, posn, and enc must be set here. */ 1748 1749 symval = OFFSET_FOR_RELOC (srel); 1750 enc = ((einsn[0] & 0x0e) << 1) | ((einsn[1] & 0xc0) >> 6); 1751 e = & enctbl[enc]; 1752 1753 if (srel->r_offset == irel->r_offset + posn 1754 && e->new_encoding != enc 1755 && symval <= e->max_disp) 1756 { 1757 einsn[0] &= 0xf1; 1758 einsn[0] |= (e->new_encoding & 0x1c) >> 1; 1759 einsn[1] &= 0x3f; 1760 einsn[1] |= (e->new_encoding & 0x03) << 6; 1761 gap_size = e->bytes - enctbl[e->new_encoding].bytes; 1762 gap = insn + posn + enctbl[e->new_encoding].bytes; 1763 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes]; 1764 break; 1765 } 1766 1767 break; 1768 1769 } /* Ends switch (reloc type) for m32c. */ 1770 } 1771 1772 if (gap_size == 0) 1773 continue; 1774 1775 *again = TRUE; 1776 1777 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type); 1778 1779 /* Note that we've changed the relocs, section contents, etc. */ 1780 elf_section_data (sec)->relocs = internal_relocs; 1781 free_relocs = NULL; 1782 1783 elf_section_data (sec)->this_hdr.contents = contents; 1784 free_contents = NULL; 1785 1786 symtab_hdr->contents = (bfd_byte *) intsyms; 1787 free_intsyms = NULL; 1788 1789 bytes_saved += gap_size; 1790 1791 if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size)) 1792 goto error_return; 1793 1794 } /* next relocation */ 1795 1796 if (free_relocs != NULL) 1797 { 1798 free (free_relocs); 1799 free_relocs = NULL; 1800 } 1801 1802 if (free_contents != NULL) 1803 { 1804 if (! link_info->keep_memory) 1805 free (free_contents); 1806 /* Cache the section contents for elf_link_input_bfd. */ 1807 else 1808 elf_section_data (sec)->this_hdr.contents = contents; 1809 1810 free_contents = NULL; 1811 } 1812 1813 if (shndx_buf != NULL) 1814 { 1815 shndx_hdr->contents = NULL; 1816 free (shndx_buf); 1817 } 1818 1819 if (free_intsyms != NULL) 1820 { 1821 if (! link_info->keep_memory) 1822 free (free_intsyms); 1823 /* Cache the symbols for elf_link_input_bfd. */ 1824 else 1825 { 1826 symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/; 1827 } 1828 1829 free_intsyms = NULL; 1830 } 1831 1832 return TRUE; 1833 1834 error_return: 1835 if (free_relocs != NULL) 1836 free (free_relocs); 1837 if (free_contents != NULL) 1838 free (free_contents); 1839 if (shndx_buf != NULL) 1840 { 1841 shndx_hdr->contents = NULL; 1842 free (shndx_buf); 1843 } 1844 if (free_intsyms != NULL) 1845 free (free_intsyms); 1846 return FALSE; 1847} 1848 1849/* Delete some bytes from a section while relaxing. */ 1850 1851static bfd_boolean 1852m32c_elf_relax_delete_bytes 1853 (bfd * abfd, 1854 asection * sec, 1855 bfd_vma addr, 1856 int count) 1857{ 1858 Elf_Internal_Shdr *symtab_hdr; 1859 Elf_Internal_Shdr *shndx_hdr; 1860 int sec_shndx; 1861 bfd_byte *contents; 1862 Elf_Internal_Rela *irel; 1863 Elf_Internal_Rela *irelend; 1864 Elf_Internal_Rela *irelalign; 1865 bfd_vma toaddr; 1866 Elf_Internal_Sym *isym; 1867 Elf_Internal_Sym *isymend; 1868 Elf_Internal_Sym *intsyms; 1869 Elf_External_Sym_Shndx *shndx_buf; 1870 Elf_External_Sym_Shndx *shndx; 1871 struct elf_link_hash_entry ** sym_hashes; 1872 struct elf_link_hash_entry ** end_hashes; 1873 unsigned int symcount; 1874 1875 contents = elf_section_data (sec)->this_hdr.contents; 1876 1877 /* The deletion must stop at the next ALIGN reloc for an aligment 1878 power larger than the number of bytes we are deleting. */ 1879 irelalign = NULL; 1880 toaddr = sec->size; 1881 1882 irel = elf_section_data (sec)->relocs; 1883 irelend = irel + sec->reloc_count; 1884 1885 /* Actually delete the bytes. */ 1886 memmove (contents + addr, contents + addr + count, (size_t) (toaddr - addr - count)); 1887 sec->size -= count; 1888 1889 /* Adjust all the relocs. */ 1890 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel ++) 1891 { 1892 /* Get the new reloc address. */ 1893 if (irel->r_offset > addr && irel->r_offset < toaddr) 1894 irel->r_offset -= count; 1895 1896 if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP 1897 && irel->r_addend == 0x10 /* one byte insn, no relocs */ 1898 && irel->r_offset + 1 < addr 1899 && irel->r_offset + 7 > addr) 1900 { 1901 bfd_vma disp; 1902 unsigned char *insn = &contents[irel->r_offset]; 1903 disp = *insn; 1904 /* This is a JMP.S, which we have to manually update. */ 1905 if (elf32_m32c_machine (abfd) == bfd_mach_m16c) 1906 { 1907 if ((*insn & 0xf8) != 0x60) 1908 continue; 1909 disp = (disp & 7); 1910 } 1911 else 1912 { 1913 if ((*insn & 0xce) != 0x4a) 1914 continue; 1915 disp = ((disp & 0x30) >> 3) | (disp & 1); 1916 } 1917 if (irel->r_offset + disp + 2 >= addr+count) 1918 { 1919 disp -= count; 1920 if (elf32_m32c_machine (abfd) == bfd_mach_m16c) 1921 { 1922 *insn = (*insn & 0xf8) | disp; 1923 } 1924 else 1925 { 1926 *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1); 1927 } 1928 } 1929 } 1930 } 1931 1932 /* Adjust the local symbols defined in this section. */ 1933 symtab_hdr = & elf_tdata (abfd)->symtab_hdr; 1934 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 1935 isym = intsyms; 1936 isymend = isym + symtab_hdr->sh_info; 1937 1938 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1939 shndx_hdr = & elf_tdata (abfd)->symtab_shndx_hdr; 1940 shndx_buf = (Elf_External_Sym_Shndx *) shndx_hdr->contents; 1941 shndx = shndx_buf; 1942 1943 for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL)) 1944 { 1945 1946 if ((int) isym->st_shndx == sec_shndx 1947 && isym->st_value > addr 1948 && isym->st_value < toaddr) 1949 { 1950 isym->st_value -= count; 1951 } 1952 } 1953 1954 /* Now adjust the global symbols defined in this section. */ 1955 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1956 - symtab_hdr->sh_info); 1957 sym_hashes = elf_sym_hashes (abfd); 1958 // sym_hashes += symtab_hdr->sh_info; 1959 end_hashes = sym_hashes + symcount; 1960 1961 for (; sym_hashes < end_hashes; sym_hashes ++) 1962 { 1963 struct elf_link_hash_entry * sym_hash = * sym_hashes; 1964 1965 if (sym_hash && 1966 ( sym_hash->root.type == bfd_link_hash_defined 1967 || sym_hash->root.type == bfd_link_hash_defweak) 1968 && sym_hash->root.u.def.section == sec 1969 && sym_hash->root.u.def.value > addr 1970 && sym_hash->root.u.def.value < toaddr) 1971 { 1972 sym_hash->root.u.def.value -= count; 1973 } 1974 } 1975 1976 return TRUE; 1977} 1978 1979 1980#define ELF_ARCH bfd_arch_m32c 1981#define ELF_MACHINE_CODE EM_M32C 1982#define ELF_MAXPAGESIZE 0x1000 1983 1984#if 0 1985#define TARGET_BIG_SYM bfd_elf32_m32c_vec 1986#define TARGET_BIG_NAME "elf32-m32c" 1987#else 1988#define TARGET_LITTLE_SYM bfd_elf32_m32c_vec 1989#define TARGET_LITTLE_NAME "elf32-m32c" 1990#endif 1991 1992#define elf_info_to_howto_rel NULL 1993#define elf_info_to_howto m32c_info_to_howto_rela 1994#define elf_backend_object_p m32c_elf_object_p 1995#define elf_backend_relocate_section m32c_elf_relocate_section 1996#define elf_backend_check_relocs m32c_elf_check_relocs 1997#define elf_backend_object_p m32c_elf_object_p 1998#define elf_symbol_leading_char ('_') 1999#define elf_backend_always_size_sections \ 2000 m32c_elf_always_size_sections 2001#define elf_backend_finish_dynamic_sections \ 2002 m32c_elf_finish_dynamic_sections 2003 2004#define elf_backend_can_gc_sections 1 2005 2006#define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup 2007#define bfd_elf32_bfd_relax_section m32c_elf_relax_section 2008#define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags 2009#define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data 2010#define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data 2011 2012#include "elf32-target.h" 2013