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 (!info->relocatable) 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 (info->relocatable) 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 (info->relocatable) 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 (info->relocatable) 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 (info->relocatable) 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 (link_info->relocatable 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_tdata (abfd)->symtab_hdr; 1477 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 1478 1479 /* Get the section contents. */ 1480 if (elf_section_data (sec)->this_hdr.contents != NULL) 1481 contents = elf_section_data (sec)->this_hdr.contents; 1482 /* Go get them off disk. */ 1483 else if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 1484 goto error_return; 1485 1486 /* Read this BFD's symbols. */ 1487 /* Get cached copy if it exists. */ 1488 if (symtab_hdr->contents != NULL) 1489 { 1490 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 1491 } 1492 else 1493 { 1494 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL); 1495 symtab_hdr->contents = (bfd_byte *) intsyms; 1496 } 1497 1498 if (shndx_hdr->sh_size != 0) 1499 { 1500 bfd_size_type amt; 1501 1502 amt = symtab_hdr->sh_info; 1503 amt *= sizeof (Elf_External_Sym_Shndx); 1504 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt); 1505 if (shndx_buf == NULL) 1506 goto error_return; 1507 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0 1508 || bfd_bread (shndx_buf, amt, abfd) != amt) 1509 goto error_return; 1510 shndx_hdr->contents = (bfd_byte *) shndx_buf; 1511 } 1512 1513 /* Get a copy of the native relocations. */ 1514 internal_relocs = (_bfd_elf_link_read_relocs 1515 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, 1516 link_info->keep_memory)); 1517 if (internal_relocs == NULL) 1518 goto error_return; 1519 if (! link_info->keep_memory) 1520 free_relocs = internal_relocs; 1521 1522 /* The RL_ relocs must be just before the operand relocs they go 1523 with, so we must sort them to guarantee this. */ 1524 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela), 1525 compare_reloc); 1526 1527 /* Walk through them looking for relaxing opportunities. */ 1528 irelend = internal_relocs + sec->reloc_count; 1529 1530 for (irel = internal_relocs; irel < irelend; irel++) 1531 { 1532 bfd_vma symval; 1533 unsigned char *insn, *gap, *einsn; 1534 bfd_vma pc; 1535 bfd_signed_vma pcrel; 1536 int relax_relocs; 1537 int gap_size; 1538 int new_type; 1539 int posn; 1540 int enc; 1541 EncodingTable *enctbl; 1542 EncodingTable *e; 1543 1544 if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP 1545 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR 1546 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR) 1547 continue; 1548 1549 srel = irel; 1550 1551 /* There will always be room for the relaxed insn, since it is smaller 1552 than the one it would replace. */ 1553 BFD_ASSERT (irel->r_offset < sec->size); 1554 1555 insn = contents + irel->r_offset; 1556 relax_relocs = irel->r_addend % 16; 1557 1558 /* Ok, we only have three relocs we care about, and they're all 1559 fake. The lower four bits of the addend is always the number 1560 of following relocs (hence the qsort above) that are assigned 1561 to this opcode. The next 8 bits of the addend indicates the 1562 number of bytes in the insn. We use the rest of them 1563 ourselves as flags for the more expensive operations (defines 1564 above). The three relocs are: 1565 1566 RL_JUMP: This marks all direct jump insns. We check the 1567 displacement and replace them with shorter jumps if 1568 they're in range. We also use this to find JMP.S 1569 insns and manually shorten them when we delete bytes. 1570 We have to decode these insns to figure out what to 1571 do. 1572 1573 RL_1ADDR: This is a :G or :Q insn, which has a single 1574 "standard" operand. We have to extract the type 1575 field, see if it's a wide displacement, then figure 1576 out if we can replace it with a narrow displacement. 1577 We don't have to decode these insns. 1578 1579 RL_2ADDR: Similarly, but two "standard" operands. Note that 1580 r_addend may still be 1, as standard operands don't 1581 always have displacements. Gas shouldn't give us one 1582 with zero operands, but since we don't know which one 1583 has the displacement, we check them both anyway. 1584 1585 These all point to the beginning of the insn itself, not the 1586 operands. 1587 1588 Note that we only relax one step at a time, relying on the 1589 linker to call us repeatedly. Thus, there is no code for 1590 JMP.A->JMP.B although that will happen in two steps. 1591 Likewise, for 2ADDR relaxes, we do one operand per cycle. 1592 */ 1593 1594 /* Get the value of the symbol referred to by the reloc. Just 1595 in case this is the last reloc in the list, use the RL's 1596 addend to choose between this reloc (no addend) or the next 1597 (yes addend, which means at least one following reloc). */ 1598 srel = irel + (relax_relocs ? 1 : 0); 1599 symval = OFFSET_FOR_RELOC (srel); 1600 1601 /* Setting gap_size nonzero is the flag which means "something 1602 shrunk". */ 1603 gap_size = 0; 1604 gap = NULL; 1605 new_type = ELF32_R_TYPE(srel->r_info); 1606 1607 pc = sec->output_section->vma + sec->output_offset 1608 + srel->r_offset; 1609 pcrel = symval - pc + srel->r_addend; 1610 1611 if (machine == bfd_mach_m16c) 1612 { 1613 /* R8C / M16C */ 1614 1615 switch (ELF32_R_TYPE(irel->r_info)) 1616 { 1617 1618 case R_M32C_RL_JUMP: 1619 switch (insn[0]) 1620 { 1621 case 0xfe: /* jmp.b */ 1622 if (pcrel >= 2 && pcrel <= 9) 1623 { 1624 /* Relax JMP.B -> JMP.S. We need to get rid of 1625 the following reloc though. */ 1626 insn[0] = 0x60 | (pcrel - 2); 1627 new_type = R_M32C_NONE; 1628 irel->r_addend = 0x10; 1629 gap_size = 1; 1630 gap = insn + 1; 1631 } 1632 break; 1633 1634 case 0xf4: /* jmp.w */ 1635 /* 128 is allowed because it will be one byte closer 1636 after relaxing. Likewise for all other pc-rel 1637 jumps. */ 1638 if (pcrel <= 128 && pcrel >= -128) 1639 { 1640 /* Relax JMP.W -> JMP.B */ 1641 insn[0] = 0xfe; 1642 insn[1] = 0; 1643 new_type = R_M32C_8_PCREL; 1644 gap_size = 1; 1645 gap = insn + 2; 1646 } 1647 break; 1648 1649 case 0xfc: /* jmp.a */ 1650 if (pcrel <= 32768 && pcrel >= -32768) 1651 { 1652 /* Relax JMP.A -> JMP.W */ 1653 insn[0] = 0xf4; 1654 insn[1] = 0; 1655 insn[2] = 0; 1656 new_type = R_M32C_16_PCREL; 1657 gap_size = 1; 1658 gap = insn + 3; 1659 } 1660 break; 1661 1662 case 0xfd: /* jsr.a */ 1663 if (pcrel <= 32768 && pcrel >= -32768) 1664 { 1665 /* Relax JSR.A -> JSR.W */ 1666 insn[0] = 0xf5; 1667 insn[1] = 0; 1668 insn[2] = 0; 1669 new_type = R_M32C_16_PCREL; 1670 gap_size = 1; 1671 gap = insn + 3; 1672 } 1673 break; 1674 } 1675 break; 1676 1677 case R_M32C_RL_2ADDR: 1678 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/ 1679 1680 enctbl = m16c_addr_encodings; 1681 posn = 2; 1682 enc = (insn[1] >> 4) & 0x0f; 1683 e = & enctbl[enc]; 1684 1685 if (srel->r_offset == irel->r_offset + posn 1686 && e->new_encoding != enc 1687 && symval <= e->max_disp) 1688 { 1689 insn[1] &= 0x0f; 1690 insn[1] |= e->new_encoding << 4; 1691 gap_size = e->bytes - enctbl[e->new_encoding].bytes; 1692 gap = insn + posn + enctbl[e->new_encoding].bytes; 1693 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes]; 1694 break; 1695 } 1696 if (relax_relocs == 2) 1697 srel ++; 1698 posn += e->bytes; 1699 1700 goto try_1addr_16; 1701 1702 case R_M32C_RL_1ADDR: 1703 /* xxxx xxxx xxxx dest [disp] */ 1704 1705 enctbl = m16c_addr_encodings; 1706 posn = 2; 1707 1708 /* Check the opcode for jumps. We know it's safe to 1709 do this because all 2ADDR insns are at least two 1710 bytes long. */ 1711 enc = insn[0] * 256 + insn[1]; 1712 enc &= 0xfff0; 1713 if (enc == 0x7d20 1714 || enc == 0x7d00 1715 || enc == 0x7d30 1716 || enc == 0x7d10) 1717 { 1718 enctbl = m16c_jmpaddr_encodings; 1719 } 1720 1721 try_1addr_16: 1722 /* srel, posn, and enc must be set here. */ 1723 1724 symval = OFFSET_FOR_RELOC (srel); 1725 enc = insn[1] & 0x0f; 1726 e = & enctbl[enc]; 1727 1728 if (srel->r_offset == irel->r_offset + posn 1729 && e->new_encoding != enc 1730 && symval <= e->max_disp) 1731 { 1732 insn[1] &= 0xf0; 1733 insn[1] |= e->new_encoding; 1734 gap_size = e->bytes - enctbl[e->new_encoding].bytes; 1735 gap = insn + posn + enctbl[e->new_encoding].bytes; 1736 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes]; 1737 break; 1738 } 1739 1740 break; 1741 1742 } /* Ends switch (reloc type) for m16c. */ 1743 } 1744 else /* machine == bfd_mach_m32c */ 1745 { 1746 /* M32CM / M32C */ 1747 1748 switch (ELF32_R_TYPE(irel->r_info)) 1749 { 1750 1751 case R_M32C_RL_JUMP: 1752 switch (insn[0]) 1753 { 1754 case 0xbb: /* jmp.b */ 1755 if (pcrel >= 2 && pcrel <= 9) 1756 { 1757 int p = pcrel - 2; 1758 /* Relax JMP.B -> JMP.S. We need to get rid of 1759 the following reloc though. */ 1760 insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1); 1761 new_type = R_M32C_NONE; 1762 irel->r_addend = 0x10; 1763 gap_size = 1; 1764 gap = insn + 1; 1765 } 1766 break; 1767 1768 case 0xce: /* jmp.w */ 1769 if (pcrel <= 128 && pcrel >= -128) 1770 { 1771 /* Relax JMP.W -> JMP.B */ 1772 insn[0] = 0xbb; 1773 insn[1] = 0; 1774 new_type = R_M32C_8_PCREL; 1775 gap_size = 1; 1776 gap = insn + 2; 1777 } 1778 break; 1779 1780 case 0xcc: /* jmp.a */ 1781 if (pcrel <= 32768 && pcrel >= -32768) 1782 { 1783 /* Relax JMP.A -> JMP.W */ 1784 insn[0] = 0xce; 1785 insn[1] = 0; 1786 insn[2] = 0; 1787 new_type = R_M32C_16_PCREL; 1788 gap_size = 1; 1789 gap = insn + 3; 1790 } 1791 break; 1792 1793 case 0xcd: /* jsr.a */ 1794 if (pcrel <= 32768 && pcrel >= -32768) 1795 { 1796 /* Relax JSR.A -> JSR.W */ 1797 insn[0] = 0xcf; 1798 insn[1] = 0; 1799 insn[2] = 0; 1800 new_type = R_M32C_16_PCREL; 1801 gap_size = 1; 1802 gap = insn + 3; 1803 } 1804 break; 1805 } 1806 break; 1807 1808 case R_M32C_RL_2ADDR: 1809 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/ 1810 1811 einsn = insn; 1812 posn = 2; 1813 if (einsn[0] == 1) 1814 { 1815 /* prefix; remove it as far as the RL reloc is concerned. */ 1816 einsn ++; 1817 posn ++; 1818 } 1819 1820 enctbl = m32c_addr_encodings; 1821 enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4); 1822 e = & enctbl[enc]; 1823 1824 if (srel->r_offset == irel->r_offset + posn 1825 && e->new_encoding != enc 1826 && symval <= e->max_disp) 1827 { 1828 einsn[0] &= 0x8f; 1829 einsn[0] |= (e->new_encoding & 0x1c) << 2; 1830 einsn[1] &= 0xcf; 1831 einsn[1] |= (e->new_encoding & 0x03) << 4; 1832 gap_size = e->bytes - enctbl[e->new_encoding].bytes; 1833 gap = insn + posn + enctbl[e->new_encoding].bytes; 1834 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes]; 1835 break; 1836 } 1837 if (relax_relocs == 2) 1838 srel ++; 1839 posn += e->bytes; 1840 1841 goto try_1addr_32; 1842 1843 case R_M32C_RL_1ADDR: 1844 /* xxxx DDDx DDxx xxxx [disp] */ 1845 1846 einsn = insn; 1847 posn = 2; 1848 if (einsn[0] == 1) 1849 { 1850 /* prefix; remove it as far as the RL reloc is concerned. */ 1851 einsn ++; 1852 posn ++; 1853 } 1854 1855 enctbl = m32c_addr_encodings; 1856 1857 try_1addr_32: 1858 /* srel, posn, and enc must be set here. */ 1859 1860 symval = OFFSET_FOR_RELOC (srel); 1861 enc = ((einsn[0] & 0x0e) << 1) | ((einsn[1] & 0xc0) >> 6); 1862 e = & enctbl[enc]; 1863 1864 if (srel->r_offset == irel->r_offset + posn 1865 && e->new_encoding != enc 1866 && symval <= e->max_disp) 1867 { 1868 einsn[0] &= 0xf1; 1869 einsn[0] |= (e->new_encoding & 0x1c) >> 1; 1870 einsn[1] &= 0x3f; 1871 einsn[1] |= (e->new_encoding & 0x03) << 6; 1872 gap_size = e->bytes - enctbl[e->new_encoding].bytes; 1873 gap = insn + posn + enctbl[e->new_encoding].bytes; 1874 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes]; 1875 break; 1876 } 1877 1878 break; 1879 1880 } /* Ends switch (reloc type) for m32c. */ 1881 } 1882 1883 if (gap_size == 0) 1884 continue; 1885 1886 *again = TRUE; 1887 1888 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type); 1889 1890 /* Note that we've changed the relocs, section contents, etc. */ 1891 elf_section_data (sec)->relocs = internal_relocs; 1892 free_relocs = NULL; 1893 1894 elf_section_data (sec)->this_hdr.contents = contents; 1895 free_contents = NULL; 1896 1897 symtab_hdr->contents = (bfd_byte *) intsyms; 1898 free_intsyms = NULL; 1899 1900 bytes_saved += gap_size; 1901 1902 if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size)) 1903 goto error_return; 1904 1905 } /* next relocation */ 1906 1907 if (free_relocs != NULL) 1908 { 1909 free (free_relocs); 1910 free_relocs = NULL; 1911 } 1912 1913 if (free_contents != NULL) 1914 { 1915 if (! link_info->keep_memory) 1916 free (free_contents); 1917 /* Cache the section contents for elf_link_input_bfd. */ 1918 else 1919 elf_section_data (sec)->this_hdr.contents = contents; 1920 1921 free_contents = NULL; 1922 } 1923 1924 if (shndx_buf != NULL) 1925 { 1926 shndx_hdr->contents = NULL; 1927 free (shndx_buf); 1928 } 1929 1930 if (free_intsyms != NULL) 1931 { 1932 if (! link_info->keep_memory) 1933 free (free_intsyms); 1934 /* Cache the symbols for elf_link_input_bfd. */ 1935 else 1936 { 1937 symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/; 1938 } 1939 1940 free_intsyms = NULL; 1941 } 1942 1943 return TRUE; 1944 1945 error_return: 1946 if (free_relocs != NULL) 1947 free (free_relocs); 1948 if (free_contents != NULL) 1949 free (free_contents); 1950 if (shndx_buf != NULL) 1951 { 1952 shndx_hdr->contents = NULL; 1953 free (shndx_buf); 1954 } 1955 if (free_intsyms != NULL) 1956 free (free_intsyms); 1957 return FALSE; 1958 } 1959 1960 /* Delete some bytes from a section while relaxing. */ 1961 1962 static bfd_boolean 1963 m32c_elf_relax_delete_bytes 1964 (bfd * abfd, 1965 asection * sec, 1966 bfd_vma addr, 1967 int count) 1968 { 1969 Elf_Internal_Shdr *symtab_hdr; 1970 Elf_Internal_Shdr *shndx_hdr; 1971 int sec_shndx; 1972 bfd_byte *contents; 1973 Elf_Internal_Rela *irel; 1974 Elf_Internal_Rela *irelend; 1975 bfd_vma toaddr; 1976 Elf_Internal_Sym *isym; 1977 Elf_Internal_Sym *isymend; 1978 Elf_Internal_Sym *intsyms; 1979 Elf_External_Sym_Shndx *shndx_buf; 1980 Elf_External_Sym_Shndx *shndx; 1981 struct elf_link_hash_entry ** sym_hashes; 1982 struct elf_link_hash_entry ** end_hashes; 1983 unsigned int symcount; 1984 1985 contents = elf_section_data (sec)->this_hdr.contents; 1986 1987 toaddr = sec->size; 1988 1989 irel = elf_section_data (sec)->relocs; 1990 irelend = irel + sec->reloc_count; 1991 1992 /* Actually delete the bytes. */ 1993 memmove (contents + addr, contents + addr + count, (size_t) (toaddr - addr - count)); 1994 sec->size -= count; 1995 1996 /* Adjust all the relocs. */ 1997 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel ++) 1998 { 1999 /* Get the new reloc address. */ 2000 if (irel->r_offset > addr && irel->r_offset < toaddr) 2001 irel->r_offset -= count; 2002 2003 if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP 2004 && irel->r_addend == 0x10 /* one byte insn, no relocs */ 2005 && irel->r_offset + 1 < addr 2006 && irel->r_offset + 7 > addr) 2007 { 2008 bfd_vma disp; 2009 unsigned char *insn = &contents[irel->r_offset]; 2010 disp = *insn; 2011 /* This is a JMP.S, which we have to manually update. */ 2012 if (elf32_m32c_machine (abfd) == bfd_mach_m16c) 2013 { 2014 if ((*insn & 0xf8) != 0x60) 2015 continue; 2016 disp = (disp & 7); 2017 } 2018 else 2019 { 2020 if ((*insn & 0xce) != 0x4a) 2021 continue; 2022 disp = ((disp & 0x30) >> 3) | (disp & 1); 2023 } 2024 if (irel->r_offset + disp + 2 >= addr+count) 2025 { 2026 disp -= count; 2027 if (elf32_m32c_machine (abfd) == bfd_mach_m16c) 2028 { 2029 *insn = (*insn & 0xf8) | disp; 2030 } 2031 else 2032 { 2033 *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1); 2034 } 2035 } 2036 } 2037 } 2038 2039 /* Adjust the local symbols defined in this section. */ 2040 symtab_hdr = & elf_tdata (abfd)->symtab_hdr; 2041 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 2042 isym = intsyms; 2043 isymend = isym + symtab_hdr->sh_info; 2044 2045 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 2046 shndx_hdr = & elf_tdata (abfd)->symtab_shndx_hdr; 2047 shndx_buf = (Elf_External_Sym_Shndx *) shndx_hdr->contents; 2048 shndx = shndx_buf; 2049 2050 for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL)) 2051 { 2052 /* If the symbol is in the range of memory we just moved, we 2053 have to adjust its value. */ 2054 if ((int) isym->st_shndx == sec_shndx 2055 && isym->st_value > addr 2056 && isym->st_value < toaddr) 2057 { 2058 isym->st_value -= count; 2059 } 2060 /* If the symbol *spans* the bytes we just deleted (i.e. it's 2061 *end* is in the moved bytes but it's *start* isn't), then we 2062 must adjust its size. */ 2063 if ((int) isym->st_shndx == sec_shndx 2064 && isym->st_value < addr 2065 && isym->st_value + isym->st_size > addr 2066 && isym->st_value + isym->st_size < toaddr) 2067 { 2068 isym->st_size -= count; 2069 } 2070 } 2071 2072 /* Now adjust the global symbols defined in this section. */ 2073 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 2074 - symtab_hdr->sh_info); 2075 sym_hashes = elf_sym_hashes (abfd); 2076 // sym_hashes += symtab_hdr->sh_info; 2077 end_hashes = sym_hashes + symcount; 2078 2079 for (; sym_hashes < end_hashes; sym_hashes ++) 2080 { 2081 struct elf_link_hash_entry * sym_hash = * sym_hashes; 2082 2083 if (sym_hash && 2084 (sym_hash->root.type == bfd_link_hash_defined 2085 || sym_hash->root.type == bfd_link_hash_defweak) 2086 && sym_hash->root.u.def.section == sec) 2087 { 2088 if (sym_hash->root.u.def.value > addr 2089 && sym_hash->root.u.def.value < toaddr) 2090 { 2091 sym_hash->root.u.def.value -= count; 2092 } 2093 if (sym_hash->root.u.def.value < addr 2094 && sym_hash->root.u.def.value + sym_hash->size > addr 2095 && sym_hash->root.u.def.value + sym_hash->size < toaddr) 2096 { 2097 sym_hash->size -= count; 2098 } 2099 } 2100 } 2101 2102 return TRUE; 2103 } 2104 2105 /* This is for versions of gcc prior to 4.3. */ 2106 static unsigned int 2107 _bfd_m32c_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED) 2108 { 2109 if ((elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK) == EF_M32C_CPU_M16C) 2110 return 2; 2111 return 4; 2112 } 2113 2114 2115 2116 #define ELF_ARCH bfd_arch_m32c 2117 #define ELF_MACHINE_CODE EM_M32C 2118 #define ELF_MACHINE_ALT1 EM_M32C_OLD 2119 #define ELF_MAXPAGESIZE 0x100 2120 2121 #if 0 2122 #define TARGET_BIG_SYM m32c_elf32_vec 2123 #define TARGET_BIG_NAME "elf32-m32c" 2124 #else 2125 #define TARGET_LITTLE_SYM m32c_elf32_vec 2126 #define TARGET_LITTLE_NAME "elf32-m32c" 2127 #endif 2128 2129 #define elf_info_to_howto_rel NULL 2130 #define elf_info_to_howto m32c_info_to_howto_rela 2131 #define elf_backend_object_p m32c_elf_object_p 2132 #define elf_backend_relocate_section m32c_elf_relocate_section 2133 #define elf_backend_check_relocs m32c_elf_check_relocs 2134 #define elf_backend_object_p m32c_elf_object_p 2135 #define elf_symbol_leading_char ('_') 2136 #define elf_backend_always_size_sections \ 2137 m32c_elf_always_size_sections 2138 #define elf_backend_finish_dynamic_sections \ 2139 m32c_elf_finish_dynamic_sections 2140 2141 #define elf_backend_can_gc_sections 1 2142 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size 2143 2144 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup 2145 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup 2146 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section 2147 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags 2148 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data 2149 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data 2150 2151 #include "elf32-target.h" 2152