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