1/* Matsushita 10200 specific support for 32-bit ELF 2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 3 Free Software Foundation, Inc. 4 5This file is part of BFD, the Binary File Descriptor library. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 20 21#include "bfd.h" 22#include "sysdep.h" 23#include "libbfd.h" 24#include "elf-bfd.h" 25 26static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup 27 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); 28static void mn10200_info_to_howto 29 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 30static bfd_boolean mn10200_elf_relax_delete_bytes 31 PARAMS ((bfd *, asection *, bfd_vma, int)); 32static bfd_boolean mn10200_elf_symbol_address_p 33 PARAMS ((bfd *, asection *, Elf_Internal_Sym *, bfd_vma)); 34static bfd_reloc_status_type mn10200_elf_final_link_relocate 35 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, 36 bfd_byte *, bfd_vma, bfd_vma, bfd_vma, 37 struct bfd_link_info *, asection *, int)); 38static bfd_boolean mn10200_elf_relocate_section 39 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, 40 bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, 41 asection **)); 42static bfd_boolean mn10200_elf_relax_section 43 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *)); 44static bfd_byte * mn10200_elf_get_relocated_section_contents 45 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, 46 bfd_byte *, bfd_boolean, asymbol **)); 47 48enum reloc_type { 49 R_MN10200_NONE = 0, 50 R_MN10200_32, 51 R_MN10200_16, 52 R_MN10200_8, 53 R_MN10200_24, 54 R_MN10200_PCREL8, 55 R_MN10200_PCREL16, 56 R_MN10200_PCREL24, 57 R_MN10200_MAX 58}; 59 60static reloc_howto_type elf_mn10200_howto_table[] = { 61 /* Dummy relocation. Does nothing. */ 62 HOWTO (R_MN10200_NONE, 63 0, 64 2, 65 16, 66 FALSE, 67 0, 68 complain_overflow_bitfield, 69 bfd_elf_generic_reloc, 70 "R_MN10200_NONE", 71 FALSE, 72 0, 73 0, 74 FALSE), 75 /* Standard 32 bit reloc. */ 76 HOWTO (R_MN10200_32, 77 0, 78 2, 79 32, 80 FALSE, 81 0, 82 complain_overflow_bitfield, 83 bfd_elf_generic_reloc, 84 "R_MN10200_32", 85 FALSE, 86 0xffffffff, 87 0xffffffff, 88 FALSE), 89 /* Standard 16 bit reloc. */ 90 HOWTO (R_MN10200_16, 91 0, 92 1, 93 16, 94 FALSE, 95 0, 96 complain_overflow_bitfield, 97 bfd_elf_generic_reloc, 98 "R_MN10200_16", 99 FALSE, 100 0xffff, 101 0xffff, 102 FALSE), 103 /* Standard 8 bit reloc. */ 104 HOWTO (R_MN10200_8, 105 0, 106 0, 107 8, 108 FALSE, 109 0, 110 complain_overflow_bitfield, 111 bfd_elf_generic_reloc, 112 "R_MN10200_8", 113 FALSE, 114 0xff, 115 0xff, 116 FALSE), 117 /* Standard 24 bit reloc. */ 118 HOWTO (R_MN10200_24, 119 0, 120 2, 121 24, 122 FALSE, 123 0, 124 complain_overflow_bitfield, 125 bfd_elf_generic_reloc, 126 "R_MN10200_24", 127 FALSE, 128 0xffffff, 129 0xffffff, 130 FALSE), 131 /* Simple 8 pc-relative reloc. */ 132 HOWTO (R_MN10200_PCREL8, 133 0, 134 0, 135 8, 136 TRUE, 137 0, 138 complain_overflow_bitfield, 139 bfd_elf_generic_reloc, 140 "R_MN10200_PCREL8", 141 FALSE, 142 0xff, 143 0xff, 144 TRUE), 145 /* Simple 16 pc-relative reloc. */ 146 HOWTO (R_MN10200_PCREL16, 147 0, 148 1, 149 16, 150 TRUE, 151 0, 152 complain_overflow_bitfield, 153 bfd_elf_generic_reloc, 154 "R_MN10200_PCREL16", 155 FALSE, 156 0xffff, 157 0xffff, 158 TRUE), 159 /* Simple 32bit pc-relative reloc with a 1 byte adjustment 160 to get the pc-relative offset correct. */ 161 HOWTO (R_MN10200_PCREL24, 162 0, 163 2, 164 24, 165 TRUE, 166 0, 167 complain_overflow_bitfield, 168 bfd_elf_generic_reloc, 169 "R_MN10200_PCREL24", 170 FALSE, 171 0xffffff, 172 0xffffff, 173 TRUE), 174}; 175 176struct mn10200_reloc_map { 177 bfd_reloc_code_real_type bfd_reloc_val; 178 unsigned char elf_reloc_val; 179}; 180 181static const struct mn10200_reloc_map mn10200_reloc_map[] = { 182 { BFD_RELOC_NONE , R_MN10200_NONE , }, 183 { BFD_RELOC_32 , R_MN10200_32 , }, 184 { BFD_RELOC_16 , R_MN10200_16 , }, 185 { BFD_RELOC_8 , R_MN10200_8 , }, 186 { BFD_RELOC_24 , R_MN10200_24 , }, 187 { BFD_RELOC_8_PCREL , R_MN10200_PCREL8 , }, 188 { BFD_RELOC_16_PCREL, R_MN10200_PCREL16, }, 189 { BFD_RELOC_24_PCREL, R_MN10200_PCREL24, }, 190}; 191 192static reloc_howto_type * 193bfd_elf32_bfd_reloc_type_lookup (abfd, code) 194 bfd *abfd ATTRIBUTE_UNUSED; 195 bfd_reloc_code_real_type code; 196{ 197 unsigned int i; 198 199 for (i = 0; 200 i < sizeof (mn10200_reloc_map) / sizeof (struct mn10200_reloc_map); 201 i++) 202 { 203 if (mn10200_reloc_map[i].bfd_reloc_val == code) 204 return &elf_mn10200_howto_table[mn10200_reloc_map[i].elf_reloc_val]; 205 } 206 207 return NULL; 208} 209 210/* Set the howto pointer for an MN10200 ELF reloc. */ 211 212static void 213mn10200_info_to_howto (abfd, cache_ptr, dst) 214 bfd *abfd ATTRIBUTE_UNUSED; 215 arelent *cache_ptr; 216 Elf_Internal_Rela *dst; 217{ 218 unsigned int r_type; 219 220 r_type = ELF32_R_TYPE (dst->r_info); 221 BFD_ASSERT (r_type < (unsigned int) R_MN10200_MAX); 222 cache_ptr->howto = &elf_mn10200_howto_table[r_type]; 223} 224 225/* Perform a relocation as part of a final link. */ 226 227static bfd_reloc_status_type 228mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd, 229 input_section, contents, offset, value, 230 addend, info, sym_sec, is_local) 231 reloc_howto_type *howto; 232 bfd *input_bfd; 233 bfd *output_bfd ATTRIBUTE_UNUSED; 234 asection *input_section; 235 bfd_byte *contents; 236 bfd_vma offset; 237 bfd_vma value; 238 bfd_vma addend; 239 struct bfd_link_info *info ATTRIBUTE_UNUSED; 240 asection *sym_sec ATTRIBUTE_UNUSED; 241 int is_local ATTRIBUTE_UNUSED; 242{ 243 unsigned long r_type = howto->type; 244 bfd_byte *hit_data = contents + offset; 245 246 switch (r_type) 247 { 248 249 case R_MN10200_NONE: 250 return bfd_reloc_ok; 251 252 case R_MN10200_32: 253 value += addend; 254 bfd_put_32 (input_bfd, value, hit_data); 255 return bfd_reloc_ok; 256 257 case R_MN10200_16: 258 value += addend; 259 260 if ((long) value > 0x7fff || (long) value < -0x8000) 261 return bfd_reloc_overflow; 262 263 bfd_put_16 (input_bfd, value, hit_data); 264 return bfd_reloc_ok; 265 266 case R_MN10200_8: 267 value += addend; 268 269 if ((long) value > 0x7f || (long) value < -0x80) 270 return bfd_reloc_overflow; 271 272 bfd_put_8 (input_bfd, value, hit_data); 273 return bfd_reloc_ok; 274 275 case R_MN10200_24: 276 value += addend; 277 278 if ((long) value > 0x7fffff || (long) value < -0x800000) 279 return bfd_reloc_overflow; 280 281 value &= 0xffffff; 282 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000); 283 bfd_put_32 (input_bfd, value, hit_data); 284 return bfd_reloc_ok; 285 286 case R_MN10200_PCREL8: 287 value -= (input_section->output_section->vma 288 + input_section->output_offset); 289 value -= (offset + 1); 290 value += addend; 291 292 if ((long) value > 0xff || (long) value < -0x100) 293 return bfd_reloc_overflow; 294 295 bfd_put_8 (input_bfd, value, hit_data); 296 return bfd_reloc_ok; 297 298 case R_MN10200_PCREL16: 299 value -= (input_section->output_section->vma 300 + input_section->output_offset); 301 value -= (offset + 2); 302 value += addend; 303 304 if ((long) value > 0xffff || (long) value < -0x10000) 305 return bfd_reloc_overflow; 306 307 bfd_put_16 (input_bfd, value, hit_data); 308 return bfd_reloc_ok; 309 310 case R_MN10200_PCREL24: 311 value -= (input_section->output_section->vma 312 + input_section->output_offset); 313 value -= (offset + 3); 314 value += addend; 315 316 if ((long) value > 0xffffff || (long) value < -0x1000000) 317 return bfd_reloc_overflow; 318 319 value &= 0xffffff; 320 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000); 321 bfd_put_32 (input_bfd, value, hit_data); 322 return bfd_reloc_ok; 323 324 default: 325 return bfd_reloc_notsupported; 326 } 327} 328 329/* Relocate an MN10200 ELF section. */ 330static bfd_boolean 331mn10200_elf_relocate_section (output_bfd, info, input_bfd, input_section, 332 contents, relocs, local_syms, local_sections) 333 bfd *output_bfd; 334 struct bfd_link_info *info; 335 bfd *input_bfd; 336 asection *input_section; 337 bfd_byte *contents; 338 Elf_Internal_Rela *relocs; 339 Elf_Internal_Sym *local_syms; 340 asection **local_sections; 341{ 342 Elf_Internal_Shdr *symtab_hdr; 343 struct elf_link_hash_entry **sym_hashes; 344 Elf_Internal_Rela *rel, *relend; 345 346 if (info->relocatable) 347 return TRUE; 348 349 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 350 sym_hashes = elf_sym_hashes (input_bfd); 351 352 rel = relocs; 353 relend = relocs + input_section->reloc_count; 354 for (; rel < relend; rel++) 355 { 356 int r_type; 357 reloc_howto_type *howto; 358 unsigned long r_symndx; 359 Elf_Internal_Sym *sym; 360 asection *sec; 361 struct elf_link_hash_entry *h; 362 bfd_vma relocation; 363 bfd_reloc_status_type r; 364 365 r_symndx = ELF32_R_SYM (rel->r_info); 366 r_type = ELF32_R_TYPE (rel->r_info); 367 howto = elf_mn10200_howto_table + r_type; 368 369 h = NULL; 370 sym = NULL; 371 sec = NULL; 372 if (r_symndx < symtab_hdr->sh_info) 373 { 374 sym = local_syms + r_symndx; 375 sec = local_sections[r_symndx]; 376 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 377 } 378 else 379 { 380 bfd_boolean unresolved_reloc, warned; 381 382 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 383 r_symndx, symtab_hdr, sym_hashes, 384 h, sec, relocation, 385 unresolved_reloc, warned); 386 } 387 388 r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd, 389 input_section, 390 contents, rel->r_offset, 391 relocation, rel->r_addend, 392 info, sec, h == NULL); 393 394 if (r != bfd_reloc_ok) 395 { 396 const char *name; 397 const char *msg = (const char *) 0; 398 399 if (h != NULL) 400 name = h->root.root.string; 401 else 402 { 403 name = (bfd_elf_string_from_elf_section 404 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 405 if (name == NULL || *name == '\0') 406 name = bfd_section_name (input_bfd, sec); 407 } 408 409 switch (r) 410 { 411 case bfd_reloc_overflow: 412 if (! ((*info->callbacks->reloc_overflow) 413 (info, (h ? &h->root : NULL), name, howto->name, 414 (bfd_vma) 0, input_bfd, input_section, 415 rel->r_offset))) 416 return FALSE; 417 break; 418 419 case bfd_reloc_undefined: 420 if (! ((*info->callbacks->undefined_symbol) 421 (info, name, input_bfd, input_section, 422 rel->r_offset, TRUE))) 423 return FALSE; 424 break; 425 426 case bfd_reloc_outofrange: 427 msg = _("internal error: out of range error"); 428 goto common_error; 429 430 case bfd_reloc_notsupported: 431 msg = _("internal error: unsupported relocation error"); 432 goto common_error; 433 434 case bfd_reloc_dangerous: 435 msg = _("internal error: dangerous error"); 436 goto common_error; 437 438 default: 439 msg = _("internal error: unknown error"); 440 /* fall through */ 441 442 common_error: 443 if (!((*info->callbacks->warning) 444 (info, msg, name, input_bfd, input_section, 445 rel->r_offset))) 446 return FALSE; 447 break; 448 } 449 } 450 } 451 452 return TRUE; 453} 454 455/* This function handles relaxing for the mn10200. 456 457 There are quite a few relaxing opportunities available on the mn10200: 458 459 * jsr:24 -> jsr:16 2 bytes 460 461 * jmp:24 -> jmp:16 2 bytes 462 * jmp:16 -> bra:8 1 byte 463 464 * If the previous instruction is a conditional branch 465 around the jump/bra, we may be able to reverse its condition 466 and change its target to the jump's target. The jump/bra 467 can then be deleted. 2 bytes 468 469 * mov abs24 -> mov abs16 2 byte savings 470 471 * Most instructions which accept imm24 can relax to imm16 2 bytes 472 - Most instructions which accept imm16 can relax to imm8 1 byte 473 474 * Most instructions which accept d24 can relax to d16 2 bytes 475 - Most instructions which accept d16 can relax to d8 1 byte 476 477 abs24, imm24, d24 all look the same at the reloc level. It 478 might make the code simpler if we had different relocs for 479 the various relaxable operand types. 480 481 We don't handle imm16->imm8 or d16->d8 as they're very rare 482 and somewhat more difficult to support. */ 483 484static bfd_boolean 485mn10200_elf_relax_section (abfd, sec, link_info, again) 486 bfd *abfd; 487 asection *sec; 488 struct bfd_link_info *link_info; 489 bfd_boolean *again; 490{ 491 Elf_Internal_Shdr *symtab_hdr; 492 Elf_Internal_Rela *internal_relocs; 493 Elf_Internal_Rela *irel, *irelend; 494 bfd_byte *contents = NULL; 495 Elf_Internal_Sym *isymbuf = NULL; 496 497 /* Assume nothing changes. */ 498 *again = FALSE; 499 500 /* We don't have to do anything for a relocatable link, if 501 this section does not have relocs, or if this is not a 502 code section. */ 503 if (link_info->relocatable 504 || (sec->flags & SEC_RELOC) == 0 505 || sec->reloc_count == 0 506 || (sec->flags & SEC_CODE) == 0) 507 return TRUE; 508 509 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 510 511 /* Get a copy of the native relocations. */ 512 internal_relocs = (_bfd_elf_link_read_relocs 513 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 514 link_info->keep_memory)); 515 if (internal_relocs == NULL) 516 goto error_return; 517 518 /* Walk through them looking for relaxing opportunities. */ 519 irelend = internal_relocs + sec->reloc_count; 520 for (irel = internal_relocs; irel < irelend; irel++) 521 { 522 bfd_vma symval; 523 524 /* If this isn't something that can be relaxed, then ignore 525 this reloc. */ 526 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE 527 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8 528 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX) 529 continue; 530 531 /* Get the section contents if we haven't done so already. */ 532 if (contents == NULL) 533 { 534 /* Get cached copy if it exists. */ 535 if (elf_section_data (sec)->this_hdr.contents != NULL) 536 contents = elf_section_data (sec)->this_hdr.contents; 537 else 538 { 539 /* Go get them off disk. */ 540 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 541 goto error_return; 542 } 543 } 544 545 /* Read this BFD's local symbols if we haven't done so already. */ 546 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 547 { 548 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 549 if (isymbuf == NULL) 550 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 551 symtab_hdr->sh_info, 0, 552 NULL, NULL, NULL); 553 if (isymbuf == NULL) 554 goto error_return; 555 } 556 557 /* Get the value of the symbol referred to by the reloc. */ 558 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 559 { 560 /* A local symbol. */ 561 Elf_Internal_Sym *isym; 562 asection *sym_sec; 563 564 isym = isymbuf + ELF32_R_SYM (irel->r_info); 565 if (isym->st_shndx == SHN_UNDEF) 566 sym_sec = bfd_und_section_ptr; 567 else if (isym->st_shndx == SHN_ABS) 568 sym_sec = bfd_abs_section_ptr; 569 else if (isym->st_shndx == SHN_COMMON) 570 sym_sec = bfd_com_section_ptr; 571 else 572 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 573 symval = (isym->st_value 574 + sym_sec->output_section->vma 575 + sym_sec->output_offset); 576 } 577 else 578 { 579 unsigned long indx; 580 struct elf_link_hash_entry *h; 581 582 /* An external symbol. */ 583 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 584 h = elf_sym_hashes (abfd)[indx]; 585 BFD_ASSERT (h != NULL); 586 if (h->root.type != bfd_link_hash_defined 587 && h->root.type != bfd_link_hash_defweak) 588 { 589 /* This appears to be a reference to an undefined 590 symbol. Just ignore it--it will be caught by the 591 regular reloc processing. */ 592 continue; 593 } 594 595 symval = (h->root.u.def.value 596 + h->root.u.def.section->output_section->vma 597 + h->root.u.def.section->output_offset); 598 } 599 600 /* For simplicity of coding, we are going to modify the section 601 contents, the section relocs, and the BFD symbol table. We 602 must tell the rest of the code not to free up this 603 information. It would be possible to instead create a table 604 of changes which have to be made, as is done in coff-mips.c; 605 that would be more work, but would require less memory when 606 the linker is run. */ 607 608 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative 609 branch/call. */ 610 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24) 611 { 612 bfd_vma value = symval; 613 614 /* Deal with pc-relative gunk. */ 615 value -= (sec->output_section->vma + sec->output_offset); 616 value -= (irel->r_offset + 3); 617 value += irel->r_addend; 618 619 /* See if the value will fit in 16 bits, note the high value is 620 0x7fff + 2 as the target will be two bytes closer if we are 621 able to relax. */ 622 if ((long) value < 0x8001 && (long) value > -0x8000) 623 { 624 unsigned char code; 625 626 /* Get the opcode. */ 627 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 628 629 if (code != 0xe0 && code != 0xe1) 630 continue; 631 632 /* Note that we've changed the relocs, section contents, etc. */ 633 elf_section_data (sec)->relocs = internal_relocs; 634 elf_section_data (sec)->this_hdr.contents = contents; 635 symtab_hdr->contents = (unsigned char *) isymbuf; 636 637 /* Fix the opcode. */ 638 if (code == 0xe0) 639 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2); 640 else if (code == 0xe1) 641 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2); 642 643 /* Fix the relocation's type. */ 644 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 645 R_MN10200_PCREL16); 646 647 /* The opcode got shorter too, so we have to fix the offset. */ 648 irel->r_offset -= 1; 649 650 /* Delete two bytes of data. */ 651 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 652 irel->r_offset + 1, 2)) 653 goto error_return; 654 655 /* That will change things, so, we should relax again. 656 Note that this is not required, and it may be slow. */ 657 *again = TRUE; 658 } 659 } 660 661 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative 662 branch. */ 663 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16) 664 { 665 bfd_vma value = symval; 666 667 /* Deal with pc-relative gunk. */ 668 value -= (sec->output_section->vma + sec->output_offset); 669 value -= (irel->r_offset + 2); 670 value += irel->r_addend; 671 672 /* See if the value will fit in 8 bits, note the high value is 673 0x7f + 1 as the target will be one bytes closer if we are 674 able to relax. */ 675 if ((long) value < 0x80 && (long) value > -0x80) 676 { 677 unsigned char code; 678 679 /* Get the opcode. */ 680 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 681 682 if (code != 0xfc) 683 continue; 684 685 /* Note that we've changed the relocs, section contents, etc. */ 686 elf_section_data (sec)->relocs = internal_relocs; 687 elf_section_data (sec)->this_hdr.contents = contents; 688 symtab_hdr->contents = (unsigned char *) isymbuf; 689 690 /* Fix the opcode. */ 691 bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1); 692 693 /* Fix the relocation's type. */ 694 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 695 R_MN10200_PCREL8); 696 697 /* Delete one byte of data. */ 698 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 699 irel->r_offset + 1, 1)) 700 goto error_return; 701 702 /* That will change things, so, we should relax again. 703 Note that this is not required, and it may be slow. */ 704 *again = TRUE; 705 } 706 } 707 708 /* Try to eliminate an unconditional 8 bit pc-relative branch 709 which immediately follows a conditional 8 bit pc-relative 710 branch around the unconditional branch. 711 712 original: new: 713 bCC lab1 bCC' lab2 714 bra lab2 715 lab1: lab1: 716 717 This happens when the bCC can't reach lab2 at assembly time, 718 but due to other relaxations it can reach at link time. */ 719 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8) 720 { 721 Elf_Internal_Rela *nrel; 722 bfd_vma value = symval; 723 unsigned char code; 724 725 /* Deal with pc-relative gunk. */ 726 value -= (sec->output_section->vma + sec->output_offset); 727 value -= (irel->r_offset + 1); 728 value += irel->r_addend; 729 730 /* Do nothing if this reloc is the last byte in the section. */ 731 if (irel->r_offset == sec->size) 732 continue; 733 734 /* See if the next instruction is an unconditional pc-relative 735 branch, more often than not this test will fail, so we 736 test it first to speed things up. */ 737 code = bfd_get_8 (abfd, contents + irel->r_offset + 1); 738 if (code != 0xea) 739 continue; 740 741 /* Also make sure the next relocation applies to the next 742 instruction and that it's a pc-relative 8 bit branch. */ 743 nrel = irel + 1; 744 if (nrel == irelend 745 || irel->r_offset + 2 != nrel->r_offset 746 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8) 747 continue; 748 749 /* Make sure our destination immediately follows the 750 unconditional branch. */ 751 if (symval != (sec->output_section->vma + sec->output_offset 752 + irel->r_offset + 3)) 753 continue; 754 755 /* Now make sure we are a conditional branch. This may not 756 be necessary, but why take the chance. 757 758 Note these checks assume that R_MN10200_PCREL8 relocs 759 only occur on bCC and bCCx insns. If they occured 760 elsewhere, we'd need to know the start of this insn 761 for this check to be accurate. */ 762 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 763 if (code != 0xe0 && code != 0xe1 && code != 0xe2 764 && code != 0xe3 && code != 0xe4 && code != 0xe5 765 && code != 0xe6 && code != 0xe7 && code != 0xe8 766 && code != 0xe9 && code != 0xec && code != 0xed 767 && code != 0xee && code != 0xef && code != 0xfc 768 && code != 0xfd && code != 0xfe && code != 0xff) 769 continue; 770 771 /* We also have to be sure there is no symbol/label 772 at the unconditional branch. */ 773 if (mn10200_elf_symbol_address_p (abfd, sec, isymbuf, 774 irel->r_offset + 1)) 775 continue; 776 777 /* Note that we've changed the relocs, section contents, etc. */ 778 elf_section_data (sec)->relocs = internal_relocs; 779 elf_section_data (sec)->this_hdr.contents = contents; 780 symtab_hdr->contents = (unsigned char *) isymbuf; 781 782 /* Reverse the condition of the first branch. */ 783 switch (code) 784 { 785 case 0xfc: 786 code = 0xfd; 787 break; 788 case 0xfd: 789 code = 0xfc; 790 break; 791 case 0xfe: 792 code = 0xff; 793 break; 794 case 0xff: 795 code = 0xfe; 796 break; 797 case 0xe8: 798 code = 0xe9; 799 break; 800 case 0xe9: 801 code = 0xe8; 802 break; 803 case 0xe0: 804 code = 0xe2; 805 break; 806 case 0xe2: 807 code = 0xe0; 808 break; 809 case 0xe3: 810 code = 0xe1; 811 break; 812 case 0xe1: 813 code = 0xe3; 814 break; 815 case 0xe4: 816 code = 0xe6; 817 break; 818 case 0xe6: 819 code = 0xe4; 820 break; 821 case 0xe7: 822 code = 0xe5; 823 break; 824 case 0xe5: 825 code = 0xe7; 826 break; 827 case 0xec: 828 code = 0xed; 829 break; 830 case 0xed: 831 code = 0xec; 832 break; 833 case 0xee: 834 code = 0xef; 835 break; 836 case 0xef: 837 code = 0xee; 838 break; 839 } 840 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 841 842 /* Set the reloc type and symbol for the first branch 843 from the second branch. */ 844 irel->r_info = nrel->r_info; 845 846 /* Make the reloc for the second branch a null reloc. */ 847 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info), 848 R_MN10200_NONE); 849 850 /* Delete two bytes of data. */ 851 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 852 irel->r_offset + 1, 2)) 853 goto error_return; 854 855 /* That will change things, so, we should relax again. 856 Note that this is not required, and it may be slow. */ 857 *again = TRUE; 858 } 859 860 /* Try to turn a 24bit immediate, displacement or absolute address 861 into a 16bit immediate, displacement or absolute address. */ 862 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24) 863 { 864 bfd_vma value = symval; 865 866 /* See if the value will fit in 16 bits. 867 We allow any 16bit match here. We prune those we can't 868 handle below. */ 869 if ((long) value < 0x7fff && (long) value > -0x8000) 870 { 871 unsigned char code; 872 873 /* All insns which have 24bit operands are 5 bytes long, 874 the first byte will always be 0xf4, but we double check 875 it just in case. */ 876 877 /* Get the first opcode. */ 878 code = bfd_get_8 (abfd, contents + irel->r_offset - 2); 879 880 if (code != 0xf4) 881 continue; 882 883 /* Get the second opcode. */ 884 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 885 886 switch (code & 0xfc) 887 { 888 /* mov imm24,dn -> mov imm16,dn */ 889 case 0x70: 890 /* Not safe if the high bit is on as relaxing may 891 move the value out of high mem and thus not fit 892 in a signed 16bit value. */ 893 if (value & 0x8000) 894 continue; 895 896 /* Note that we've changed the relocation contents, etc. */ 897 elf_section_data (sec)->relocs = internal_relocs; 898 elf_section_data (sec)->this_hdr.contents = contents; 899 symtab_hdr->contents = (unsigned char *) isymbuf; 900 901 /* Fix the opcode. */ 902 bfd_put_8 (abfd, 0xf8 + (code & 0x03), 903 contents + irel->r_offset - 2); 904 905 /* Fix the relocation's type. */ 906 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 907 R_MN10200_16); 908 909 /* The opcode got shorter too, so we have to fix the 910 offset. */ 911 irel->r_offset -= 1; 912 913 /* Delete two bytes of data. */ 914 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 915 irel->r_offset + 1, 2)) 916 goto error_return; 917 918 /* That will change things, so, we should relax again. 919 Note that this is not required, and it may be slow. */ 920 *again = TRUE; 921 break; 922 923 /* mov imm24,an -> mov imm16,an 924 cmp imm24,an -> cmp imm16,an 925 mov (abs24),dn -> mov (abs16),dn 926 mov dn,(abs24) -> mov dn,(abs16) 927 movb dn,(abs24) -> movb dn,(abs16) 928 movbu (abs24),dn -> movbu (abs16),dn */ 929 case 0x74: 930 case 0x7c: 931 case 0xc0: 932 case 0x40: 933 case 0x44: 934 case 0xc8: 935 /* Note that we've changed the relocation contents, etc. */ 936 elf_section_data (sec)->relocs = internal_relocs; 937 elf_section_data (sec)->this_hdr.contents = contents; 938 symtab_hdr->contents = (unsigned char *) isymbuf; 939 940 if ((code & 0xfc) == 0x74) 941 code = 0xdc + (code & 0x03); 942 else if ((code & 0xfc) == 0x7c) 943 code = 0xec + (code & 0x03); 944 else if ((code & 0xfc) == 0xc0) 945 code = 0xc8 + (code & 0x03); 946 else if ((code & 0xfc) == 0x40) 947 code = 0xc0 + (code & 0x03); 948 else if ((code & 0xfc) == 0x44) 949 code = 0xc4 + (code & 0x03); 950 else if ((code & 0xfc) == 0xc8) 951 code = 0xcc + (code & 0x03); 952 953 /* Fix the opcode. */ 954 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); 955 956 /* Fix the relocation's type. */ 957 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 958 R_MN10200_16); 959 960 /* The opcode got shorter too, so we have to fix the 961 offset. */ 962 irel->r_offset -= 1; 963 964 /* Delete two bytes of data. */ 965 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 966 irel->r_offset + 1, 2)) 967 goto error_return; 968 969 /* That will change things, so, we should relax again. 970 Note that this is not required, and it may be slow. */ 971 *again = TRUE; 972 break; 973 974 /* cmp imm24,dn -> cmp imm16,dn 975 mov (abs24),an -> mov (abs16),an 976 mov an,(abs24) -> mov an,(abs16) 977 add imm24,dn -> add imm16,dn 978 add imm24,an -> add imm16,an 979 sub imm24,dn -> sub imm16,dn 980 sub imm24,an -> sub imm16,an 981 And all d24->d16 in memory ops. */ 982 case 0x78: 983 case 0xd0: 984 case 0x50: 985 case 0x60: 986 case 0x64: 987 case 0x68: 988 case 0x6c: 989 case 0x80: 990 case 0xf0: 991 case 0x00: 992 case 0x10: 993 case 0xb0: 994 case 0x30: 995 case 0xa0: 996 case 0x20: 997 case 0x90: 998 /* Not safe if the high bit is on as relaxing may 999 move the value out of high mem and thus not fit 1000 in a signed 16bit value. */ 1001 if (((code & 0xfc) == 0x78 1002 || (code & 0xfc) == 0x60 1003 || (code & 0xfc) == 0x64 1004 || (code & 0xfc) == 0x68 1005 || (code & 0xfc) == 0x6c 1006 || (code & 0xfc) == 0x80 1007 || (code & 0xfc) == 0xf0 1008 || (code & 0xfc) == 0x00 1009 || (code & 0xfc) == 0x10 1010 || (code & 0xfc) == 0xb0 1011 || (code & 0xfc) == 0x30 1012 || (code & 0xfc) == 0xa0 1013 || (code & 0xfc) == 0x20 1014 || (code & 0xfc) == 0x90) 1015 && (value & 0x8000) != 0) 1016 continue; 1017 1018 /* Note that we've changed the relocation contents, etc. */ 1019 elf_section_data (sec)->relocs = internal_relocs; 1020 elf_section_data (sec)->this_hdr.contents = contents; 1021 symtab_hdr->contents = (unsigned char *) isymbuf; 1022 1023 /* Fix the opcode. */ 1024 bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2); 1025 1026 if ((code & 0xfc) == 0x78) 1027 code = 0x48 + (code & 0x03); 1028 else if ((code & 0xfc) == 0xd0) 1029 code = 0x30 + (code & 0x03); 1030 else if ((code & 0xfc) == 0x50) 1031 code = 0x20 + (code & 0x03); 1032 else if ((code & 0xfc) == 0x60) 1033 code = 0x18 + (code & 0x03); 1034 else if ((code & 0xfc) == 0x64) 1035 code = 0x08 + (code & 0x03); 1036 else if ((code & 0xfc) == 0x68) 1037 code = 0x1c + (code & 0x03); 1038 else if ((code & 0xfc) == 0x6c) 1039 code = 0x0c + (code & 0x03); 1040 else if ((code & 0xfc) == 0x80) 1041 code = 0xc0 + (code & 0x07); 1042 else if ((code & 0xfc) == 0xf0) 1043 code = 0xb0 + (code & 0x07); 1044 else if ((code & 0xfc) == 0x00) 1045 code = 0x80 + (code & 0x07); 1046 else if ((code & 0xfc) == 0x10) 1047 code = 0xa0 + (code & 0x07); 1048 else if ((code & 0xfc) == 0xb0) 1049 code = 0x70 + (code & 0x07); 1050 else if ((code & 0xfc) == 0x30) 1051 code = 0x60 + (code & 0x07); 1052 else if ((code & 0xfc) == 0xa0) 1053 code = 0xd0 + (code & 0x07); 1054 else if ((code & 0xfc) == 0x20) 1055 code = 0x90 + (code & 0x07); 1056 else if ((code & 0xfc) == 0x90) 1057 code = 0x50 + (code & 0x07); 1058 1059 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 1060 1061 /* Fix the relocation's type. */ 1062 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1063 R_MN10200_16); 1064 1065 /* Delete one bytes of data. */ 1066 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 1067 irel->r_offset + 2, 1)) 1068 goto error_return; 1069 1070 /* That will change things, so, we should relax again. 1071 Note that this is not required, and it may be slow. */ 1072 *again = TRUE; 1073 break; 1074 1075 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */ 1076 case 0xc4: 1077 /* Note that we've changed the reldection contents, etc. */ 1078 elf_section_data (sec)->relocs = internal_relocs; 1079 elf_section_data (sec)->this_hdr.contents = contents; 1080 symtab_hdr->contents = (unsigned char *) isymbuf; 1081 1082 bfd_put_8 (abfd, 0xcc + (code & 0x03), 1083 contents + irel->r_offset - 2); 1084 1085 bfd_put_8 (abfd, 0xb8 + (code & 0x03), 1086 contents + irel->r_offset - 1); 1087 1088 /* Fix the relocation's type. */ 1089 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1090 R_MN10200_16); 1091 1092 /* The reloc will be applied one byte in front of its 1093 current location. */ 1094 irel->r_offset -= 1; 1095 1096 /* Delete one bytes of data. */ 1097 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 1098 irel->r_offset + 2, 1)) 1099 goto error_return; 1100 1101 /* That will change things, so, we should relax again. 1102 Note that this is not required, and it may be slow. */ 1103 *again = TRUE; 1104 break; 1105 } 1106 } 1107 } 1108 } 1109 1110 if (isymbuf != NULL 1111 && symtab_hdr->contents != (unsigned char *) isymbuf) 1112 { 1113 if (! link_info->keep_memory) 1114 free (isymbuf); 1115 else 1116 { 1117 /* Cache the symbols for elf_link_input_bfd. */ 1118 symtab_hdr->contents = (unsigned char *) isymbuf; 1119 } 1120 } 1121 1122 if (contents != NULL 1123 && elf_section_data (sec)->this_hdr.contents != contents) 1124 { 1125 if (! link_info->keep_memory) 1126 free (contents); 1127 else 1128 { 1129 /* Cache the section contents for elf_link_input_bfd. */ 1130 elf_section_data (sec)->this_hdr.contents = contents; 1131 } 1132 } 1133 1134 if (internal_relocs != NULL 1135 && elf_section_data (sec)->relocs != internal_relocs) 1136 free (internal_relocs); 1137 1138 return TRUE; 1139 1140 error_return: 1141 if (isymbuf != NULL 1142 && symtab_hdr->contents != (unsigned char *) isymbuf) 1143 free (isymbuf); 1144 if (contents != NULL 1145 && elf_section_data (sec)->this_hdr.contents != contents) 1146 free (contents); 1147 if (internal_relocs != NULL 1148 && elf_section_data (sec)->relocs != internal_relocs) 1149 free (internal_relocs); 1150 1151 return FALSE; 1152} 1153 1154/* Delete some bytes from a section while relaxing. */ 1155 1156static bfd_boolean 1157mn10200_elf_relax_delete_bytes (abfd, sec, addr, count) 1158 bfd *abfd; 1159 asection *sec; 1160 bfd_vma addr; 1161 int count; 1162{ 1163 Elf_Internal_Shdr *symtab_hdr; 1164 unsigned int sec_shndx; 1165 bfd_byte *contents; 1166 Elf_Internal_Rela *irel, *irelend; 1167 Elf_Internal_Rela *irelalign; 1168 bfd_vma toaddr; 1169 Elf_Internal_Sym *isym; 1170 Elf_Internal_Sym *isymend; 1171 struct elf_link_hash_entry **sym_hashes; 1172 struct elf_link_hash_entry **end_hashes; 1173 unsigned int symcount; 1174 1175 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1176 1177 contents = elf_section_data (sec)->this_hdr.contents; 1178 1179 /* The deletion must stop at the next ALIGN reloc for an aligment 1180 power larger than the number of bytes we are deleting. */ 1181 1182 irelalign = NULL; 1183 toaddr = sec->size; 1184 1185 irel = elf_section_data (sec)->relocs; 1186 irelend = irel + sec->reloc_count; 1187 1188 /* Actually delete the bytes. */ 1189 memmove (contents + addr, contents + addr + count, 1190 (size_t) (toaddr - addr - count)); 1191 sec->size -= count; 1192 1193 /* Adjust all the relocs. */ 1194 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 1195 { 1196 /* Get the new reloc address. */ 1197 if ((irel->r_offset > addr 1198 && irel->r_offset < toaddr)) 1199 irel->r_offset -= count; 1200 } 1201 1202 /* Adjust the local symbols defined in this section. */ 1203 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1204 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 1205 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 1206 { 1207 if (isym->st_shndx == sec_shndx 1208 && isym->st_value > addr 1209 && isym->st_value < toaddr) 1210 isym->st_value -= count; 1211 } 1212 1213 /* Now adjust the global symbols defined in this section. */ 1214 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1215 - symtab_hdr->sh_info); 1216 sym_hashes = elf_sym_hashes (abfd); 1217 end_hashes = sym_hashes + symcount; 1218 for (; sym_hashes < end_hashes; sym_hashes++) 1219 { 1220 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1221 if ((sym_hash->root.type == bfd_link_hash_defined 1222 || sym_hash->root.type == bfd_link_hash_defweak) 1223 && sym_hash->root.u.def.section == sec 1224 && sym_hash->root.u.def.value > addr 1225 && sym_hash->root.u.def.value < toaddr) 1226 { 1227 sym_hash->root.u.def.value -= count; 1228 } 1229 } 1230 1231 return TRUE; 1232} 1233 1234/* Return TRUE if a symbol exists at the given address, else return 1235 FALSE. */ 1236static bfd_boolean 1237mn10200_elf_symbol_address_p (abfd, sec, isym, addr) 1238 bfd *abfd; 1239 asection *sec; 1240 Elf_Internal_Sym *isym; 1241 bfd_vma addr; 1242{ 1243 Elf_Internal_Shdr *symtab_hdr; 1244 unsigned int sec_shndx; 1245 Elf_Internal_Sym *isymend; 1246 struct elf_link_hash_entry **sym_hashes; 1247 struct elf_link_hash_entry **end_hashes; 1248 unsigned int symcount; 1249 1250 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1251 1252 /* Examine all the local symbols. */ 1253 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1254 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 1255 { 1256 if (isym->st_shndx == sec_shndx 1257 && isym->st_value == addr) 1258 return TRUE; 1259 } 1260 1261 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1262 - symtab_hdr->sh_info); 1263 sym_hashes = elf_sym_hashes (abfd); 1264 end_hashes = sym_hashes + symcount; 1265 for (; sym_hashes < end_hashes; sym_hashes++) 1266 { 1267 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1268 if ((sym_hash->root.type == bfd_link_hash_defined 1269 || sym_hash->root.type == bfd_link_hash_defweak) 1270 && sym_hash->root.u.def.section == sec 1271 && sym_hash->root.u.def.value == addr) 1272 return TRUE; 1273 } 1274 1275 return FALSE; 1276} 1277 1278/* This is a version of bfd_generic_get_relocated_section_contents 1279 which uses mn10200_elf_relocate_section. */ 1280 1281static bfd_byte * 1282mn10200_elf_get_relocated_section_contents (output_bfd, link_info, link_order, 1283 data, relocatable, symbols) 1284 bfd *output_bfd; 1285 struct bfd_link_info *link_info; 1286 struct bfd_link_order *link_order; 1287 bfd_byte *data; 1288 bfd_boolean relocatable; 1289 asymbol **symbols; 1290{ 1291 Elf_Internal_Shdr *symtab_hdr; 1292 asection *input_section = link_order->u.indirect.section; 1293 bfd *input_bfd = input_section->owner; 1294 asection **sections = NULL; 1295 Elf_Internal_Rela *internal_relocs = NULL; 1296 Elf_Internal_Sym *isymbuf = NULL; 1297 1298 /* We only need to handle the case of relaxing, or of having a 1299 particular set of section contents, specially. */ 1300 if (relocatable 1301 || elf_section_data (input_section)->this_hdr.contents == NULL) 1302 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 1303 link_order, data, 1304 relocatable, 1305 symbols); 1306 1307 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1308 1309 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 1310 (size_t) input_section->size); 1311 1312 if ((input_section->flags & SEC_RELOC) != 0 1313 && input_section->reloc_count > 0) 1314 { 1315 Elf_Internal_Sym *isym; 1316 Elf_Internal_Sym *isymend; 1317 asection **secpp; 1318 bfd_size_type amt; 1319 1320 internal_relocs = (_bfd_elf_link_read_relocs 1321 (input_bfd, input_section, (PTR) NULL, 1322 (Elf_Internal_Rela *) NULL, FALSE)); 1323 if (internal_relocs == NULL) 1324 goto error_return; 1325 1326 if (symtab_hdr->sh_info != 0) 1327 { 1328 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1329 if (isymbuf == NULL) 1330 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 1331 symtab_hdr->sh_info, 0, 1332 NULL, NULL, NULL); 1333 if (isymbuf == NULL) 1334 goto error_return; 1335 } 1336 1337 amt = symtab_hdr->sh_info; 1338 amt *= sizeof (asection *); 1339 sections = (asection **) bfd_malloc (amt); 1340 if (sections == NULL && amt != 0) 1341 goto error_return; 1342 1343 isymend = isymbuf + symtab_hdr->sh_info; 1344 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 1345 { 1346 asection *isec; 1347 1348 if (isym->st_shndx == SHN_UNDEF) 1349 isec = bfd_und_section_ptr; 1350 else if (isym->st_shndx == SHN_ABS) 1351 isec = bfd_abs_section_ptr; 1352 else if (isym->st_shndx == SHN_COMMON) 1353 isec = bfd_com_section_ptr; 1354 else 1355 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 1356 1357 *secpp = isec; 1358 } 1359 1360 if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd, 1361 input_section, data, internal_relocs, 1362 isymbuf, sections)) 1363 goto error_return; 1364 1365 if (sections != NULL) 1366 free (sections); 1367 if (isymbuf != NULL 1368 && symtab_hdr->contents != (unsigned char *) isymbuf) 1369 free (isymbuf); 1370 if (elf_section_data (input_section)->relocs != internal_relocs) 1371 free (internal_relocs); 1372 } 1373 1374 return data; 1375 1376 error_return: 1377 if (sections != NULL) 1378 free (sections); 1379 if (isymbuf != NULL 1380 && symtab_hdr->contents != (unsigned char *) isymbuf) 1381 free (isymbuf); 1382 if (internal_relocs != NULL 1383 && elf_section_data (input_section)->relocs != internal_relocs) 1384 free (internal_relocs); 1385 return NULL; 1386} 1387 1388#define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec 1389#define TARGET_LITTLE_NAME "elf32-mn10200" 1390#define ELF_ARCH bfd_arch_mn10200 1391#define ELF_MACHINE_CODE EM_MN10200 1392#define ELF_MACHINE_ALT1 EM_CYGNUS_MN10200 1393#define ELF_MAXPAGESIZE 0x1000 1394 1395#define elf_backend_rela_normal 1 1396#define elf_info_to_howto mn10200_info_to_howto 1397#define elf_info_to_howto_rel 0 1398#define elf_backend_relocate_section mn10200_elf_relocate_section 1399#define bfd_elf32_bfd_relax_section mn10200_elf_relax_section 1400#define bfd_elf32_bfd_get_relocated_section_contents \ 1401 mn10200_elf_get_relocated_section_contents 1402 1403#define elf_symbol_leading_char '_' 1404 1405#include "elf32-target.h" 1406