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