1 /* SPARC-specific support for 64-bit ELF
2 Copyright (C) 1993-2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
25 #include "elf/sparc.h"
26 #include "opcode/sparc.h"
27 #include "elfxx-sparc.h"
29 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
30 #define MINUS_ONE (~ (bfd_vma) 0)
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
37 elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
39 return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
43 elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd)
45 return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
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. */
54 elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
55 Elf_Internal_Shdr *rel_hdr,
56 asymbol **symbols, bfd_boolean dynamic)
58 void * allocated = NULL;
59 bfd_byte *native_relocs;
66 allocated = bfd_malloc (rel_hdr->sh_size);
67 if (allocated == NULL)
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)
74 native_relocs = (bfd_byte *) allocated;
76 relents = asect->relocation + canon_reloc_count (asect);
78 entsize = rel_hdr->sh_entsize;
79 BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
81 count = rel_hdr->sh_size / entsize;
83 for (i = 0, relent = relents; i < count;
84 i++, relent++, native_relocs += entsize)
86 Elf_Internal_Rela rela;
89 bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela);
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;
98 relent->address = rela.r_offset - asect->vma;
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))
104 && ELF64_R_SYM(rela.r_info) > bfd_get_dynamic_symcount(abfd)))
105 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
110 ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
113 /* Canonicalize ELF section symbols. FIXME: Why? */
114 if ((s->flags & BSF_SECTION_SYM) == 0)
115 relent->sym_ptr_ptr = ps;
117 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
120 relent->addend = rela.r_addend;
122 r_type = ELF64_R_TYPE_ID (rela.r_info);
123 if (r_type == R_SPARC_OLO10)
125 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_LO10);
126 relent[1].address = relent->address;
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);
133 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
136 canon_reloc_count (asect) += relent - relents;
138 if (allocated != NULL)
144 if (allocated != NULL)
149 /* Read in and swap the external relocs. */
152 elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
153 asymbol **symbols, bfd_boolean dynamic)
155 struct bfd_elf_section_data * const d = elf_section_data (asect);
156 Elf_Internal_Shdr *rel_hdr;
157 Elf_Internal_Shdr *rel_hdr2;
160 if (asect->relocation != NULL)
165 if ((asect->flags & SEC_RELOC) == 0
166 || asect->reloc_count == 0)
169 rel_hdr = d->rel.hdr;
170 rel_hdr2 = d->rela.hdr;
172 BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)
173 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
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)
184 rel_hdr = &d->this_hdr;
185 asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
189 amt = asect->reloc_count;
190 amt *= 2 * sizeof (arelent);
191 asect->relocation = (arelent *) bfd_alloc (abfd, amt);
192 if (asect->relocation == NULL)
195 /* The elf64_sparc_slurp_one_reloc_table routine increments
196 canon_reloc_count. */
197 canon_reloc_count (asect) = 0;
200 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
205 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
212 /* Canonicalize the relocs. */
215 elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section,
216 arelent **relptr, asymbol **symbols)
220 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
222 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
225 tblptr = section->relocation;
226 for (i = 0; i < canon_reloc_count (section); i++)
227 *relptr++ = tblptr++;
231 return canon_reloc_count (section);
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
245 elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage,
251 if (elf_dynsymtab (abfd) == 0)
253 bfd_set_error (bfd_error_invalid_operation);
258 for (s = abfd->sections; s != NULL; s = s->next)
260 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
261 && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
266 if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, TRUE))
268 count = canon_reloc_count (s);
270 for (i = 0; i < count; i++)
281 /* Write out the relocs. */
284 elf64_sparc_write_relocs (bfd *abfd, asection *sec, void * data)
286 bfd_boolean *failedp = (bfd_boolean *) data;
287 Elf_Internal_Shdr *rela_hdr;
289 Elf64_External_Rela *outbound_relocas, *src_rela;
290 unsigned int idx, count;
291 asymbol *last_sym = 0;
292 int last_sym_idx = 0;
294 /* If we have already failed, don't do anything. */
298 if ((sec->flags & SEC_RELOC) == 0)
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
305 if (sec->reloc_count == 0)
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. */
312 for (idx = 0; idx < sec->reloc_count; idx++)
318 addr = sec->orelocation[idx]->address;
319 if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
320 && idx < sec->reloc_count - 1)
322 arelent *r = sec->orelocation[idx + 1];
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)
332 rela_hdr = elf_section_data (sec)->rela.hdr;
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)
342 /* Figure out whether the relocations are RELA or REL relocations. */
343 if (rela_hdr->sh_type != SHT_RELA)
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. */
350 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
351 addr_offset = sec->vma;
353 /* orelocation has the data, reloc_count has the count... */
354 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
355 src_rela = outbound_relocas;
357 for (idx = 0; idx < sec->reloc_count; idx++)
359 Elf_Internal_Rela dst_rela;
364 ptr = sec->orelocation[idx];
365 sym = *ptr->sym_ptr_ptr;
368 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
373 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
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))
390 if (ptr->howto->type == R_SPARC_LO10
391 && idx < sec->reloc_count - 1)
393 arelent *r = sec->orelocation[idx + 1];
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)
402 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
406 dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
409 dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
411 dst_rela.r_offset = ptr->address + addr_offset;
412 dst_rela.r_addend = ptr->addend;
414 bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela);
419 /* Hook called by the linker routine which adds symbols from an object
420 file. We use it for STT_REGISTER symbols. */
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)
429 static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
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;
436 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
439 struct _bfd_sparc_elf_app_reg *p;
441 reg = (int)sym->st_value;
444 case 2: reg -= 2; break;
445 case 6: reg -= 4; break;
448 (_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
453 if (info->output_bfd->xvec != abfd->xvec
454 || (abfd->flags & DYNAMIC) != 0)
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. */
463 p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
465 if (p->name != NULL && strcmp (p->name, *namep))
468 /* xgettext:c-format */
469 (_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
470 abfd, p->abfd, (int) sym->st_value,
471 **namep ? *namep : "#scratch",
472 *p->name ? p->name : "#scratch");
480 struct elf_link_hash_entry *h;
482 h = (struct elf_link_hash_entry *)
483 bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
487 unsigned char type = h->type;
492 /* xgettext:c-format */
493 (_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
494 abfd, p->abfd, *namep, stt_types[type]);
498 p->name = bfd_hash_allocate (&info->hash->table,
499 strlen (*namep) + 1);
503 strcpy (p->name, *namep);
507 p->bind = ELF_ST_BIND (sym->st_info);
509 p->shndx = sym->st_shndx;
513 if (p->bind == STB_WEAK
514 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
516 p->bind = STB_GLOBAL;
523 else if (*namep && **namep
524 && info->output_bfd->xvec == abfd->xvec)
527 struct _bfd_sparc_elf_app_reg *p;
529 p = _bfd_sparc_elf_hash_table(info)->app_regs;
530 for (i = 0; i < 4; i++, p++)
531 if (p->name != NULL && ! strcmp (p->name, *namep))
533 unsigned char type = ELF_ST_TYPE (sym->st_info);
538 /* xgettext:c-format */
539 (_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
540 abfd, p->abfd, *namep, stt_types[type]);
547 /* This function takes care of emitting STT_REGISTER symbols
548 which we cannot easily keep in the symbol hash table. */
551 elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
552 struct bfd_link_info *info,
554 int (*func) (void *, const char *,
557 struct elf_link_hash_entry *))
560 struct _bfd_sparc_elf_app_reg *app_regs =
561 _bfd_sparc_elf_hash_table(info)->app_regs;
562 Elf_Internal_Sym sym;
564 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
565 at the end of the dynlocal list, so they came at the end of the local
566 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
567 to back up symtab->sh_info. */
568 if (elf_hash_table (info)->dynlocal)
570 bfd * dynobj = elf_hash_table (info)->dynobj;
571 asection *dynsymsec = bfd_get_linker_section (dynobj, ".dynsym");
572 struct elf_link_local_dynamic_entry *e;
574 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
575 if (e->input_indx == -1)
579 elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
584 if (info->strip == strip_all)
587 for (reg = 0; reg < 4; reg++)
588 if (app_regs [reg].name != NULL)
590 if (info->strip == strip_some
591 && bfd_hash_lookup (info->keep_hash,
593 FALSE, FALSE) == NULL)
596 sym.st_value = reg < 2 ? reg + 2 : reg + 4;
599 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
600 sym.st_shndx = app_regs [reg].shndx;
601 sym.st_target_internal = 0;
602 if ((*func) (flaginfo, app_regs [reg].name, &sym,
603 sym.st_shndx == SHN_ABS
604 ? bfd_abs_section_ptr : bfd_und_section_ptr,
613 elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
615 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
621 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
622 even in SHN_UNDEF section. */
625 elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
627 elf_symbol_type *elfsym;
629 elfsym = (elf_symbol_type *) asym;
630 if (elfsym->internal_elf_sym.st_info
631 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
633 asym->flags |= BSF_GLOBAL;
638 /* Functions for dealing with the e_flags field. */
640 /* Merge backend specific data from an object file to the output
641 object file when linking. */
644 elf64_sparc_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
646 bfd *obfd = info->output_bfd;
648 flagword new_flags, old_flags;
651 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
652 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
655 new_flags = elf_elfheader (ibfd)->e_flags;
656 old_flags = elf_elfheader (obfd)->e_flags;
658 if (!elf_flags_init (obfd)) /* First call, no flags set */
660 elf_flags_init (obfd) = TRUE;
661 elf_elfheader (obfd)->e_flags = new_flags;
664 else if (new_flags == old_flags) /* Compatible flags are ok */
667 else /* Incompatible flags */
671 #define EF_SPARC_ISA_EXTENSIONS \
672 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
674 if ((ibfd->flags & DYNAMIC) != 0)
676 /* We don't want dynamic objects memory ordering and
677 architecture to have any role. That's what dynamic linker
679 new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
680 new_flags |= (old_flags
681 & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
685 /* Choose the highest architecture requirements. */
686 old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
687 new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
688 if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
689 && (old_flags & EF_SPARC_HAL_R1))
693 (_("%B: linking UltraSPARC specific with HAL specific code"),
696 /* Choose the most restrictive memory ordering. */
697 old_mm = (old_flags & EF_SPARCV9_MM);
698 new_mm = (new_flags & EF_SPARCV9_MM);
699 old_flags &= ~EF_SPARCV9_MM;
700 new_flags &= ~EF_SPARCV9_MM;
707 /* Warn about any other mismatches */
708 if (new_flags != old_flags)
712 /* xgettext:c-format */
713 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
714 ibfd, (long) new_flags, (long) old_flags);
717 elf_elfheader (obfd)->e_flags = old_flags;
721 bfd_set_error (bfd_error_bad_value);
725 return _bfd_sparc_elf_merge_private_bfd_data (ibfd, info);
728 /* MARCO: Set the correct entry size for the .stab section. */
731 elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
732 Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
737 name = bfd_get_section_name (abfd, sec);
739 if (strcmp (name, ".stab") == 0)
741 /* Even in the 64bit case the stab entries are only 12 bytes long. */
742 elf_section_data (sec)->this_hdr.sh_entsize = 12;
748 /* Print a STT_REGISTER symbol to file FILE. */
751 elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, void * filep,
754 FILE *file = (FILE *) filep;
757 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
761 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
762 type = symbol->flags;
763 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
765 ? (type & BSF_GLOBAL) ? '!' : 'l'
766 : (type & BSF_GLOBAL) ? 'g' : ' '),
767 (type & BSF_WEAK) ? 'w' : ' ');
768 if (symbol->name == NULL || symbol->name [0] == '\0')
774 static enum elf_reloc_type_class
775 elf64_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
776 const asection *rel_sec ATTRIBUTE_UNUSED,
777 const Elf_Internal_Rela *rela)
779 switch ((int) ELF64_R_TYPE (rela->r_info))
781 case R_SPARC_RELATIVE:
782 return reloc_class_relative;
783 case R_SPARC_JMP_SLOT:
784 return reloc_class_plt;
786 return reloc_class_copy;
788 return reloc_class_normal;
792 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
793 standard ELF, because R_SPARC_OLO10 has secondary addend in
794 ELF64_R_TYPE_DATA field. This structure is used to redirect the
795 relocation handling routines. */
797 const struct elf_size_info elf64_sparc_size_info =
799 sizeof (Elf64_External_Ehdr),
800 sizeof (Elf64_External_Phdr),
801 sizeof (Elf64_External_Shdr),
802 sizeof (Elf64_External_Rel),
803 sizeof (Elf64_External_Rela),
804 sizeof (Elf64_External_Sym),
805 sizeof (Elf64_External_Dyn),
806 sizeof (Elf_External_Note),
807 4, /* hash-table entry size. */
808 /* Internal relocations per external relocations.
809 For link purposes we use just 1 internal per
810 1 external, for assembly and slurp symbol table
814 3, /* log_file_align. */
817 bfd_elf64_write_out_phdrs,
818 bfd_elf64_write_shdrs_and_ehdr,
819 bfd_elf64_checksum_contents,
820 elf64_sparc_write_relocs,
821 bfd_elf64_swap_symbol_in,
822 bfd_elf64_swap_symbol_out,
823 elf64_sparc_slurp_reloc_table,
824 bfd_elf64_slurp_symbol_table,
825 bfd_elf64_swap_dyn_in,
826 bfd_elf64_swap_dyn_out,
827 bfd_elf64_swap_reloc_in,
828 bfd_elf64_swap_reloc_out,
829 bfd_elf64_swap_reloca_in,
830 bfd_elf64_swap_reloca_out
833 #define TARGET_BIG_SYM sparc_elf64_vec
834 #define TARGET_BIG_NAME "elf64-sparc"
835 #define ELF_ARCH bfd_arch_sparc
836 #define ELF_MAXPAGESIZE 0x100000
837 #define ELF_COMMONPAGESIZE 0x2000
839 /* This is the official ABI value. */
840 #define ELF_MACHINE_CODE EM_SPARCV9
842 /* This is the value that we used before the ABI was released. */
843 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
845 #define elf_backend_reloc_type_class \
846 elf64_sparc_reloc_type_class
847 #define bfd_elf64_get_reloc_upper_bound \
848 elf64_sparc_get_reloc_upper_bound
849 #define bfd_elf64_get_dynamic_reloc_upper_bound \
850 elf64_sparc_get_dynamic_reloc_upper_bound
851 #define bfd_elf64_canonicalize_reloc \
852 elf64_sparc_canonicalize_reloc
853 #define bfd_elf64_canonicalize_dynamic_reloc \
854 elf64_sparc_canonicalize_dynamic_reloc
855 #define elf_backend_add_symbol_hook \
856 elf64_sparc_add_symbol_hook
857 #define elf_backend_get_symbol_type \
858 elf64_sparc_get_symbol_type
859 #define elf_backend_symbol_processing \
860 elf64_sparc_symbol_processing
861 #define elf_backend_print_symbol_all \
862 elf64_sparc_print_symbol_all
863 #define elf_backend_output_arch_syms \
864 elf64_sparc_output_arch_syms
865 #define bfd_elf64_bfd_merge_private_bfd_data \
866 elf64_sparc_merge_private_bfd_data
867 #define elf_backend_fake_sections \
868 elf64_sparc_fake_sections
869 #define elf_backend_size_info \
870 elf64_sparc_size_info
872 #define elf_backend_plt_sym_val \
873 _bfd_sparc_elf_plt_sym_val
874 #define bfd_elf64_bfd_link_hash_table_create \
875 _bfd_sparc_elf_link_hash_table_create
876 #define elf_info_to_howto \
877 _bfd_sparc_elf_info_to_howto
878 #define elf_backend_copy_indirect_symbol \
879 _bfd_sparc_elf_copy_indirect_symbol
880 #define bfd_elf64_bfd_reloc_type_lookup \
881 _bfd_sparc_elf_reloc_type_lookup
882 #define bfd_elf64_bfd_reloc_name_lookup \
883 _bfd_sparc_elf_reloc_name_lookup
884 #define bfd_elf64_bfd_relax_section \
885 _bfd_sparc_elf_relax_section
886 #define bfd_elf64_new_section_hook \
887 _bfd_sparc_elf_new_section_hook
889 #define elf_backend_create_dynamic_sections \
890 _bfd_sparc_elf_create_dynamic_sections
891 #define elf_backend_relocs_compatible \
892 _bfd_elf_relocs_compatible
893 #define elf_backend_check_relocs \
894 _bfd_sparc_elf_check_relocs
895 #define elf_backend_adjust_dynamic_symbol \
896 _bfd_sparc_elf_adjust_dynamic_symbol
897 #define elf_backend_omit_section_dynsym \
898 _bfd_sparc_elf_omit_section_dynsym
899 #define elf_backend_size_dynamic_sections \
900 _bfd_sparc_elf_size_dynamic_sections
901 #define elf_backend_relocate_section \
902 _bfd_sparc_elf_relocate_section
903 #define elf_backend_finish_dynamic_symbol \
904 _bfd_sparc_elf_finish_dynamic_symbol
905 #define elf_backend_finish_dynamic_sections \
906 _bfd_sparc_elf_finish_dynamic_sections
908 #define bfd_elf64_mkobject \
909 _bfd_sparc_elf_mkobject
910 #define elf_backend_object_p \
911 _bfd_sparc_elf_object_p
912 #define elf_backend_gc_mark_hook \
913 _bfd_sparc_elf_gc_mark_hook
914 #define elf_backend_gc_sweep_hook \
915 _bfd_sparc_elf_gc_sweep_hook
916 #define elf_backend_init_index_section \
917 _bfd_elf_init_1_index_section
919 #define elf_backend_can_gc_sections 1
920 #define elf_backend_can_refcount 1
921 #define elf_backend_want_got_plt 0
922 #define elf_backend_plt_readonly 0
923 #define elf_backend_want_plt_sym 1
924 #define elf_backend_got_header_size 8
925 #define elf_backend_want_dynrelro 1
926 #define elf_backend_rela_normal 1
928 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
929 #define elf_backend_plt_alignment 8
931 #include "elf64-target.h"
933 /* FreeBSD support */
934 #undef TARGET_BIG_SYM
935 #define TARGET_BIG_SYM sparc_elf64_fbsd_vec
936 #undef TARGET_BIG_NAME
937 #define TARGET_BIG_NAME "elf64-sparc-freebsd"
939 #define ELF_OSABI ELFOSABI_FREEBSD
942 #define elf64_bed elf64_sparc_fbsd_bed
944 #include "elf64-target.h"
948 #undef TARGET_BIG_SYM
949 #define TARGET_BIG_SYM sparc_elf64_sol2_vec
950 #undef TARGET_BIG_NAME
951 #define TARGET_BIG_NAME "elf64-sparc-sol2"
953 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
954 objects won't be recognized. */
958 #define elf64_bed elf64_sparc_sol2_bed
960 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
962 #undef elf_backend_static_tls_alignment
963 #define elf_backend_static_tls_alignment 16
965 #include "elf64-target.h"