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