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