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