1 /* SPARC-specific support for 64-bit ELF
2 Copyright (C) 1993-2020 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. */
26 #include "elf/sparc.h"
27 #include "opcode/sparc.h"
28 #include "elfxx-sparc.h"
30 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
31 #define MINUS_ONE (~ (bfd_vma) 0)
33 /* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
34 section can represent up to two relocs, we must tell the user to allocate
38 elf64_sparc_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
)
40 #if SIZEOF_LONG == SIZEOF_INT
41 if (sec
->reloc_count
>= LONG_MAX
/ 2 / sizeof (arelent
*))
43 bfd_set_error (bfd_error_file_too_big
);
47 return (sec
->reloc_count
* 2 + 1) * sizeof (arelent
*);
51 elf64_sparc_get_dynamic_reloc_upper_bound (bfd
*abfd
)
53 long ret
= _bfd_elf_get_dynamic_reloc_upper_bound (abfd
);
54 if (ret
> LONG_MAX
/ 2)
56 bfd_set_error (bfd_error_file_too_big
);
64 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
65 them. We cannot use generic elf routines for this, because R_SPARC_OLO10
66 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
67 for the same location, R_SPARC_LO10 and R_SPARC_13. */
70 elf64_sparc_slurp_one_reloc_table (bfd
*abfd
, asection
*asect
,
71 Elf_Internal_Shdr
*rel_hdr
,
72 asymbol
**symbols
, bfd_boolean dynamic
)
74 void * allocated
= NULL
;
75 bfd_byte
*native_relocs
;
82 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
84 allocated
= _bfd_malloc_and_read (abfd
, rel_hdr
->sh_size
, rel_hdr
->sh_size
);
85 if (allocated
== NULL
)
88 native_relocs
= (bfd_byte
*) allocated
;
90 relents
= asect
->relocation
+ canon_reloc_count (asect
);
92 entsize
= rel_hdr
->sh_entsize
;
93 BFD_ASSERT (entsize
== sizeof (Elf64_External_Rela
));
95 count
= rel_hdr
->sh_size
/ entsize
;
97 for (i
= 0, relent
= relents
; i
< count
;
98 i
++, relent
++, native_relocs
+= entsize
)
100 Elf_Internal_Rela rela
;
103 bfd_elf64_swap_reloca_in (abfd
, native_relocs
, &rela
);
105 /* The address of an ELF reloc is section relative for an object
106 file, and absolute for an executable file or shared library.
107 The address of a normal BFD reloc is always section relative,
108 and the address of a dynamic reloc is absolute.. */
109 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
110 relent
->address
= rela
.r_offset
;
112 relent
->address
= rela
.r_offset
- asect
->vma
;
114 if (ELF64_R_SYM (rela
.r_info
) == STN_UNDEF
)
115 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
116 else if (/* PR 17512: file: 996185f8. */
117 ELF64_R_SYM (rela
.r_info
) > (dynamic
118 ? bfd_get_dynamic_symcount (abfd
)
119 : bfd_get_symcount (abfd
)))
122 /* xgettext:c-format */
123 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
124 abfd
, asect
, i
, (long) ELF64_R_SYM (rela
.r_info
));
125 bfd_set_error (bfd_error_bad_value
);
126 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
132 ps
= symbols
+ ELF64_R_SYM (rela
.r_info
) - 1;
135 /* Canonicalize ELF section symbols. FIXME: Why? */
136 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
137 relent
->sym_ptr_ptr
= ps
;
139 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
142 relent
->addend
= rela
.r_addend
;
144 r_type
= ELF64_R_TYPE_ID (rela
.r_info
);
145 if (r_type
== R_SPARC_OLO10
)
147 relent
->howto
= _bfd_sparc_elf_info_to_howto_ptr (abfd
, R_SPARC_LO10
);
148 relent
[1].address
= relent
->address
;
150 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
151 relent
->addend
= ELF64_R_TYPE_DATA (rela
.r_info
);
152 relent
->howto
= _bfd_sparc_elf_info_to_howto_ptr (abfd
, R_SPARC_13
);
156 relent
->howto
= _bfd_sparc_elf_info_to_howto_ptr (abfd
, r_type
);
157 if (relent
->howto
== NULL
)
162 canon_reloc_count (asect
) += relent
- relents
;
164 if (allocated
!= NULL
)
170 if (allocated
!= NULL
)
175 /* Read in and swap the external relocs. */
178 elf64_sparc_slurp_reloc_table (bfd
*abfd
, asection
*asect
,
179 asymbol
**symbols
, bfd_boolean dynamic
)
181 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
182 Elf_Internal_Shdr
*rel_hdr
;
183 Elf_Internal_Shdr
*rel_hdr2
;
186 if (asect
->relocation
!= NULL
)
191 if ((asect
->flags
& SEC_RELOC
) == 0
192 || asect
->reloc_count
== 0)
195 rel_hdr
= d
->rel
.hdr
;
196 rel_hdr2
= d
->rela
.hdr
;
198 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
199 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
203 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
204 case because relocations against this section may use the
205 dynamic symbol table, and in that case bfd_section_from_shdr
206 in elf.c does not update the RELOC_COUNT. */
207 if (asect
->size
== 0)
210 rel_hdr
= &d
->this_hdr
;
211 asect
->reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
215 amt
= asect
->reloc_count
;
216 amt
*= 2 * sizeof (arelent
);
217 asect
->relocation
= (arelent
*) bfd_alloc (abfd
, amt
);
218 if (asect
->relocation
== NULL
)
221 /* The elf64_sparc_slurp_one_reloc_table routine increments
222 canon_reloc_count. */
223 canon_reloc_count (asect
) = 0;
226 && !elf64_sparc_slurp_one_reloc_table (abfd
, asect
, rel_hdr
, symbols
,
231 && !elf64_sparc_slurp_one_reloc_table (abfd
, asect
, rel_hdr2
, symbols
,
238 /* Canonicalize the relocs. */
241 elf64_sparc_canonicalize_reloc (bfd
*abfd
, sec_ptr section
,
242 arelent
**relptr
, asymbol
**symbols
)
246 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
248 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
251 tblptr
= section
->relocation
;
252 for (i
= 0; i
< canon_reloc_count (section
); i
++)
253 *relptr
++ = tblptr
++;
257 return canon_reloc_count (section
);
261 /* Canonicalize the dynamic relocation entries. Note that we return
262 the dynamic relocations as a single block, although they are
263 actually associated with particular sections; the interface, which
264 was designed for SunOS style shared libraries, expects that there
265 is only one set of dynamic relocs. Any section that was actually
266 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
267 the dynamic symbol table, is considered to be a dynamic reloc
271 elf64_sparc_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**storage
,
277 if (elf_dynsymtab (abfd
) == 0)
279 bfd_set_error (bfd_error_invalid_operation
);
284 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
286 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
287 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
292 if (! elf64_sparc_slurp_reloc_table (abfd
, s
, syms
, TRUE
))
294 count
= canon_reloc_count (s
);
296 for (i
= 0; i
< count
; i
++)
307 /* Install a new set of internal relocs. */
310 elf64_sparc_set_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
315 asect
->orelocation
= location
;
316 canon_reloc_count (asect
) = count
;
319 /* Write out the relocs. */
322 elf64_sparc_write_relocs (bfd
*abfd
, asection
*sec
, void * data
)
324 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
325 Elf_Internal_Shdr
*rela_hdr
;
327 Elf64_External_Rela
*outbound_relocas
, *src_rela
;
328 unsigned int idx
, count
;
329 asymbol
*last_sym
= 0;
330 int last_sym_idx
= 0;
332 /* If we have already failed, don't do anything. */
336 if ((sec
->flags
& SEC_RELOC
) == 0)
339 /* The linker backend writes the relocs out itself, and sets the
340 reloc_count field to zero to inhibit writing them here. Also,
341 sometimes the SEC_RELOC flag gets set even when there aren't any
343 if (canon_reloc_count (sec
) == 0)
346 /* We can combine two relocs that refer to the same address
347 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
348 latter is R_SPARC_13 with no associated symbol. */
350 for (idx
= 0; idx
< canon_reloc_count (sec
); idx
++)
356 addr
= sec
->orelocation
[idx
]->address
;
357 if (sec
->orelocation
[idx
]->howto
->type
== R_SPARC_LO10
358 && idx
< canon_reloc_count (sec
) - 1)
360 arelent
*r
= sec
->orelocation
[idx
+ 1];
362 if (r
->howto
->type
== R_SPARC_13
363 && r
->address
== addr
364 && bfd_is_abs_section ((*r
->sym_ptr_ptr
)->section
)
365 && (*r
->sym_ptr_ptr
)->value
== 0)
370 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
372 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* count
;
373 rela_hdr
->contents
= bfd_alloc (abfd
, rela_hdr
->sh_size
);
374 if (rela_hdr
->contents
== NULL
)
380 /* Figure out whether the relocations are RELA or REL relocations. */
381 if (rela_hdr
->sh_type
!= SHT_RELA
)
384 /* The address of an ELF reloc is section relative for an object
385 file, and absolute for an executable file or shared library.
386 The address of a BFD reloc is always section relative. */
388 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
389 addr_offset
= sec
->vma
;
391 /* orelocation has the data, reloc_count has the count... */
392 outbound_relocas
= (Elf64_External_Rela
*) rela_hdr
->contents
;
393 src_rela
= outbound_relocas
;
395 for (idx
= 0; idx
< canon_reloc_count (sec
); idx
++)
397 Elf_Internal_Rela dst_rela
;
402 ptr
= sec
->orelocation
[idx
];
403 sym
= *ptr
->sym_ptr_ptr
;
406 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
411 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
420 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
421 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
422 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
428 if (ptr
->howto
->type
== R_SPARC_LO10
429 && idx
< canon_reloc_count (sec
) - 1)
431 arelent
*r
= sec
->orelocation
[idx
+ 1];
433 if (r
->howto
->type
== R_SPARC_13
434 && r
->address
== ptr
->address
435 && bfd_is_abs_section ((*r
->sym_ptr_ptr
)->section
)
436 && (*r
->sym_ptr_ptr
)->value
== 0)
440 = ELF64_R_INFO (n
, ELF64_R_TYPE_INFO (r
->addend
,
444 dst_rela
.r_info
= ELF64_R_INFO (n
, R_SPARC_LO10
);
447 dst_rela
.r_info
= ELF64_R_INFO (n
, ptr
->howto
->type
);
449 dst_rela
.r_offset
= ptr
->address
+ addr_offset
;
450 dst_rela
.r_addend
= ptr
->addend
;
452 bfd_elf64_swap_reloca_out (abfd
, &dst_rela
, (bfd_byte
*) src_rela
);
457 /* Hook called by the linker routine which adds symbols from an object
458 file. We use it for STT_REGISTER symbols. */
461 elf64_sparc_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
462 Elf_Internal_Sym
*sym
, const char **namep
,
463 flagword
*flagsp ATTRIBUTE_UNUSED
,
464 asection
**secp ATTRIBUTE_UNUSED
,
465 bfd_vma
*valp ATTRIBUTE_UNUSED
)
467 static const char *const stt_types
[] = { "NOTYPE", "OBJECT", "FUNCTION" };
469 if (ELF_ST_TYPE (sym
->st_info
) == STT_REGISTER
)
472 struct _bfd_sparc_elf_app_reg
*p
;
474 reg
= (int)sym
->st_value
;
477 case 2: reg
-= 2; break;
478 case 6: reg
-= 4; break;
481 (_("%pB: only registers %%g[2367] can be declared using STT_REGISTER"),
486 if (info
->output_bfd
->xvec
!= abfd
->xvec
487 || (abfd
->flags
& DYNAMIC
) != 0)
489 /* STT_REGISTER only works when linking an elf64_sparc object.
490 If STT_REGISTER comes from a dynamic object, don't put it into
491 the output bfd. The dynamic linker will recheck it. */
496 p
= _bfd_sparc_elf_hash_table(info
)->app_regs
+ reg
;
498 if (p
->name
!= NULL
&& strcmp (p
->name
, *namep
))
501 /* xgettext:c-format */
502 (_("register %%g%d used incompatibly: %s in %pB,"
503 " previously %s in %pB"),
504 (int) sym
->st_value
, **namep
? *namep
: "#scratch", abfd
,
505 *p
->name
? p
->name
: "#scratch", p
->abfd
);
513 struct elf_link_hash_entry
*h
;
515 h
= (struct elf_link_hash_entry
*)
516 bfd_link_hash_lookup (info
->hash
, *namep
, FALSE
, FALSE
, FALSE
);
520 unsigned char type
= h
->type
;
525 /* xgettext:c-format */
526 (_("symbol `%s' has differing types: REGISTER in %pB,"
527 " previously %s in %pB"),
528 *namep
, abfd
, stt_types
[type
], p
->abfd
);
532 p
->name
= bfd_hash_allocate (&info
->hash
->table
,
533 strlen (*namep
) + 1);
537 strcpy (p
->name
, *namep
);
541 p
->bind
= ELF_ST_BIND (sym
->st_info
);
543 p
->shndx
= sym
->st_shndx
;
547 if (p
->bind
== STB_WEAK
548 && ELF_ST_BIND (sym
->st_info
) == STB_GLOBAL
)
550 p
->bind
= STB_GLOBAL
;
557 else if (*namep
&& **namep
558 && info
->output_bfd
->xvec
== abfd
->xvec
)
561 struct _bfd_sparc_elf_app_reg
*p
;
563 p
= _bfd_sparc_elf_hash_table(info
)->app_regs
;
564 for (i
= 0; i
< 4; i
++, p
++)
565 if (p
->name
!= NULL
&& ! strcmp (p
->name
, *namep
))
567 unsigned char type
= ELF_ST_TYPE (sym
->st_info
);
572 /* xgettext:c-format */
573 (_("Symbol `%s' has differing types: %s in %pB,"
574 " previously REGISTER in %pB"),
575 *namep
, stt_types
[type
], abfd
, p
->abfd
);
582 /* This function takes care of emitting STT_REGISTER symbols
583 which we cannot easily keep in the symbol hash table. */
586 elf64_sparc_output_arch_syms (bfd
*output_bfd ATTRIBUTE_UNUSED
,
587 struct bfd_link_info
*info
,
589 int (*func
) (void *, const char *,
592 struct elf_link_hash_entry
*))
595 struct _bfd_sparc_elf_app_reg
*app_regs
=
596 _bfd_sparc_elf_hash_table(info
)->app_regs
;
597 Elf_Internal_Sym sym
;
599 for (reg
= 0; reg
< 4; reg
++)
600 if (app_regs
[reg
].name
!= NULL
)
602 if (info
->strip
== strip_some
603 && bfd_hash_lookup (info
->keep_hash
,
605 FALSE
, FALSE
) == NULL
)
608 sym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
611 sym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
, STT_REGISTER
);
612 sym
.st_shndx
= app_regs
[reg
].shndx
;
613 sym
.st_target_internal
= 0;
614 if ((*func
) (flaginfo
, app_regs
[reg
].name
, &sym
,
615 sym
.st_shndx
== SHN_ABS
616 ? bfd_abs_section_ptr
: bfd_und_section_ptr
,
625 elf64_sparc_get_symbol_type (Elf_Internal_Sym
*elf_sym
, int type
)
627 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_REGISTER
)
633 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
634 even in SHN_UNDEF section. */
637 elf64_sparc_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
, asymbol
*asym
)
639 elf_symbol_type
*elfsym
;
641 elfsym
= (elf_symbol_type
*) asym
;
642 if (elfsym
->internal_elf_sym
.st_info
643 == ELF_ST_INFO (STB_GLOBAL
, STT_REGISTER
))
645 asym
->flags
|= BSF_GLOBAL
;
650 /* Functions for dealing with the e_flags field. */
652 /* Merge backend specific data from an object file to the output
653 object file when linking. */
656 elf64_sparc_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
658 bfd
*obfd
= info
->output_bfd
;
660 flagword new_flags
, old_flags
;
663 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
664 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
667 new_flags
= elf_elfheader (ibfd
)->e_flags
;
668 old_flags
= elf_elfheader (obfd
)->e_flags
;
670 if (!elf_flags_init (obfd
)) /* First call, no flags set */
672 elf_flags_init (obfd
) = TRUE
;
673 elf_elfheader (obfd
)->e_flags
= new_flags
;
676 else if (new_flags
== old_flags
) /* Compatible flags are ok */
679 else /* Incompatible flags */
683 #define EF_SPARC_ISA_EXTENSIONS \
684 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
686 if ((ibfd
->flags
& DYNAMIC
) != 0)
688 /* We don't want dynamic objects memory ordering and
689 architecture to have any role. That's what dynamic linker
691 new_flags
&= ~(EF_SPARCV9_MM
| EF_SPARC_ISA_EXTENSIONS
);
692 new_flags
|= (old_flags
693 & (EF_SPARCV9_MM
| EF_SPARC_ISA_EXTENSIONS
));
697 /* Choose the highest architecture requirements. */
698 old_flags
|= (new_flags
& EF_SPARC_ISA_EXTENSIONS
);
699 new_flags
|= (old_flags
& EF_SPARC_ISA_EXTENSIONS
);
700 if ((old_flags
& (EF_SPARC_SUN_US1
| EF_SPARC_SUN_US3
))
701 && (old_flags
& EF_SPARC_HAL_R1
))
705 (_("%pB: linking UltraSPARC specific with HAL specific code"),
708 /* Choose the most restrictive memory ordering. */
709 old_mm
= (old_flags
& EF_SPARCV9_MM
);
710 new_mm
= (new_flags
& EF_SPARCV9_MM
);
711 old_flags
&= ~EF_SPARCV9_MM
;
712 new_flags
&= ~EF_SPARCV9_MM
;
719 /* Warn about any other mismatches */
720 if (new_flags
!= old_flags
)
724 /* xgettext:c-format */
725 (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
726 ibfd
, new_flags
, old_flags
);
729 elf_elfheader (obfd
)->e_flags
= old_flags
;
733 bfd_set_error (bfd_error_bad_value
);
737 return _bfd_sparc_elf_merge_private_bfd_data (ibfd
, info
);
740 /* MARCO: Set the correct entry size for the .stab section. */
743 elf64_sparc_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
744 Elf_Internal_Shdr
*hdr ATTRIBUTE_UNUSED
,
749 name
= bfd_section_name (sec
);
751 if (strcmp (name
, ".stab") == 0)
753 /* Even in the 64bit case the stab entries are only 12 bytes long. */
754 elf_section_data (sec
)->this_hdr
.sh_entsize
= 12;
760 /* Print a STT_REGISTER symbol to file FILE. */
763 elf64_sparc_print_symbol_all (bfd
*abfd ATTRIBUTE_UNUSED
, void * filep
,
766 FILE *file
= (FILE *) filep
;
769 if (ELF_ST_TYPE (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_info
)
773 reg
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
774 type
= symbol
->flags
;
775 fprintf (file
, "REG_%c%c%11s%c%c R", "GOLI" [reg
/ 8], '0' + (reg
& 7), "",
777 ? (type
& BSF_GLOBAL
) ? '!' : 'l'
778 : (type
& BSF_GLOBAL
) ? 'g' : ' '),
779 (type
& BSF_WEAK
) ? 'w' : ' ');
780 if (symbol
->name
== NULL
|| symbol
->name
[0] == '\0')
786 /* Used to decide how to sort relocs in an optimal manner for the
787 dynamic linker, before writing them out. */
789 static enum elf_reloc_type_class
790 elf64_sparc_reloc_type_class (const struct bfd_link_info
*info
,
791 const asection
*rel_sec ATTRIBUTE_UNUSED
,
792 const Elf_Internal_Rela
*rela
)
794 bfd
*abfd
= info
->output_bfd
;
795 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
796 struct _bfd_sparc_elf_link_hash_table
*htab
797 = _bfd_sparc_elf_hash_table (info
);
798 BFD_ASSERT (htab
!= NULL
);
800 if (htab
->elf
.dynsym
!= NULL
801 && htab
->elf
.dynsym
->contents
!= NULL
)
803 /* Check relocation against STT_GNU_IFUNC symbol if there are
805 unsigned long r_symndx
= htab
->r_symndx (rela
->r_info
);
806 if (r_symndx
!= STN_UNDEF
)
808 Elf_Internal_Sym sym
;
809 if (!bed
->s
->swap_symbol_in (abfd
,
810 (htab
->elf
.dynsym
->contents
811 + r_symndx
* bed
->s
->sizeof_sym
),
815 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
816 return reloc_class_ifunc
;
820 switch ((int) ELF64_R_TYPE (rela
->r_info
))
822 case R_SPARC_IRELATIVE
:
823 return reloc_class_ifunc
;
824 case R_SPARC_RELATIVE
:
825 return reloc_class_relative
;
826 case R_SPARC_JMP_SLOT
:
827 return reloc_class_plt
;
829 return reloc_class_copy
;
831 return reloc_class_normal
;
835 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
836 standard ELF, because R_SPARC_OLO10 has secondary addend in
837 ELF64_R_TYPE_DATA field. This structure is used to redirect the
838 relocation handling routines. */
840 const struct elf_size_info elf64_sparc_size_info
=
842 sizeof (Elf64_External_Ehdr
),
843 sizeof (Elf64_External_Phdr
),
844 sizeof (Elf64_External_Shdr
),
845 sizeof (Elf64_External_Rel
),
846 sizeof (Elf64_External_Rela
),
847 sizeof (Elf64_External_Sym
),
848 sizeof (Elf64_External_Dyn
),
849 sizeof (Elf_External_Note
),
850 4, /* hash-table entry size. */
851 /* Internal relocations per external relocations.
852 For link purposes we use just 1 internal per
853 1 external, for assembly and slurp symbol table
857 3, /* log_file_align. */
860 bfd_elf64_write_out_phdrs
,
861 bfd_elf64_write_shdrs_and_ehdr
,
862 bfd_elf64_checksum_contents
,
863 elf64_sparc_write_relocs
,
864 bfd_elf64_swap_symbol_in
,
865 bfd_elf64_swap_symbol_out
,
866 elf64_sparc_slurp_reloc_table
,
867 bfd_elf64_slurp_symbol_table
,
868 bfd_elf64_swap_dyn_in
,
869 bfd_elf64_swap_dyn_out
,
870 bfd_elf64_swap_reloc_in
,
871 bfd_elf64_swap_reloc_out
,
872 bfd_elf64_swap_reloca_in
,
873 bfd_elf64_swap_reloca_out
876 #define TARGET_BIG_SYM sparc_elf64_vec
877 #define TARGET_BIG_NAME "elf64-sparc"
878 #define ELF_ARCH bfd_arch_sparc
879 #define ELF_MAXPAGESIZE 0x100000
880 #define ELF_COMMONPAGESIZE 0x2000
882 /* This is the official ABI value. */
883 #define ELF_MACHINE_CODE EM_SPARCV9
885 /* This is the value that we used before the ABI was released. */
886 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
888 #define elf_backend_reloc_type_class \
889 elf64_sparc_reloc_type_class
890 #define bfd_elf64_get_reloc_upper_bound \
891 elf64_sparc_get_reloc_upper_bound
892 #define bfd_elf64_get_dynamic_reloc_upper_bound \
893 elf64_sparc_get_dynamic_reloc_upper_bound
894 #define bfd_elf64_canonicalize_reloc \
895 elf64_sparc_canonicalize_reloc
896 #define bfd_elf64_canonicalize_dynamic_reloc \
897 elf64_sparc_canonicalize_dynamic_reloc
898 #define bfd_elf64_set_reloc \
899 elf64_sparc_set_reloc
900 #define elf_backend_add_symbol_hook \
901 elf64_sparc_add_symbol_hook
902 #define elf_backend_get_symbol_type \
903 elf64_sparc_get_symbol_type
904 #define elf_backend_symbol_processing \
905 elf64_sparc_symbol_processing
906 #define elf_backend_print_symbol_all \
907 elf64_sparc_print_symbol_all
908 #define elf_backend_output_arch_syms \
909 elf64_sparc_output_arch_syms
910 #define bfd_elf64_bfd_merge_private_bfd_data \
911 elf64_sparc_merge_private_bfd_data
912 #define elf_backend_fake_sections \
913 elf64_sparc_fake_sections
914 #define elf_backend_size_info \
915 elf64_sparc_size_info
917 #define elf_backend_plt_sym_val \
918 _bfd_sparc_elf_plt_sym_val
919 #define bfd_elf64_bfd_link_hash_table_create \
920 _bfd_sparc_elf_link_hash_table_create
921 #define elf_info_to_howto \
922 _bfd_sparc_elf_info_to_howto
923 #define elf_backend_copy_indirect_symbol \
924 _bfd_sparc_elf_copy_indirect_symbol
925 #define bfd_elf64_bfd_reloc_type_lookup \
926 _bfd_sparc_elf_reloc_type_lookup
927 #define bfd_elf64_bfd_reloc_name_lookup \
928 _bfd_sparc_elf_reloc_name_lookup
929 #define bfd_elf64_bfd_relax_section \
930 _bfd_sparc_elf_relax_section
931 #define bfd_elf64_new_section_hook \
932 _bfd_sparc_elf_new_section_hook
934 #define elf_backend_create_dynamic_sections \
935 _bfd_sparc_elf_create_dynamic_sections
936 #define elf_backend_relocs_compatible \
937 _bfd_elf_relocs_compatible
938 #define elf_backend_check_relocs \
939 _bfd_sparc_elf_check_relocs
940 #define elf_backend_adjust_dynamic_symbol \
941 _bfd_sparc_elf_adjust_dynamic_symbol
942 #define elf_backend_omit_section_dynsym \
943 _bfd_sparc_elf_omit_section_dynsym
944 #define elf_backend_size_dynamic_sections \
945 _bfd_sparc_elf_size_dynamic_sections
946 #define elf_backend_relocate_section \
947 _bfd_sparc_elf_relocate_section
948 #define elf_backend_finish_dynamic_symbol \
949 _bfd_sparc_elf_finish_dynamic_symbol
950 #define elf_backend_finish_dynamic_sections \
951 _bfd_sparc_elf_finish_dynamic_sections
952 #define elf_backend_fixup_symbol \
953 _bfd_sparc_elf_fixup_symbol
955 #define bfd_elf64_mkobject \
956 _bfd_sparc_elf_mkobject
957 #define elf_backend_object_p \
958 _bfd_sparc_elf_object_p
959 #define elf_backend_gc_mark_hook \
960 _bfd_sparc_elf_gc_mark_hook
961 #define elf_backend_init_index_section \
962 _bfd_elf_init_1_index_section
964 #define elf_backend_can_gc_sections 1
965 #define elf_backend_can_refcount 1
966 #define elf_backend_want_got_plt 0
967 #define elf_backend_plt_readonly 0
968 #define elf_backend_want_plt_sym 1
969 #define elf_backend_got_header_size 8
970 #define elf_backend_want_dynrelro 1
971 #define elf_backend_rela_normal 1
973 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
974 #define elf_backend_plt_alignment 8
976 #include "elf64-target.h"
978 /* FreeBSD support */
979 #undef TARGET_BIG_SYM
980 #define TARGET_BIG_SYM sparc_elf64_fbsd_vec
981 #undef TARGET_BIG_NAME
982 #define TARGET_BIG_NAME "elf64-sparc-freebsd"
984 #define ELF_OSABI ELFOSABI_FREEBSD
987 #define elf64_bed elf64_sparc_fbsd_bed
989 #include "elf64-target.h"
993 #undef TARGET_BIG_SYM
994 #define TARGET_BIG_SYM sparc_elf64_sol2_vec
995 #undef TARGET_BIG_NAME
996 #define TARGET_BIG_NAME "elf64-sparc-sol2"
998 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
999 objects won't be recognized. */
1003 #define elf64_bed elf64_sparc_sol2_bed
1005 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
1007 #undef elf_backend_static_tls_alignment
1008 #define elf_backend_static_tls_alignment 16
1010 #include "elf64-target.h"