elf32-iq2000.c revision 1.8
1/* IQ2000-specific support for 32-bit ELF. 2 Copyright (C) 2003-2019 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, MA 02110-1301, USA. */ 19 20#include "sysdep.h" 21#include "bfd.h" 22#include "libbfd.h" 23#include "elf-bfd.h" 24#include "elf/iq2000.h" 25#include "libiberty.h" 26 27/* Forward declarations. */ 28 29static bfd_reloc_status_type iq2000_elf_howto_hi16_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 30 31 32static reloc_howto_type iq2000_elf_howto_table [] = 33{ 34 /* This reloc does nothing. */ 35 36 HOWTO (R_IQ2000_NONE, /* type */ 37 0, /* rightshift */ 38 3, /* size (0 = byte, 1 = short, 2 = long) */ 39 0, /* bitsize */ 40 FALSE, /* pc_relative */ 41 0, /* bitpos */ 42 complain_overflow_dont, /* complain_on_overflow */ 43 bfd_elf_generic_reloc, /* special_function */ 44 "R_IQ2000_NONE", /* name */ 45 FALSE, /* partial_inplace */ 46 0, /* src_mask */ 47 0, /* dst_mask */ 48 FALSE), /* pcrel_offset */ 49 50 /* A 16 bit absolute relocation. */ 51 HOWTO (R_IQ2000_16, /* type */ 52 0, /* rightshift */ 53 1, /* size (0 = byte, 1 = short, 2 = long) */ 54 16, /* bitsize */ 55 FALSE, /* pc_relative */ 56 0, /* bitpos */ 57 complain_overflow_bitfield, /* complain_on_overflow */ 58 bfd_elf_generic_reloc, /* special_function */ 59 "R_IQ2000_16", /* name */ 60 FALSE, /* partial_inplace */ 61 0x0000, /* src_mask */ 62 0xffff, /* dst_mask */ 63 FALSE), /* pcrel_offset */ 64 65 /* A 32 bit absolute relocation. */ 66 HOWTO (R_IQ2000_32, /* type */ 67 0, /* rightshift */ 68 2, /* size (0 = byte, 1 = short, 2 = long) */ 69 31, /* bitsize */ 70 FALSE, /* pc_relative */ 71 0, /* bitpos */ 72 complain_overflow_bitfield, /* complain_on_overflow */ 73 bfd_elf_generic_reloc, /* special_function */ 74 "R_IQ2000_32", /* name */ 75 FALSE, /* partial_inplace */ 76 0x00000000, /* src_mask */ 77 0x7fffffff, /* dst_mask */ 78 FALSE), /* pcrel_offset */ 79 80 /* 26 bit branch address. */ 81 HOWTO (R_IQ2000_26, /* type */ 82 2, /* rightshift */ 83 2, /* size (0 = byte, 1 = short, 2 = long) */ 84 26, /* bitsize */ 85 FALSE, /* pc_relative */ 86 0, /* bitpos */ 87 complain_overflow_dont, /* complain_on_overflow */ 88 /* This needs complex overflow 89 detection, because the upper four 90 bits must match the PC. */ 91 bfd_elf_generic_reloc, /* special_function */ 92 "R_IQ2000_26", /* name */ 93 FALSE, /* partial_inplace */ 94 0x00000000, /* src_mask */ 95 0x03ffffff, /* dst_mask */ 96 FALSE), /* pcrel_offset */ 97 98 /* 16 bit PC relative reference. */ 99 HOWTO (R_IQ2000_PC16, /* type */ 100 2, /* rightshift */ 101 2, /* size (0 = byte, 1 = short, 2 = long) */ 102 16, /* bitsize */ 103 TRUE, /* pc_relative */ 104 0, /* bitpos */ 105 complain_overflow_signed, /* complain_on_overflow */ 106 bfd_elf_generic_reloc, /* special_function */ 107 "R_IQ2000_PC16", /* name */ 108 FALSE, /* partial_inplace */ 109 0x0000, /* src_mask */ 110 0xffff, /* dst_mask */ 111 TRUE), /* pcrel_offset */ 112 113 /* high 16 bits of symbol value. */ 114 HOWTO (R_IQ2000_HI16, /* type */ 115 16, /* rightshift */ 116 2, /* size (0 = byte, 1 = short, 2 = long) */ 117 15, /* bitsize */ 118 FALSE, /* pc_relative */ 119 0, /* bitpos */ 120 complain_overflow_dont, /* complain_on_overflow */ 121 iq2000_elf_howto_hi16_reloc, /* special_function */ 122 "R_IQ2000_HI16", /* name */ 123 FALSE, /* partial_inplace */ 124 0x0000, /* src_mask */ 125 0x7fff, /* dst_mask */ 126 FALSE), /* pcrel_offset */ 127 128 /* Low 16 bits of symbol value. */ 129 HOWTO (R_IQ2000_LO16, /* type */ 130 0, /* rightshift */ 131 2, /* size (0 = byte, 1 = short, 2 = long) */ 132 16, /* bitsize */ 133 FALSE, /* pc_relative */ 134 0, /* bitpos */ 135 complain_overflow_dont, /* complain_on_overflow */ 136 bfd_elf_generic_reloc, /* special_function */ 137 "R_IQ2000_LO16", /* name */ 138 FALSE, /* partial_inplace */ 139 0x0000, /* src_mask */ 140 0xffff, /* dst_mask */ 141 FALSE), /* pcrel_offset */ 142 143 /* 16-bit jump offset. */ 144 HOWTO (R_IQ2000_OFFSET_16, /* type */ 145 2, /* rightshift */ 146 2, /* size (0 = byte, 1 = short, 2 = long) */ 147 16, /* bitsize */ 148 FALSE, /* pc_relative */ 149 0, /* bitpos */ 150 complain_overflow_dont, /* complain_on_overflow */ 151 bfd_elf_generic_reloc, /* special_function */ 152 "R_IQ2000_OFFSET_16", /* name */ 153 FALSE, /* partial_inplace */ 154 0x0000, /* src_mask */ 155 0xffff, /* dst_mask */ 156 FALSE), /* pcrel_offset */ 157 158 /* 21-bit jump offset. */ 159 HOWTO (R_IQ2000_OFFSET_21, /* type */ 160 2, /* rightshift */ 161 2, /* size (0 = byte, 1 = short, 2 = long) */ 162 21, /* bitsize */ 163 FALSE, /* pc_relative */ 164 0, /* bitpos */ 165 complain_overflow_dont, /* complain_on_overflow */ 166 bfd_elf_generic_reloc, /* special_function */ 167 "R_IQ2000_OFFSET_21", /* name */ 168 FALSE, /* partial_inplace */ 169 0x000000, /* src_mask */ 170 0x1fffff, /* dst_mask */ 171 FALSE), /* pcrel_offset */ 172 173 /* unsigned high 16 bits of value. */ 174 HOWTO (R_IQ2000_OFFSET_21, /* type */ 175 16, /* rightshift */ 176 2, /* size (0 = byte, 1 = short, 2 = long) */ 177 16, /* bitsize */ 178 FALSE, /* pc_relative */ 179 0, /* bitpos */ 180 complain_overflow_dont, /* complain_on_overflow */ 181 bfd_elf_generic_reloc, /* special_function */ 182 "R_IQ2000_UHI16", /* name */ 183 FALSE, /* partial_inplace */ 184 0x0000, /* src_mask */ 185 0x7fff, /* dst_mask */ 186 FALSE), /* pcrel_offset */ 187 188 /* A 32 bit absolute debug relocation. */ 189 HOWTO (R_IQ2000_32_DEBUG, /* type */ 190 0, /* rightshift */ 191 2, /* size (0 = byte, 1 = short, 2 = long) */ 192 32, /* bitsize */ 193 FALSE, /* pc_relative */ 194 0, /* bitpos */ 195 complain_overflow_bitfield, /* complain_on_overflow */ 196 bfd_elf_generic_reloc, /* special_function */ 197 "R_IQ2000_32", /* name */ 198 FALSE, /* partial_inplace */ 199 0x00000000, /* src_mask */ 200 0xffffffff, /* dst_mask */ 201 FALSE), /* pcrel_offset */ 202 203}; 204 205/* GNU extension to record C++ vtable hierarchy. */ 206static reloc_howto_type iq2000_elf_vtinherit_howto = 207 HOWTO (R_IQ2000_GNU_VTINHERIT, /* type */ 208 0, /* rightshift */ 209 2, /* size (0 = byte, 1 = short, 2 = long) */ 210 0, /* bitsize */ 211 FALSE, /* pc_relative */ 212 0, /* bitpos */ 213 complain_overflow_dont, /* complain_on_overflow */ 214 NULL, /* special_function */ 215 "R_IQ2000_GNU_VTINHERIT", /* name */ 216 FALSE, /* partial_inplace */ 217 0, /* src_mask */ 218 0, /* dst_mask */ 219 FALSE); /* pcrel_offset */ 220 221/* GNU extension to record C++ vtable member usage. */ 222static reloc_howto_type iq2000_elf_vtentry_howto = 223 HOWTO (R_IQ2000_GNU_VTENTRY, /* type */ 224 0, /* rightshift */ 225 2, /* size (0 = byte, 1 = short, 2 = long) */ 226 0, /* bitsize */ 227 FALSE, /* pc_relative */ 228 0, /* bitpos */ 229 complain_overflow_dont, /* complain_on_overflow */ 230 NULL, /* special_function */ 231 "R_IQ2000_GNU_VTENTRY", /* name */ 232 FALSE, /* partial_inplace */ 233 0, /* src_mask */ 234 0, /* dst_mask */ 235 FALSE); /* pcrel_offset */ 236 237 238static bfd_reloc_status_type 239iq2000_elf_howto_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, 240 arelent *reloc_entry, 241 asymbol *symbol, 242 void * data, 243 asection *input_section, 244 bfd *output_bfd, 245 char **error_message ATTRIBUTE_UNUSED) 246{ 247 bfd_reloc_status_type ret; 248 bfd_vma relocation; 249 250 /* If we're relocating and this an external symbol, 251 we don't want to change anything. */ 252 if (output_bfd != (bfd *) NULL 253 && (symbol->flags & BSF_SECTION_SYM) == 0 254 && reloc_entry->addend == 0) 255 { 256 reloc_entry->address += input_section->output_offset; 257 return bfd_reloc_ok; 258 } 259 260 if (bfd_is_com_section (symbol->section)) 261 relocation = 0; 262 else 263 relocation = symbol->value; 264 265 relocation += symbol->section->output_section->vma; 266 relocation += symbol->section->output_offset; 267 relocation += reloc_entry->addend; 268 269 /* If %lo will have sign-extension, compensate by add 0x10000 to hi portion. */ 270 if (relocation & 0x8000) 271 reloc_entry->addend += 0x10000; 272 273 /* Now do the reloc in the usual way. */ 274 ret = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 275 input_section, output_bfd, error_message); 276 277 /* Put it back the way it was. */ 278 if (relocation & 0x8000) 279 reloc_entry->addend -= 0x10000; 280 281 return ret; 282} 283 284static bfd_reloc_status_type 285iq2000_elf_relocate_hi16 (bfd *input_bfd, 286 Elf_Internal_Rela *relhi, 287 bfd_byte *contents, 288 bfd_vma value) 289{ 290 bfd_vma insn; 291 292 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); 293 294 value += relhi->r_addend; 295 value &= 0x7fffffff; /* Mask off top-bit which is Harvard mask bit. */ 296 297 /* If top-bit of %lo value is on, this means that %lo will 298 sign-propagate and so we compensate by adding 1 to %hi value. */ 299 if (value & 0x8000) 300 value += 0x10000; 301 302 value >>= 16; 303 insn = ((insn & ~0xFFFF) | value); 304 305 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); 306 return bfd_reloc_ok; 307} 308 309static bfd_reloc_status_type 310iq2000_elf_relocate_offset16 (bfd *input_bfd, 311 Elf_Internal_Rela *rel, 312 bfd_byte *contents, 313 bfd_vma value, 314 bfd_vma location) 315{ 316 bfd_vma insn; 317 bfd_vma jtarget; 318 319 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 320 321 value += rel->r_addend; 322 323 if (value & 3) 324 return bfd_reloc_dangerous; 325 326 jtarget = (value & 0x3fffc) | (location & 0xf0000000L); 327 328 if (jtarget != value) 329 return bfd_reloc_overflow; 330 331 insn = (insn & ~0xFFFF) | ((value >> 2) & 0xFFFF); 332 333 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 334 return bfd_reloc_ok; 335} 336 337/* Map BFD reloc types to IQ2000 ELF reloc types. */ 338 339static reloc_howto_type * 340iq2000_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 341 bfd_reloc_code_real_type code) 342{ 343 /* Note that the iq2000_elf_howto_table is indxed by the R_ 344 constants. Thus, the order that the howto records appear in the 345 table *must* match the order of the relocation types defined in 346 include/elf/iq2000.h. */ 347 348 switch (code) 349 { 350 case BFD_RELOC_NONE: 351 return &iq2000_elf_howto_table[ (int) R_IQ2000_NONE]; 352 case BFD_RELOC_16: 353 return &iq2000_elf_howto_table[ (int) R_IQ2000_16]; 354 case BFD_RELOC_32: 355 return &iq2000_elf_howto_table[ (int) R_IQ2000_32]; 356 case BFD_RELOC_MIPS_JMP: 357 return &iq2000_elf_howto_table[ (int) R_IQ2000_26]; 358 case BFD_RELOC_IQ2000_OFFSET_16: 359 return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_16]; 360 case BFD_RELOC_IQ2000_OFFSET_21: 361 return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_21]; 362 case BFD_RELOC_16_PCREL_S2: 363 return &iq2000_elf_howto_table[ (int) R_IQ2000_PC16]; 364 case BFD_RELOC_HI16: 365 return &iq2000_elf_howto_table[ (int) R_IQ2000_HI16]; 366 case BFD_RELOC_IQ2000_UHI16: 367 return &iq2000_elf_howto_table[ (int) R_IQ2000_UHI16]; 368 case BFD_RELOC_LO16: 369 return &iq2000_elf_howto_table[ (int) R_IQ2000_LO16]; 370 case BFD_RELOC_VTABLE_INHERIT: 371 return &iq2000_elf_vtinherit_howto; 372 case BFD_RELOC_VTABLE_ENTRY: 373 return &iq2000_elf_vtentry_howto; 374 default: 375 /* Pacify gcc -Wall. */ 376 return NULL; 377 } 378 return NULL; 379} 380 381static reloc_howto_type * 382iq2000_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) 383{ 384 unsigned int i; 385 386 for (i = 0; 387 i < (sizeof (iq2000_elf_howto_table) 388 / sizeof (iq2000_elf_howto_table[0])); 389 i++) 390 if (iq2000_elf_howto_table[i].name != NULL 391 && strcasecmp (iq2000_elf_howto_table[i].name, r_name) == 0) 392 return &iq2000_elf_howto_table[i]; 393 394 if (strcasecmp (iq2000_elf_vtinherit_howto.name, r_name) == 0) 395 return &iq2000_elf_vtinherit_howto; 396 if (strcasecmp (iq2000_elf_vtentry_howto.name, r_name) == 0) 397 return &iq2000_elf_vtentry_howto; 398 399 return NULL; 400} 401 402/* Perform a single relocation. By default we use the standard BFD 403 routines. */ 404 405static bfd_reloc_status_type 406iq2000_final_link_relocate (reloc_howto_type * howto, 407 bfd * input_bfd, 408 asection * input_section, 409 bfd_byte * contents, 410 Elf_Internal_Rela * rel, 411 bfd_vma relocation) 412{ 413 return _bfd_final_link_relocate (howto, input_bfd, input_section, 414 contents, rel->r_offset, 415 relocation, rel->r_addend); 416} 417 418/* Set the howto pointer for a IQ2000 ELF reloc. */ 419 420static bfd_boolean 421iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED, 422 arelent * cache_ptr, 423 Elf_Internal_Rela * dst) 424{ 425 unsigned int r_type; 426 427 r_type = ELF32_R_TYPE (dst->r_info); 428 switch (r_type) 429 { 430 case R_IQ2000_GNU_VTINHERIT: 431 cache_ptr->howto = & iq2000_elf_vtinherit_howto; 432 break; 433 434 case R_IQ2000_GNU_VTENTRY: 435 cache_ptr->howto = & iq2000_elf_vtentry_howto; 436 break; 437 438 default: 439 if (r_type >= ARRAY_SIZE (iq2000_elf_howto_table)) 440 { 441 /* xgettext:c-format */ 442 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 443 abfd, r_type); 444 bfd_set_error (bfd_error_bad_value); 445 return FALSE; 446 } 447 cache_ptr->howto = & iq2000_elf_howto_table [r_type]; 448 break; 449 } 450 return TRUE; 451} 452 453/* Look through the relocs for a section during the first phase. 454 Since we don't do .gots or .plts, we just need to consider the 455 virtual table relocs for gc. */ 456 457static bfd_boolean 458iq2000_elf_check_relocs (bfd *abfd, 459 struct bfd_link_info *info, 460 asection *sec, 461 const Elf_Internal_Rela *relocs) 462{ 463 Elf_Internal_Shdr *symtab_hdr; 464 struct elf_link_hash_entry **sym_hashes; 465 const Elf_Internal_Rela *rel; 466 const Elf_Internal_Rela *rel_end; 467 bfd_boolean changed = FALSE; 468 469 if (bfd_link_relocatable (info)) 470 return TRUE; 471 472 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 473 sym_hashes = elf_sym_hashes (abfd); 474 475 rel_end = relocs + sec->reloc_count; 476 for (rel = relocs; rel < rel_end; rel++) 477 { 478 struct elf_link_hash_entry *h; 479 unsigned long r_symndx; 480 481 r_symndx = ELF32_R_SYM (rel->r_info); 482 if (r_symndx < symtab_hdr->sh_info) 483 h = NULL; 484 else 485 { 486 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 487 while (h->root.type == bfd_link_hash_indirect 488 || h->root.type == bfd_link_hash_warning) 489 h = (struct elf_link_hash_entry *) h->root.u.i.link; 490 } 491 492 switch (ELF32_R_TYPE (rel->r_info)) 493 { 494 /* This relocation describes the C++ object vtable 495 hierarchy. Reconstruct it for later use during GC. */ 496 case R_IQ2000_GNU_VTINHERIT: 497 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 498 return FALSE; 499 break; 500 501 /* This relocation describes which C++ vtable entries 502 are actually used. Record for later use during GC. */ 503 case R_IQ2000_GNU_VTENTRY: 504 BFD_ASSERT (h != NULL); 505 if (h != NULL 506 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 507 return FALSE; 508 break; 509 510 case R_IQ2000_32: 511 /* For debug section, change to special harvard-aware relocations. */ 512 if (CONST_STRNEQ (sec->name, ".debug") 513 || CONST_STRNEQ (sec->name, ".stab") 514 || CONST_STRNEQ (sec->name, ".eh_frame")) 515 { 516 ((Elf_Internal_Rela *) rel)->r_info 517 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG); 518 changed = TRUE; 519 } 520 break; 521 } 522 } 523 524 if (changed) 525 /* Note that we've changed relocs, otherwise if !info->keep_memory 526 we'll free the relocs and lose our changes. */ 527 elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs; 528 529 return TRUE; 530} 531 532 533/* Relocate a IQ2000 ELF section. 534 There is some attempt to make this function usable for many architectures, 535 both USE_REL and USE_RELA ['twould be nice if such a critter existed], 536 if only to serve as a learning tool. 537 538 The RELOCATE_SECTION function is called by the new ELF backend linker 539 to handle the relocations for a section. 540 541 The relocs are always passed as Rela structures; if the section 542 actually uses Rel structures, the r_addend field will always be 543 zero. 544 545 This function is responsible for adjusting the section contents as 546 necessary, and (if using Rela relocs and generating a relocatable 547 output file) adjusting the reloc addend as necessary. 548 549 This function does not have to worry about setting the reloc 550 address or the reloc symbol index. 551 552 LOCAL_SYMS is a pointer to the swapped in local symbols. 553 554 LOCAL_SECTIONS is an array giving the section in the input file 555 corresponding to the st_shndx field of each local symbol. 556 557 The global hash table entry for the global symbols can be found 558 via elf_sym_hashes (input_bfd). 559 560 When generating relocatable output, this function must handle 561 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 562 going to be the section symbol corresponding to the output 563 section, which means that the addend must be adjusted 564 accordingly. */ 565 566static bfd_boolean 567iq2000_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED, 568 struct bfd_link_info * info, 569 bfd * input_bfd, 570 asection * input_section, 571 bfd_byte * contents, 572 Elf_Internal_Rela * relocs, 573 Elf_Internal_Sym * local_syms, 574 asection ** local_sections) 575{ 576 Elf_Internal_Shdr * symtab_hdr; 577 struct elf_link_hash_entry ** sym_hashes; 578 Elf_Internal_Rela * rel; 579 Elf_Internal_Rela * relend; 580 581 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 582 sym_hashes = elf_sym_hashes (input_bfd); 583 relend = relocs + input_section->reloc_count; 584 585 for (rel = relocs; rel < relend; rel ++) 586 { 587 reloc_howto_type * howto; 588 unsigned long r_symndx; 589 Elf_Internal_Sym * sym; 590 asection * sec; 591 struct elf_link_hash_entry * h; 592 bfd_vma relocation; 593 bfd_reloc_status_type r; 594 const char * name = NULL; 595 int r_type; 596 597 r_type = ELF32_R_TYPE (rel->r_info); 598 599 if ( r_type == R_IQ2000_GNU_VTINHERIT 600 || r_type == R_IQ2000_GNU_VTENTRY) 601 continue; 602 603 r_symndx = ELF32_R_SYM (rel->r_info); 604 605 howto = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info); 606 h = NULL; 607 sym = NULL; 608 sec = NULL; 609 610 if (r_symndx < symtab_hdr->sh_info) 611 { 612 asection *osec; 613 614 sym = local_syms + r_symndx; 615 osec = sec = local_sections [r_symndx]; 616 if ((sec->flags & SEC_MERGE) 617 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 618 /* This relocation is relative to a section symbol that is 619 going to be merged. Change it so that it is relative 620 to the merged section symbol. */ 621 rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym, &sec, 622 rel->r_addend); 623 624 relocation = (sec->output_section->vma 625 + sec->output_offset 626 + sym->st_value); 627 628 name = bfd_elf_string_from_elf_section 629 (input_bfd, symtab_hdr->sh_link, sym->st_name); 630 name = (name == NULL) ? bfd_section_name (input_bfd, osec) : name; 631 } 632 else 633 { 634 bfd_boolean unresolved_reloc; 635 bfd_boolean warned, ignored; 636 637 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 638 r_symndx, symtab_hdr, sym_hashes, 639 h, sec, relocation, 640 unresolved_reloc, warned, ignored); 641 642 name = h->root.root.string; 643 } 644 645 if (sec != NULL && discarded_section (sec)) 646 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 647 rel, 1, relend, howto, 0, contents); 648 649 if (bfd_link_relocatable (info)) 650 continue; 651 652 switch (r_type) 653 { 654 case R_IQ2000_HI16: 655 r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation); 656 break; 657 658 case R_IQ2000_OFFSET_16: 659 r = iq2000_elf_relocate_offset16 (input_bfd, rel, contents, relocation, 660 input_section->output_section->vma 661 + input_section->output_offset 662 + rel->r_offset); 663 break; 664 665 case R_IQ2000_PC16: 666 rel->r_addend -= 4; 667 /* Fall through. */ 668 669 default: 670 r = iq2000_final_link_relocate (howto, input_bfd, input_section, 671 contents, rel, relocation); 672 break; 673 } 674 675 if (r != bfd_reloc_ok) 676 { 677 const char * msg = (const char *) NULL; 678 679 switch (r) 680 { 681 case bfd_reloc_overflow: 682 (*info->callbacks->reloc_overflow) 683 (info, (h ? &h->root : NULL), name, howto->name, 684 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 685 break; 686 687 case bfd_reloc_undefined: 688 (*info->callbacks->undefined_symbol) 689 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 690 break; 691 692 case bfd_reloc_outofrange: 693 msg = _("internal error: out of range error"); 694 break; 695 696 case bfd_reloc_notsupported: 697 msg = _("internal error: unsupported relocation error"); 698 break; 699 700 case bfd_reloc_dangerous: 701 msg = _("internal error: dangerous relocation"); 702 break; 703 704 default: 705 msg = _("internal error: unknown error"); 706 break; 707 } 708 709 if (msg) 710 (*info->callbacks->warning) (info, msg, name, input_bfd, 711 input_section, rel->r_offset); 712 } 713 } 714 715 return TRUE; 716} 717 718 719/* Return the section that should be marked against GC for a given 720 relocation. */ 721 722static asection * 723iq2000_elf_gc_mark_hook (asection *sec, 724 struct bfd_link_info *info, 725 Elf_Internal_Rela *rel, 726 struct elf_link_hash_entry *h, 727 Elf_Internal_Sym *sym) 728{ 729 if (h != NULL) 730 switch (ELF32_R_TYPE (rel->r_info)) 731 { 732 case R_IQ2000_GNU_VTINHERIT: 733 case R_IQ2000_GNU_VTENTRY: 734 return NULL; 735 } 736 737 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 738} 739 740 741/* Return the MACH for an e_flags value. */ 742 743static int 744elf32_iq2000_machine (bfd *abfd) 745{ 746 switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK) 747 { 748 case EF_IQ2000_CPU_IQ10: 749 return bfd_mach_iq10; 750 751 case EF_IQ2000_CPU_IQ2000: 752 default: 753 return bfd_mach_iq2000; 754 } 755} 756 757 758/* Function to set the ELF flag bits. */ 759 760static bfd_boolean 761iq2000_elf_set_private_flags (bfd *abfd, flagword flags) 762{ 763 elf_elfheader (abfd)->e_flags = flags; 764 elf_flags_init (abfd) = TRUE; 765 return TRUE; 766} 767 768/* Merge backend specific data from an object 769 file to the output object file when linking. */ 770 771static bfd_boolean 772iq2000_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 773{ 774 bfd *obfd = info->output_bfd; 775 flagword old_flags, old_partial; 776 flagword new_flags, new_partial; 777 bfd_boolean error = FALSE; 778 char new_opt[80]; 779 char old_opt[80]; 780 781 new_opt[0] = old_opt[0] = '\0'; 782 new_flags = elf_elfheader (ibfd)->e_flags; 783 old_flags = elf_elfheader (obfd)->e_flags; 784 785 if (!elf_flags_init (obfd)) 786 { 787 /* First call, no flags set. */ 788 elf_flags_init (obfd) = TRUE; 789 elf_elfheader (obfd)->e_flags = new_flags; 790 } 791 792 else if (new_flags != old_flags) 793 { 794 /* Warn if different cpu is used, but allow a 795 specific cpu to override the generic cpu. */ 796 new_partial = (new_flags & EF_IQ2000_CPU_MASK); 797 old_partial = (old_flags & EF_IQ2000_CPU_MASK); 798 799 if (new_partial != old_partial) 800 { 801 switch (new_partial) 802 { 803 case EF_IQ2000_CPU_IQ10: 804 strcat (new_opt, " -m10"); 805 break; 806 807 default: 808 case EF_IQ2000_CPU_IQ2000: 809 strcat (new_opt, " -m2000"); 810 break; 811 } 812 813 switch (old_partial) 814 { 815 case EF_IQ2000_CPU_IQ10: 816 strcat (old_opt, " -m10"); 817 break; 818 819 default: 820 case EF_IQ2000_CPU_IQ2000: 821 strcat (old_opt, " -m2000"); 822 break; 823 } 824 } 825 826 /* Print out any mismatches from above. */ 827 if (new_opt[0]) 828 { 829 error = TRUE; 830 _bfd_error_handler 831 /* xgettext:c-format */ 832 (_("%pB: compiled with %s and linked with modules compiled with %s"), 833 ibfd, new_opt, old_opt); 834 } 835 836 new_flags &= ~ EF_IQ2000_ALL_FLAGS; 837 old_flags &= ~ EF_IQ2000_ALL_FLAGS; 838 839 /* Warn about any other mismatches. */ 840 if (new_flags != old_flags) 841 { 842 error = TRUE; 843 844 _bfd_error_handler 845 /* xgettext:c-format */ 846 (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"), 847 ibfd, new_flags, old_flags); 848 } 849 } 850 851 if (error) 852 bfd_set_error (bfd_error_bad_value); 853 854 return !error; 855} 856 857 858static bfd_boolean 859iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr) 860{ 861 FILE *file = (FILE *) ptr; 862 flagword flags; 863 864 BFD_ASSERT (abfd != NULL && ptr != NULL); 865 866 /* Print normal ELF private data. */ 867 _bfd_elf_print_private_bfd_data (abfd, ptr); 868 869 flags = elf_elfheader (abfd)->e_flags; 870 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags); 871 872 switch (flags & EF_IQ2000_CPU_MASK) 873 { 874 case EF_IQ2000_CPU_IQ10: 875 fprintf (file, " -m10"); 876 break; 877 case EF_IQ2000_CPU_IQ2000: 878 fprintf (file, " -m2000"); 879 break; 880 default: 881 break; 882 } 883 884 fputc ('\n', file); 885 return TRUE; 886} 887 888static 889bfd_boolean 890iq2000_elf_object_p (bfd *abfd) 891{ 892 bfd_default_set_arch_mach (abfd, bfd_arch_iq2000, 893 elf32_iq2000_machine (abfd)); 894 return TRUE; 895} 896 897 898#define ELF_ARCH bfd_arch_iq2000 899#define ELF_MACHINE_CODE EM_IQ2000 900#define ELF_MAXPAGESIZE 0x1000 901 902#define TARGET_BIG_SYM iq2000_elf32_vec 903#define TARGET_BIG_NAME "elf32-iq2000" 904 905#define elf_info_to_howto_rel NULL 906#define elf_info_to_howto iq2000_info_to_howto_rela 907#define elf_backend_relocate_section iq2000_elf_relocate_section 908#define elf_backend_gc_mark_hook iq2000_elf_gc_mark_hook 909#define elf_backend_check_relocs iq2000_elf_check_relocs 910#define elf_backend_object_p iq2000_elf_object_p 911#define elf_backend_rela_normal 1 912 913#define elf_backend_can_gc_sections 1 914 915#define bfd_elf32_bfd_reloc_type_lookup iq2000_reloc_type_lookup 916#define bfd_elf32_bfd_reloc_name_lookup iq2000_reloc_name_lookup 917#define bfd_elf32_bfd_set_private_flags iq2000_elf_set_private_flags 918#define bfd_elf32_bfd_merge_private_bfd_data iq2000_elf_merge_private_bfd_data 919#define bfd_elf32_bfd_print_private_bfd_data iq2000_elf_print_private_bfd_data 920 921#include "elf32-target.h" 922