1 /* ft32-specific support for 32-bit ELF. 2 Copyright (C) 2013-2018 Free Software Foundation, Inc. 3 4 Copied from elf32-moxie.c which is.. 5 Copyright (C) 2009-2018 Free Software Foundation, Inc. 6 Free Software Foundation, Inc. 7 8 This file is part of BFD, the Binary File Descriptor library. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 23 MA 02110-1301, USA. */ 24 25 #include "sysdep.h" 26 #include "bfd.h" 27 #include "libbfd.h" 28 #include "elf-bfd.h" 29 #include "elf/ft32.h" 30 #include "opcode/ft32.h" 31 32 static bfd_boolean debug_relax = FALSE; 33 34 static bfd_reloc_status_type 35 bfd_elf_ft32_diff_reloc (bfd *, arelent *, asymbol *, void *, 36 asection *, bfd *, char **); 37 38 static reloc_howto_type ft32_elf_howto_table [] = 39 { 40 /* This reloc does nothing. */ 41 HOWTO (R_FT32_NONE, /* type */ 42 0, /* rightshift */ 43 2, /* size (0 = byte, 1 = short, 2 = long) */ 44 32, /* bitsize */ 45 FALSE, /* pc_relative */ 46 0, /* bitpos */ 47 complain_overflow_bitfield, /* complain_on_overflow */ 48 bfd_elf_generic_reloc, /* special_function */ 49 "R_FT32_NONE", /* name */ 50 FALSE, /* partial_inplace */ 51 0, /* src_mask */ 52 0, /* dst_mask */ 53 FALSE), /* pcrel_offset */ 54 55 /* A 32 bit absolute relocation. */ 56 57 HOWTO (R_FT32_32, /* type */ 58 0, /* rightshift */ 59 2, /* size (0 = byte, 1 = short, 2 = long) */ 60 32, /* bitsize */ 61 FALSE, /* pc_relative */ 62 0, /* bitpos */ 63 complain_overflow_bitfield, /* complain_on_overflow */ 64 bfd_elf_generic_reloc, /* special_function */ 65 "R_FT32_32", /* name */ 66 FALSE, /* partial_inplace */ 67 0x00000000, /* src_mask */ 68 0xffffffff, /* dst_mask */ 69 FALSE), /* pcrel_offset */ 70 71 HOWTO (R_FT32_16, /* type */ 72 0, /* rightshift */ 73 1, /* size (0 = byte, 1 = short, 2 = long) */ 74 16, /* bitsize */ 75 FALSE, /* pc_relative */ 76 0, /* bitpos */ 77 complain_overflow_dont, /* complain_on_overflow */ 78 bfd_elf_generic_reloc, /* special_function */ 79 "R_FT32_16", /* name */ 80 FALSE, /* partial_inplace */ 81 0x00000000, /* src_mask */ 82 0x0000ffff, /* dst_mask */ 83 FALSE), /* pcrel_offset */ 84 85 HOWTO (R_FT32_8, /* type */ 86 0, /* rightshift */ 87 0, /* size (0 = byte, 1 = short, 2 = long) */ 88 8, /* bitsize */ 89 FALSE, /* pc_relative */ 90 0, /* bitpos */ 91 complain_overflow_signed, /* complain_on_overflow */ 92 bfd_elf_generic_reloc, /* special_function */ 93 "R_FT32_8", /* name */ 94 FALSE, /* partial_inplace */ 95 0x00000000, /* src_mask */ 96 0x000000ff, /* dst_mask */ 97 FALSE), /* pcrel_offset */ 98 99 HOWTO (R_FT32_10, /* type */ 100 0, /* rightshift */ 101 1, /* size (0 = byte, 1 = short, 2 = long) */ 102 10, /* bitsize */ 103 FALSE, /* pc_relative */ 104 4, /* bitpos */ 105 complain_overflow_bitfield, /* complain_on_overflow */ 106 bfd_elf_generic_reloc, /* special_function */ 107 "R_FT32_10", /* name */ 108 FALSE, /* partial_inplace */ 109 0x00000000, /* src_mask */ 110 0x00003ff0, /* dst_mask */ 111 FALSE), /* pcrel_offset */ 112 113 HOWTO (R_FT32_20, /* type */ 114 0, /* rightshift */ 115 2, /* size (0 = byte, 1 = short, 2 = long) */ 116 20, /* bitsize */ 117 FALSE, /* pc_relative */ 118 0, /* bitpos */ 119 complain_overflow_dont, /* complain_on_overflow */ 120 bfd_elf_generic_reloc, /* special_function */ 121 "R_FT32_20", /* name */ 122 FALSE, /* partial_inplace */ 123 0x00000000, /* src_mask */ 124 0x000fffff, /* dst_mask */ 125 FALSE), /* pcrel_offset */ 126 127 HOWTO (R_FT32_17, /* type */ 128 0, /* rightshift */ 129 2, /* size (0 = byte, 1 = short, 2 = long) */ 130 17, /* bitsize */ 131 FALSE, /* pc_relative */ 132 0, /* bitpos */ 133 complain_overflow_dont, /* complain_on_overflow */ 134 bfd_elf_generic_reloc, /* special_function */ 135 "R_FT32_17", /* name */ 136 FALSE, /* partial_inplace */ 137 0x00000000, /* src_mask */ 138 0x0001ffff, /* dst_mask */ 139 FALSE), /* pcrel_offset */ 140 141 HOWTO (R_FT32_18, /* type */ 142 2, /* rightshift */ 143 2, /* size (0 = byte, 1 = short, 2 = long) */ 144 18, /* bitsize */ 145 FALSE, /* pc_relative */ 146 0, /* bitpos */ 147 complain_overflow_dont, /* complain_on_overflow */ 148 bfd_elf_generic_reloc, /* special_function */ 149 "R_FT32_18", /* name */ 150 FALSE, /* partial_inplace */ 151 0x00000000, /* src_mask */ 152 0x0003ffff, /* dst_mask */ 153 FALSE), /* pcrel_offset */ 154 155 HOWTO (R_FT32_RELAX, /* type */ 156 0, /* rightshift */ 157 1, /* size (0 = byte, 1 = short, 2 = long) */ 158 10, /* bitsize */ 159 FALSE, /* pc_relative */ 160 4, /* bitpos */ 161 complain_overflow_signed, /* complain_on_overflow */ 162 bfd_elf_generic_reloc, /* special_function */ 163 "R_FT32_RELAX", /* name */ 164 FALSE, /* partial_inplace */ 165 0x00000000, /* src_mask */ 166 0x00000000, /* dst_mask */ 167 FALSE), /* pcrel_offset */ 168 169 HOWTO (R_FT32_SC0, /* type */ 170 0, /* rightshift */ 171 1, /* size (0 = byte, 1 = short, 2 = long) */ 172 10, /* bitsize */ 173 FALSE, /* pc_relative */ 174 4, /* bitpos */ 175 complain_overflow_signed, /* complain_on_overflow */ 176 bfd_elf_generic_reloc, /* special_function */ 177 "R_FT32_SC0", /* name */ 178 FALSE, /* partial_inplace */ 179 0x00000000, /* src_mask */ 180 0x00000000, /* dst_mask */ 181 FALSE), /* pcrel_offset */ 182 HOWTO (R_FT32_SC1, /* type */ 183 2, /* rightshift */ 184 2, /* size (0 = byte, 1 = short, 2 = long) */ 185 22, /* bitsize */ 186 TRUE, /* pc_relative */ 187 7, /* bitpos */ 188 complain_overflow_dont, /* complain_on_overflow */ 189 bfd_elf_generic_reloc, /* special_function */ 190 "R_FT32_SC1", /* name */ 191 TRUE, /* partial_inplace */ 192 0x07ffff80, /* src_mask */ 193 0x07ffff80, /* dst_mask */ 194 FALSE), /* pcrel_offset */ 195 HOWTO (R_FT32_15, /* type */ 196 0, /* rightshift */ 197 2, /* size (0 = byte, 1 = short, 2 = long) */ 198 15, /* bitsize */ 199 FALSE, /* pc_relative */ 200 0, /* bitpos */ 201 complain_overflow_dont, /* complain_on_overflow */ 202 bfd_elf_generic_reloc, /* special_function */ 203 "R_FT32_15", /* name */ 204 FALSE, /* partial_inplace */ 205 0x00000000, /* src_mask */ 206 0x00007fff, /* dst_mask */ 207 FALSE), /* pcrel_offset */ 208 HOWTO (R_FT32_DIFF32, /* type */ 209 0, /* rightshift */ 210 2, /* size (0 = byte, 1 = short, 2 = long) */ 211 32, /* bitsize */ 212 FALSE, /* pc_relative */ 213 0, /* bitpos */ 214 complain_overflow_dont, /* complain_on_overflow */ 215 bfd_elf_ft32_diff_reloc, /* special_function */ 216 "R_FT32_DIFF32", /* name */ 217 FALSE, /* partial_inplace */ 218 0, /* src_mask */ 219 0xffffffff, /* dst_mask */ 220 FALSE), /* pcrel_offset */ 221 }; 222 223 224 /* Map BFD reloc types to FT32 ELF reloc types. */ 225 226 struct ft32_reloc_map 227 { 228 bfd_reloc_code_real_type bfd_reloc_val; 229 unsigned int ft32_reloc_val; 230 }; 231 232 static const struct ft32_reloc_map ft32_reloc_map [] = 233 { 234 { BFD_RELOC_NONE, R_FT32_NONE }, 235 { BFD_RELOC_32, R_FT32_32 }, 236 { BFD_RELOC_16, R_FT32_16 }, 237 { BFD_RELOC_8, R_FT32_8 }, 238 { BFD_RELOC_FT32_10, R_FT32_10 }, 239 { BFD_RELOC_FT32_20, R_FT32_20 }, 240 { BFD_RELOC_FT32_17, R_FT32_17 }, 241 { BFD_RELOC_FT32_18, R_FT32_18 }, 242 { BFD_RELOC_FT32_RELAX, R_FT32_RELAX }, 243 { BFD_RELOC_FT32_SC0, R_FT32_SC0 }, 244 { BFD_RELOC_FT32_SC1, R_FT32_SC1 }, 245 { BFD_RELOC_FT32_15, R_FT32_15 }, 246 { BFD_RELOC_FT32_DIFF32, R_FT32_DIFF32 }, 247 }; 248 249 /* Perform a diff relocation. Nothing to do, as the difference value is 250 already written into the section's contents. */ 251 252 static bfd_reloc_status_type 253 bfd_elf_ft32_diff_reloc (bfd *abfd ATTRIBUTE_UNUSED, 254 arelent *reloc_entry ATTRIBUTE_UNUSED, 255 asymbol *symbol ATTRIBUTE_UNUSED, 256 void *data ATTRIBUTE_UNUSED, 257 asection *input_section ATTRIBUTE_UNUSED, 258 bfd *output_bfd ATTRIBUTE_UNUSED, 259 char **error_message ATTRIBUTE_UNUSED) 260 { 261 return bfd_reloc_ok; 262 } 263 264 static reloc_howto_type * 265 ft32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 266 bfd_reloc_code_real_type code) 267 { 268 unsigned int i; 269 270 for (i = sizeof (ft32_reloc_map) / sizeof (ft32_reloc_map[0]); 271 --i;) 272 if (ft32_reloc_map [i].bfd_reloc_val == code) 273 return & ft32_elf_howto_table [ft32_reloc_map[i].ft32_reloc_val]; 274 275 return NULL; 276 } 277 278 static reloc_howto_type * 279 ft32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) 280 { 281 unsigned int i; 282 283 for (i = 0; 284 i < sizeof (ft32_elf_howto_table) / sizeof (ft32_elf_howto_table[0]); 285 i++) 286 if (ft32_elf_howto_table[i].name != NULL 287 && strcasecmp (ft32_elf_howto_table[i].name, r_name) == 0) 288 return &ft32_elf_howto_table[i]; 289 290 return NULL; 291 } 292 293 /* Set the howto pointer for an FT32 ELF reloc. */ 294 295 static bfd_boolean 296 ft32_info_to_howto_rela (bfd *abfd, 297 arelent *cache_ptr, 298 Elf_Internal_Rela *dst) 299 { 300 unsigned int r_type; 301 302 r_type = ELF32_R_TYPE (dst->r_info); 303 if (r_type >= (unsigned int) R_FT32_max) 304 { 305 /* xgettext:c-format */ 306 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 307 abfd, r_type); 308 bfd_set_error (bfd_error_bad_value); 309 return FALSE; 310 } 311 312 cache_ptr->howto = & ft32_elf_howto_table [r_type]; 313 return cache_ptr->howto != NULL; 314 } 315 316 /* Relocate an FT32 ELF section. 317 318 The RELOCATE_SECTION function is called by the new ELF backend linker 319 to handle the relocations for a section. 320 321 The relocs are always passed as Rela structures; if the section 322 actually uses Rel structures, the r_addend field will always be 323 zero. 324 325 This function is responsible for adjusting the section contents as 326 necessary, and (if using Rela relocs and generating a relocatable 327 output file) adjusting the reloc addend as necessary. 328 329 This function does not have to worry about setting the reloc 330 address or the reloc symbol index. 331 332 LOCAL_SYMS is a pointer to the swapped in local symbols. 333 334 LOCAL_SECTIONS is an array giving the section in the input file 335 corresponding to the st_shndx field of each local symbol. 336 337 The global hash table entry for the global symbols can be found 338 via elf_sym_hashes (input_bfd). 339 340 When generating relocatable output, this function must handle 341 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 342 going to be the section symbol corresponding to the output 343 section, which means that the addend must be adjusted 344 accordingly. */ 345 346 static bfd_boolean 347 ft32_elf_relocate_section (bfd *output_bfd, 348 struct bfd_link_info *info, 349 bfd *input_bfd, 350 asection *input_section, 351 bfd_byte *contents, 352 Elf_Internal_Rela *relocs, 353 Elf_Internal_Sym *local_syms, 354 asection **local_sections) 355 { 356 Elf_Internal_Shdr *symtab_hdr; 357 struct elf_link_hash_entry **sym_hashes; 358 Elf_Internal_Rela *rel; 359 Elf_Internal_Rela *relend; 360 361 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 362 sym_hashes = elf_sym_hashes (input_bfd); 363 relend = relocs + input_section->reloc_count; 364 365 for (rel = relocs; rel < relend; rel ++) 366 { 367 reloc_howto_type *howto; 368 unsigned long r_symndx; 369 Elf_Internal_Sym *sym; 370 asection *sec; 371 struct elf_link_hash_entry *h; 372 bfd_vma relocation; 373 bfd_reloc_status_type r; 374 const char *name; 375 int r_type; 376 377 r_type = ELF32_R_TYPE (rel->r_info); 378 r_symndx = ELF32_R_SYM (rel->r_info); 379 howto = ft32_elf_howto_table + r_type; 380 h = NULL; 381 sym = NULL; 382 sec = NULL; 383 384 if (r_symndx < symtab_hdr->sh_info) 385 { 386 sym = local_syms + r_symndx; 387 sec = local_sections [r_symndx]; 388 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 389 390 name = bfd_elf_string_from_elf_section 391 (input_bfd, symtab_hdr->sh_link, sym->st_name); 392 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; 393 } 394 else 395 { 396 bfd_boolean unresolved_reloc, warned, ignored; 397 398 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 399 r_symndx, symtab_hdr, sym_hashes, 400 h, sec, relocation, 401 unresolved_reloc, warned, ignored); 402 403 name = h->root.root.string; 404 } 405 406 if (sec != NULL && discarded_section (sec)) 407 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 408 rel, 1, relend, howto, 0, contents); 409 410 if (bfd_link_relocatable (info)) 411 continue; 412 413 switch (howto->type) 414 { 415 case R_FT32_SC0: 416 { 417 unsigned int insn; 418 int offset; 419 unsigned int code15[2]; 420 421 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 422 ft32_split_shortcode (insn, code15); 423 424 offset = (int)relocation; 425 offset += (int)(rel->r_addend - rel->r_offset); 426 offset -= (input_section->output_section->vma + 427 input_section->output_offset); 428 if ((offset < -1024) || (offset >= 1024)) 429 { 430 r = bfd_reloc_outofrange; 431 break; 432 } 433 code15[0] |= ((offset / 4) & 511); 434 insn = ft32_merge_shortcode (code15); 435 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 436 } 437 r = bfd_reloc_ok; 438 break; 439 440 case R_FT32_SC1: 441 { 442 unsigned int insn; 443 int offset; 444 unsigned int code15[2]; 445 446 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 447 ft32_split_shortcode (insn, code15); 448 449 offset = (int)relocation; 450 offset += (int)(rel->r_addend - rel->r_offset); 451 offset -= (input_section->output_section->vma + 452 input_section->output_offset); 453 if ((offset < -1024) || (offset >= 1024)) 454 { 455 r = bfd_reloc_outofrange; 456 break; 457 } 458 code15[1] |= ((offset / 4) & 511); 459 insn = ft32_merge_shortcode (code15); 460 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 461 } 462 r = bfd_reloc_ok; 463 break; 464 465 case R_FT32_DIFF32: 466 r = bfd_reloc_ok; 467 break; 468 469 default: 470 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 471 contents, rel->r_offset, 472 relocation, rel->r_addend); 473 break; 474 } 475 476 if (r != bfd_reloc_ok) 477 { 478 const char * msg = NULL; 479 480 switch (r) 481 { 482 case bfd_reloc_overflow: 483 (*info->callbacks->reloc_overflow) 484 (info, (h ? &h->root : NULL), name, howto->name, 485 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 486 break; 487 488 case bfd_reloc_undefined: 489 (*info->callbacks->undefined_symbol) 490 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 491 break; 492 493 case bfd_reloc_outofrange: 494 msg = _("internal error: out of range error"); 495 break; 496 497 case bfd_reloc_notsupported: 498 msg = _("internal error: unsupported relocation error"); 499 break; 500 501 case bfd_reloc_dangerous: 502 msg = _("internal error: dangerous relocation"); 503 break; 504 505 default: 506 msg = _("internal error: unknown error"); 507 break; 508 } 509 510 if (msg) 511 (*info->callbacks->warning) (info, msg, name, input_bfd, 512 input_section, rel->r_offset); 513 } 514 } 515 516 return TRUE; 517 } 518 519 /* Relaxation. */ 520 521 static bfd_boolean 522 ft32_reloc_shortable 523 (bfd * abfd, 524 asection * sec, 525 Elf_Internal_Sym * isymbuf ATTRIBUTE_UNUSED, 526 bfd_byte * contents, 527 bfd_vma pc ATTRIBUTE_UNUSED, 528 Elf_Internal_Rela * irel, 529 unsigned int * sc) 530 { 531 Elf_Internal_Shdr *symtab_hdr ATTRIBUTE_UNUSED; 532 bfd_vma symval; 533 534 enum elf_ft32_reloc_type r_type; 535 reloc_howto_type *howto = NULL; 536 unsigned int insn; 537 int offset; 538 bfd_vma dot, value; 539 540 r_type = ELF32_R_TYPE (irel->r_info); 541 howto = &ft32_elf_howto_table [r_type]; 542 543 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 544 545 /* Get the value of the symbol referred to by the reloc. */ 546 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 547 { 548 /* A local symbol. */ 549 Elf_Internal_Sym *isym; 550 asection *sym_sec; 551 552 isym = isymbuf + ELF32_R_SYM (irel->r_info); 553 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 554 symval = isym->st_value; 555 /* If the reloc is absolute, it will not have 556 a symbol or section associated with it. */ 557 if (sym_sec) 558 symval += sym_sec->output_section->vma 559 + sym_sec->output_offset; 560 } 561 else 562 { 563 unsigned long indx; 564 struct elf_link_hash_entry *h; 565 566 /* An external symbol. */ 567 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 568 h = elf_sym_hashes (abfd)[indx]; 569 BFD_ASSERT (h != NULL); 570 if (h->root.type != bfd_link_hash_defined 571 && h->root.type != bfd_link_hash_defweak) 572 /* This appears to be a reference to an undefined 573 symbol. Just ignore it--it will be caught by the 574 regular reloc processing. */ 575 return FALSE; 576 577 symval = (h->root.u.def.value 578 + h->root.u.def.section->output_section->vma 579 + h->root.u.def.section->output_offset); 580 } 581 582 switch (r_type) 583 { 584 case R_FT32_8: 585 case R_FT32_10: 586 case R_FT32_16: 587 case R_FT32_20: 588 case R_FT32_RELAX: 589 if (symval != 0) 590 return FALSE; 591 insn = bfd_get_32 (abfd, contents + irel->r_offset); 592 insn |= ((symval + irel->r_addend) << howto->bitpos) & howto->dst_mask; 593 return ft32_shortcode (insn, sc); 594 595 case R_FT32_18: 596 insn = bfd_get_32 (abfd, contents + irel->r_offset); 597 /* Get the address of this instruction. */ 598 dot = (sec->output_section->vma 599 + sec->output_offset + irel->r_offset); 600 value = symval + irel->r_addend; 601 offset = (value - dot) / 4; 602 603 if ((dot > 0x8c) && (-256 <= offset) && (offset < 256)) 604 { 605 switch (insn) 606 { 607 case 0x00200000: *sc = (3 << 13) | (0 << 9); return TRUE; 608 case 0x00280000: *sc = (3 << 13) | (1 << 9); return TRUE; 609 case 0x00600000: *sc = (3 << 13) | (2 << 9); return TRUE; 610 case 0x00680000: *sc = (3 << 13) | (3 << 9); return TRUE; 611 case 0x00a00000: *sc = (3 << 13) | (4 << 9); return TRUE; 612 case 0x00a80000: *sc = (3 << 13) | (5 << 9); return TRUE; 613 case 0x00e00000: *sc = (3 << 13) | (6 << 9); return TRUE; 614 case 0x00e80000: *sc = (3 << 13) | (7 << 9); return TRUE; 615 case 0x01200000: *sc = (3 << 13) | (8 << 9); return TRUE; 616 case 0x01280000: *sc = (3 << 13) | (9 << 9); return TRUE; 617 case 0x01600000: *sc = (3 << 13) | (10 << 9); return TRUE; 618 case 0x01680000: *sc = (3 << 13) | (11 << 9); return TRUE; 619 case 0x01a00000: *sc = (3 << 13) | (12 << 9); return TRUE; 620 case 0x01a80000: *sc = (3 << 13) | (13 << 9); return TRUE; 621 622 case 0x00300000: *sc = (3 << 13) | (14 << 9); return TRUE; 623 case 0x00340000: *sc = (3 << 13) | (15 << 9); return TRUE; 624 625 default: 626 break; 627 } 628 } 629 break; 630 631 default: 632 break; 633 } 634 return FALSE; 635 } 636 637 /* Returns whether the relocation type passed is a diff reloc. */ 638 639 static bfd_boolean 640 elf32_ft32_is_diff_reloc (Elf_Internal_Rela *irel) 641 { 642 return (ELF32_R_TYPE (irel->r_info) == R_FT32_DIFF32); 643 } 644 645 /* Reduce the diff value written in the section by count if the shrinked 646 insn address happens to fall between the two symbols for which this 647 diff reloc was emitted. */ 648 649 static bfd_boolean 650 elf32_ft32_adjust_diff_reloc_value (bfd *abfd, 651 struct bfd_section *isec, 652 Elf_Internal_Rela *irel, 653 bfd_vma symval, 654 bfd_vma shrinked_insn_address, 655 int count) 656 { 657 unsigned char * reloc_contents = NULL; 658 unsigned char * isec_contents = elf_section_data (isec)->this_hdr.contents; 659 bfd_signed_vma x = 0; 660 bfd_vma sym2_address; 661 bfd_vma sym1_address; 662 bfd_vma start_address; 663 bfd_vma end_address; 664 665 666 if (isec_contents == NULL) 667 { 668 if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents)) 669 return FALSE; 670 671 elf_section_data (isec)->this_hdr.contents = isec_contents; 672 } 673 674 reloc_contents = isec_contents + irel->r_offset; 675 676 /* Read value written in object file. */ 677 switch (ELF32_R_TYPE (irel->r_info)) 678 { 679 case R_FT32_DIFF32: 680 x = bfd_get_signed_32 (abfd, reloc_contents); 681 break; 682 683 default: 684 return FALSE; 685 } 686 687 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written 688 into the object file at the reloc offset. sym2's logical value is 689 symval (<start_of_section>) + reloc addend. Compute the start and end 690 addresses and check if the shrinked insn falls between sym1 and sym2. */ 691 sym2_address = symval + irel->r_addend; 692 sym1_address = sym2_address - x; 693 694 /* Don't assume sym2 is bigger than sym1 - the difference 695 could be negative. Compute start and end addresses, and 696 use those to see if they span shrinked_insn_address. */ 697 start_address = sym1_address < sym2_address ? sym1_address : sym2_address; 698 end_address = sym1_address > sym2_address ? sym1_address : sym2_address; 699 700 if (shrinked_insn_address >= start_address 701 && shrinked_insn_address < end_address) 702 { 703 /* Reduce the diff value by count bytes and write it back into section 704 contents. */ 705 bfd_signed_vma new_diff = x < 0 ? x + count : x - count; 706 707 if (sym2_address > shrinked_insn_address) 708 irel->r_addend -= count; 709 710 switch (ELF32_R_TYPE (irel->r_info)) 711 { 712 case R_FT32_DIFF32: 713 bfd_put_signed_32 (abfd, new_diff & 0xFFFFFFFF, reloc_contents); 714 break; 715 716 default: 717 return FALSE; 718 } 719 } 720 721 return TRUE; 722 } 723 724 static bfd_boolean 725 elf32_ft32_adjust_reloc_if_spans_insn (bfd *abfd, 726 asection *isec, 727 Elf_Internal_Rela *irel, bfd_vma symval, 728 bfd_vma shrinked_insn_address, 729 bfd_vma shrink_boundary, 730 int count) 731 { 732 733 if (elf32_ft32_is_diff_reloc (irel)) 734 { 735 if (!elf32_ft32_adjust_diff_reloc_value (abfd, isec, irel, 736 symval, 737 shrinked_insn_address, 738 count)) 739 return FALSE; 740 } 741 else 742 { 743 bfd_vma reloc_value = symval + irel->r_addend; 744 bfd_boolean addend_within_shrink_boundary = 745 (reloc_value <= shrink_boundary); 746 bfd_boolean reloc_spans_insn = 747 (symval <= shrinked_insn_address 748 && reloc_value > shrinked_insn_address 749 && addend_within_shrink_boundary); 750 751 if (! reloc_spans_insn) 752 return TRUE; 753 754 irel->r_addend -= count; 755 756 if (debug_relax) 757 printf ("Relocation's addend needed to be fixed \n"); 758 } 759 return TRUE; 760 } 761 762 /* Delete some bytes from a section while relaxing. */ 763 764 static bfd_boolean 765 elf32_ft32_relax_delete_bytes (struct bfd_link_info *link_info, bfd * abfd, 766 asection * sec, bfd_vma addr, int count) 767 { 768 Elf_Internal_Shdr *symtab_hdr; 769 unsigned int sec_shndx; 770 bfd_byte *contents; 771 Elf_Internal_Rela *irel, *irelend; 772 bfd_vma toaddr; 773 Elf_Internal_Sym *isym; 774 Elf_Internal_Sym *isymend; 775 struct elf_link_hash_entry **sym_hashes; 776 struct elf_link_hash_entry **end_hashes; 777 struct elf_link_hash_entry **start_hashes; 778 unsigned int symcount; 779 Elf_Internal_Sym *isymbuf = NULL; 780 781 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 782 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 783 784 contents = elf_section_data (sec)->this_hdr.contents; 785 786 toaddr = sec->size; 787 788 irel = elf_section_data (sec)->relocs; 789 irelend = irel + sec->reloc_count; 790 791 /* Actually delete the bytes. */ 792 memmove (contents + addr, contents + addr + count, 793 (size_t) (toaddr - addr - count)); 794 sec->size -= count; 795 796 /* Adjust all the relocs. */ 797 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 798 /* Get the new reloc address. */ 799 if ((irel->r_offset > addr && irel->r_offset < toaddr)) 800 irel->r_offset -= count; 801 802 /* The reloc's own addresses are now ok. However, we need to readjust 803 the reloc's addend, i.e. the reloc's value if two conditions are met: 804 1.) the reloc is relative to a symbol in this section that 805 is located in front of the shrinked instruction 806 2.) symbol plus addend end up behind the shrinked instruction. 807 808 The most common case where this happens are relocs relative to 809 the section-start symbol. 810 811 This step needs to be done for all of the sections of the bfd. */ 812 { 813 struct bfd_section *isec; 814 815 for (isec = abfd->sections; isec; isec = isec->next) 816 { 817 bfd_vma symval; 818 bfd_vma shrinked_insn_address; 819 820 if (isec->reloc_count == 0) 821 continue; 822 823 shrinked_insn_address = (sec->output_section->vma 824 + sec->output_offset + addr - count); 825 826 irel = elf_section_data (isec)->relocs; 827 /* PR 12161: Read in the relocs for this section if necessary. */ 828 if (irel == NULL) 829 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE); 830 831 for (irelend = irel + isec->reloc_count; irel < irelend; irel++) 832 { 833 /* Read this BFD's local symbols if we haven't done 834 so already. */ 835 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 836 { 837 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 838 if (isymbuf == NULL) 839 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 840 symtab_hdr->sh_info, 0, 841 NULL, NULL, NULL); 842 if (isymbuf == NULL) 843 return FALSE; 844 } 845 846 /* Get the value of the symbol referred to by the reloc. */ 847 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 848 { 849 /* A local symbol. */ 850 asection *sym_sec; 851 852 isym = isymbuf + ELF32_R_SYM (irel->r_info); 853 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 854 symval = isym->st_value; 855 /* If the reloc is absolute, it will not have 856 a symbol or section associated with it. */ 857 if (sym_sec == sec) 858 { 859 symval += sym_sec->output_section->vma 860 + sym_sec->output_offset; 861 862 if (debug_relax) 863 printf ("Checking if the relocation's " 864 "addend needs corrections.\n" 865 "Address of anchor symbol: 0x%x \n" 866 "Address of relocation target: 0x%x \n" 867 "Address of relaxed insn: 0x%x \n", 868 (unsigned int) symval, 869 (unsigned int) (symval + irel->r_addend), 870 (unsigned int) shrinked_insn_address); 871 872 if (symval <= shrinked_insn_address 873 && (symval + irel->r_addend) > shrinked_insn_address) 874 { 875 /* If there is an alignment boundary, we only need to 876 adjust addends that end up below the boundary. */ 877 bfd_vma shrink_boundary = (toaddr 878 + sec->output_section->vma 879 + sec->output_offset); 880 881 if (debug_relax) 882 printf 883 ("Relocation's addend needed to be fixed \n"); 884 885 if (!elf32_ft32_adjust_reloc_if_spans_insn (abfd, isec, 886 irel, symval, 887 shrinked_insn_address, 888 shrink_boundary, 889 count)) 890 return FALSE; 891 } 892 } 893 /* else reference symbol is absolute. No adjustment needed. */ 894 } 895 /* else...Reference symbol is extern. No need for adjusting 896 the addend. */ 897 } 898 } 899 } 900 901 /* Adjust the local symbols defined in this section. */ 902 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 903 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 904 if (isym) 905 { 906 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 907 { 908 if (isym->st_shndx == sec_shndx 909 && isym->st_value > addr && isym->st_value < toaddr) 910 isym->st_value -= count; 911 } 912 } 913 914 /* Now adjust the global symbols defined in this section. */ 915 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 916 - symtab_hdr->sh_info); 917 sym_hashes = start_hashes = elf_sym_hashes (abfd); 918 end_hashes = sym_hashes + symcount; 919 920 for (; sym_hashes < end_hashes; sym_hashes++) 921 { 922 struct elf_link_hash_entry *sym_hash = *sym_hashes; 923 924 /* The '--wrap SYMBOL' option is causing a pain when the object file, 925 containing the definition of __wrap_SYMBOL, includes a direct 926 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference 927 the same symbol (which is __wrap_SYMBOL), but still exist as two 928 different symbols in 'sym_hashes', we don't want to adjust 929 the global symbol __wrap_SYMBOL twice. 930 This check is only relevant when symbols are being wrapped. */ 931 if (link_info->wrap_hash != NULL) 932 { 933 struct elf_link_hash_entry **cur_sym_hashes; 934 935 /* Loop only over the symbols whom been already checked. */ 936 for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes; 937 cur_sym_hashes++) 938 /* If the current symbol is identical to 'sym_hash', that means 939 the symbol was already adjusted (or at least checked). */ 940 if (*cur_sym_hashes == sym_hash) 941 break; 942 943 /* Don't adjust the symbol again. */ 944 if (cur_sym_hashes < sym_hashes) 945 continue; 946 } 947 948 if ((sym_hash->root.type == bfd_link_hash_defined 949 || sym_hash->root.type == bfd_link_hash_defweak) 950 && sym_hash->root.u.def.section == sec 951 && sym_hash->root.u.def.value > addr 952 && sym_hash->root.u.def.value < toaddr) 953 sym_hash->root.u.def.value -= count; 954 } 955 956 return TRUE; 957 } 958 959 /* Return TRUE if LOC can be a target of a branch, jump or call. */ 960 961 static bfd_boolean 962 elf32_ft32_relax_is_branch_target (struct bfd_link_info *link_info, 963 bfd * abfd, asection * sec, 964 bfd_vma loc) 965 { 966 Elf_Internal_Shdr *symtab_hdr; 967 Elf_Internal_Rela *irel, *irelend; 968 Elf_Internal_Sym *isym; 969 Elf_Internal_Sym *isymbuf = NULL; 970 bfd_vma symval; 971 struct bfd_section *isec; 972 973 struct elf_link_hash_entry **sym_hashes; 974 struct elf_link_hash_entry **end_hashes; 975 struct elf_link_hash_entry **start_hashes; 976 unsigned int symcount; 977 978 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 979 980 /* Now we check for relocations pointing to ret. */ 981 for (isec = abfd->sections; isec; isec = isec->next) 982 { 983 irel = elf_section_data (isec)->relocs; 984 if (irel == NULL) 985 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE); 986 987 irelend = irel + isec->reloc_count; 988 989 for (; irel < irelend; irel++) 990 { 991 /* Read this BFD's local symbols if we haven't done 992 so already. */ 993 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 994 { 995 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 996 if (isymbuf == NULL) 997 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 998 symtab_hdr->sh_info, 0, 999 NULL, NULL, NULL); 1000 if (isymbuf == NULL) 1001 return FALSE; 1002 } 1003 1004 /* Get the value of the symbol referred to by the reloc. */ 1005 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 1006 { 1007 /* A local symbol. */ 1008 asection *sym_sec; 1009 1010 isym = isymbuf + ELF32_R_SYM (irel->r_info); 1011 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 1012 symval = isym->st_value; 1013 /* If the reloc is absolute, it will not have 1014 a symbol or section associated with it. */ 1015 if (sym_sec == sec) 1016 { 1017 symval += sym_sec->output_section->vma 1018 + sym_sec->output_offset; 1019 1020 if (debug_relax) 1021 printf ("0x%x: Address of anchor symbol: 0x%x " 1022 "Address of relocation target: 0x%x \n", 1023 (unsigned int) irel->r_offset, 1024 (unsigned int) symval, 1025 (unsigned int) (symval + irel->r_addend)); 1026 if ((irel->r_addend) == loc) 1027 return TRUE; 1028 } 1029 } 1030 } 1031 } 1032 1033 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1034 - symtab_hdr->sh_info); 1035 sym_hashes = start_hashes = elf_sym_hashes (abfd); 1036 end_hashes = sym_hashes + symcount; 1037 1038 for (; sym_hashes < end_hashes; sym_hashes++) 1039 { 1040 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1041 1042 /* The '--wrap SYMBOL' option is causing a pain when the object file, 1043 containing the definition of __wrap_SYMBOL, includes a direct 1044 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference 1045 the same symbol (which is __wrap_SYMBOL), but still exist as two 1046 different symbols in 'sym_hashes', we don't want to adjust 1047 the global symbol __wrap_SYMBOL twice. 1048 This check is only relevant when symbols are being wrapped. */ 1049 if (link_info->wrap_hash != NULL) 1050 { 1051 struct elf_link_hash_entry **cur_sym_hashes; 1052 1053 /* Loop only over the symbols whom been already checked. */ 1054 for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes; 1055 cur_sym_hashes++) 1056 /* If the current symbol is identical to 'sym_hash', that means 1057 the symbol was already adjusted (or at least checked). */ 1058 if (*cur_sym_hashes == sym_hash) 1059 break; 1060 1061 /* Don't adjust the symbol again. */ 1062 if (cur_sym_hashes < sym_hashes) 1063 continue; 1064 } 1065 1066 if ((sym_hash->root.type == bfd_link_hash_defined 1067 || sym_hash->root.type == bfd_link_hash_defweak) 1068 && sym_hash->root.u.def.section == sec 1069 && sym_hash->root.u.def.value == loc) 1070 return TRUE; 1071 } 1072 1073 return FALSE; 1074 } 1075 1076 static bfd_boolean 1077 ft32_elf_relax_section 1078 (bfd * abfd, 1079 asection * sec, 1080 struct bfd_link_info * link_info, 1081 bfd_boolean * again) 1082 { 1083 Elf_Internal_Rela * free_relocs = NULL; 1084 Elf_Internal_Rela * internal_relocs; 1085 Elf_Internal_Rela * irelend; 1086 Elf_Internal_Rela * irel; 1087 bfd_byte * contents = NULL; 1088 Elf_Internal_Shdr * symtab_hdr; 1089 Elf_Internal_Sym * isymbuf = NULL; 1090 1091 /* Assume nothing changes. */ 1092 *again = FALSE; 1093 1094 /* We don't have to do anything for a relocatable link, if 1095 this section does not have relocs, or if this is not a 1096 code section. */ 1097 if (bfd_link_relocatable (link_info) 1098 || (sec->flags & SEC_RELOC) == 0 1099 || sec->reloc_count == 0 1100 || (sec->flags & SEC_CODE) == 0) 1101 return TRUE; 1102 1103 /* Get the section contents. */ 1104 if (elf_section_data (sec)->this_hdr.contents != NULL) 1105 contents = elf_section_data (sec)->this_hdr.contents; 1106 /* Go get them off disk. */ 1107 else 1108 { 1109 if (! bfd_malloc_and_get_section (abfd, sec, &contents)) 1110 goto error_return; 1111 elf_section_data (sec)->this_hdr.contents = contents; 1112 } 1113 1114 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1115 1116 /* Read this BFD's local symbols if we haven't done so already. */ 1117 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 1118 { 1119 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1120 if (isymbuf == NULL) 1121 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 1122 symtab_hdr->sh_info, 0, 1123 NULL, NULL, NULL); 1124 if (isymbuf == NULL) 1125 goto error_return; 1126 symtab_hdr->contents = (unsigned char *) isymbuf; 1127 } 1128 1129 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 1130 link_info->keep_memory); 1131 if (internal_relocs == NULL) 1132 goto error_return; 1133 if (! link_info->keep_memory) 1134 free_relocs = internal_relocs; 1135 1136 /* Walk through them looking for relaxing opportunities. */ 1137 irelend = internal_relocs + sec->reloc_count; 1138 1139 /* Test every adjacent pair of relocs. If both have shortcodes, 1140 fuse them and delete the relocs. */ 1141 irel = internal_relocs; 1142 while (irel < irelend - 1) 1143 { 1144 Elf_Internal_Rela * irel_next = irel + 1; 1145 unsigned int sc0, sc1; 1146 bfd_vma pc; 1147 1148 pc = irel->r_offset; 1149 1150 if (((pc + 4) == (irel_next->r_offset)) 1151 && ft32_reloc_shortable (abfd, sec, isymbuf, contents, pc, irel, 1152 &sc0) 1153 && ft32_reloc_shortable (abfd, sec, isymbuf, contents, pc, 1154 irel_next, &sc1) 1155 && !elf32_ft32_relax_is_branch_target (link_info, abfd, sec, 1156 irel_next->r_offset)) 1157 { 1158 unsigned int code30 = (sc1 << 15) | sc0; 1159 unsigned int code27 = code30 >> 3; 1160 unsigned int code3 = code30 & 7; 1161 static const unsigned char pat3[] = {2, 3, 4, 5, 6, 9, 10, 14}; 1162 unsigned int pattern = pat3[code3]; 1163 unsigned int fused = (pattern << 27) | code27; 1164 1165 /* Move second reloc to same place as first. */ 1166 irel_next->r_offset = irel->r_offset; 1167 1168 /* Change both relocs to R_FT32_NONE. */ 1169 1170 if (ELF32_R_TYPE (irel->r_info) == R_FT32_18) 1171 { 1172 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1173 R_FT32_SC0); 1174 } 1175 else 1176 { 1177 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1178 R_FT32_NONE); 1179 } 1180 1181 if (ELF32_R_TYPE (irel_next->r_info) == R_FT32_18) 1182 { 1183 irel_next->r_info = ELF32_R_INFO (ELF32_R_SYM (irel_next->r_info), 1184 R_FT32_SC1); 1185 } 1186 else 1187 { 1188 irel_next->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1189 R_FT32_NONE); 1190 } 1191 1192 /* Replace the first insn with the fused version. */ 1193 bfd_put_32 (abfd, fused, contents + irel->r_offset); 1194 1195 /* Delete the second insn. */ 1196 if (!elf32_ft32_relax_delete_bytes (link_info, abfd, sec, 1197 irel->r_offset + 4, 4)) 1198 goto error_return; 1199 1200 /* That will change things, so, we should relax again. 1201 Note that this is not required, and it may be slow. */ 1202 *again = TRUE; 1203 1204 irel += 2; 1205 } 1206 else 1207 { 1208 irel += 1; 1209 } 1210 } 1211 1212 if (isymbuf != NULL 1213 && symtab_hdr->contents != (unsigned char *) isymbuf) 1214 { 1215 if (! link_info->keep_memory) 1216 free (isymbuf); 1217 else 1218 /* Cache the symbols for elf_link_input_bfd. */ 1219 symtab_hdr->contents = (unsigned char *) isymbuf; 1220 } 1221 1222 if (contents != NULL 1223 && elf_section_data (sec)->this_hdr.contents != contents) 1224 { 1225 if (! link_info->keep_memory) 1226 free (contents); 1227 else 1228 /* Cache the section contents for elf_link_input_bfd. */ 1229 elf_section_data (sec)->this_hdr.contents = contents; 1230 1231 } 1232 1233 if (internal_relocs != NULL 1234 && elf_section_data (sec)->relocs != internal_relocs) 1235 free (internal_relocs); 1236 1237 return TRUE; 1238 1239 error_return: 1240 if (free_relocs != NULL) 1241 free (free_relocs); 1242 1243 return TRUE; 1244 } 1245 1246 #define ELF_ARCH bfd_arch_ft32 1247 #define ELF_MACHINE_CODE EM_FT32 1248 #define ELF_MAXPAGESIZE 0x1 1249 1250 #define TARGET_LITTLE_SYM ft32_elf32_vec 1251 #define TARGET_LITTLE_NAME "elf32-ft32" 1252 1253 #define elf_info_to_howto_rel NULL 1254 #define elf_info_to_howto ft32_info_to_howto_rela 1255 #define elf_backend_relocate_section ft32_elf_relocate_section 1256 1257 #define elf_backend_can_gc_sections 1 1258 #define elf_backend_rela_normal 1 1259 1260 #define bfd_elf32_bfd_reloc_type_lookup ft32_reloc_type_lookup 1261 #define bfd_elf32_bfd_reloc_name_lookup ft32_reloc_name_lookup 1262 1263 #define bfd_elf32_bfd_relax_section ft32_elf_relax_section 1264 1265 #include "elf32-target.h" 1266