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 /* 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 (abfd
, 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 (abfd
, R_SPARC_13
);
134 relent
->howto
= _bfd_sparc_elf_info_to_howto_ptr (abfd
, r_type
);
135 if (relent
->howto
== NULL
)
140 canon_reloc_count (asect
) += relent
- relents
;
142 if (allocated
!= NULL
)
148 if (allocated
!= NULL
)
153 /* Read in and swap the external relocs. */
156 elf64_sparc_slurp_reloc_table (bfd
*abfd
, asection
*asect
,
157 asymbol
**symbols
, bfd_boolean dynamic
)
159 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
160 Elf_Internal_Shdr
*rel_hdr
;
161 Elf_Internal_Shdr
*rel_hdr2
;
164 if (asect
->relocation
!= NULL
)
169 if ((asect
->flags
& SEC_RELOC
) == 0
170 || asect
->reloc_count
== 0)
173 rel_hdr
= d
->rel
.hdr
;
174 rel_hdr2
= d
->rela
.hdr
;
176 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
177 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
181 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
182 case because relocations against this section may use the
183 dynamic symbol table, and in that case bfd_section_from_shdr
184 in elf.c does not update the RELOC_COUNT. */
185 if (asect
->size
== 0)
188 rel_hdr
= &d
->this_hdr
;
189 asect
->reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
193 amt
= asect
->reloc_count
;
194 amt
*= 2 * sizeof (arelent
);
195 asect
->relocation
= (arelent
*) bfd_alloc (abfd
, amt
);
196 if (asect
->relocation
== NULL
)
199 /* The elf64_sparc_slurp_one_reloc_table routine increments
200 canon_reloc_count. */
201 canon_reloc_count (asect
) = 0;
204 && !elf64_sparc_slurp_one_reloc_table (abfd
, asect
, rel_hdr
, symbols
,
209 && !elf64_sparc_slurp_one_reloc_table (abfd
, asect
, rel_hdr2
, symbols
,
216 /* Canonicalize the relocs. */
219 elf64_sparc_canonicalize_reloc (bfd
*abfd
, sec_ptr section
,
220 arelent
**relptr
, asymbol
**symbols
)
224 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
226 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
229 tblptr
= section
->relocation
;
230 for (i
= 0; i
< canon_reloc_count (section
); i
++)
231 *relptr
++ = tblptr
++;
235 return canon_reloc_count (section
);
239 /* Canonicalize the dynamic relocation entries. Note that we return
240 the dynamic relocations as a single block, although they are
241 actually associated with particular sections; the interface, which
242 was designed for SunOS style shared libraries, expects that there
243 is only one set of dynamic relocs. Any section that was actually
244 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
245 the dynamic symbol table, is considered to be a dynamic reloc
249 elf64_sparc_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**storage
,
255 if (elf_dynsymtab (abfd
) == 0)
257 bfd_set_error (bfd_error_invalid_operation
);
262 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
264 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
265 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
270 if (! elf64_sparc_slurp_reloc_table (abfd
, s
, syms
, TRUE
))
272 count
= canon_reloc_count (s
);
274 for (i
= 0; i
< count
; i
++)
285 /* Install a new set of internal relocs. */
288 elf64_sparc_set_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
293 asect
->orelocation
= location
;
294 canon_reloc_count (asect
) = count
;
297 /* Write out the relocs. */
300 elf64_sparc_write_relocs (bfd
*abfd
, asection
*sec
, void * data
)
302 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
303 Elf_Internal_Shdr
*rela_hdr
;
305 Elf64_External_Rela
*outbound_relocas
, *src_rela
;
306 unsigned int idx
, count
;
307 asymbol
*last_sym
= 0;
308 int last_sym_idx
= 0;
310 /* If we have already failed, don't do anything. */
314 if ((sec
->flags
& SEC_RELOC
) == 0)
317 /* The linker backend writes the relocs out itself, and sets the
318 reloc_count field to zero to inhibit writing them here. Also,
319 sometimes the SEC_RELOC flag gets set even when there aren't any
321 if (canon_reloc_count (sec
) == 0)
324 /* We can combine two relocs that refer to the same address
325 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
326 latter is R_SPARC_13 with no associated symbol. */
328 for (idx
= 0; idx
< canon_reloc_count (sec
); idx
++)
334 addr
= sec
->orelocation
[idx
]->address
;
335 if (sec
->orelocation
[idx
]->howto
->type
== R_SPARC_LO10
336 && idx
< canon_reloc_count (sec
) - 1)
338 arelent
*r
= sec
->orelocation
[idx
+ 1];
340 if (r
->howto
->type
== R_SPARC_13
341 && r
->address
== addr
342 && bfd_is_abs_section ((*r
->sym_ptr_ptr
)->section
)
343 && (*r
->sym_ptr_ptr
)->value
== 0)
348 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
350 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* count
;
351 rela_hdr
->contents
= bfd_alloc (abfd
, rela_hdr
->sh_size
);
352 if (rela_hdr
->contents
== NULL
)
358 /* Figure out whether the relocations are RELA or REL relocations. */
359 if (rela_hdr
->sh_type
!= SHT_RELA
)
362 /* The address of an ELF reloc is section relative for an object
363 file, and absolute for an executable file or shared library.
364 The address of a BFD reloc is always section relative. */
366 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
367 addr_offset
= sec
->vma
;
369 /* orelocation has the data, reloc_count has the count... */
370 outbound_relocas
= (Elf64_External_Rela
*) rela_hdr
->contents
;
371 src_rela
= outbound_relocas
;
373 for (idx
= 0; idx
< canon_reloc_count (sec
); idx
++)
375 Elf_Internal_Rela dst_rela
;
380 ptr
= sec
->orelocation
[idx
];
381 sym
= *ptr
->sym_ptr_ptr
;
384 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
389 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
398 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
399 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
400 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
406 if (ptr
->howto
->type
== R_SPARC_LO10
407 && idx
< canon_reloc_count (sec
) - 1)
409 arelent
*r
= sec
->orelocation
[idx
+ 1];
411 if (r
->howto
->type
== R_SPARC_13
412 && r
->address
== ptr
->address
413 && bfd_is_abs_section ((*r
->sym_ptr_ptr
)->section
)
414 && (*r
->sym_ptr_ptr
)->value
== 0)
418 = ELF64_R_INFO (n
, ELF64_R_TYPE_INFO (r
->addend
,
422 dst_rela
.r_info
= ELF64_R_INFO (n
, R_SPARC_LO10
);
425 dst_rela
.r_info
= ELF64_R_INFO (n
, ptr
->howto
->type
);
427 dst_rela
.r_offset
= ptr
->address
+ addr_offset
;
428 dst_rela
.r_addend
= ptr
->addend
;
430 bfd_elf64_swap_reloca_out (abfd
, &dst_rela
, (bfd_byte
*) src_rela
);
435 /* Hook called by the linker routine which adds symbols from an object
436 file. We use it for STT_REGISTER symbols. */
439 elf64_sparc_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
440 Elf_Internal_Sym
*sym
, const char **namep
,
441 flagword
*flagsp ATTRIBUTE_UNUSED
,
442 asection
**secp ATTRIBUTE_UNUSED
,
443 bfd_vma
*valp ATTRIBUTE_UNUSED
)
445 static const char *const stt_types
[] = { "NOTYPE", "OBJECT", "FUNCTION" };
447 if (ELF_ST_TYPE (sym
->st_info
) == STT_REGISTER
)
450 struct _bfd_sparc_elf_app_reg
*p
;
452 reg
= (int)sym
->st_value
;
455 case 2: reg
-= 2; break;
456 case 6: reg
-= 4; break;
459 (_("%pB: only registers %%g[2367] can be declared using STT_REGISTER"),
464 if (info
->output_bfd
->xvec
!= abfd
->xvec
465 || (abfd
->flags
& DYNAMIC
) != 0)
467 /* STT_REGISTER only works when linking an elf64_sparc object.
468 If STT_REGISTER comes from a dynamic object, don't put it into
469 the output bfd. The dynamic linker will recheck it. */
474 p
= _bfd_sparc_elf_hash_table(info
)->app_regs
+ reg
;
476 if (p
->name
!= NULL
&& strcmp (p
->name
, *namep
))
479 /* xgettext:c-format */
480 (_("register %%g%d used incompatibly: %s in %pB,"
481 " previously %s in %pB"),
482 (int) sym
->st_value
, **namep
? *namep
: "#scratch", abfd
,
483 *p
->name
? p
->name
: "#scratch", p
->abfd
);
491 struct elf_link_hash_entry
*h
;
493 h
= (struct elf_link_hash_entry
*)
494 bfd_link_hash_lookup (info
->hash
, *namep
, FALSE
, FALSE
, FALSE
);
498 unsigned char type
= h
->type
;
503 /* xgettext:c-format */
504 (_("symbol `%s' has differing types: REGISTER in %pB,"
505 " previously %s in %pB"),
506 *namep
, abfd
, stt_types
[type
], p
->abfd
);
510 p
->name
= bfd_hash_allocate (&info
->hash
->table
,
511 strlen (*namep
) + 1);
515 strcpy (p
->name
, *namep
);
519 p
->bind
= ELF_ST_BIND (sym
->st_info
);
521 p
->shndx
= sym
->st_shndx
;
525 if (p
->bind
== STB_WEAK
526 && ELF_ST_BIND (sym
->st_info
) == STB_GLOBAL
)
528 p
->bind
= STB_GLOBAL
;
535 else if (*namep
&& **namep
536 && info
->output_bfd
->xvec
== abfd
->xvec
)
539 struct _bfd_sparc_elf_app_reg
*p
;
541 p
= _bfd_sparc_elf_hash_table(info
)->app_regs
;
542 for (i
= 0; i
< 4; i
++, p
++)
543 if (p
->name
!= NULL
&& ! strcmp (p
->name
, *namep
))
545 unsigned char type
= ELF_ST_TYPE (sym
->st_info
);
550 /* xgettext:c-format */
551 (_("Symbol `%s' has differing types: %s in %pB,"
552 " previously REGISTER in %pB"),
553 *namep
, stt_types
[type
], abfd
, p
->abfd
);
560 /* This function takes care of emitting STT_REGISTER symbols
561 which we cannot easily keep in the symbol hash table. */
564 elf64_sparc_output_arch_syms (bfd
*output_bfd ATTRIBUTE_UNUSED
,
565 struct bfd_link_info
*info
,
567 int (*func
) (void *, const char *,
570 struct elf_link_hash_entry
*))
573 struct _bfd_sparc_elf_app_reg
*app_regs
=
574 _bfd_sparc_elf_hash_table(info
)->app_regs
;
575 Elf_Internal_Sym sym
;
577 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
578 at the end of the dynlocal list, so they came at the end of the local
579 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
580 to back up symtab->sh_info. */
581 if (elf_hash_table (info
)->dynlocal
)
583 bfd
* dynobj
= elf_hash_table (info
)->dynobj
;
584 asection
*dynsymsec
= bfd_get_linker_section (dynobj
, ".dynsym");
585 struct elf_link_local_dynamic_entry
*e
;
587 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
588 if (e
->input_indx
== -1)
592 elf_section_data (dynsymsec
->output_section
)->this_hdr
.sh_info
597 if (info
->strip
== strip_all
)
600 for (reg
= 0; reg
< 4; reg
++)
601 if (app_regs
[reg
].name
!= NULL
)
603 if (info
->strip
== strip_some
604 && bfd_hash_lookup (info
->keep_hash
,
606 FALSE
, FALSE
) == NULL
)
609 sym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
612 sym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
, STT_REGISTER
);
613 sym
.st_shndx
= app_regs
[reg
].shndx
;
614 sym
.st_target_internal
= 0;
615 if ((*func
) (flaginfo
, app_regs
[reg
].name
, &sym
,
616 sym
.st_shndx
== SHN_ABS
617 ? bfd_abs_section_ptr
: bfd_und_section_ptr
,
626 elf64_sparc_get_symbol_type (Elf_Internal_Sym
*elf_sym
, int type
)
628 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_REGISTER
)
634 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
635 even in SHN_UNDEF section. */
638 elf64_sparc_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
, asymbol
*asym
)
640 elf_symbol_type
*elfsym
;
642 elfsym
= (elf_symbol_type
*) asym
;
643 if (elfsym
->internal_elf_sym
.st_info
644 == ELF_ST_INFO (STB_GLOBAL
, STT_REGISTER
))
646 asym
->flags
|= BSF_GLOBAL
;
651 /* Functions for dealing with the e_flags field. */
653 /* Merge backend specific data from an object file to the output
654 object file when linking. */
657 elf64_sparc_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
659 bfd
*obfd
= info
->output_bfd
;
661 flagword new_flags
, old_flags
;
664 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
665 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
668 new_flags
= elf_elfheader (ibfd
)->e_flags
;
669 old_flags
= elf_elfheader (obfd
)->e_flags
;
671 if (!elf_flags_init (obfd
)) /* First call, no flags set */
673 elf_flags_init (obfd
) = TRUE
;
674 elf_elfheader (obfd
)->e_flags
= new_flags
;
677 else if (new_flags
== old_flags
) /* Compatible flags are ok */
680 else /* Incompatible flags */
684 #define EF_SPARC_ISA_EXTENSIONS \
685 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
687 if ((ibfd
->flags
& DYNAMIC
) != 0)
689 /* We don't want dynamic objects memory ordering and
690 architecture to have any role. That's what dynamic linker
692 new_flags
&= ~(EF_SPARCV9_MM
| EF_SPARC_ISA_EXTENSIONS
);
693 new_flags
|= (old_flags
694 & (EF_SPARCV9_MM
| EF_SPARC_ISA_EXTENSIONS
));
698 /* Choose the highest architecture requirements. */
699 old_flags
|= (new_flags
& EF_SPARC_ISA_EXTENSIONS
);
700 new_flags
|= (old_flags
& EF_SPARC_ISA_EXTENSIONS
);
701 if ((old_flags
& (EF_SPARC_SUN_US1
| EF_SPARC_SUN_US3
))
702 && (old_flags
& EF_SPARC_HAL_R1
))
706 (_("%pB: linking UltraSPARC specific with HAL specific code"),
709 /* Choose the most restrictive memory ordering. */
710 old_mm
= (old_flags
& EF_SPARCV9_MM
);
711 new_mm
= (new_flags
& EF_SPARCV9_MM
);
712 old_flags
&= ~EF_SPARCV9_MM
;
713 new_flags
&= ~EF_SPARCV9_MM
;
720 /* Warn about any other mismatches */
721 if (new_flags
!= old_flags
)
725 /* xgettext:c-format */
726 (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
727 ibfd
, new_flags
, old_flags
);
730 elf_elfheader (obfd
)->e_flags
= old_flags
;
734 bfd_set_error (bfd_error_bad_value
);
738 return _bfd_sparc_elf_merge_private_bfd_data (ibfd
, info
);
741 /* MARCO: Set the correct entry size for the .stab section. */
744 elf64_sparc_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
745 Elf_Internal_Shdr
*hdr ATTRIBUTE_UNUSED
,
750 name
= bfd_get_section_name (abfd
, sec
);
752 if (strcmp (name
, ".stab") == 0)
754 /* Even in the 64bit case the stab entries are only 12 bytes long. */
755 elf_section_data (sec
)->this_hdr
.sh_entsize
= 12;
761 /* Print a STT_REGISTER symbol to file FILE. */
764 elf64_sparc_print_symbol_all (bfd
*abfd ATTRIBUTE_UNUSED
, void * filep
,
767 FILE *file
= (FILE *) filep
;
770 if (ELF_ST_TYPE (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_info
)
774 reg
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
775 type
= symbol
->flags
;
776 fprintf (file
, "REG_%c%c%11s%c%c R", "GOLI" [reg
/ 8], '0' + (reg
& 7), "",
778 ? (type
& BSF_GLOBAL
) ? '!' : 'l'
779 : (type
& BSF_GLOBAL
) ? 'g' : ' '),
780 (type
& BSF_WEAK
) ? 'w' : ' ');
781 if (symbol
->name
== NULL
|| symbol
->name
[0] == '\0')
787 static enum elf_reloc_type_class
788 elf64_sparc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
789 const asection
*rel_sec ATTRIBUTE_UNUSED
,
790 const Elf_Internal_Rela
*rela
)
792 switch ((int) ELF64_R_TYPE (rela
->r_info
))
794 case R_SPARC_RELATIVE
:
795 return reloc_class_relative
;
796 case R_SPARC_JMP_SLOT
:
797 return reloc_class_plt
;
799 return reloc_class_copy
;
801 return reloc_class_normal
;
805 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
806 standard ELF, because R_SPARC_OLO10 has secondary addend in
807 ELF64_R_TYPE_DATA field. This structure is used to redirect the
808 relocation handling routines. */
810 const struct elf_size_info elf64_sparc_size_info
=
812 sizeof (Elf64_External_Ehdr
),
813 sizeof (Elf64_External_Phdr
),
814 sizeof (Elf64_External_Shdr
),
815 sizeof (Elf64_External_Rel
),
816 sizeof (Elf64_External_Rela
),
817 sizeof (Elf64_External_Sym
),
818 sizeof (Elf64_External_Dyn
),
819 sizeof (Elf_External_Note
),
820 4, /* hash-table entry size. */
821 /* Internal relocations per external relocations.
822 For link purposes we use just 1 internal per
823 1 external, for assembly and slurp symbol table
827 3, /* log_file_align. */
830 bfd_elf64_write_out_phdrs
,
831 bfd_elf64_write_shdrs_and_ehdr
,
832 bfd_elf64_checksum_contents
,
833 elf64_sparc_write_relocs
,
834 bfd_elf64_swap_symbol_in
,
835 bfd_elf64_swap_symbol_out
,
836 elf64_sparc_slurp_reloc_table
,
837 bfd_elf64_slurp_symbol_table
,
838 bfd_elf64_swap_dyn_in
,
839 bfd_elf64_swap_dyn_out
,
840 bfd_elf64_swap_reloc_in
,
841 bfd_elf64_swap_reloc_out
,
842 bfd_elf64_swap_reloca_in
,
843 bfd_elf64_swap_reloca_out
846 #define TARGET_BIG_SYM sparc_elf64_vec
847 #define TARGET_BIG_NAME "elf64-sparc"
848 #define ELF_ARCH bfd_arch_sparc
849 #define ELF_MAXPAGESIZE 0x100000
850 #define ELF_COMMONPAGESIZE 0x2000
852 /* This is the official ABI value. */
853 #define ELF_MACHINE_CODE EM_SPARCV9
855 /* This is the value that we used before the ABI was released. */
856 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
858 #define elf_backend_reloc_type_class \
859 elf64_sparc_reloc_type_class
860 #define bfd_elf64_get_reloc_upper_bound \
861 elf64_sparc_get_reloc_upper_bound
862 #define bfd_elf64_get_dynamic_reloc_upper_bound \
863 elf64_sparc_get_dynamic_reloc_upper_bound
864 #define bfd_elf64_canonicalize_reloc \
865 elf64_sparc_canonicalize_reloc
866 #define bfd_elf64_canonicalize_dynamic_reloc \
867 elf64_sparc_canonicalize_dynamic_reloc
868 #define bfd_elf64_set_reloc \
869 elf64_sparc_set_reloc
870 #define elf_backend_add_symbol_hook \
871 elf64_sparc_add_symbol_hook
872 #define elf_backend_get_symbol_type \
873 elf64_sparc_get_symbol_type
874 #define elf_backend_symbol_processing \
875 elf64_sparc_symbol_processing
876 #define elf_backend_print_symbol_all \
877 elf64_sparc_print_symbol_all
878 #define elf_backend_output_arch_syms \
879 elf64_sparc_output_arch_syms
880 #define bfd_elf64_bfd_merge_private_bfd_data \
881 elf64_sparc_merge_private_bfd_data
882 #define elf_backend_fake_sections \
883 elf64_sparc_fake_sections
884 #define elf_backend_size_info \
885 elf64_sparc_size_info
887 #define elf_backend_plt_sym_val \
888 _bfd_sparc_elf_plt_sym_val
889 #define bfd_elf64_bfd_link_hash_table_create \
890 _bfd_sparc_elf_link_hash_table_create
891 #define elf_info_to_howto \
892 _bfd_sparc_elf_info_to_howto
893 #define elf_backend_copy_indirect_symbol \
894 _bfd_sparc_elf_copy_indirect_symbol
895 #define bfd_elf64_bfd_reloc_type_lookup \
896 _bfd_sparc_elf_reloc_type_lookup
897 #define bfd_elf64_bfd_reloc_name_lookup \
898 _bfd_sparc_elf_reloc_name_lookup
899 #define bfd_elf64_bfd_relax_section \
900 _bfd_sparc_elf_relax_section
901 #define bfd_elf64_new_section_hook \
902 _bfd_sparc_elf_new_section_hook
904 #define elf_backend_create_dynamic_sections \
905 _bfd_sparc_elf_create_dynamic_sections
906 #define elf_backend_relocs_compatible \
907 _bfd_elf_relocs_compatible
908 #define elf_backend_check_relocs \
909 _bfd_sparc_elf_check_relocs
910 #define elf_backend_adjust_dynamic_symbol \
911 _bfd_sparc_elf_adjust_dynamic_symbol
912 #define elf_backend_omit_section_dynsym \
913 _bfd_sparc_elf_omit_section_dynsym
914 #define elf_backend_size_dynamic_sections \
915 _bfd_sparc_elf_size_dynamic_sections
916 #define elf_backend_relocate_section \
917 _bfd_sparc_elf_relocate_section
918 #define elf_backend_finish_dynamic_symbol \
919 _bfd_sparc_elf_finish_dynamic_symbol
920 #define elf_backend_finish_dynamic_sections \
921 _bfd_sparc_elf_finish_dynamic_sections
922 #define elf_backend_fixup_symbol \
923 _bfd_sparc_elf_fixup_symbol
925 #define bfd_elf64_mkobject \
926 _bfd_sparc_elf_mkobject
927 #define elf_backend_object_p \
928 _bfd_sparc_elf_object_p
929 #define elf_backend_gc_mark_hook \
930 _bfd_sparc_elf_gc_mark_hook
931 #define elf_backend_init_index_section \
932 _bfd_elf_init_1_index_section
934 #define elf_backend_can_gc_sections 1
935 #define elf_backend_can_refcount 1
936 #define elf_backend_want_got_plt 0
937 #define elf_backend_plt_readonly 0
938 #define elf_backend_want_plt_sym 1
939 #define elf_backend_got_header_size 8
940 #define elf_backend_want_dynrelro 1
941 #define elf_backend_rela_normal 1
943 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
944 #define elf_backend_plt_alignment 8
946 #include "elf64-target.h"
948 /* FreeBSD support */
949 #undef TARGET_BIG_SYM
950 #define TARGET_BIG_SYM sparc_elf64_fbsd_vec
951 #undef TARGET_BIG_NAME
952 #define TARGET_BIG_NAME "elf64-sparc-freebsd"
954 #define ELF_OSABI ELFOSABI_FREEBSD
957 #define elf64_bed elf64_sparc_fbsd_bed
959 #include "elf64-target.h"
963 #undef TARGET_BIG_SYM
964 #define TARGET_BIG_SYM sparc_elf64_sol2_vec
965 #undef TARGET_BIG_NAME
966 #define TARGET_BIG_NAME "elf64-sparc-sol2"
968 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
969 objects won't be recognized. */
973 #define elf64_bed elf64_sparc_sol2_bed
975 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
977 #undef elf_backend_static_tls_alignment
978 #define elf_backend_static_tls_alignment 16
980 #include "elf64-target.h"