1 /* SPARC-specific support for 64-bit ELF 2 Copyright (C) 1993-2022 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 <limits.h> 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "elf/sparc.h" 27 #include "opcode/sparc.h" 28 #include "elfxx-sparc.h" 29 30 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */ 31 #define MINUS_ONE (~ (bfd_vma) 0) 32 33 /* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA 34 section can represent up to two relocs, we must tell the user to allocate 35 more space. */ 36 37 static long 38 elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 39 { 40 size_t count, raw; 41 42 count = sec->reloc_count; 43 if (count >= LONG_MAX / 2 / sizeof (arelent *) 44 || _bfd_mul_overflow (count, sizeof (Elf64_External_Rela), &raw)) 45 { 46 bfd_set_error (bfd_error_file_too_big); 47 return -1; 48 } 49 if (!bfd_write_p (abfd)) 50 { 51 ufile_ptr filesize = bfd_get_file_size (abfd); 52 if (filesize != 0 && raw > filesize) 53 { 54 bfd_set_error (bfd_error_file_truncated); 55 return -1; 56 } 57 } 58 return (count * 2 + 1) * sizeof (arelent *); 59 } 60 61 static long 62 elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd) 63 { 64 long ret = _bfd_elf_get_dynamic_reloc_upper_bound (abfd); 65 if (ret > LONG_MAX / 2) 66 { 67 bfd_set_error (bfd_error_file_too_big); 68 ret = -1; 69 } 70 else if (ret > 0) 71 ret *= 2; 72 return ret; 73 } 74 75 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of 76 them. We cannot use generic elf routines for this, because R_SPARC_OLO10 77 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations 78 for the same location, R_SPARC_LO10 and R_SPARC_13. */ 79 80 static bool 81 elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect, 82 Elf_Internal_Shdr *rel_hdr, 83 asymbol **symbols, bool dynamic) 84 { 85 void * allocated = NULL; 86 bfd_byte *native_relocs; 87 arelent *relent; 88 unsigned int i; 89 int entsize; 90 bfd_size_type count; 91 arelent *relents; 92 93 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0) 94 return false; 95 allocated = _bfd_malloc_and_read (abfd, rel_hdr->sh_size, rel_hdr->sh_size); 96 if (allocated == NULL) 97 return false; 98 99 native_relocs = (bfd_byte *) allocated; 100 101 relents = asect->relocation + canon_reloc_count (asect); 102 103 entsize = rel_hdr->sh_entsize; 104 BFD_ASSERT (entsize == sizeof (Elf64_External_Rela)); 105 106 count = rel_hdr->sh_size / entsize; 107 108 for (i = 0, relent = relents; i < count; 109 i++, relent++, native_relocs += entsize) 110 { 111 Elf_Internal_Rela rela; 112 unsigned int r_type; 113 114 bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela); 115 116 /* The address of an ELF reloc is section relative for an object 117 file, and absolute for an executable file or shared library. 118 The address of a normal BFD reloc is always section relative, 119 and the address of a dynamic reloc is absolute.. */ 120 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic) 121 relent->address = rela.r_offset; 122 else 123 relent->address = rela.r_offset - asect->vma; 124 125 if (ELF64_R_SYM (rela.r_info) == STN_UNDEF) 126 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 127 else if (/* PR 17512: file: 996185f8. */ 128 ELF64_R_SYM (rela.r_info) > (dynamic 129 ? bfd_get_dynamic_symcount (abfd) 130 : bfd_get_symcount (abfd))) 131 { 132 _bfd_error_handler 133 /* xgettext:c-format */ 134 (_("%pB(%pA): relocation %d has invalid symbol index %ld"), 135 abfd, asect, i, (long) ELF64_R_SYM (rela.r_info)); 136 bfd_set_error (bfd_error_bad_value); 137 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 138 } 139 else 140 { 141 asymbol **ps, *s; 142 143 ps = symbols + ELF64_R_SYM (rela.r_info) - 1; 144 s = *ps; 145 146 /* Canonicalize ELF section symbols. FIXME: Why? */ 147 if ((s->flags & BSF_SECTION_SYM) == 0) 148 relent->sym_ptr_ptr = ps; 149 else 150 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr; 151 } 152 153 relent->addend = rela.r_addend; 154 155 r_type = ELF64_R_TYPE_ID (rela.r_info); 156 if (r_type == R_SPARC_OLO10) 157 { 158 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, R_SPARC_LO10); 159 relent[1].address = relent->address; 160 relent++; 161 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 162 relent->addend = ELF64_R_TYPE_DATA (rela.r_info); 163 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, R_SPARC_13); 164 } 165 else 166 { 167 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, r_type); 168 if (relent->howto == NULL) 169 goto error_return; 170 } 171 } 172 173 canon_reloc_count (asect) += relent - relents; 174 175 free (allocated); 176 return true; 177 178 error_return: 179 free (allocated); 180 return false; 181 } 182 183 /* Read in and swap the external relocs. */ 184 185 static bool 186 elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect, 187 asymbol **symbols, bool dynamic) 188 { 189 struct bfd_elf_section_data * const d = elf_section_data (asect); 190 Elf_Internal_Shdr *rel_hdr; 191 Elf_Internal_Shdr *rel_hdr2; 192 bfd_size_type amt; 193 194 if (asect->relocation != NULL) 195 return true; 196 197 if (! dynamic) 198 { 199 if ((asect->flags & SEC_RELOC) == 0 200 || asect->reloc_count == 0) 201 return true; 202 203 rel_hdr = d->rel.hdr; 204 rel_hdr2 = d->rela.hdr; 205 206 BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset) 207 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset)); 208 } 209 else 210 { 211 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this 212 case because relocations against this section may use the 213 dynamic symbol table, and in that case bfd_section_from_shdr 214 in elf.c does not update the RELOC_COUNT. */ 215 if (asect->size == 0) 216 return true; 217 218 rel_hdr = &d->this_hdr; 219 asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr); 220 rel_hdr2 = NULL; 221 } 222 223 amt = asect->reloc_count; 224 amt *= 2 * sizeof (arelent); 225 asect->relocation = (arelent *) bfd_alloc (abfd, amt); 226 if (asect->relocation == NULL) 227 return false; 228 229 /* The elf64_sparc_slurp_one_reloc_table routine increments 230 canon_reloc_count. */ 231 canon_reloc_count (asect) = 0; 232 233 if (rel_hdr 234 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, 235 dynamic)) 236 return false; 237 238 if (rel_hdr2 239 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols, 240 dynamic)) 241 return false; 242 243 return true; 244 } 245 246 /* Canonicalize the relocs. */ 247 248 static long 249 elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section, 250 arelent **relptr, asymbol **symbols) 251 { 252 arelent *tblptr; 253 unsigned int i; 254 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 255 256 if (! bed->s->slurp_reloc_table (abfd, section, symbols, false)) 257 return -1; 258 259 tblptr = section->relocation; 260 for (i = 0; i < canon_reloc_count (section); i++) 261 *relptr++ = tblptr++; 262 263 *relptr = NULL; 264 265 return canon_reloc_count (section); 266 } 267 268 269 /* Canonicalize the dynamic relocation entries. Note that we return 270 the dynamic relocations as a single block, although they are 271 actually associated with particular sections; the interface, which 272 was designed for SunOS style shared libraries, expects that there 273 is only one set of dynamic relocs. Any section that was actually 274 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses 275 the dynamic symbol table, is considered to be a dynamic reloc 276 section. */ 277 278 static long 279 elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage, 280 asymbol **syms) 281 { 282 asection *s; 283 long ret; 284 285 if (elf_dynsymtab (abfd) == 0) 286 { 287 bfd_set_error (bfd_error_invalid_operation); 288 return -1; 289 } 290 291 ret = 0; 292 for (s = abfd->sections; s != NULL; s = s->next) 293 { 294 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 295 && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 296 { 297 arelent *p; 298 long count, i; 299 300 if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, true)) 301 return -1; 302 count = canon_reloc_count (s); 303 p = s->relocation; 304 for (i = 0; i < count; i++) 305 *storage++ = p++; 306 ret += count; 307 } 308 } 309 310 *storage = NULL; 311 312 return ret; 313 } 314 315 /* Install a new set of internal relocs. */ 316 317 static void 318 elf64_sparc_set_reloc (bfd *abfd ATTRIBUTE_UNUSED, 319 asection *asect, 320 arelent **location, 321 unsigned int count) 322 { 323 asect->orelocation = location; 324 canon_reloc_count (asect) = count; 325 if (count != 0) 326 asect->flags |= SEC_RELOC; 327 else 328 asect->flags &= ~SEC_RELOC; 329 } 330 331 /* Write out the relocs. */ 332 333 static void 334 elf64_sparc_write_relocs (bfd *abfd, asection *sec, void * data) 335 { 336 bool *failedp = (bool *) data; 337 Elf_Internal_Shdr *rela_hdr; 338 bfd_vma addr_offset; 339 Elf64_External_Rela *outbound_relocas, *src_rela; 340 unsigned int idx, count; 341 asymbol *last_sym = 0; 342 int last_sym_idx = 0; 343 344 /* If we have already failed, don't do anything. */ 345 if (*failedp) 346 return; 347 348 if ((sec->flags & SEC_RELOC) == 0) 349 return; 350 351 /* The linker backend writes the relocs out itself, and sets the 352 reloc_count field to zero to inhibit writing them here. Also, 353 sometimes the SEC_RELOC flag gets set even when there aren't any 354 relocs. */ 355 if (canon_reloc_count (sec) == 0) 356 return; 357 358 /* We can combine two relocs that refer to the same address 359 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the 360 latter is R_SPARC_13 with no associated symbol. */ 361 count = 0; 362 for (idx = 0; idx < canon_reloc_count (sec); idx++) 363 { 364 bfd_vma addr; 365 366 ++count; 367 368 addr = sec->orelocation[idx]->address; 369 if (sec->orelocation[idx]->howto->type == R_SPARC_LO10 370 && idx < canon_reloc_count (sec) - 1) 371 { 372 arelent *r = sec->orelocation[idx + 1]; 373 374 if (r->howto->type == R_SPARC_13 375 && r->address == addr 376 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section) 377 && (*r->sym_ptr_ptr)->value == 0) 378 ++idx; 379 } 380 } 381 382 rela_hdr = elf_section_data (sec)->rela.hdr; 383 384 rela_hdr->sh_size = rela_hdr->sh_entsize * count; 385 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size); 386 if (rela_hdr->contents == NULL) 387 { 388 *failedp = true; 389 return; 390 } 391 392 /* Figure out whether the relocations are RELA or REL relocations. */ 393 if (rela_hdr->sh_type != SHT_RELA) 394 abort (); 395 396 /* The address of an ELF reloc is section relative for an object 397 file, and absolute for an executable file or shared library. 398 The address of a BFD reloc is always section relative. */ 399 addr_offset = 0; 400 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) 401 addr_offset = sec->vma; 402 403 /* orelocation has the data, reloc_count has the count... */ 404 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents; 405 src_rela = outbound_relocas; 406 407 for (idx = 0; idx < canon_reloc_count (sec); idx++) 408 { 409 Elf_Internal_Rela dst_rela; 410 arelent *ptr; 411 asymbol *sym; 412 int n; 413 414 ptr = sec->orelocation[idx]; 415 sym = *ptr->sym_ptr_ptr; 416 if (sym == last_sym) 417 n = last_sym_idx; 418 else if (bfd_is_abs_section (sym->section) && sym->value == 0) 419 n = STN_UNDEF; 420 else 421 { 422 last_sym = sym; 423 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym); 424 if (n < 0) 425 { 426 *failedp = true; 427 return; 428 } 429 last_sym_idx = n; 430 } 431 432 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL 433 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec 434 && ! _bfd_elf_validate_reloc (abfd, ptr)) 435 { 436 *failedp = true; 437 return; 438 } 439 440 if (ptr->howto->type == R_SPARC_LO10 441 && idx < canon_reloc_count (sec) - 1) 442 { 443 arelent *r = sec->orelocation[idx + 1]; 444 445 if (r->howto->type == R_SPARC_13 446 && r->address == ptr->address 447 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section) 448 && (*r->sym_ptr_ptr)->value == 0) 449 { 450 idx++; 451 dst_rela.r_info 452 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend, 453 R_SPARC_OLO10)); 454 } 455 else 456 dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10); 457 } 458 else 459 dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type); 460 461 dst_rela.r_offset = ptr->address + addr_offset; 462 dst_rela.r_addend = ptr->addend; 463 464 bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela); 465 ++src_rela; 466 } 467 } 468 469 /* Hook called by the linker routine which adds symbols from an object 470 file. We use it for STT_REGISTER symbols. */ 471 472 static bool 473 elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, 474 Elf_Internal_Sym *sym, const char **namep, 475 flagword *flagsp ATTRIBUTE_UNUSED, 476 asection **secp ATTRIBUTE_UNUSED, 477 bfd_vma *valp ATTRIBUTE_UNUSED) 478 { 479 static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" }; 480 481 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER) 482 { 483 int reg; 484 struct _bfd_sparc_elf_app_reg *p; 485 486 reg = (int)sym->st_value; 487 switch (reg & ~1) 488 { 489 case 2: reg -= 2; break; 490 case 6: reg -= 4; break; 491 default: 492 _bfd_error_handler 493 (_("%pB: only registers %%g[2367] can be declared using STT_REGISTER"), 494 abfd); 495 return false; 496 } 497 498 if (info->output_bfd->xvec != abfd->xvec 499 || (abfd->flags & DYNAMIC) != 0) 500 { 501 /* STT_REGISTER only works when linking an elf64_sparc object. 502 If STT_REGISTER comes from a dynamic object, don't put it into 503 the output bfd. The dynamic linker will recheck it. */ 504 *namep = NULL; 505 return true; 506 } 507 508 p = _bfd_sparc_elf_hash_table(info)->app_regs + reg; 509 510 if (p->name != NULL && strcmp (p->name, *namep)) 511 { 512 _bfd_error_handler 513 /* xgettext:c-format */ 514 (_("register %%g%d used incompatibly: %s in %pB," 515 " previously %s in %pB"), 516 (int) sym->st_value, **namep ? *namep : "#scratch", abfd, 517 *p->name ? p->name : "#scratch", p->abfd); 518 return false; 519 } 520 521 if (p->name == NULL) 522 { 523 if (**namep) 524 { 525 struct elf_link_hash_entry *h; 526 527 h = (struct elf_link_hash_entry *) 528 bfd_link_hash_lookup (info->hash, *namep, false, false, false); 529 530 if (h != NULL) 531 { 532 unsigned char type = h->type; 533 534 if (type > STT_FUNC) 535 type = 0; 536 _bfd_error_handler 537 /* xgettext:c-format */ 538 (_("symbol `%s' has differing types: REGISTER in %pB," 539 " previously %s in %pB"), 540 *namep, abfd, stt_types[type], p->abfd); 541 return false; 542 } 543 544 p->name = bfd_hash_allocate (&info->hash->table, 545 strlen (*namep) + 1); 546 if (!p->name) 547 return false; 548 549 strcpy (p->name, *namep); 550 } 551 else 552 p->name = ""; 553 p->bind = ELF_ST_BIND (sym->st_info); 554 p->abfd = abfd; 555 p->shndx = sym->st_shndx; 556 } 557 else 558 { 559 if (p->bind == STB_WEAK 560 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL) 561 { 562 p->bind = STB_GLOBAL; 563 p->abfd = abfd; 564 } 565 } 566 *namep = NULL; 567 return true; 568 } 569 else if (*namep && **namep 570 && info->output_bfd->xvec == abfd->xvec) 571 { 572 int i; 573 struct _bfd_sparc_elf_app_reg *p; 574 575 p = _bfd_sparc_elf_hash_table(info)->app_regs; 576 for (i = 0; i < 4; i++, p++) 577 if (p->name != NULL && ! strcmp (p->name, *namep)) 578 { 579 unsigned char type = ELF_ST_TYPE (sym->st_info); 580 581 if (type > STT_FUNC) 582 type = 0; 583 _bfd_error_handler 584 /* xgettext:c-format */ 585 (_("Symbol `%s' has differing types: %s in %pB," 586 " previously REGISTER in %pB"), 587 *namep, stt_types[type], abfd, p->abfd); 588 return false; 589 } 590 } 591 return true; 592 } 593 594 /* This function takes care of emitting STT_REGISTER symbols 595 which we cannot easily keep in the symbol hash table. */ 596 597 static bool 598 elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED, 599 struct bfd_link_info *info, 600 void * flaginfo, 601 int (*func) (void *, const char *, 602 Elf_Internal_Sym *, 603 asection *, 604 struct elf_link_hash_entry *)) 605 { 606 int reg; 607 struct _bfd_sparc_elf_app_reg *app_regs = 608 _bfd_sparc_elf_hash_table(info)->app_regs; 609 Elf_Internal_Sym sym; 610 611 for (reg = 0; reg < 4; reg++) 612 if (app_regs [reg].name != NULL) 613 { 614 if (info->strip == strip_some 615 && bfd_hash_lookup (info->keep_hash, 616 app_regs [reg].name, 617 false, false) == NULL) 618 continue; 619 620 sym.st_value = reg < 2 ? reg + 2 : reg + 4; 621 sym.st_size = 0; 622 sym.st_other = 0; 623 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER); 624 sym.st_shndx = app_regs [reg].shndx; 625 sym.st_target_internal = 0; 626 if ((*func) (flaginfo, app_regs [reg].name, &sym, 627 sym.st_shndx == SHN_ABS 628 ? bfd_abs_section_ptr : bfd_und_section_ptr, 629 NULL) != 1) 630 return false; 631 } 632 633 return true; 634 } 635 636 static int 637 elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type) 638 { 639 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER) 640 return STT_REGISTER; 641 else 642 return type; 643 } 644 645 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL 646 even in SHN_UNDEF section. */ 647 648 static void 649 elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym) 650 { 651 elf_symbol_type *elfsym; 652 653 elfsym = (elf_symbol_type *) asym; 654 if (elfsym->internal_elf_sym.st_info 655 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER)) 656 { 657 asym->flags |= BSF_GLOBAL; 658 } 659 } 660 661 662 /* Functions for dealing with the e_flags field. */ 663 664 /* Merge backend specific data from an object file to the output 665 object file when linking. */ 666 667 static bool 668 elf64_sparc_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 669 { 670 bfd *obfd = info->output_bfd; 671 bool error; 672 flagword new_flags, old_flags; 673 int new_mm, old_mm; 674 675 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 676 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 677 return true; 678 679 new_flags = elf_elfheader (ibfd)->e_flags; 680 old_flags = elf_elfheader (obfd)->e_flags; 681 682 if (!elf_flags_init (obfd)) /* First call, no flags set */ 683 { 684 elf_flags_init (obfd) = true; 685 elf_elfheader (obfd)->e_flags = new_flags; 686 } 687 688 else if (new_flags == old_flags) /* Compatible flags are ok */ 689 ; 690 691 else /* Incompatible flags */ 692 { 693 error = false; 694 695 #define EF_SPARC_ISA_EXTENSIONS \ 696 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1) 697 698 if ((ibfd->flags & DYNAMIC) != 0) 699 { 700 /* We don't want dynamic objects memory ordering and 701 architecture to have any role. That's what dynamic linker 702 should do. */ 703 new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS); 704 new_flags |= (old_flags 705 & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS)); 706 } 707 else 708 { 709 /* Choose the highest architecture requirements. */ 710 old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS); 711 new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS); 712 if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3)) 713 && (old_flags & EF_SPARC_HAL_R1)) 714 { 715 error = true; 716 _bfd_error_handler 717 (_("%pB: linking UltraSPARC specific with HAL specific code"), 718 ibfd); 719 } 720 /* Choose the most restrictive memory ordering. */ 721 old_mm = (old_flags & EF_SPARCV9_MM); 722 new_mm = (new_flags & EF_SPARCV9_MM); 723 old_flags &= ~EF_SPARCV9_MM; 724 new_flags &= ~EF_SPARCV9_MM; 725 if (new_mm < old_mm) 726 old_mm = new_mm; 727 old_flags |= old_mm; 728 new_flags |= old_mm; 729 } 730 731 /* Warn about any other mismatches */ 732 if (new_flags != old_flags) 733 { 734 error = true; 735 _bfd_error_handler 736 /* xgettext:c-format */ 737 (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"), 738 ibfd, new_flags, old_flags); 739 } 740 741 elf_elfheader (obfd)->e_flags = old_flags; 742 743 if (error) 744 { 745 bfd_set_error (bfd_error_bad_value); 746 return false; 747 } 748 } 749 return _bfd_sparc_elf_merge_private_bfd_data (ibfd, info); 750 } 751 752 /* MARCO: Set the correct entry size for the .stab section. */ 753 754 static bool 755 elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, 756 Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED, 757 asection *sec) 758 { 759 const char *name; 760 761 name = bfd_section_name (sec); 762 763 if (strcmp (name, ".stab") == 0) 764 { 765 /* Even in the 64bit case the stab entries are only 12 bytes long. */ 766 elf_section_data (sec)->this_hdr.sh_entsize = 12; 767 } 768 769 return true; 770 } 771 772 /* Print a STT_REGISTER symbol to file FILE. */ 773 774 static const char * 775 elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, void * filep, 776 asymbol *symbol) 777 { 778 FILE *file = (FILE *) filep; 779 int reg, type; 780 781 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info) 782 != STT_REGISTER) 783 return NULL; 784 785 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value; 786 type = symbol->flags; 787 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "", 788 ((type & BSF_LOCAL) 789 ? (type & BSF_GLOBAL) ? '!' : 'l' 790 : (type & BSF_GLOBAL) ? 'g' : ' '), 791 (type & BSF_WEAK) ? 'w' : ' '); 792 if (symbol->name == NULL || symbol->name [0] == '\0') 793 return "#scratch"; 794 else 795 return symbol->name; 796 } 797 798 /* Used to decide how to sort relocs in an optimal manner for the 799 dynamic linker, before writing them out. */ 800 801 static enum elf_reloc_type_class 802 elf64_sparc_reloc_type_class (const struct bfd_link_info *info, 803 const asection *rel_sec ATTRIBUTE_UNUSED, 804 const Elf_Internal_Rela *rela) 805 { 806 bfd *abfd = info->output_bfd; 807 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 808 struct _bfd_sparc_elf_link_hash_table *htab 809 = _bfd_sparc_elf_hash_table (info); 810 BFD_ASSERT (htab != NULL); 811 812 if (htab->elf.dynsym != NULL 813 && htab->elf.dynsym->contents != NULL) 814 { 815 /* Check relocation against STT_GNU_IFUNC symbol if there are 816 dynamic symbols. */ 817 unsigned long r_symndx = htab->r_symndx (rela->r_info); 818 if (r_symndx != STN_UNDEF) 819 { 820 Elf_Internal_Sym sym; 821 if (!bed->s->swap_symbol_in (abfd, 822 (htab->elf.dynsym->contents 823 + r_symndx * bed->s->sizeof_sym), 824 0, &sym)) 825 abort (); 826 827 if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC) 828 return reloc_class_ifunc; 829 } 830 } 831 832 switch ((int) ELF64_R_TYPE (rela->r_info)) 833 { 834 case R_SPARC_IRELATIVE: 835 return reloc_class_ifunc; 836 case R_SPARC_RELATIVE: 837 return reloc_class_relative; 838 case R_SPARC_JMP_SLOT: 839 return reloc_class_plt; 840 case R_SPARC_COPY: 841 return reloc_class_copy; 842 default: 843 return reloc_class_normal; 844 } 845 } 846 847 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in 848 standard ELF, because R_SPARC_OLO10 has secondary addend in 849 ELF64_R_TYPE_DATA field. This structure is used to redirect the 850 relocation handling routines. */ 851 852 const struct elf_size_info elf64_sparc_size_info = 853 { 854 sizeof (Elf64_External_Ehdr), 855 sizeof (Elf64_External_Phdr), 856 sizeof (Elf64_External_Shdr), 857 sizeof (Elf64_External_Rel), 858 sizeof (Elf64_External_Rela), 859 sizeof (Elf64_External_Sym), 860 sizeof (Elf64_External_Dyn), 861 sizeof (Elf_External_Note), 862 4, /* hash-table entry size. */ 863 /* Internal relocations per external relocations. 864 For link purposes we use just 1 internal per 865 1 external, for assembly and slurp symbol table 866 we use 2. */ 867 1, 868 64, /* arch_size. */ 869 3, /* log_file_align. */ 870 ELFCLASS64, 871 EV_CURRENT, 872 bfd_elf64_write_out_phdrs, 873 bfd_elf64_write_shdrs_and_ehdr, 874 bfd_elf64_checksum_contents, 875 elf64_sparc_write_relocs, 876 bfd_elf64_swap_symbol_in, 877 bfd_elf64_swap_symbol_out, 878 elf64_sparc_slurp_reloc_table, 879 bfd_elf64_slurp_symbol_table, 880 bfd_elf64_swap_dyn_in, 881 bfd_elf64_swap_dyn_out, 882 bfd_elf64_swap_reloc_in, 883 bfd_elf64_swap_reloc_out, 884 bfd_elf64_swap_reloca_in, 885 bfd_elf64_swap_reloca_out 886 }; 887 888 #define TARGET_BIG_SYM sparc_elf64_vec 889 #define TARGET_BIG_NAME "elf64-sparc" 890 #define ELF_ARCH bfd_arch_sparc 891 #define ELF_MAXPAGESIZE 0x100000 892 #define ELF_COMMONPAGESIZE 0x2000 893 894 /* This is the official ABI value. */ 895 #define ELF_MACHINE_CODE EM_SPARCV9 896 897 /* This is the value that we used before the ABI was released. */ 898 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9 899 900 #define elf_backend_reloc_type_class \ 901 elf64_sparc_reloc_type_class 902 #define bfd_elf64_get_reloc_upper_bound \ 903 elf64_sparc_get_reloc_upper_bound 904 #define bfd_elf64_get_dynamic_reloc_upper_bound \ 905 elf64_sparc_get_dynamic_reloc_upper_bound 906 #define bfd_elf64_canonicalize_reloc \ 907 elf64_sparc_canonicalize_reloc 908 #define bfd_elf64_canonicalize_dynamic_reloc \ 909 elf64_sparc_canonicalize_dynamic_reloc 910 #define bfd_elf64_set_reloc \ 911 elf64_sparc_set_reloc 912 #define elf_backend_add_symbol_hook \ 913 elf64_sparc_add_symbol_hook 914 #define elf_backend_get_symbol_type \ 915 elf64_sparc_get_symbol_type 916 #define elf_backend_symbol_processing \ 917 elf64_sparc_symbol_processing 918 #define elf_backend_print_symbol_all \ 919 elf64_sparc_print_symbol_all 920 #define elf_backend_output_arch_syms \ 921 elf64_sparc_output_arch_syms 922 #define bfd_elf64_bfd_merge_private_bfd_data \ 923 elf64_sparc_merge_private_bfd_data 924 #define elf_backend_fake_sections \ 925 elf64_sparc_fake_sections 926 #define elf_backend_size_info \ 927 elf64_sparc_size_info 928 929 #define elf_backend_plt_sym_val \ 930 _bfd_sparc_elf_plt_sym_val 931 #define bfd_elf64_bfd_link_hash_table_create \ 932 _bfd_sparc_elf_link_hash_table_create 933 #define elf_info_to_howto \ 934 _bfd_sparc_elf_info_to_howto 935 #define elf_backend_copy_indirect_symbol \ 936 _bfd_sparc_elf_copy_indirect_symbol 937 #define bfd_elf64_bfd_reloc_type_lookup \ 938 _bfd_sparc_elf_reloc_type_lookup 939 #define bfd_elf64_bfd_reloc_name_lookup \ 940 _bfd_sparc_elf_reloc_name_lookup 941 #define bfd_elf64_bfd_relax_section \ 942 _bfd_sparc_elf_relax_section 943 #define bfd_elf64_new_section_hook \ 944 _bfd_sparc_elf_new_section_hook 945 946 #define elf_backend_create_dynamic_sections \ 947 _bfd_sparc_elf_create_dynamic_sections 948 #define elf_backend_relocs_compatible \ 949 _bfd_elf_relocs_compatible 950 #define elf_backend_check_relocs \ 951 _bfd_sparc_elf_check_relocs 952 #define elf_backend_adjust_dynamic_symbol \ 953 _bfd_sparc_elf_adjust_dynamic_symbol 954 #define elf_backend_omit_section_dynsym \ 955 _bfd_sparc_elf_omit_section_dynsym 956 #define elf_backend_size_dynamic_sections \ 957 _bfd_sparc_elf_size_dynamic_sections 958 #define elf_backend_relocate_section \ 959 _bfd_sparc_elf_relocate_section 960 #define elf_backend_finish_dynamic_symbol \ 961 _bfd_sparc_elf_finish_dynamic_symbol 962 #define elf_backend_finish_dynamic_sections \ 963 _bfd_sparc_elf_finish_dynamic_sections 964 #define elf_backend_fixup_symbol \ 965 _bfd_sparc_elf_fixup_symbol 966 967 #define bfd_elf64_mkobject \ 968 _bfd_sparc_elf_mkobject 969 #define elf_backend_object_p \ 970 _bfd_sparc_elf_object_p 971 #define elf_backend_gc_mark_hook \ 972 _bfd_sparc_elf_gc_mark_hook 973 #define elf_backend_init_index_section \ 974 _bfd_elf_init_1_index_section 975 976 #define elf_backend_can_gc_sections 1 977 #define elf_backend_can_refcount 1 978 #define elf_backend_want_got_plt 0 979 #define elf_backend_plt_readonly 0 980 #define elf_backend_want_plt_sym 1 981 #define elf_backend_got_header_size 8 982 #define elf_backend_want_dynrelro 1 983 #define elf_backend_rela_normal 1 984 985 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */ 986 #define elf_backend_plt_alignment 8 987 988 #include "elf64-target.h" 989 990 /* FreeBSD support */ 991 #undef TARGET_BIG_SYM 992 #define TARGET_BIG_SYM sparc_elf64_fbsd_vec 993 #undef TARGET_BIG_NAME 994 #define TARGET_BIG_NAME "elf64-sparc-freebsd" 995 #undef ELF_OSABI 996 #define ELF_OSABI ELFOSABI_FREEBSD 997 998 #undef elf64_bed 999 #define elf64_bed elf64_sparc_fbsd_bed 1000 1001 #include "elf64-target.h" 1002 1003 /* Solaris 2. */ 1004 1005 #undef TARGET_BIG_SYM 1006 #define TARGET_BIG_SYM sparc_elf64_sol2_vec 1007 #undef TARGET_BIG_NAME 1008 #define TARGET_BIG_NAME "elf64-sparc-sol2" 1009 1010 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE 1011 objects won't be recognized. */ 1012 #undef ELF_OSABI 1013 1014 #undef elf64_bed 1015 #define elf64_bed elf64_sparc_sol2_bed 1016 1017 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte 1018 boundary. */ 1019 #undef elf_backend_static_tls_alignment 1020 #define elf_backend_static_tls_alignment 16 1021 1022 #undef elf_backend_strtab_flags 1023 #define elf_backend_strtab_flags SHF_STRINGS 1024 1025 static bool 1026 elf64_sparc_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED, 1027 bfd *obfd ATTRIBUTE_UNUSED, 1028 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED, 1029 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED) 1030 { 1031 /* PR 19938: FIXME: Need to add code for setting the sh_info 1032 and sh_link fields of Solaris specific section types. */ 1033 return false; 1034 } 1035 1036 #undef elf_backend_copy_special_section_fields 1037 #define elf_backend_copy_special_section_fields elf64_sparc_copy_solaris_special_section_fields 1038 1039 #include "elf64-target.h" 1040 1041 #undef elf_backend_strtab_flags 1042 #undef elf_backend_copy_special_section_fields 1043