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