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