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