elf-m10200.c revision 1.1.1.8
1 /* Matsushita 10200 specific support for 32-bit ELF 2 Copyright (C) 1996-2025 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 bool 27 mn10200_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int); 28 static bool 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 0, 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 4, 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 2, 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 1, 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 4, 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 1, 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 2, 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 4, 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 bool 216 mn10200_info_to_howto (bfd *abfd, 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 if (r_type >= (unsigned int) R_MN10200_MAX) 224 { 225 /* xgettext:c-format */ 226 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 227 abfd, r_type); 228 bfd_set_error (bfd_error_bad_value); 229 return false; 230 } 231 232 cache_ptr->howto = &elf_mn10200_howto_table[r_type]; 233 return cache_ptr->howto != NULL; 234 } 235 236 /* Perform a relocation as part of a final link. */ 237 238 static bfd_reloc_status_type 239 mn10200_elf_final_link_relocate (reloc_howto_type *howto, 240 bfd *input_bfd, 241 bfd *output_bfd ATTRIBUTE_UNUSED, 242 asection *input_section, 243 bfd_byte *contents, 244 bfd_vma offset, 245 bfd_vma value, 246 bfd_vma addend, 247 struct bfd_link_info *info ATTRIBUTE_UNUSED, 248 asection *sym_sec ATTRIBUTE_UNUSED, 249 int is_local ATTRIBUTE_UNUSED) 250 { 251 unsigned long r_type = howto->type; 252 bfd_byte *hit_data = contents + offset; 253 254 switch (r_type) 255 { 256 257 case R_MN10200_NONE: 258 return bfd_reloc_ok; 259 260 case R_MN10200_32: 261 value += addend; 262 bfd_put_32 (input_bfd, value, hit_data); 263 return bfd_reloc_ok; 264 265 case R_MN10200_16: 266 value += addend; 267 268 if ((long) value > 0x7fff || (long) value < -0x8000) 269 return bfd_reloc_overflow; 270 271 bfd_put_16 (input_bfd, value, hit_data); 272 return bfd_reloc_ok; 273 274 case R_MN10200_8: 275 value += addend; 276 277 if ((long) value > 0x7f || (long) value < -0x80) 278 return bfd_reloc_overflow; 279 280 bfd_put_8 (input_bfd, value, hit_data); 281 return bfd_reloc_ok; 282 283 case R_MN10200_24: 284 value += addend; 285 286 if ((long) value > 0x7fffff || (long) value < -0x800000) 287 return bfd_reloc_overflow; 288 289 value &= 0xffffff; 290 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000); 291 bfd_put_32 (input_bfd, value, hit_data); 292 return bfd_reloc_ok; 293 294 case R_MN10200_PCREL8: 295 value -= (input_section->output_section->vma 296 + input_section->output_offset); 297 value -= (offset + 1); 298 value += addend; 299 300 if ((long) value > 0xff || (long) value < -0x100) 301 return bfd_reloc_overflow; 302 303 bfd_put_8 (input_bfd, value, hit_data); 304 return bfd_reloc_ok; 305 306 case R_MN10200_PCREL16: 307 value -= (input_section->output_section->vma 308 + input_section->output_offset); 309 value -= (offset + 2); 310 value += addend; 311 312 if ((long) value > 0xffff || (long) value < -0x10000) 313 return bfd_reloc_overflow; 314 315 bfd_put_16 (input_bfd, value, hit_data); 316 return bfd_reloc_ok; 317 318 case R_MN10200_PCREL24: 319 value -= (input_section->output_section->vma 320 + input_section->output_offset); 321 value -= (offset + 3); 322 value += addend; 323 324 if ((long) value > 0xffffff || (long) value < -0x1000000) 325 return bfd_reloc_overflow; 326 327 value &= 0xffffff; 328 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000); 329 bfd_put_32 (input_bfd, value, hit_data); 330 return bfd_reloc_ok; 331 332 default: 333 return bfd_reloc_notsupported; 334 } 335 } 336 337 /* Relocate an MN10200 ELF section. */ 339 static int 340 mn10200_elf_relocate_section (bfd *output_bfd, 341 struct bfd_link_info *info, 342 bfd *input_bfd, 343 asection *input_section, 344 bfd_byte *contents, 345 Elf_Internal_Rela *relocs, 346 Elf_Internal_Sym *local_syms, 347 asection **local_sections) 348 { 349 Elf_Internal_Shdr *symtab_hdr; 350 struct elf_link_hash_entry **sym_hashes; 351 Elf_Internal_Rela *rel, *relend; 352 353 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 354 sym_hashes = elf_sym_hashes (input_bfd); 355 356 rel = relocs; 357 relend = relocs + input_section->reloc_count; 358 for (; rel < relend; rel++) 359 { 360 int r_type; 361 reloc_howto_type *howto; 362 unsigned long r_symndx; 363 Elf_Internal_Sym *sym; 364 asection *sec; 365 struct elf_link_hash_entry *h; 366 bfd_vma relocation; 367 bfd_reloc_status_type r; 368 369 r_symndx = ELF32_R_SYM (rel->r_info); 370 r_type = ELF32_R_TYPE (rel->r_info); 371 howto = elf_mn10200_howto_table + r_type; 372 373 h = NULL; 374 sym = NULL; 375 sec = NULL; 376 if (r_symndx < symtab_hdr->sh_info) 377 { 378 sym = local_syms + r_symndx; 379 sec = local_sections[r_symndx]; 380 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 381 } 382 else 383 { 384 bool unresolved_reloc, warned, ignored; 385 386 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 387 r_symndx, symtab_hdr, sym_hashes, 388 h, sec, relocation, 389 unresolved_reloc, warned, ignored); 390 } 391 392 if (sec != NULL && discarded_section (sec)) 393 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 394 rel, 1, relend, howto, 0, contents); 395 396 if (bfd_link_relocatable (info)) 397 continue; 398 399 r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd, 400 input_section, 401 contents, rel->r_offset, 402 relocation, rel->r_addend, 403 info, sec, h == NULL); 404 405 if (r != bfd_reloc_ok) 406 { 407 const char *name; 408 const char *msg = (const char *) 0; 409 410 if (h != NULL) 411 name = h->root.root.string; 412 else 413 { 414 name = (bfd_elf_string_from_elf_section 415 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 416 if (name == NULL || *name == '\0') 417 name = bfd_section_name (sec); 418 } 419 420 switch (r) 421 { 422 case bfd_reloc_overflow: 423 (*info->callbacks->reloc_overflow) 424 (info, (h ? &h->root : NULL), name, howto->name, 425 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 426 break; 427 428 case bfd_reloc_undefined: 429 (*info->callbacks->undefined_symbol) (info, name, input_bfd, 430 input_section, 431 rel->r_offset, true); 432 break; 433 434 case bfd_reloc_outofrange: 435 msg = _("internal error: out of range error"); 436 goto common_error; 437 438 case bfd_reloc_notsupported: 439 msg = _("internal error: unsupported relocation error"); 440 goto common_error; 441 442 case bfd_reloc_dangerous: 443 msg = _("internal error: dangerous error"); 444 goto common_error; 445 446 default: 447 msg = _("internal error: unknown error"); 448 /* fall through */ 449 450 common_error: 451 (*info->callbacks->warning) (info, msg, name, input_bfd, 452 input_section, rel->r_offset); 453 break; 454 } 455 } 456 } 457 458 return true; 459 } 460 461 /* Delete some bytes from a section while relaxing. */ 462 463 static bool 464 mn10200_elf_relax_delete_bytes (bfd *abfd, asection *sec, 465 bfd_vma addr, int count) 466 { 467 Elf_Internal_Shdr *symtab_hdr; 468 unsigned int sec_shndx; 469 bfd_byte *contents; 470 Elf_Internal_Rela *irel, *irelend; 471 bfd_vma toaddr; 472 Elf_Internal_Sym *isym; 473 Elf_Internal_Sym *isymend; 474 struct elf_link_hash_entry **sym_hashes; 475 struct elf_link_hash_entry **end_hashes; 476 unsigned int symcount; 477 478 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 479 480 contents = elf_section_data (sec)->this_hdr.contents; 481 482 toaddr = sec->size; 483 484 irel = elf_section_data (sec)->relocs; 485 irelend = irel + sec->reloc_count; 486 487 /* Actually delete the bytes. */ 488 memmove (contents + addr, contents + addr + count, 489 (size_t) (toaddr - addr - count)); 490 sec->size -= count; 491 492 /* Adjust all the relocs. */ 493 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 494 { 495 /* Get the new reloc address. */ 496 if ((irel->r_offset > addr 497 && irel->r_offset < toaddr)) 498 irel->r_offset -= count; 499 } 500 501 /* Adjust the local symbols defined in this section. */ 502 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 503 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 504 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 505 { 506 if (isym->st_shndx == sec_shndx 507 && isym->st_value > addr 508 && isym->st_value < toaddr) 509 isym->st_value -= count; 510 } 511 512 /* Now adjust the global symbols defined in this section. */ 513 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 514 - symtab_hdr->sh_info); 515 sym_hashes = elf_sym_hashes (abfd); 516 end_hashes = sym_hashes + symcount; 517 for (; sym_hashes < end_hashes; sym_hashes++) 518 { 519 struct elf_link_hash_entry *sym_hash = *sym_hashes; 520 if ((sym_hash->root.type == bfd_link_hash_defined 521 || sym_hash->root.type == bfd_link_hash_defweak) 522 && sym_hash->root.u.def.section == sec 523 && sym_hash->root.u.def.value > addr 524 && sym_hash->root.u.def.value < toaddr) 525 { 526 sym_hash->root.u.def.value -= count; 527 } 528 } 529 530 return true; 531 } 532 533 /* This function handles relaxing for the mn10200. 534 535 There are quite a few relaxing opportunities available on the mn10200: 536 537 * jsr:24 -> jsr:16 2 bytes 538 539 * jmp:24 -> jmp:16 2 bytes 540 * jmp:16 -> bra:8 1 byte 541 542 * If the previous instruction is a conditional branch 543 around the jump/bra, we may be able to reverse its condition 544 and change its target to the jump's target. The jump/bra 545 can then be deleted. 2 bytes 546 547 * mov abs24 -> mov abs16 2 byte savings 548 549 * Most instructions which accept imm24 can relax to imm16 2 bytes 550 - Most instructions which accept imm16 can relax to imm8 1 byte 551 552 * Most instructions which accept d24 can relax to d16 2 bytes 553 - Most instructions which accept d16 can relax to d8 1 byte 554 555 abs24, imm24, d24 all look the same at the reloc level. It 556 might make the code simpler if we had different relocs for 557 the various relaxable operand types. 558 559 We don't handle imm16->imm8 or d16->d8 as they're very rare 560 and somewhat more difficult to support. */ 561 562 static bool 563 mn10200_elf_relax_section (bfd *abfd, 564 asection *sec, 565 struct bfd_link_info *link_info, 566 bool *again) 567 { 568 Elf_Internal_Shdr *symtab_hdr; 569 Elf_Internal_Rela *internal_relocs; 570 Elf_Internal_Rela *irel, *irelend; 571 bfd_byte *contents = NULL; 572 Elf_Internal_Sym *isymbuf = NULL; 573 574 /* Assume nothing changes. */ 575 *again = false; 576 577 /* We don't have to do anything for a relocatable link, if 578 this section does not have relocs, or if this is not a 579 code section. */ 580 if (bfd_link_relocatable (link_info) 581 || sec->reloc_count == 0 582 || (sec->flags & SEC_RELOC) == 0 583 || (sec->flags & SEC_HAS_CONTENTS) == 0 584 || (sec->flags & SEC_CODE) == 0) 585 return true; 586 587 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 588 589 /* Get a copy of the native relocations. */ 590 internal_relocs = (_bfd_elf_link_read_relocs 591 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, 592 link_info->keep_memory)); 593 if (internal_relocs == NULL) 594 goto error_return; 595 596 /* Walk through them looking for relaxing opportunities. */ 597 irelend = internal_relocs + sec->reloc_count; 598 for (irel = internal_relocs; irel < irelend; irel++) 599 { 600 bfd_vma symval; 601 602 /* If this isn't something that can be relaxed, then ignore 603 this reloc. */ 604 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE 605 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8 606 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX) 607 continue; 608 609 /* Get the section contents if we haven't done so already. */ 610 if (contents == NULL) 611 { 612 /* Get cached copy if it exists. */ 613 if (elf_section_data (sec)->this_hdr.contents != NULL) 614 contents = elf_section_data (sec)->this_hdr.contents; 615 else 616 { 617 /* Go get them off disk. */ 618 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 619 goto error_return; 620 } 621 } 622 623 /* Read this BFD's local symbols if we haven't done so already. */ 624 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 625 { 626 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 627 if (isymbuf == NULL) 628 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 629 symtab_hdr->sh_info, 0, 630 NULL, NULL, NULL); 631 if (isymbuf == NULL) 632 goto error_return; 633 } 634 635 /* Get the value of the symbol referred to by the reloc. */ 636 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 637 { 638 /* A local symbol. */ 639 Elf_Internal_Sym *isym; 640 asection *sym_sec; 641 642 isym = isymbuf + ELF32_R_SYM (irel->r_info); 643 if (isym->st_shndx == SHN_UNDEF) 644 sym_sec = bfd_und_section_ptr; 645 else if (isym->st_shndx == SHN_ABS) 646 sym_sec = bfd_abs_section_ptr; 647 else if (isym->st_shndx == SHN_COMMON) 648 sym_sec = bfd_com_section_ptr; 649 else 650 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 651 symval = (isym->st_value 652 + sym_sec->output_section->vma 653 + sym_sec->output_offset); 654 } 655 else 656 { 657 unsigned long indx; 658 struct elf_link_hash_entry *h; 659 660 /* An external symbol. */ 661 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 662 h = elf_sym_hashes (abfd)[indx]; 663 BFD_ASSERT (h != NULL); 664 if (h->root.type != bfd_link_hash_defined 665 && h->root.type != bfd_link_hash_defweak) 666 { 667 /* This appears to be a reference to an undefined 668 symbol. Just ignore it--it will be caught by the 669 regular reloc processing. */ 670 continue; 671 } 672 673 symval = (h->root.u.def.value 674 + h->root.u.def.section->output_section->vma 675 + h->root.u.def.section->output_offset); 676 } 677 678 /* For simplicity of coding, we are going to modify the section 679 contents, the section relocs, and the BFD symbol table. We 680 must tell the rest of the code not to free up this 681 information. It would be possible to instead create a table 682 of changes which have to be made, as is done in coff-mips.c; 683 that would be more work, but would require less memory when 684 the linker is run. */ 685 686 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative 687 branch/call. */ 688 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24) 689 { 690 bfd_vma value = symval; 691 692 /* Deal with pc-relative gunk. */ 693 value -= (sec->output_section->vma + sec->output_offset); 694 value -= (irel->r_offset + 3); 695 value += irel->r_addend; 696 697 /* See if the value will fit in 16 bits, note the high value is 698 0x7fff + 2 as the target will be two bytes closer if we are 699 able to relax. */ 700 if ((long) value < 0x8001 && (long) value > -0x8000) 701 { 702 unsigned char code; 703 704 /* Get the opcode. */ 705 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 706 707 if (code != 0xe0 && code != 0xe1) 708 continue; 709 710 /* Note that we've changed the relocs, section contents, etc. */ 711 elf_section_data (sec)->relocs = internal_relocs; 712 elf_section_data (sec)->this_hdr.contents = contents; 713 symtab_hdr->contents = (unsigned char *) isymbuf; 714 715 /* Fix the opcode. */ 716 if (code == 0xe0) 717 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2); 718 else if (code == 0xe1) 719 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2); 720 721 /* Fix the relocation's type. */ 722 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 723 R_MN10200_PCREL16); 724 725 /* The opcode got shorter too, so we have to fix the offset. */ 726 irel->r_offset -= 1; 727 728 /* Delete two bytes of data. */ 729 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 730 irel->r_offset + 1, 2)) 731 goto error_return; 732 733 /* That will change things, so, we should relax again. 734 Note that this is not required, and it may be slow. */ 735 *again = true; 736 } 737 } 738 739 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative 740 branch. */ 741 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16) 742 { 743 bfd_vma value = symval; 744 745 /* Deal with pc-relative gunk. */ 746 value -= (sec->output_section->vma + sec->output_offset); 747 value -= (irel->r_offset + 2); 748 value += irel->r_addend; 749 750 /* See if the value will fit in 8 bits, note the high value is 751 0x7f + 1 as the target will be one bytes closer if we are 752 able to relax. */ 753 if ((long) value < 0x80 && (long) value > -0x80) 754 { 755 unsigned char code; 756 757 /* Get the opcode. */ 758 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 759 760 if (code != 0xfc) 761 continue; 762 763 /* Note that we've changed the relocs, section contents, etc. */ 764 elf_section_data (sec)->relocs = internal_relocs; 765 elf_section_data (sec)->this_hdr.contents = contents; 766 symtab_hdr->contents = (unsigned char *) isymbuf; 767 768 /* Fix the opcode. */ 769 bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1); 770 771 /* Fix the relocation's type. */ 772 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 773 R_MN10200_PCREL8); 774 775 /* Delete one byte of data. */ 776 if (!mn10200_elf_relax_delete_bytes (abfd, sec, 777 irel->r_offset + 1, 1)) 778 goto error_return; 779 780 /* That will change things, so, we should relax again. 781 Note that this is not required, and it may be slow. */ 782 *again = true; 783 } 784 } 785 786 /* Try to eliminate an unconditional 8 bit pc-relative branch 787 which immediately follows a conditional 8 bit pc-relative 788 branch around the unconditional branch. 789 790 original: new: 791 bCC lab1 bCC' lab2 792 bra lab2 793 lab1: lab1: 794 795 This happens when the bCC can't reach lab2 at assembly time, 796 but due to other relaxations it can reach at link time. */ 797 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8) 798 { 799 Elf_Internal_Rela *nrel; 800 unsigned char code; 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 (elf_section_data (sec)->relocs != internal_relocs) 1207 free (internal_relocs); 1208 1209 return true; 1210 1211 error_return: 1212 if (symtab_hdr->contents != (unsigned char *) isymbuf) 1213 free (isymbuf); 1214 if (elf_section_data (sec)->this_hdr.contents != contents) 1215 free (contents); 1216 if (elf_section_data (sec)->relocs != internal_relocs) 1217 free (internal_relocs); 1218 1219 return false; 1220 } 1221 1222 /* Return TRUE if a symbol exists at the given address, else return 1223 FALSE. */ 1224 static bool 1225 mn10200_elf_symbol_address_p (bfd *abfd, 1226 asection *sec, 1227 Elf_Internal_Sym *isym, 1228 bfd_vma addr) 1229 { 1230 Elf_Internal_Shdr *symtab_hdr; 1231 unsigned int sec_shndx; 1232 Elf_Internal_Sym *isymend; 1233 struct elf_link_hash_entry **sym_hashes; 1234 struct elf_link_hash_entry **end_hashes; 1235 unsigned int symcount; 1236 1237 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1238 1239 /* Examine all the local symbols. */ 1240 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1241 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 1242 { 1243 if (isym->st_shndx == sec_shndx 1244 && isym->st_value == addr) 1245 return true; 1246 } 1247 1248 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1249 - symtab_hdr->sh_info); 1250 sym_hashes = elf_sym_hashes (abfd); 1251 end_hashes = sym_hashes + symcount; 1252 for (; sym_hashes < end_hashes; sym_hashes++) 1253 { 1254 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1255 if ((sym_hash->root.type == bfd_link_hash_defined 1256 || sym_hash->root.type == bfd_link_hash_defweak) 1257 && sym_hash->root.u.def.section == sec 1258 && sym_hash->root.u.def.value == addr) 1259 return true; 1260 } 1261 1262 return false; 1263 } 1264 1265 /* This is a version of bfd_generic_get_relocated_section_contents 1266 which uses mn10200_elf_relocate_section. */ 1267 1268 static bfd_byte * 1269 mn10200_elf_get_relocated_section_contents (bfd *output_bfd, 1270 struct bfd_link_info *link_info, 1271 struct bfd_link_order *link_order, 1272 bfd_byte *data, 1273 bool relocatable, 1274 asymbol **symbols) 1275 { 1276 Elf_Internal_Shdr *symtab_hdr; 1277 asection *input_section = link_order->u.indirect.section; 1278 bfd *input_bfd = input_section->owner; 1279 asection **sections = NULL; 1280 Elf_Internal_Rela *internal_relocs = NULL; 1281 Elf_Internal_Sym *isymbuf = NULL; 1282 1283 /* We only need to handle the case of relaxing, or of having a 1284 particular set of section contents, specially. */ 1285 if (relocatable 1286 || elf_section_data (input_section)->this_hdr.contents == NULL) 1287 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 1288 link_order, data, 1289 relocatable, 1290 symbols); 1291 1292 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1293 1294 bfd_byte *orig_data = data; 1295 if (data == NULL) 1296 { 1297 data = bfd_malloc (input_section->size); 1298 if (data == NULL) 1299 return NULL; 1300 } 1301 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 1302 (size_t) input_section->size); 1303 1304 if ((input_section->flags & SEC_RELOC) != 0 1305 && input_section->reloc_count > 0) 1306 { 1307 Elf_Internal_Sym *isym; 1308 Elf_Internal_Sym *isymend; 1309 asection **secpp; 1310 bfd_size_type amt; 1311 1312 internal_relocs = (_bfd_elf_link_read_relocs 1313 (input_bfd, input_section, NULL, 1314 (Elf_Internal_Rela *) NULL, false)); 1315 if (internal_relocs == NULL) 1316 goto error_return; 1317 1318 if (symtab_hdr->sh_info != 0) 1319 { 1320 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1321 if (isymbuf == NULL) 1322 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 1323 symtab_hdr->sh_info, 0, 1324 NULL, NULL, NULL); 1325 if (isymbuf == NULL) 1326 goto error_return; 1327 } 1328 1329 amt = symtab_hdr->sh_info; 1330 amt *= sizeof (asection *); 1331 sections = (asection **) bfd_malloc (amt); 1332 if (sections == NULL && amt != 0) 1333 goto error_return; 1334 1335 isymend = isymbuf + symtab_hdr->sh_info; 1336 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 1337 { 1338 asection *isec; 1339 1340 if (isym->st_shndx == SHN_UNDEF) 1341 isec = bfd_und_section_ptr; 1342 else if (isym->st_shndx == SHN_ABS) 1343 isec = bfd_abs_section_ptr; 1344 else if (isym->st_shndx == SHN_COMMON) 1345 isec = bfd_com_section_ptr; 1346 else 1347 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 1348 1349 *secpp = isec; 1350 } 1351 1352 if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd, 1353 input_section, data, internal_relocs, 1354 isymbuf, sections)) 1355 goto error_return; 1356 1357 free (sections); 1358 if (symtab_hdr->contents != (unsigned char *) isymbuf) 1359 free (isymbuf); 1360 if (elf_section_data (input_section)->relocs != internal_relocs) 1361 free (internal_relocs); 1362 } 1363 1364 return data; 1365 1366 error_return: 1367 free (sections); 1368 if (symtab_hdr->contents != (unsigned char *) isymbuf) 1369 free (isymbuf); 1370 if (elf_section_data (input_section)->relocs != internal_relocs) 1371 free (internal_relocs); 1372 if (orig_data == NULL) 1373 free (data); 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 NULL 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
Indexes created Sun Mar 01 05:31:48 UTC 2026