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 || ELF64_R_SYM (rela
.r_info
) > bfd_get_symcount (abfd
))
103 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
108 ps
= symbols
+ ELF64_R_SYM (rela
.r_info
) - 1;
111 /* Canonicalize ELF section symbols. FIXME: Why? */
112 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
113 relent
->sym_ptr_ptr
= ps
;
115 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
118 relent
->addend
= rela
.r_addend
;
120 r_type
= ELF64_R_TYPE_ID (rela
.r_info
);
121 if (r_type
== R_SPARC_OLO10
)
123 relent
->howto
= _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_LO10
);
124 relent
[1].address
= relent
->address
;
126 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
127 relent
->addend
= ELF64_R_TYPE_DATA (rela
.r_info
);
128 relent
->howto
= _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_13
);
131 relent
->howto
= _bfd_sparc_elf_info_to_howto_ptr (r_type
);
134 canon_reloc_count (asect
) += relent
- relents
;
136 if (allocated
!= NULL
)
142 if (allocated
!= NULL
)
147 /* Read in and swap the external relocs. */
150 elf64_sparc_slurp_reloc_table (bfd
*abfd
, asection
*asect
,
151 asymbol
**symbols
, bfd_boolean dynamic
)
153 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
154 Elf_Internal_Shdr
*rel_hdr
;
155 Elf_Internal_Shdr
*rel_hdr2
;
158 if (asect
->relocation
!= NULL
)
163 if ((asect
->flags
& SEC_RELOC
) == 0
164 || asect
->reloc_count
== 0)
167 rel_hdr
= d
->rel
.hdr
;
168 rel_hdr2
= d
->rela
.hdr
;
170 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
171 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
175 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
176 case because relocations against this section may use the
177 dynamic symbol table, and in that case bfd_section_from_shdr
178 in elf.c does not update the RELOC_COUNT. */
179 if (asect
->size
== 0)
182 rel_hdr
= &d
->this_hdr
;
183 asect
->reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
187 amt
= asect
->reloc_count
;
188 amt
*= 2 * sizeof (arelent
);
189 asect
->relocation
= (arelent
*) bfd_alloc (abfd
, amt
);
190 if (asect
->relocation
== NULL
)
193 /* The elf64_sparc_slurp_one_reloc_table routine increments
194 canon_reloc_count. */
195 canon_reloc_count (asect
) = 0;
198 && !elf64_sparc_slurp_one_reloc_table (abfd
, asect
, rel_hdr
, symbols
,
203 && !elf64_sparc_slurp_one_reloc_table (abfd
, asect
, rel_hdr2
, symbols
,
210 /* Canonicalize the relocs. */
213 elf64_sparc_canonicalize_reloc (bfd
*abfd
, sec_ptr section
,
214 arelent
**relptr
, asymbol
**symbols
)
218 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
220 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
223 tblptr
= section
->relocation
;
224 for (i
= 0; i
< canon_reloc_count (section
); i
++)
225 *relptr
++ = tblptr
++;
229 return canon_reloc_count (section
);
233 /* Canonicalize the dynamic relocation entries. Note that we return
234 the dynamic relocations as a single block, although they are
235 actually associated with particular sections; the interface, which
236 was designed for SunOS style shared libraries, expects that there
237 is only one set of dynamic relocs. Any section that was actually
238 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
239 the dynamic symbol table, is considered to be a dynamic reloc
243 elf64_sparc_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**storage
,
249 if (elf_dynsymtab (abfd
) == 0)
251 bfd_set_error (bfd_error_invalid_operation
);
256 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
258 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
259 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
264 if (! elf64_sparc_slurp_reloc_table (abfd
, s
, syms
, TRUE
))
266 count
= canon_reloc_count (s
);
268 for (i
= 0; i
< count
; i
++)
279 /* Write out the relocs. */
282 elf64_sparc_write_relocs (bfd
*abfd
, asection
*sec
, void * data
)
284 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
285 Elf_Internal_Shdr
*rela_hdr
;
287 Elf64_External_Rela
*outbound_relocas
, *src_rela
;
288 unsigned int idx
, count
;
289 asymbol
*last_sym
= 0;
290 int last_sym_idx
= 0;
292 /* If we have already failed, don't do anything. */
296 if ((sec
->flags
& SEC_RELOC
) == 0)
299 /* The linker backend writes the relocs out itself, and sets the
300 reloc_count field to zero to inhibit writing them here. Also,
301 sometimes the SEC_RELOC flag gets set even when there aren't any
303 if (sec
->reloc_count
== 0)
306 /* We can combine two relocs that refer to the same address
307 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
308 latter is R_SPARC_13 with no associated symbol. */
310 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
316 addr
= sec
->orelocation
[idx
]->address
;
317 if (sec
->orelocation
[idx
]->howto
->type
== R_SPARC_LO10
318 && idx
< sec
->reloc_count
- 1)
320 arelent
*r
= sec
->orelocation
[idx
+ 1];
322 if (r
->howto
->type
== R_SPARC_13
323 && r
->address
== addr
324 && bfd_is_abs_section ((*r
->sym_ptr_ptr
)->section
)
325 && (*r
->sym_ptr_ptr
)->value
== 0)
330 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
332 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* count
;
333 rela_hdr
->contents
= bfd_alloc (abfd
, rela_hdr
->sh_size
);
334 if (rela_hdr
->contents
== NULL
)
340 /* Figure out whether the relocations are RELA or REL relocations. */
341 if (rela_hdr
->sh_type
!= SHT_RELA
)
344 /* The address of an ELF reloc is section relative for an object
345 file, and absolute for an executable file or shared library.
346 The address of a BFD reloc is always section relative. */
348 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
349 addr_offset
= sec
->vma
;
351 /* orelocation has the data, reloc_count has the count... */
352 outbound_relocas
= (Elf64_External_Rela
*) rela_hdr
->contents
;
353 src_rela
= outbound_relocas
;
355 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
357 Elf_Internal_Rela dst_rela
;
362 ptr
= sec
->orelocation
[idx
];
363 sym
= *ptr
->sym_ptr_ptr
;
366 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
371 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
380 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
381 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
382 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
388 if (ptr
->howto
->type
== R_SPARC_LO10
389 && idx
< sec
->reloc_count
- 1)
391 arelent
*r
= sec
->orelocation
[idx
+ 1];
393 if (r
->howto
->type
== R_SPARC_13
394 && r
->address
== ptr
->address
395 && bfd_is_abs_section ((*r
->sym_ptr_ptr
)->section
)
396 && (*r
->sym_ptr_ptr
)->value
== 0)
400 = ELF64_R_INFO (n
, ELF64_R_TYPE_INFO (r
->addend
,
404 dst_rela
.r_info
= ELF64_R_INFO (n
, R_SPARC_LO10
);
407 dst_rela
.r_info
= ELF64_R_INFO (n
, ptr
->howto
->type
);
409 dst_rela
.r_offset
= ptr
->address
+ addr_offset
;
410 dst_rela
.r_addend
= ptr
->addend
;
412 bfd_elf64_swap_reloca_out (abfd
, &dst_rela
, (bfd_byte
*) src_rela
);
417 /* Hook called by the linker routine which adds symbols from an object
418 file. We use it for STT_REGISTER symbols. */
421 elf64_sparc_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
422 Elf_Internal_Sym
*sym
, const char **namep
,
423 flagword
*flagsp ATTRIBUTE_UNUSED
,
424 asection
**secp ATTRIBUTE_UNUSED
,
425 bfd_vma
*valp ATTRIBUTE_UNUSED
)
427 static const char *const stt_types
[] = { "NOTYPE", "OBJECT", "FUNCTION" };
429 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
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
|= elf_gnu_symbol_ifunc
;
434 if (ELF_ST_TYPE (sym
->st_info
) == STT_REGISTER
)
437 struct _bfd_sparc_elf_app_reg
*p
;
439 reg
= (int)sym
->st_value
;
442 case 2: reg
-= 2; break;
443 case 6: reg
-= 4; break;
446 (_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
451 if (info
->output_bfd
->xvec
!= abfd
->xvec
452 || (abfd
->flags
& DYNAMIC
) != 0)
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. */
461 p
= _bfd_sparc_elf_hash_table(info
)->app_regs
+ reg
;
463 if (p
->name
!= NULL
&& strcmp (p
->name
, *namep
))
466 /* xgettext:c-format */
467 (_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
468 abfd
, p
->abfd
, (int) sym
->st_value
,
469 **namep
? *namep
: "#scratch",
470 *p
->name
? p
->name
: "#scratch");
478 struct elf_link_hash_entry
*h
;
480 h
= (struct elf_link_hash_entry
*)
481 bfd_link_hash_lookup (info
->hash
, *namep
, FALSE
, FALSE
, FALSE
);
485 unsigned char type
= h
->type
;
490 /* xgettext:c-format */
491 (_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
492 abfd
, p
->abfd
, *namep
, stt_types
[type
]);
496 p
->name
= bfd_hash_allocate (&info
->hash
->table
,
497 strlen (*namep
) + 1);
501 strcpy (p
->name
, *namep
);
505 p
->bind
= ELF_ST_BIND (sym
->st_info
);
507 p
->shndx
= sym
->st_shndx
;
511 if (p
->bind
== STB_WEAK
512 && ELF_ST_BIND (sym
->st_info
) == STB_GLOBAL
)
514 p
->bind
= STB_GLOBAL
;
521 else if (*namep
&& **namep
522 && info
->output_bfd
->xvec
== abfd
->xvec
)
525 struct _bfd_sparc_elf_app_reg
*p
;
527 p
= _bfd_sparc_elf_hash_table(info
)->app_regs
;
528 for (i
= 0; i
< 4; i
++, p
++)
529 if (p
->name
!= NULL
&& ! strcmp (p
->name
, *namep
))
531 unsigned char type
= ELF_ST_TYPE (sym
->st_info
);
536 /* xgettext:c-format */
537 (_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
538 abfd
, p
->abfd
, *namep
, stt_types
[type
]);
545 /* This function takes care of emitting STT_REGISTER symbols
546 which we cannot easily keep in the symbol hash table. */
549 elf64_sparc_output_arch_syms (bfd
*output_bfd ATTRIBUTE_UNUSED
,
550 struct bfd_link_info
*info
,
552 int (*func
) (void *, const char *,
555 struct elf_link_hash_entry
*))
558 struct _bfd_sparc_elf_app_reg
*app_regs
=
559 _bfd_sparc_elf_hash_table(info
)->app_regs
;
560 Elf_Internal_Sym sym
;
562 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
563 at the end of the dynlocal list, so they came at the end of the local
564 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
565 to back up symtab->sh_info. */
566 if (elf_hash_table (info
)->dynlocal
)
568 bfd
* dynobj
= elf_hash_table (info
)->dynobj
;
569 asection
*dynsymsec
= bfd_get_linker_section (dynobj
, ".dynsym");
570 struct elf_link_local_dynamic_entry
*e
;
572 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
573 if (e
->input_indx
== -1)
577 elf_section_data (dynsymsec
->output_section
)->this_hdr
.sh_info
582 if (info
->strip
== strip_all
)
585 for (reg
= 0; reg
< 4; reg
++)
586 if (app_regs
[reg
].name
!= NULL
)
588 if (info
->strip
== strip_some
589 && bfd_hash_lookup (info
->keep_hash
,
591 FALSE
, FALSE
) == NULL
)
594 sym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
597 sym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
, STT_REGISTER
);
598 sym
.st_shndx
= app_regs
[reg
].shndx
;
599 sym
.st_target_internal
= 0;
600 if ((*func
) (flaginfo
, app_regs
[reg
].name
, &sym
,
601 sym
.st_shndx
== SHN_ABS
602 ? bfd_abs_section_ptr
: bfd_und_section_ptr
,
611 elf64_sparc_get_symbol_type (Elf_Internal_Sym
*elf_sym
, int type
)
613 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_REGISTER
)
619 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
620 even in SHN_UNDEF section. */
623 elf64_sparc_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
, asymbol
*asym
)
625 elf_symbol_type
*elfsym
;
627 elfsym
= (elf_symbol_type
*) asym
;
628 if (elfsym
->internal_elf_sym
.st_info
629 == ELF_ST_INFO (STB_GLOBAL
, STT_REGISTER
))
631 asym
->flags
|= BSF_GLOBAL
;
636 /* Functions for dealing with the e_flags field. */
638 /* Merge backend specific data from an object file to the output
639 object file when linking. */
642 elf64_sparc_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
644 bfd
*obfd
= info
->output_bfd
;
646 flagword new_flags
, old_flags
;
649 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
650 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
653 new_flags
= elf_elfheader (ibfd
)->e_flags
;
654 old_flags
= elf_elfheader (obfd
)->e_flags
;
656 if (!elf_flags_init (obfd
)) /* First call, no flags set */
658 elf_flags_init (obfd
) = TRUE
;
659 elf_elfheader (obfd
)->e_flags
= new_flags
;
662 else if (new_flags
== old_flags
) /* Compatible flags are ok */
665 else /* Incompatible flags */
669 #define EF_SPARC_ISA_EXTENSIONS \
670 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
672 if ((ibfd
->flags
& DYNAMIC
) != 0)
674 /* We don't want dynamic objects memory ordering and
675 architecture to have any role. That's what dynamic linker
677 new_flags
&= ~(EF_SPARCV9_MM
| EF_SPARC_ISA_EXTENSIONS
);
678 new_flags
|= (old_flags
679 & (EF_SPARCV9_MM
| EF_SPARC_ISA_EXTENSIONS
));
683 /* Choose the highest architecture requirements. */
684 old_flags
|= (new_flags
& EF_SPARC_ISA_EXTENSIONS
);
685 new_flags
|= (old_flags
& EF_SPARC_ISA_EXTENSIONS
);
686 if ((old_flags
& (EF_SPARC_SUN_US1
| EF_SPARC_SUN_US3
))
687 && (old_flags
& EF_SPARC_HAL_R1
))
691 (_("%B: linking UltraSPARC specific with HAL specific code"),
694 /* Choose the most restrictive memory ordering. */
695 old_mm
= (old_flags
& EF_SPARCV9_MM
);
696 new_mm
= (new_flags
& EF_SPARCV9_MM
);
697 old_flags
&= ~EF_SPARCV9_MM
;
698 new_flags
&= ~EF_SPARCV9_MM
;
705 /* Warn about any other mismatches */
706 if (new_flags
!= old_flags
)
710 /* xgettext:c-format */
711 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
712 ibfd
, (long) new_flags
, (long) old_flags
);
715 elf_elfheader (obfd
)->e_flags
= old_flags
;
719 bfd_set_error (bfd_error_bad_value
);
723 return _bfd_sparc_elf_merge_private_bfd_data (ibfd
, info
);
726 /* MARCO: Set the correct entry size for the .stab section. */
729 elf64_sparc_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
730 Elf_Internal_Shdr
*hdr ATTRIBUTE_UNUSED
,
735 name
= bfd_get_section_name (abfd
, sec
);
737 if (strcmp (name
, ".stab") == 0)
739 /* Even in the 64bit case the stab entries are only 12 bytes long. */
740 elf_section_data (sec
)->this_hdr
.sh_entsize
= 12;
746 /* Print a STT_REGISTER symbol to file FILE. */
749 elf64_sparc_print_symbol_all (bfd
*abfd ATTRIBUTE_UNUSED
, void * filep
,
752 FILE *file
= (FILE *) filep
;
755 if (ELF_ST_TYPE (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_info
)
759 reg
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
760 type
= symbol
->flags
;
761 fprintf (file
, "REG_%c%c%11s%c%c R", "GOLI" [reg
/ 8], '0' + (reg
& 7), "",
763 ? (type
& BSF_GLOBAL
) ? '!' : 'l'
764 : (type
& BSF_GLOBAL
) ? 'g' : ' '),
765 (type
& BSF_WEAK
) ? 'w' : ' ');
766 if (symbol
->name
== NULL
|| symbol
->name
[0] == '\0')
772 static enum elf_reloc_type_class
773 elf64_sparc_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
774 const asection
*rel_sec ATTRIBUTE_UNUSED
,
775 const Elf_Internal_Rela
*rela
)
777 switch ((int) ELF64_R_TYPE (rela
->r_info
))
779 case R_SPARC_RELATIVE
:
780 return reloc_class_relative
;
781 case R_SPARC_JMP_SLOT
:
782 return reloc_class_plt
;
784 return reloc_class_copy
;
786 return reloc_class_normal
;
790 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
791 standard ELF, because R_SPARC_OLO10 has secondary addend in
792 ELF64_R_TYPE_DATA field. This structure is used to redirect the
793 relocation handling routines. */
795 const struct elf_size_info elf64_sparc_size_info
=
797 sizeof (Elf64_External_Ehdr
),
798 sizeof (Elf64_External_Phdr
),
799 sizeof (Elf64_External_Shdr
),
800 sizeof (Elf64_External_Rel
),
801 sizeof (Elf64_External_Rela
),
802 sizeof (Elf64_External_Sym
),
803 sizeof (Elf64_External_Dyn
),
804 sizeof (Elf_External_Note
),
805 4, /* hash-table entry size. */
806 /* Internal relocations per external relocations.
807 For link purposes we use just 1 internal per
808 1 external, for assembly and slurp symbol table
812 3, /* log_file_align. */
815 bfd_elf64_write_out_phdrs
,
816 bfd_elf64_write_shdrs_and_ehdr
,
817 bfd_elf64_checksum_contents
,
818 elf64_sparc_write_relocs
,
819 bfd_elf64_swap_symbol_in
,
820 bfd_elf64_swap_symbol_out
,
821 elf64_sparc_slurp_reloc_table
,
822 bfd_elf64_slurp_symbol_table
,
823 bfd_elf64_swap_dyn_in
,
824 bfd_elf64_swap_dyn_out
,
825 bfd_elf64_swap_reloc_in
,
826 bfd_elf64_swap_reloc_out
,
827 bfd_elf64_swap_reloca_in
,
828 bfd_elf64_swap_reloca_out
831 #define TARGET_BIG_SYM sparc_elf64_vec
832 #define TARGET_BIG_NAME "elf64-sparc"
833 #define ELF_ARCH bfd_arch_sparc
834 #define ELF_MAXPAGESIZE 0x100000
835 #define ELF_COMMONPAGESIZE 0x2000
837 /* This is the official ABI value. */
838 #define ELF_MACHINE_CODE EM_SPARCV9
840 /* This is the value that we used before the ABI was released. */
841 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
843 #define elf_backend_reloc_type_class \
844 elf64_sparc_reloc_type_class
845 #define bfd_elf64_get_reloc_upper_bound \
846 elf64_sparc_get_reloc_upper_bound
847 #define bfd_elf64_get_dynamic_reloc_upper_bound \
848 elf64_sparc_get_dynamic_reloc_upper_bound
849 #define bfd_elf64_canonicalize_reloc \
850 elf64_sparc_canonicalize_reloc
851 #define bfd_elf64_canonicalize_dynamic_reloc \
852 elf64_sparc_canonicalize_dynamic_reloc
853 #define elf_backend_add_symbol_hook \
854 elf64_sparc_add_symbol_hook
855 #define elf_backend_get_symbol_type \
856 elf64_sparc_get_symbol_type
857 #define elf_backend_symbol_processing \
858 elf64_sparc_symbol_processing
859 #define elf_backend_print_symbol_all \
860 elf64_sparc_print_symbol_all
861 #define elf_backend_output_arch_syms \
862 elf64_sparc_output_arch_syms
863 #define bfd_elf64_bfd_merge_private_bfd_data \
864 elf64_sparc_merge_private_bfd_data
865 #define elf_backend_fake_sections \
866 elf64_sparc_fake_sections
867 #define elf_backend_size_info \
868 elf64_sparc_size_info
870 #define elf_backend_plt_sym_val \
871 _bfd_sparc_elf_plt_sym_val
872 #define bfd_elf64_bfd_link_hash_table_create \
873 _bfd_sparc_elf_link_hash_table_create
874 #define elf_info_to_howto \
875 _bfd_sparc_elf_info_to_howto
876 #define elf_backend_copy_indirect_symbol \
877 _bfd_sparc_elf_copy_indirect_symbol
878 #define bfd_elf64_bfd_reloc_type_lookup \
879 _bfd_sparc_elf_reloc_type_lookup
880 #define bfd_elf64_bfd_reloc_name_lookup \
881 _bfd_sparc_elf_reloc_name_lookup
882 #define bfd_elf64_bfd_relax_section \
883 _bfd_sparc_elf_relax_section
884 #define bfd_elf64_new_section_hook \
885 _bfd_sparc_elf_new_section_hook
887 #define elf_backend_create_dynamic_sections \
888 _bfd_sparc_elf_create_dynamic_sections
889 #define elf_backend_relocs_compatible \
890 _bfd_elf_relocs_compatible
891 #define elf_backend_check_relocs \
892 _bfd_sparc_elf_check_relocs
893 #define elf_backend_adjust_dynamic_symbol \
894 _bfd_sparc_elf_adjust_dynamic_symbol
895 #define elf_backend_omit_section_dynsym \
896 _bfd_sparc_elf_omit_section_dynsym
897 #define elf_backend_size_dynamic_sections \
898 _bfd_sparc_elf_size_dynamic_sections
899 #define elf_backend_relocate_section \
900 _bfd_sparc_elf_relocate_section
901 #define elf_backend_finish_dynamic_symbol \
902 _bfd_sparc_elf_finish_dynamic_symbol
903 #define elf_backend_finish_dynamic_sections \
904 _bfd_sparc_elf_finish_dynamic_sections
906 #define bfd_elf64_mkobject \
907 _bfd_sparc_elf_mkobject
908 #define elf_backend_object_p \
909 _bfd_sparc_elf_object_p
910 #define elf_backend_gc_mark_hook \
911 _bfd_sparc_elf_gc_mark_hook
912 #define elf_backend_gc_sweep_hook \
913 _bfd_sparc_elf_gc_sweep_hook
914 #define elf_backend_init_index_section \
915 _bfd_elf_init_1_index_section
917 #define elf_backend_can_gc_sections 1
918 #define elf_backend_can_refcount 1
919 #define elf_backend_want_got_plt 0
920 #define elf_backend_plt_readonly 0
921 #define elf_backend_want_plt_sym 1
922 #define elf_backend_got_header_size 8
923 #define elf_backend_want_dynrelro 1
924 #define elf_backend_rela_normal 1
926 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
927 #define elf_backend_plt_alignment 8
929 #include "elf64-target.h"
931 /* FreeBSD support */
932 #undef TARGET_BIG_SYM
933 #define TARGET_BIG_SYM sparc_elf64_fbsd_vec
934 #undef TARGET_BIG_NAME
935 #define TARGET_BIG_NAME "elf64-sparc-freebsd"
937 #define ELF_OSABI ELFOSABI_FREEBSD
940 #define elf64_bed elf64_sparc_fbsd_bed
942 #include "elf64-target.h"
946 #undef TARGET_BIG_SYM
947 #define TARGET_BIG_SYM sparc_elf64_sol2_vec
948 #undef TARGET_BIG_NAME
949 #define TARGET_BIG_NAME "elf64-sparc-sol2"
951 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
952 objects won't be recognized. */
956 #define elf64_bed elf64_sparc_sol2_bed
958 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
960 #undef elf_backend_static_tls_alignment
961 #define elf_backend_static_tls_alignment 16
963 #include "elf64-target.h"