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