1 /* SPARC-specific support for 64-bit ELF
2 Copyright (C) 1993-2018 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 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
102 else if (/* PR 17512: file: 996185f8. */
103 (!dynamic && ELF64_R_SYM(rela.r_info) > bfd_get_symcount(abfd))
105 && ELF64_R_SYM(rela.r_info) > bfd_get_dynamic_symcount(abfd)))
108 /* xgettext:c-format */
109 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
110 abfd, asect, i, (long) ELF64_R_SYM (rela.r_info));
111 bfd_set_error (bfd_error_bad_value);
112 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
118 ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
121 /* Canonicalize ELF section symbols. FIXME: Why? */
122 if ((s->flags & BSF_SECTION_SYM) == 0)
123 relent->sym_ptr_ptr = ps;
125 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
128 relent->addend = rela.r_addend;
130 r_type = ELF64_R_TYPE_ID (rela.r_info);
131 if (r_type == R_SPARC_OLO10)
133 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, R_SPARC_LO10);
134 relent[1].address = relent->address;
136 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
137 relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
138 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, R_SPARC_13);
142 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, r_type);
143 if (relent->howto == NULL)
148 canon_reloc_count (asect) += relent - relents;
150 if (allocated != NULL)
156 if (allocated != NULL)
161 /* Read in and swap the external relocs. */
164 elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
165 asymbol **symbols, bfd_boolean dynamic)
167 struct bfd_elf_section_data * const d = elf_section_data (asect);
168 Elf_Internal_Shdr *rel_hdr;
169 Elf_Internal_Shdr *rel_hdr2;
172 if (asect->relocation != NULL)
177 if ((asect->flags & SEC_RELOC) == 0
178 || asect->reloc_count == 0)
181 rel_hdr = d->rel.hdr;
182 rel_hdr2 = d->rela.hdr;
184 BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)
185 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
189 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
190 case because relocations against this section may use the
191 dynamic symbol table, and in that case bfd_section_from_shdr
192 in elf.c does not update the RELOC_COUNT. */
193 if (asect->size == 0)
196 rel_hdr = &d->this_hdr;
197 asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
201 amt = asect->reloc_count;
202 amt *= 2 * sizeof (arelent);
203 asect->relocation = (arelent *) bfd_alloc (abfd, amt);
204 if (asect->relocation == NULL)
207 /* The elf64_sparc_slurp_one_reloc_table routine increments
208 canon_reloc_count. */
209 canon_reloc_count (asect) = 0;
212 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
217 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
224 /* Canonicalize the relocs. */
227 elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section,
228 arelent **relptr, asymbol **symbols)
232 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
234 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
237 tblptr = section->relocation;
238 for (i = 0; i < canon_reloc_count (section); i++)
239 *relptr++ = tblptr++;
243 return canon_reloc_count (section);
247 /* Canonicalize the dynamic relocation entries. Note that we return
248 the dynamic relocations as a single block, although they are
249 actually associated with particular sections; the interface, which
250 was designed for SunOS style shared libraries, expects that there
251 is only one set of dynamic relocs. Any section that was actually
252 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
253 the dynamic symbol table, is considered to be a dynamic reloc
257 elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage,
263 if (elf_dynsymtab (abfd) == 0)
265 bfd_set_error (bfd_error_invalid_operation);
270 for (s = abfd->sections; s != NULL; s = s->next)
272 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
273 && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
278 if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, TRUE))
280 count = canon_reloc_count (s);
282 for (i = 0; i < count; i++)
293 /* Install a new set of internal relocs. */
296 elf64_sparc_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
301 asect->orelocation = location;
302 canon_reloc_count (asect) = count;
305 /* Write out the relocs. */
308 elf64_sparc_write_relocs (bfd *abfd, asection *sec, void * data)
310 bfd_boolean *failedp = (bfd_boolean *) data;
311 Elf_Internal_Shdr *rela_hdr;
313 Elf64_External_Rela *outbound_relocas, *src_rela;
314 unsigned int idx, count;
315 asymbol *last_sym = 0;
316 int last_sym_idx = 0;
318 /* If we have already failed, don't do anything. */
322 if ((sec->flags & SEC_RELOC) == 0)
325 /* The linker backend writes the relocs out itself, and sets the
326 reloc_count field to zero to inhibit writing them here. Also,
327 sometimes the SEC_RELOC flag gets set even when there aren't any
329 if (canon_reloc_count (sec) == 0)
332 /* We can combine two relocs that refer to the same address
333 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
334 latter is R_SPARC_13 with no associated symbol. */
336 for (idx = 0; idx < canon_reloc_count (sec); idx++)
342 addr = sec->orelocation[idx]->address;
343 if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
344 && idx < canon_reloc_count (sec) - 1)
346 arelent *r = sec->orelocation[idx + 1];
348 if (r->howto->type == R_SPARC_13
349 && r->address == addr
350 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
351 && (*r->sym_ptr_ptr)->value == 0)
356 rela_hdr = elf_section_data (sec)->rela.hdr;
358 rela_hdr->sh_size = rela_hdr->sh_entsize * count;
359 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
360 if (rela_hdr->contents == NULL)
366 /* Figure out whether the relocations are RELA or REL relocations. */
367 if (rela_hdr->sh_type != SHT_RELA)
370 /* The address of an ELF reloc is section relative for an object
371 file, and absolute for an executable file or shared library.
372 The address of a BFD reloc is always section relative. */
374 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
375 addr_offset = sec->vma;
377 /* orelocation has the data, reloc_count has the count... */
378 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
379 src_rela = outbound_relocas;
381 for (idx = 0; idx < canon_reloc_count (sec); idx++)
383 Elf_Internal_Rela dst_rela;
388 ptr = sec->orelocation[idx];
389 sym = *ptr->sym_ptr_ptr;
392 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
397 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
406 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
407 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
408 && ! _bfd_elf_validate_reloc (abfd, ptr))
414 if (ptr->howto->type == R_SPARC_LO10
415 && idx < canon_reloc_count (sec) - 1)
417 arelent *r = sec->orelocation[idx + 1];
419 if (r->howto->type == R_SPARC_13
420 && r->address == ptr->address
421 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
422 && (*r->sym_ptr_ptr)->value == 0)
426 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
430 dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
433 dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
435 dst_rela.r_offset = ptr->address + addr_offset;
436 dst_rela.r_addend = ptr->addend;
438 bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela);
443 /* Hook called by the linker routine which adds symbols from an object
444 file. We use it for STT_REGISTER symbols. */
447 elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
448 Elf_Internal_Sym *sym, const char **namep,
449 flagword *flagsp ATTRIBUTE_UNUSED,
450 asection **secp ATTRIBUTE_UNUSED,
451 bfd_vma *valp ATTRIBUTE_UNUSED)
453 static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
455 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
458 struct _bfd_sparc_elf_app_reg *p;
460 reg = (int)sym->st_value;
463 case 2: reg -= 2; break;
464 case 6: reg -= 4; break;
467 (_("%pB: only registers %%g[2367] can be declared using STT_REGISTER"),
472 if (info->output_bfd->xvec != abfd->xvec
473 || (abfd->flags & DYNAMIC) != 0)
475 /* STT_REGISTER only works when linking an elf64_sparc object.
476 If STT_REGISTER comes from a dynamic object, don't put it into
477 the output bfd. The dynamic linker will recheck it. */
482 p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
484 if (p->name != NULL && strcmp (p->name, *namep))
487 /* xgettext:c-format */
488 (_("register %%g%d used incompatibly: %s in %pB,"
489 " previously %s in %pB"),
490 (int) sym->st_value, **namep ? *namep : "#scratch", abfd,
491 *p->name ? p->name : "#scratch", p->abfd);
499 struct elf_link_hash_entry *h;
501 h = (struct elf_link_hash_entry *)
502 bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
506 unsigned char type = h->type;
511 /* xgettext:c-format */
512 (_("symbol `%s' has differing types: REGISTER in %pB,"
513 " previously %s in %pB"),
514 *namep, abfd, stt_types[type], p->abfd);
518 p->name = bfd_hash_allocate (&info->hash->table,
519 strlen (*namep) + 1);
523 strcpy (p->name, *namep);
527 p->bind = ELF_ST_BIND (sym->st_info);
529 p->shndx = sym->st_shndx;
533 if (p->bind == STB_WEAK
534 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
536 p->bind = STB_GLOBAL;
543 else if (*namep && **namep
544 && info->output_bfd->xvec == abfd->xvec)
547 struct _bfd_sparc_elf_app_reg *p;
549 p = _bfd_sparc_elf_hash_table(info)->app_regs;
550 for (i = 0; i < 4; i++, p++)
551 if (p->name != NULL && ! strcmp (p->name, *namep))
553 unsigned char type = ELF_ST_TYPE (sym->st_info);
558 /* xgettext:c-format */
559 (_("Symbol `%s' has differing types: %s in %pB,"
560 " previously REGISTER in %pB"),
561 *namep, stt_types[type], abfd, p->abfd);
568 /* This function takes care of emitting STT_REGISTER symbols
569 which we cannot easily keep in the symbol hash table. */
572 elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
573 struct bfd_link_info *info,
575 int (*func) (void *, const char *,
578 struct elf_link_hash_entry *))
581 struct _bfd_sparc_elf_app_reg *app_regs =
582 _bfd_sparc_elf_hash_table(info)->app_regs;
583 Elf_Internal_Sym sym;
585 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
586 at the end of the dynlocal list, so they came at the end of the local
587 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
588 to back up symtab->sh_info. */
589 if (elf_hash_table (info)->dynlocal)
591 bfd * dynobj = elf_hash_table (info)->dynobj;
592 asection *dynsymsec = bfd_get_linker_section (dynobj, ".dynsym");
593 struct elf_link_local_dynamic_entry *e;
595 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
596 if (e->input_indx == -1)
600 elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
605 if (info->strip == strip_all)
608 for (reg = 0; reg < 4; reg++)
609 if (app_regs [reg].name != NULL)
611 if (info->strip == strip_some
612 && bfd_hash_lookup (info->keep_hash,
614 FALSE, FALSE) == NULL)
617 sym.st_value = reg < 2 ? reg + 2 : reg + 4;
620 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
621 sym.st_shndx = app_regs [reg].shndx;
622 sym.st_target_internal = 0;
623 if ((*func) (flaginfo, app_regs [reg].name, &sym,
624 sym.st_shndx == SHN_ABS
625 ? bfd_abs_section_ptr : bfd_und_section_ptr,
634 elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
636 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
642 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
643 even in SHN_UNDEF section. */
646 elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
648 elf_symbol_type *elfsym;
650 elfsym = (elf_symbol_type *) asym;
651 if (elfsym->internal_elf_sym.st_info
652 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
654 asym->flags |= BSF_GLOBAL;
659 /* Functions for dealing with the e_flags field. */
661 /* Merge backend specific data from an object file to the output
662 object file when linking. */
665 elf64_sparc_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
667 bfd *obfd = info->output_bfd;
669 flagword new_flags, old_flags;
672 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
673 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
676 new_flags = elf_elfheader (ibfd)->e_flags;
677 old_flags = elf_elfheader (obfd)->e_flags;
679 if (!elf_flags_init (obfd)) /* First call, no flags set */
681 elf_flags_init (obfd) = TRUE;
682 elf_elfheader (obfd)->e_flags = new_flags;
685 else if (new_flags == old_flags) /* Compatible flags are ok */
688 else /* Incompatible flags */
692 #define EF_SPARC_ISA_EXTENSIONS \
693 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
695 if ((ibfd->flags & DYNAMIC) != 0)
697 /* We don't want dynamic objects memory ordering and
698 architecture to have any role. That's what dynamic linker
700 new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
701 new_flags |= (old_flags
702 & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
706 /* Choose the highest architecture requirements. */
707 old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
708 new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
709 if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
710 && (old_flags & EF_SPARC_HAL_R1))
714 (_("%pB: linking UltraSPARC specific with HAL specific code"),
717 /* Choose the most restrictive memory ordering. */
718 old_mm = (old_flags & EF_SPARCV9_MM);
719 new_mm = (new_flags & EF_SPARCV9_MM);
720 old_flags &= ~EF_SPARCV9_MM;
721 new_flags &= ~EF_SPARCV9_MM;
728 /* Warn about any other mismatches */
729 if (new_flags != old_flags)
733 /* xgettext:c-format */
734 (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
735 ibfd, new_flags, old_flags);
738 elf_elfheader (obfd)->e_flags = old_flags;
742 bfd_set_error (bfd_error_bad_value);
746 return _bfd_sparc_elf_merge_private_bfd_data (ibfd, info);
749 /* MARCO: Set the correct entry size for the .stab section. */
752 elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
753 Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
758 name = bfd_get_section_name (abfd, sec);
760 if (strcmp (name, ".stab") == 0)
762 /* Even in the 64bit case the stab entries are only 12 bytes long. */
763 elf_section_data (sec)->this_hdr.sh_entsize = 12;
769 /* Print a STT_REGISTER symbol to file FILE. */
772 elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, void * filep,
775 FILE *file = (FILE *) filep;
778 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
782 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
783 type = symbol->flags;
784 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
786 ? (type & BSF_GLOBAL) ? '!' : 'l'
787 : (type & BSF_GLOBAL) ? 'g' : ' '),
788 (type & BSF_WEAK) ? 'w' : ' ');
789 if (symbol->name == NULL || symbol->name [0] == '\0')
795 static enum elf_reloc_type_class
796 elf64_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
797 const asection *rel_sec ATTRIBUTE_UNUSED,
798 const Elf_Internal_Rela *rela)
800 switch ((int) ELF64_R_TYPE (rela->r_info))
802 case R_SPARC_RELATIVE:
803 return reloc_class_relative;
804 case R_SPARC_JMP_SLOT:
805 return reloc_class_plt;
807 return reloc_class_copy;
809 return reloc_class_normal;
813 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
814 standard ELF, because R_SPARC_OLO10 has secondary addend in
815 ELF64_R_TYPE_DATA field. This structure is used to redirect the
816 relocation handling routines. */
818 const struct elf_size_info elf64_sparc_size_info =
820 sizeof (Elf64_External_Ehdr),
821 sizeof (Elf64_External_Phdr),
822 sizeof (Elf64_External_Shdr),
823 sizeof (Elf64_External_Rel),
824 sizeof (Elf64_External_Rela),
825 sizeof (Elf64_External_Sym),
826 sizeof (Elf64_External_Dyn),
827 sizeof (Elf_External_Note),
828 4, /* hash-table entry size. */
829 /* Internal relocations per external relocations.
830 For link purposes we use just 1 internal per
831 1 external, for assembly and slurp symbol table
835 3, /* log_file_align. */
838 bfd_elf64_write_out_phdrs,
839 bfd_elf64_write_shdrs_and_ehdr,
840 bfd_elf64_checksum_contents,
841 elf64_sparc_write_relocs,
842 bfd_elf64_swap_symbol_in,
843 bfd_elf64_swap_symbol_out,
844 elf64_sparc_slurp_reloc_table,
845 bfd_elf64_slurp_symbol_table,
846 bfd_elf64_swap_dyn_in,
847 bfd_elf64_swap_dyn_out,
848 bfd_elf64_swap_reloc_in,
849 bfd_elf64_swap_reloc_out,
850 bfd_elf64_swap_reloca_in,
851 bfd_elf64_swap_reloca_out
854 #define TARGET_BIG_SYM sparc_elf64_vec
855 #define TARGET_BIG_NAME "elf64-sparc"
856 #define ELF_ARCH bfd_arch_sparc
857 #define ELF_MAXPAGESIZE 0x100000
858 #define ELF_COMMONPAGESIZE 0x2000
860 /* This is the official ABI value. */
861 #define ELF_MACHINE_CODE EM_SPARCV9
863 /* This is the value that we used before the ABI was released. */
864 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
866 #define elf_backend_reloc_type_class \
867 elf64_sparc_reloc_type_class
868 #define bfd_elf64_get_reloc_upper_bound \
869 elf64_sparc_get_reloc_upper_bound
870 #define bfd_elf64_get_dynamic_reloc_upper_bound \
871 elf64_sparc_get_dynamic_reloc_upper_bound
872 #define bfd_elf64_canonicalize_reloc \
873 elf64_sparc_canonicalize_reloc
874 #define bfd_elf64_canonicalize_dynamic_reloc \
875 elf64_sparc_canonicalize_dynamic_reloc
876 #define bfd_elf64_set_reloc \
877 elf64_sparc_set_reloc
878 #define elf_backend_add_symbol_hook \
879 elf64_sparc_add_symbol_hook
880 #define elf_backend_get_symbol_type \
881 elf64_sparc_get_symbol_type
882 #define elf_backend_symbol_processing \
883 elf64_sparc_symbol_processing
884 #define elf_backend_print_symbol_all \
885 elf64_sparc_print_symbol_all
886 #define elf_backend_output_arch_syms \
887 elf64_sparc_output_arch_syms
888 #define bfd_elf64_bfd_merge_private_bfd_data \
889 elf64_sparc_merge_private_bfd_data
890 #define elf_backend_fake_sections \
891 elf64_sparc_fake_sections
892 #define elf_backend_size_info \
893 elf64_sparc_size_info
895 #define elf_backend_plt_sym_val \
896 _bfd_sparc_elf_plt_sym_val
897 #define bfd_elf64_bfd_link_hash_table_create \
898 _bfd_sparc_elf_link_hash_table_create
899 #define elf_info_to_howto \
900 _bfd_sparc_elf_info_to_howto
901 #define elf_backend_copy_indirect_symbol \
902 _bfd_sparc_elf_copy_indirect_symbol
903 #define bfd_elf64_bfd_reloc_type_lookup \
904 _bfd_sparc_elf_reloc_type_lookup
905 #define bfd_elf64_bfd_reloc_name_lookup \
906 _bfd_sparc_elf_reloc_name_lookup
907 #define bfd_elf64_bfd_relax_section \
908 _bfd_sparc_elf_relax_section
909 #define bfd_elf64_new_section_hook \
910 _bfd_sparc_elf_new_section_hook
912 #define elf_backend_create_dynamic_sections \
913 _bfd_sparc_elf_create_dynamic_sections
914 #define elf_backend_relocs_compatible \
915 _bfd_elf_relocs_compatible
916 #define elf_backend_check_relocs \
917 _bfd_sparc_elf_check_relocs
918 #define elf_backend_adjust_dynamic_symbol \
919 _bfd_sparc_elf_adjust_dynamic_symbol
920 #define elf_backend_omit_section_dynsym \
921 _bfd_sparc_elf_omit_section_dynsym
922 #define elf_backend_size_dynamic_sections \
923 _bfd_sparc_elf_size_dynamic_sections
924 #define elf_backend_relocate_section \
925 _bfd_sparc_elf_relocate_section
926 #define elf_backend_finish_dynamic_symbol \
927 _bfd_sparc_elf_finish_dynamic_symbol
928 #define elf_backend_finish_dynamic_sections \
929 _bfd_sparc_elf_finish_dynamic_sections
930 #define elf_backend_fixup_symbol \
931 _bfd_sparc_elf_fixup_symbol
933 #define bfd_elf64_mkobject \
934 _bfd_sparc_elf_mkobject
935 #define elf_backend_object_p \
936 _bfd_sparc_elf_object_p
937 #define elf_backend_gc_mark_hook \
938 _bfd_sparc_elf_gc_mark_hook
939 #define elf_backend_init_index_section \
940 _bfd_elf_init_1_index_section
942 #define elf_backend_can_gc_sections 1
943 #define elf_backend_can_refcount 1
944 #define elf_backend_want_got_plt 0
945 #define elf_backend_plt_readonly 0
946 #define elf_backend_want_plt_sym 1
947 #define elf_backend_got_header_size 8
948 #define elf_backend_want_dynrelro 1
949 #define elf_backend_rela_normal 1
951 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
952 #define elf_backend_plt_alignment 8
954 #include "elf64-target.h"
956 /* FreeBSD support */
957 #undef TARGET_BIG_SYM
958 #define TARGET_BIG_SYM sparc_elf64_fbsd_vec
959 #undef TARGET_BIG_NAME
960 #define TARGET_BIG_NAME "elf64-sparc-freebsd"
962 #define ELF_OSABI ELFOSABI_FREEBSD
965 #define elf64_bed elf64_sparc_fbsd_bed
967 #include "elf64-target.h"
971 #undef TARGET_BIG_SYM
972 #define TARGET_BIG_SYM sparc_elf64_sol2_vec
973 #undef TARGET_BIG_NAME
974 #define TARGET_BIG_NAME "elf64-sparc-sol2"
976 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
977 objects won't be recognized. */
981 #define elf64_bed elf64_sparc_sol2_bed
983 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
985 #undef elf_backend_static_tls_alignment
986 #define elf_backend_static_tls_alignment 16
988 #include "elf64-target.h"