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