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