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