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