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