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