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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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, name, howto->name, (bfd_vma) 0, 414 input_bfd, input_section, rel->r_offset))) 415 return FALSE; 416 break; 417 418 case bfd_reloc_undefined: 419 if (! ((*info->callbacks->undefined_symbol) 420 (info, name, input_bfd, input_section, 421 rel->r_offset, TRUE))) 422 return FALSE; 423 break; 424 425 case bfd_reloc_outofrange: 426 msg = _("internal error: out of range error"); 427 goto common_error; 428 429 case bfd_reloc_notsupported: 430 msg = _("internal error: unsupported relocation error"); 431 goto common_error; 432 433 case bfd_reloc_dangerous: 434 msg = _("internal error: dangerous error"); 435 goto common_error; 436 437 default: 438 msg = _("internal error: unknown error"); 439 /* fall through */ 440 441 common_error: 442 if (!((*info->callbacks->warning) 443 (info, msg, name, input_bfd, input_section, 444 rel->r_offset))) 445 return FALSE; 446 break; 447 } 448 } 449 } 450 451 return TRUE; 452} 453 454/* This function handles relaxing for the mn10200. 455 456 There are quite a few relaxing opportunities available on the mn10200: 457 458 * jsr:24 -> jsr:16 2 bytes 459 460 * jmp:24 -> jmp:16 2 bytes 461 * jmp:16 -> bra:8 1 byte 462 463 * If the previous instruction is a conditional branch 464 around the jump/bra, we may be able to reverse its condition 465 and change its target to the jump's target. The jump/bra 466 can then be deleted. 2 bytes 467 468 * mov abs24 -> mov abs16 2 byte savings 469 470 * Most instructions which accept imm24 can relax to imm16 2 bytes 471 - Most instructions which accept imm16 can relax to imm8 1 byte 472 473 * Most instructions which accept d24 can relax to d16 2 bytes 474 - Most instructions which accept d16 can relax to d8 1 byte 475 476 abs24, imm24, d24 all look the same at the reloc level. It 477 might make the code simpler if we had different relocs for 478 the various relaxable operand types. 479 480 We don't handle imm16->imm8 or d16->d8 as they're very rare 481 and somewhat more difficult to support. */ 482 483static bfd_boolean 484mn10200_elf_relax_section (abfd, sec, link_info, again) 485 bfd *abfd; 486 asection *sec; 487 struct bfd_link_info *link_info; 488 bfd_boolean *again; 489{ 490 Elf_Internal_Shdr *symtab_hdr; 491 Elf_Internal_Rela *internal_relocs; 492 Elf_Internal_Rela *irel, *irelend; 493 bfd_byte *contents = NULL; 494 Elf_Internal_Sym *isymbuf = NULL; 495 496 /* Assume nothing changes. */ 497 *again = FALSE; 498 499 /* We don't have to do anything for a relocatable link, if 500 this section does not have relocs, or if this is not a 501 code section. */ 502 if (link_info->relocatable 503 || (sec->flags & SEC_RELOC) == 0 504 || sec->reloc_count == 0 505 || (sec->flags & SEC_CODE) == 0) 506 return TRUE; 507 508 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 509 510 /* Get a copy of the native relocations. */ 511 internal_relocs = (_bfd_elf_link_read_relocs 512 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 513 link_info->keep_memory)); 514 if (internal_relocs == NULL) 515 goto error_return; 516 517 /* Walk through them looking for relaxing opportunities. */ 518 irelend = internal_relocs + sec->reloc_count; 519 for (irel = internal_relocs; irel < irelend; irel++) 520 { 521 bfd_vma symval; 522 523 /* If this isn't something that can be relaxed, then ignore 524 this reloc. */ 525 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE 526 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8 527 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX) 528 continue; 529 530 /* Get the section contents if we haven't done so already. */ 531 if (contents == NULL) 532 { 533 /* Get cached copy if it exists. */ 534 if (elf_section_data (sec)->this_hdr.contents != NULL) 535 contents = elf_section_data (sec)->this_hdr.contents; 536 else 537 { 538 /* Go get them off disk. */ 539 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 540 goto error_return; 541 } 542 } 543 544 /* Read this BFD's local symbols if we haven't done so already. */ 545 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 546 { 547 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 548 if (isymbuf == NULL) 549 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 550 symtab_hdr->sh_info, 0, 551 NULL, NULL, NULL); 552 if (isymbuf == NULL) 553 goto error_return; 554 } 555 556 /* Get the value of the symbol referred to by the reloc. */ 557 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 558 { 559 /* A local symbol. */ 560 Elf_Internal_Sym *isym; 561 asection *sym_sec; 562 563 isym = isymbuf + ELF32_R_SYM (irel->r_info); 564 if (isym->st_shndx == SHN_UNDEF) 565 sym_sec = bfd_und_section_ptr; 566 else if (isym->st_shndx == SHN_ABS) 567 sym_sec = bfd_abs_section_ptr; 568 else if (isym->st_shndx == SHN_COMMON) 569 sym_sec = bfd_com_section_ptr; 570 else 571 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 572 symval = (isym->st_value 573 + sym_sec->output_section->vma 574 + sym_sec->output_offset); 575 } 576 else 577 { 578 unsigned long indx; 579 struct elf_link_hash_entry *h; 580 581 /* An external symbol. */ 582 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 583 h = elf_sym_hashes (abfd)[indx]; 584 BFD_ASSERT (h != NULL); 585 if (h->root.type != bfd_link_hash_defined 586 && h->root.type != bfd_link_hash_defweak) 587 { 588 /* This appears to be a reference to an undefined 589 symbol. Just ignore it--it will be caught by the 590 regular reloc processing. */ 591 continue; 592 } 593 594 symval = (h->root.u.def.value 595 + h->root.u.def.section->output_section->vma 596 + h->root.u.def.section->output_offset); 597 } 598 599 /* For simplicity of coding, we are going to modify the section 600 contents, the section relocs, and the BFD symbol table. We 601 must tell the rest of the code not to free up this 602 information. It would be possible to instead create a table 603 of changes which have to be made, as is done in coff-mips.c; 604 that would be more work, but would require less memory when 605 the linker is run. */ 606 607 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative 608 branch/call. */ 609 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24) 610 { 611 bfd_vma value = symval; 612 613 /* Deal with pc-relative gunk. */ 614 value -= (sec->output_section->vma + sec->output_offset); 615 value -= (irel->r_offset + 3); 616 value += irel->r_addend; 617 618 /* See if the value will fit in 16 bits, note the high value is 619 0x7fff + 2 as the target will be two bytes closer if we are 620 able to relax. */ 621 if ((long) value < 0x8001 && (long) value > -0x8000) 622 { 623 unsigned char code; 624 625 /* Get the opcode. */ 626 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 627 628 if (code != 0xe0 && code != 0xe1) 629 continue; 630 631 /* Note that we've changed the relocs, section contents, etc. */ 632 elf_section_data (sec)->relocs = internal_relocs; 633 elf_section_data (sec)->this_hdr.contents = contents; 634 symtab_hdr->contents = (unsigned char *) isymbuf; 635 636 /* Fix the opcode. */ 637 if (code == 0xe0) 638 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2); 639 else if (code == 0xe1) 640 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2); 641 642 /* Fix the relocation's type. */ 643 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 644 R_MN10200_PCREL16); 645 646 /* The opcode got shorter too, so we have to fix the offset. */ 647 irel->r_offset -= 1; 648 649 /* Delete two bytes of data. */ 650 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 651 irel->r_offset + 1, 2)) 652 goto error_return; 653 654 /* That will change things, so, we should relax again. 655 Note that this is not required, and it may be slow. */ 656 *again = TRUE; 657 } 658 } 659 660 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative 661 branch. */ 662 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16) 663 { 664 bfd_vma value = symval; 665 666 /* Deal with pc-relative gunk. */ 667 value -= (sec->output_section->vma + sec->output_offset); 668 value -= (irel->r_offset + 2); 669 value += irel->r_addend; 670 671 /* See if the value will fit in 8 bits, note the high value is 672 0x7f + 1 as the target will be one bytes closer if we are 673 able to relax. */ 674 if ((long) value < 0x80 && (long) value > -0x80) 675 { 676 unsigned char code; 677 678 /* Get the opcode. */ 679 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 680 681 if (code != 0xfc) 682 continue; 683 684 /* Note that we've changed the relocs, section contents, etc. */ 685 elf_section_data (sec)->relocs = internal_relocs; 686 elf_section_data (sec)->this_hdr.contents = contents; 687 symtab_hdr->contents = (unsigned char *) isymbuf; 688 689 /* Fix the opcode. */ 690 bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1); 691 692 /* Fix the relocation's type. */ 693 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 694 R_MN10200_PCREL8); 695 696 /* Delete one byte of data. */ 697 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 698 irel->r_offset + 1, 1)) 699 goto error_return; 700 701 /* That will change things, so, we should relax again. 702 Note that this is not required, and it may be slow. */ 703 *again = TRUE; 704 } 705 } 706 707 /* Try to eliminate an unconditional 8 bit pc-relative branch 708 which immediately follows a conditional 8 bit pc-relative 709 branch around the unconditional branch. 710 711 original: new: 712 bCC lab1 bCC' lab2 713 bra lab2 714 lab1: lab1: 715 716 This happens when the bCC can't reach lab2 at assembly time, 717 but due to other relaxations it can reach at link time. */ 718 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8) 719 { 720 Elf_Internal_Rela *nrel; 721 bfd_vma value = symval; 722 unsigned char code; 723 724 /* Deal with pc-relative gunk. */ 725 value -= (sec->output_section->vma + sec->output_offset); 726 value -= (irel->r_offset + 1); 727 value += irel->r_addend; 728 729 /* Do nothing if this reloc is the last byte in the section. */ 730 if (irel->r_offset == sec->size) 731 continue; 732 733 /* See if the next instruction is an unconditional pc-relative 734 branch, more often than not this test will fail, so we 735 test it first to speed things up. */ 736 code = bfd_get_8 (abfd, contents + irel->r_offset + 1); 737 if (code != 0xea) 738 continue; 739 740 /* Also make sure the next relocation applies to the next 741 instruction and that it's a pc-relative 8 bit branch. */ 742 nrel = irel + 1; 743 if (nrel == irelend 744 || irel->r_offset + 2 != nrel->r_offset 745 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8) 746 continue; 747 748 /* Make sure our destination immediately follows the 749 unconditional branch. */ 750 if (symval != (sec->output_section->vma + sec->output_offset 751 + irel->r_offset + 3)) 752 continue; 753 754 /* Now make sure we are a conditional branch. This may not 755 be necessary, but why take the chance. 756 757 Note these checks assume that R_MN10200_PCREL8 relocs 758 only occur on bCC and bCCx insns. If they occured 759 elsewhere, we'd need to know the start of this insn 760 for this check to be accurate. */ 761 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 762 if (code != 0xe0 && code != 0xe1 && code != 0xe2 763 && code != 0xe3 && code != 0xe4 && code != 0xe5 764 && code != 0xe6 && code != 0xe7 && code != 0xe8 765 && code != 0xe9 && code != 0xec && code != 0xed 766 && code != 0xee && code != 0xef && code != 0xfc 767 && code != 0xfd && code != 0xfe && code != 0xff) 768 continue; 769 770 /* We also have to be sure there is no symbol/label 771 at the unconditional branch. */ 772 if (mn10200_elf_symbol_address_p (abfd, sec, isymbuf, 773 irel->r_offset + 1)) 774 continue; 775 776 /* Note that we've changed the relocs, section contents, etc. */ 777 elf_section_data (sec)->relocs = internal_relocs; 778 elf_section_data (sec)->this_hdr.contents = contents; 779 symtab_hdr->contents = (unsigned char *) isymbuf; 780 781 /* Reverse the condition of the first branch. */ 782 switch (code) 783 { 784 case 0xfc: 785 code = 0xfd; 786 break; 787 case 0xfd: 788 code = 0xfc; 789 break; 790 case 0xfe: 791 code = 0xff; 792 break; 793 case 0xff: 794 code = 0xfe; 795 break; 796 case 0xe8: 797 code = 0xe9; 798 break; 799 case 0xe9: 800 code = 0xe8; 801 break; 802 case 0xe0: 803 code = 0xe2; 804 break; 805 case 0xe2: 806 code = 0xe0; 807 break; 808 case 0xe3: 809 code = 0xe1; 810 break; 811 case 0xe1: 812 code = 0xe3; 813 break; 814 case 0xe4: 815 code = 0xe6; 816 break; 817 case 0xe6: 818 code = 0xe4; 819 break; 820 case 0xe7: 821 code = 0xe5; 822 break; 823 case 0xe5: 824 code = 0xe7; 825 break; 826 case 0xec: 827 code = 0xed; 828 break; 829 case 0xed: 830 code = 0xec; 831 break; 832 case 0xee: 833 code = 0xef; 834 break; 835 case 0xef: 836 code = 0xee; 837 break; 838 } 839 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 840 841 /* Set the reloc type and symbol for the first branch 842 from the second branch. */ 843 irel->r_info = nrel->r_info; 844 845 /* Make the reloc for the second branch a null reloc. */ 846 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info), 847 R_MN10200_NONE); 848 849 /* Delete two bytes of data. */ 850 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 851 irel->r_offset + 1, 2)) 852 goto error_return; 853 854 /* That will change things, so, we should relax again. 855 Note that this is not required, and it may be slow. */ 856 *again = TRUE; 857 } 858 859 /* Try to turn a 24bit immediate, displacement or absolute address 860 into a 16bit immediate, displacement or absolute address. */ 861 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24) 862 { 863 bfd_vma value = symval; 864 865 /* See if the value will fit in 16 bits. 866 We allow any 16bit match here. We prune those we can't 867 handle below. */ 868 if ((long) value < 0x7fff && (long) value > -0x8000) 869 { 870 unsigned char code; 871 872 /* All insns which have 24bit operands are 5 bytes long, 873 the first byte will always be 0xf4, but we double check 874 it just in case. */ 875 876 /* Get the first opcode. */ 877 code = bfd_get_8 (abfd, contents + irel->r_offset - 2); 878 879 if (code != 0xf4) 880 continue; 881 882 /* Get the second opcode. */ 883 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 884 885 switch (code & 0xfc) 886 { 887 /* mov imm24,dn -> mov imm16,dn */ 888 case 0x70: 889 /* Not safe if the high bit is on as relaxing may 890 move the value out of high mem and thus not fit 891 in a signed 16bit value. */ 892 if (value & 0x8000) 893 continue; 894 895 /* Note that we've changed the relocation contents, etc. */ 896 elf_section_data (sec)->relocs = internal_relocs; 897 elf_section_data (sec)->this_hdr.contents = contents; 898 symtab_hdr->contents = (unsigned char *) isymbuf; 899 900 /* Fix the opcode. */ 901 bfd_put_8 (abfd, 0xf8 + (code & 0x03), 902 contents + irel->r_offset - 2); 903 904 /* Fix the relocation's type. */ 905 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 906 R_MN10200_16); 907 908 /* The opcode got shorter too, so we have to fix the 909 offset. */ 910 irel->r_offset -= 1; 911 912 /* Delete two bytes of data. */ 913 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 914 irel->r_offset + 1, 2)) 915 goto error_return; 916 917 /* That will change things, so, we should relax again. 918 Note that this is not required, and it may be slow. */ 919 *again = TRUE; 920 break; 921 922 /* mov imm24,an -> mov imm16,an 923 cmp imm24,an -> cmp imm16,an 924 mov (abs24),dn -> mov (abs16),dn 925 mov dn,(abs24) -> mov dn,(abs16) 926 movb dn,(abs24) -> movb dn,(abs16) 927 movbu (abs24),dn -> movbu (abs16),dn */ 928 case 0x74: 929 case 0x7c: 930 case 0xc0: 931 case 0x40: 932 case 0x44: 933 case 0xc8: 934 /* Note that we've changed the relocation contents, etc. */ 935 elf_section_data (sec)->relocs = internal_relocs; 936 elf_section_data (sec)->this_hdr.contents = contents; 937 symtab_hdr->contents = (unsigned char *) isymbuf; 938 939 if ((code & 0xfc) == 0x74) 940 code = 0xdc + (code & 0x03); 941 else if ((code & 0xfc) == 0x7c) 942 code = 0xec + (code & 0x03); 943 else if ((code & 0xfc) == 0xc0) 944 code = 0xc8 + (code & 0x03); 945 else if ((code & 0xfc) == 0x40) 946 code = 0xc0 + (code & 0x03); 947 else if ((code & 0xfc) == 0x44) 948 code = 0xc4 + (code & 0x03); 949 else if ((code & 0xfc) == 0xc8) 950 code = 0xcc + (code & 0x03); 951 952 /* Fix the opcode. */ 953 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); 954 955 /* Fix the relocation's type. */ 956 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 957 R_MN10200_16); 958 959 /* The opcode got shorter too, so we have to fix the 960 offset. */ 961 irel->r_offset -= 1; 962 963 /* Delete two bytes of data. */ 964 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 965 irel->r_offset + 1, 2)) 966 goto error_return; 967 968 /* That will change things, so, we should relax again. 969 Note that this is not required, and it may be slow. */ 970 *again = TRUE; 971 break; 972 973 /* cmp imm24,dn -> cmp imm16,dn 974 mov (abs24),an -> mov (abs16),an 975 mov an,(abs24) -> mov an,(abs16) 976 add imm24,dn -> add imm16,dn 977 add imm24,an -> add imm16,an 978 sub imm24,dn -> sub imm16,dn 979 sub imm24,an -> sub imm16,an 980 And all d24->d16 in memory ops. */ 981 case 0x78: 982 case 0xd0: 983 case 0x50: 984 case 0x60: 985 case 0x64: 986 case 0x68: 987 case 0x6c: 988 case 0x80: 989 case 0xf0: 990 case 0x00: 991 case 0x10: 992 case 0xb0: 993 case 0x30: 994 case 0xa0: 995 case 0x20: 996 case 0x90: 997 /* Not safe if the high bit is on as relaxing may 998 move the value out of high mem and thus not fit 999 in a signed 16bit value. */ 1000 if (((code & 0xfc) == 0x78 1001 || (code & 0xfc) == 0x60 1002 || (code & 0xfc) == 0x64 1003 || (code & 0xfc) == 0x68 1004 || (code & 0xfc) == 0x6c 1005 || (code & 0xfc) == 0x80 1006 || (code & 0xfc) == 0xf0 1007 || (code & 0xfc) == 0x00 1008 || (code & 0xfc) == 0x10 1009 || (code & 0xfc) == 0xb0 1010 || (code & 0xfc) == 0x30 1011 || (code & 0xfc) == 0xa0 1012 || (code & 0xfc) == 0x20 1013 || (code & 0xfc) == 0x90) 1014 && (value & 0x8000) != 0) 1015 continue; 1016 1017 /* Note that we've changed the relocation contents, etc. */ 1018 elf_section_data (sec)->relocs = internal_relocs; 1019 elf_section_data (sec)->this_hdr.contents = contents; 1020 symtab_hdr->contents = (unsigned char *) isymbuf; 1021 1022 /* Fix the opcode. */ 1023 bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2); 1024 1025 if ((code & 0xfc) == 0x78) 1026 code = 0x48 + (code & 0x03); 1027 else if ((code & 0xfc) == 0xd0) 1028 code = 0x30 + (code & 0x03); 1029 else if ((code & 0xfc) == 0x50) 1030 code = 0x20 + (code & 0x03); 1031 else if ((code & 0xfc) == 0x60) 1032 code = 0x18 + (code & 0x03); 1033 else if ((code & 0xfc) == 0x64) 1034 code = 0x08 + (code & 0x03); 1035 else if ((code & 0xfc) == 0x68) 1036 code = 0x1c + (code & 0x03); 1037 else if ((code & 0xfc) == 0x6c) 1038 code = 0x0c + (code & 0x03); 1039 else if ((code & 0xfc) == 0x80) 1040 code = 0xc0 + (code & 0x07); 1041 else if ((code & 0xfc) == 0xf0) 1042 code = 0xb0 + (code & 0x07); 1043 else if ((code & 0xfc) == 0x00) 1044 code = 0x80 + (code & 0x07); 1045 else if ((code & 0xfc) == 0x10) 1046 code = 0xa0 + (code & 0x07); 1047 else if ((code & 0xfc) == 0xb0) 1048 code = 0x70 + (code & 0x07); 1049 else if ((code & 0xfc) == 0x30) 1050 code = 0x60 + (code & 0x07); 1051 else if ((code & 0xfc) == 0xa0) 1052 code = 0xd0 + (code & 0x07); 1053 else if ((code & 0xfc) == 0x20) 1054 code = 0x90 + (code & 0x07); 1055 else if ((code & 0xfc) == 0x90) 1056 code = 0x50 + (code & 0x07); 1057 1058 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 1059 1060 /* Fix the relocation's type. */ 1061 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1062 R_MN10200_16); 1063 1064 /* Delete one bytes of data. */ 1065 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 1066 irel->r_offset + 2, 1)) 1067 goto error_return; 1068 1069 /* That will change things, so, we should relax again. 1070 Note that this is not required, and it may be slow. */ 1071 *again = TRUE; 1072 break; 1073 1074 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */ 1075 case 0xc4: 1076 /* Note that we've changed the reldection contents, etc. */ 1077 elf_section_data (sec)->relocs = internal_relocs; 1078 elf_section_data (sec)->this_hdr.contents = contents; 1079 symtab_hdr->contents = (unsigned char *) isymbuf; 1080 1081 bfd_put_8 (abfd, 0xcc + (code & 0x03), 1082 contents + irel->r_offset - 2); 1083 1084 bfd_put_8 (abfd, 0xb8 + (code & 0x03), 1085 contents + irel->r_offset - 1); 1086 1087 /* Fix the relocation's type. */ 1088 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1089 R_MN10200_16); 1090 1091 /* The reloc will be applied one byte in front of its 1092 current location. */ 1093 irel->r_offset -= 1; 1094 1095 /* Delete one bytes of data. */ 1096 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 1097 irel->r_offset + 2, 1)) 1098 goto error_return; 1099 1100 /* That will change things, so, we should relax again. 1101 Note that this is not required, and it may be slow. */ 1102 *again = TRUE; 1103 break; 1104 } 1105 } 1106 } 1107 } 1108 1109 if (isymbuf != NULL 1110 && symtab_hdr->contents != (unsigned char *) isymbuf) 1111 { 1112 if (! link_info->keep_memory) 1113 free (isymbuf); 1114 else 1115 { 1116 /* Cache the symbols for elf_link_input_bfd. */ 1117 symtab_hdr->contents = (unsigned char *) isymbuf; 1118 } 1119 } 1120 1121 if (contents != NULL 1122 && elf_section_data (sec)->this_hdr.contents != contents) 1123 { 1124 if (! link_info->keep_memory) 1125 free (contents); 1126 else 1127 { 1128 /* Cache the section contents for elf_link_input_bfd. */ 1129 elf_section_data (sec)->this_hdr.contents = contents; 1130 } 1131 } 1132 1133 if (internal_relocs != NULL 1134 && elf_section_data (sec)->relocs != internal_relocs) 1135 free (internal_relocs); 1136 1137 return TRUE; 1138 1139 error_return: 1140 if (isymbuf != NULL 1141 && symtab_hdr->contents != (unsigned char *) isymbuf) 1142 free (isymbuf); 1143 if (contents != NULL 1144 && elf_section_data (sec)->this_hdr.contents != contents) 1145 free (contents); 1146 if (internal_relocs != NULL 1147 && elf_section_data (sec)->relocs != internal_relocs) 1148 free (internal_relocs); 1149 1150 return FALSE; 1151} 1152 1153/* Delete some bytes from a section while relaxing. */ 1154 1155static bfd_boolean 1156mn10200_elf_relax_delete_bytes (abfd, sec, addr, count) 1157 bfd *abfd; 1158 asection *sec; 1159 bfd_vma addr; 1160 int count; 1161{ 1162 Elf_Internal_Shdr *symtab_hdr; 1163 unsigned int sec_shndx; 1164 bfd_byte *contents; 1165 Elf_Internal_Rela *irel, *irelend; 1166 Elf_Internal_Rela *irelalign; 1167 bfd_vma toaddr; 1168 Elf_Internal_Sym *isym; 1169 Elf_Internal_Sym *isymend; 1170 struct elf_link_hash_entry **sym_hashes; 1171 struct elf_link_hash_entry **end_hashes; 1172 unsigned int symcount; 1173 1174 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1175 1176 contents = elf_section_data (sec)->this_hdr.contents; 1177 1178 /* The deletion must stop at the next ALIGN reloc for an aligment 1179 power larger than the number of bytes we are deleting. */ 1180 1181 irelalign = NULL; 1182 toaddr = sec->size; 1183 1184 irel = elf_section_data (sec)->relocs; 1185 irelend = irel + sec->reloc_count; 1186 1187 /* Actually delete the bytes. */ 1188 memmove (contents + addr, contents + addr + count, 1189 (size_t) (toaddr - addr - count)); 1190 sec->size -= count; 1191 1192 /* Adjust all the relocs. */ 1193 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 1194 { 1195 /* Get the new reloc address. */ 1196 if ((irel->r_offset > addr 1197 && irel->r_offset < toaddr)) 1198 irel->r_offset -= count; 1199 } 1200 1201 /* Adjust the local symbols defined in this section. */ 1202 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1203 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 1204 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 1205 { 1206 if (isym->st_shndx == sec_shndx 1207 && isym->st_value > addr 1208 && isym->st_value < toaddr) 1209 isym->st_value -= count; 1210 } 1211 1212 /* Now adjust the global symbols defined in this section. */ 1213 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1214 - symtab_hdr->sh_info); 1215 sym_hashes = elf_sym_hashes (abfd); 1216 end_hashes = sym_hashes + symcount; 1217 for (; sym_hashes < end_hashes; sym_hashes++) 1218 { 1219 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1220 if ((sym_hash->root.type == bfd_link_hash_defined 1221 || sym_hash->root.type == bfd_link_hash_defweak) 1222 && sym_hash->root.u.def.section == sec 1223 && sym_hash->root.u.def.value > addr 1224 && sym_hash->root.u.def.value < toaddr) 1225 { 1226 sym_hash->root.u.def.value -= count; 1227 } 1228 } 1229 1230 return TRUE; 1231} 1232 1233/* Return TRUE if a symbol exists at the given address, else return 1234 FALSE. */ 1235static bfd_boolean 1236mn10200_elf_symbol_address_p (abfd, sec, isym, addr) 1237 bfd *abfd; 1238 asection *sec; 1239 Elf_Internal_Sym *isym; 1240 bfd_vma addr; 1241{ 1242 Elf_Internal_Shdr *symtab_hdr; 1243 unsigned int sec_shndx; 1244 Elf_Internal_Sym *isymend; 1245 struct elf_link_hash_entry **sym_hashes; 1246 struct elf_link_hash_entry **end_hashes; 1247 unsigned int symcount; 1248 1249 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1250 1251 /* Examine all the local symbols. */ 1252 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1253 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 1254 { 1255 if (isym->st_shndx == sec_shndx 1256 && isym->st_value == addr) 1257 return TRUE; 1258 } 1259 1260 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1261 - symtab_hdr->sh_info); 1262 sym_hashes = elf_sym_hashes (abfd); 1263 end_hashes = sym_hashes + symcount; 1264 for (; sym_hashes < end_hashes; sym_hashes++) 1265 { 1266 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1267 if ((sym_hash->root.type == bfd_link_hash_defined 1268 || sym_hash->root.type == bfd_link_hash_defweak) 1269 && sym_hash->root.u.def.section == sec 1270 && sym_hash->root.u.def.value == addr) 1271 return TRUE; 1272 } 1273 1274 return FALSE; 1275} 1276 1277/* This is a version of bfd_generic_get_relocated_section_contents 1278 which uses mn10200_elf_relocate_section. */ 1279 1280static bfd_byte * 1281mn10200_elf_get_relocated_section_contents (output_bfd, link_info, link_order, 1282 data, relocatable, symbols) 1283 bfd *output_bfd; 1284 struct bfd_link_info *link_info; 1285 struct bfd_link_order *link_order; 1286 bfd_byte *data; 1287 bfd_boolean relocatable; 1288 asymbol **symbols; 1289{ 1290 Elf_Internal_Shdr *symtab_hdr; 1291 asection *input_section = link_order->u.indirect.section; 1292 bfd *input_bfd = input_section->owner; 1293 asection **sections = NULL; 1294 Elf_Internal_Rela *internal_relocs = NULL; 1295 Elf_Internal_Sym *isymbuf = NULL; 1296 1297 /* We only need to handle the case of relaxing, or of having a 1298 particular set of section contents, specially. */ 1299 if (relocatable 1300 || elf_section_data (input_section)->this_hdr.contents == NULL) 1301 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 1302 link_order, data, 1303 relocatable, 1304 symbols); 1305 1306 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1307 1308 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 1309 (size_t) input_section->size); 1310 1311 if ((input_section->flags & SEC_RELOC) != 0 1312 && input_section->reloc_count > 0) 1313 { 1314 Elf_Internal_Sym *isym; 1315 Elf_Internal_Sym *isymend; 1316 asection **secpp; 1317 bfd_size_type amt; 1318 1319 internal_relocs = (_bfd_elf_link_read_relocs 1320 (input_bfd, input_section, (PTR) NULL, 1321 (Elf_Internal_Rela *) NULL, FALSE)); 1322 if (internal_relocs == NULL) 1323 goto error_return; 1324 1325 if (symtab_hdr->sh_info != 0) 1326 { 1327 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1328 if (isymbuf == NULL) 1329 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 1330 symtab_hdr->sh_info, 0, 1331 NULL, NULL, NULL); 1332 if (isymbuf == NULL) 1333 goto error_return; 1334 } 1335 1336 amt = symtab_hdr->sh_info; 1337 amt *= sizeof (asection *); 1338 sections = (asection **) bfd_malloc (amt); 1339 if (sections == NULL && amt != 0) 1340 goto error_return; 1341 1342 isymend = isymbuf + symtab_hdr->sh_info; 1343 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 1344 { 1345 asection *isec; 1346 1347 if (isym->st_shndx == SHN_UNDEF) 1348 isec = bfd_und_section_ptr; 1349 else if (isym->st_shndx == SHN_ABS) 1350 isec = bfd_abs_section_ptr; 1351 else if (isym->st_shndx == SHN_COMMON) 1352 isec = bfd_com_section_ptr; 1353 else 1354 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 1355 1356 *secpp = isec; 1357 } 1358 1359 if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd, 1360 input_section, data, internal_relocs, 1361 isymbuf, sections)) 1362 goto error_return; 1363 1364 if (sections != NULL) 1365 free (sections); 1366 if (isymbuf != NULL 1367 && symtab_hdr->contents != (unsigned char *) isymbuf) 1368 free (isymbuf); 1369 if (elf_section_data (input_section)->relocs != internal_relocs) 1370 free (internal_relocs); 1371 } 1372 1373 return data; 1374 1375 error_return: 1376 if (sections != NULL) 1377 free (sections); 1378 if (isymbuf != NULL 1379 && symtab_hdr->contents != (unsigned char *) isymbuf) 1380 free (isymbuf); 1381 if (internal_relocs != NULL 1382 && elf_section_data (input_section)->relocs != internal_relocs) 1383 free (internal_relocs); 1384 return NULL; 1385} 1386 1387#define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec 1388#define TARGET_LITTLE_NAME "elf32-mn10200" 1389#define ELF_ARCH bfd_arch_mn10200 1390#define ELF_MACHINE_CODE EM_MN10200 1391#define ELF_MACHINE_ALT1 EM_CYGNUS_MN10200 1392#define ELF_MAXPAGESIZE 0x1000 1393 1394#define elf_backend_rela_normal 1 1395#define elf_info_to_howto mn10200_info_to_howto 1396#define elf_info_to_howto_rel 0 1397#define elf_backend_relocate_section mn10200_elf_relocate_section 1398#define bfd_elf32_bfd_relax_section mn10200_elf_relax_section 1399#define bfd_elf32_bfd_get_relocated_section_contents \ 1400 mn10200_elf_get_relocated_section_contents 1401 1402#define elf_symbol_leading_char '_' 1403 1404#include "elf32-target.h" 1405