X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Felf32-sparc.c;h=1bfd40e9ae583792d10c4e6542383ccd5caf4998;hb=13835d88dc51497b9bd68dc1f394ca0de099a380;hp=213d20a13822d8f45b1d01d2aac9288e18223cb9;hpb=6f2750feaf2827ef8a1a0a5b2f90c1e9a6cabbd1;p=binutils-gdb.git diff --git a/bfd/elf32-sparc.c b/bfd/elf32-sparc.c index 213d20a1382..1bfd40e9ae5 100644 --- a/bfd/elf32-sparc.c +++ b/bfd/elf32-sparc.c @@ -1,5 +1,5 @@ /* SPARC-specific support for 32-bit ELF - Copyright (C) 1993-2016 Free Software Foundation, Inc. + Copyright (C) 1993-2022 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -30,13 +30,13 @@ /* Support for core dump NOTE sections. */ -static bfd_boolean +static bool elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) { switch (note->descsz) { default: - return FALSE; + return false; case 260: /* Solaris prpsinfo_t. */ elf_tdata (abfd)->core->program @@ -53,7 +53,7 @@ elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) break; } - return TRUE; + return true; } /* Functions for dealing with the e_flags field. @@ -66,26 +66,27 @@ elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) /* Merge backend specific data from an object file to the output object file when linking. */ -static bfd_boolean -elf32_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd) +static bool +elf32_sparc_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) { - bfd_boolean error; + bfd *obfd = info->output_bfd; + bool error; unsigned long ibfd_mach; /* FIXME: This should not be static. */ static unsigned long previous_ibfd_e_flags = (unsigned long) -1; if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour || bfd_get_flavour (obfd) != bfd_target_elf_flavour) - return TRUE; + return true; - error = FALSE; + error = false; ibfd_mach = bfd_get_mach (ibfd); if (bfd_mach_sparc_64bit_p (ibfd_mach)) { - error = TRUE; - (*_bfd_error_handler) - (_("%B: compiled for a 64 bit system and target is 32 bit"), ibfd); + error = true; + _bfd_error_handler + (_("%pB: compiled for a 64 bit system and target is 32 bit"), ibfd); } else if ((ibfd->flags & DYNAMIC) == 0) { @@ -97,66 +98,113 @@ elf32_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd) != previous_ibfd_e_flags) && previous_ibfd_e_flags != (unsigned long) -1) { - (*_bfd_error_handler) - (_("%B: linking little endian files with big endian files"), ibfd); - error = TRUE; + _bfd_error_handler + (_("%pB: linking little endian files with big endian files"), ibfd); + error = true; } previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA; if (error) { bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } - return _bfd_sparc_elf_merge_private_bfd_data (ibfd, obfd); + return _bfd_sparc_elf_merge_private_bfd_data (ibfd, info); } /* The final processing done just before writing out the object file. We need to set the e_machine field appropriately. */ static void -elf32_sparc_final_write_processing (bfd *abfd, - bfd_boolean linker ATTRIBUTE_UNUSED) +sparc_final_write_processing (bfd *abfd) { switch (bfd_get_mach (abfd)) { - case bfd_mach_sparc : - case bfd_mach_sparc_sparclet : - case bfd_mach_sparc_sparclite : + case bfd_mach_sparc: + case bfd_mach_sparc_sparclet: + case bfd_mach_sparc_sparclite: break; /* nothing to do */ - case bfd_mach_sparc_v8plus : + case bfd_mach_sparc_v8plus: elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS; break; - case bfd_mach_sparc_v8plusa : + case bfd_mach_sparc_v8plusa: elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1; break; - case bfd_mach_sparc_v8plusb : + case bfd_mach_sparc_v8plusb: + case bfd_mach_sparc_v8plusc: + case bfd_mach_sparc_v8plusd: + case bfd_mach_sparc_v8pluse: + case bfd_mach_sparc_v8plusv: + case bfd_mach_sparc_v8plusm: + case bfd_mach_sparc_v8plusm8: elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3; break; - case bfd_mach_sparc_sparclite_le : + case bfd_mach_sparc_sparclite_le: elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA; break; - default : - abort (); + case 0: /* A non-sparc architecture - ignore. */ + break; + default: + _bfd_error_handler + (_("%pB: unhandled sparc machine value '%lu' detected during write processing"), + abfd, (long) bfd_get_mach (abfd)); break; } } +static bool +elf32_sparc_final_write_processing (bfd *abfd) +{ + sparc_final_write_processing (abfd); + return _bfd_elf_final_write_processing (abfd); +} + +/* Used to decide how to sort relocs in an optimal manner for the + dynamic linker, before writing them out. */ + static enum elf_reloc_type_class -elf32_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, +elf32_sparc_reloc_type_class (const struct bfd_link_info *info, const asection *rel_sec ATTRIBUTE_UNUSED, const Elf_Internal_Rela *rela) { + bfd *abfd = info->output_bfd; + const struct elf_backend_data *bed = get_elf_backend_data (abfd); + struct _bfd_sparc_elf_link_hash_table *htab + = _bfd_sparc_elf_hash_table (info); + BFD_ASSERT (htab != NULL); + + if (htab->elf.dynsym != NULL + && htab->elf.dynsym->contents != NULL) + { + /* Check relocation against STT_GNU_IFUNC symbol if there are + dynamic symbols. */ + unsigned long r_symndx = htab->r_symndx (rela->r_info); + if (r_symndx != STN_UNDEF) + { + Elf_Internal_Sym sym; + if (!bed->s->swap_symbol_in (abfd, + (htab->elf.dynsym->contents + + r_symndx * bed->s->sizeof_sym), + 0, &sym)) + abort (); + + if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC) + return reloc_class_ifunc; + } + } + switch ((int) ELF32_R_TYPE (rela->r_info)) { + case R_SPARC_IRELATIVE: + return reloc_class_ifunc; case R_SPARC_RELATIVE: return reloc_class_relative; case R_SPARC_JMP_SLOT: @@ -168,26 +216,6 @@ elf32_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, } } -/* Hook called by the linker routine which adds symbols from an object - file. */ - -static bfd_boolean -elf32_sparc_add_symbol_hook (bfd * abfd, - struct bfd_link_info * info, - Elf_Internal_Sym * sym, - const char ** namep ATTRIBUTE_UNUSED, - flagword * flagsp ATTRIBUTE_UNUSED, - asection ** secp ATTRIBUTE_UNUSED, - bfd_vma * valp ATTRIBUTE_UNUSED) -{ - if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC - || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE) - && (abfd->flags & DYNAMIC) == 0 - && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour) - elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any; - return TRUE; -} - #define TARGET_BIG_SYM sparc_elf32_vec #define TARGET_BIG_NAME "elf32-sparc" #define ELF_ARCH bfd_arch_sparc @@ -230,9 +258,9 @@ elf32_sparc_add_symbol_hook (bfd * abfd, #define bfd_elf32_mkobject _bfd_sparc_elf_mkobject #define elf_backend_object_p _bfd_sparc_elf_object_p #define elf_backend_gc_mark_hook _bfd_sparc_elf_gc_mark_hook -#define elf_backend_gc_sweep_hook _bfd_sparc_elf_gc_sweep_hook #define elf_backend_plt_sym_val _bfd_sparc_elf_plt_sym_val #define elf_backend_init_index_section _bfd_elf_init_1_index_section +#define elf_backend_fixup_symbol _bfd_sparc_elf_fixup_symbol #define elf_backend_can_gc_sections 1 #define elf_backend_can_refcount 1 @@ -240,9 +268,10 @@ elf32_sparc_add_symbol_hook (bfd * abfd, #define elf_backend_plt_readonly 0 #define elf_backend_want_plt_sym 1 #define elf_backend_got_header_size 4 +#define elf_backend_want_dynrelro 1 #define elf_backend_rela_normal 1 -#define elf_backend_add_symbol_hook elf32_sparc_add_symbol_hook +#define elf_backend_linux_prpsinfo32_ugid16 true #include "elf32-target.h" @@ -258,73 +287,74 @@ elf32_sparc_add_symbol_hook (bfd * abfd, /* The 32-bit static TLS arena size is rounded to the nearest 8-byte boundary. */ -#undef elf_backend_static_tls_alignment +#undef elf_backend_static_tls_alignment #define elf_backend_static_tls_alignment 8 -#include "elf32-target.h" - -/* A wrapper around _bfd_sparc_elf_link_hash_table_create that identifies - the target system as VxWorks. */ +#undef elf_backend_strtab_flags +#define elf_backend_strtab_flags SHF_STRINGS -static struct bfd_link_hash_table * -elf32_sparc_vxworks_link_hash_table_create (bfd *abfd) +static bool +elf32_sparc_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED, + bfd *obfd ATTRIBUTE_UNUSED, + const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED, + Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED) { - struct bfd_link_hash_table *ret; + /* PR 19938: FIXME: Need to add code for setting the sh_info + and sh_link fields of Solaris specific section types. */ + return false; +} - ret = _bfd_sparc_elf_link_hash_table_create (abfd); - if (ret) - { - struct _bfd_sparc_elf_link_hash_table *htab; +#undef elf_backend_copy_special_section_fields +#define elf_backend_copy_special_section_fields elf32_sparc_copy_solaris_special_section_fields - htab = (struct _bfd_sparc_elf_link_hash_table *) ret; - htab->is_vxworks = 1; - } - return ret; -} +#include "elf32-target.h" /* A final_write_processing hook that does both the SPARC- and VxWorks- specific handling. */ -static void -elf32_sparc_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker) +static bool +elf32_sparc_vxworks_final_write_processing (bfd *abfd) { - elf32_sparc_final_write_processing (abfd, linker); - elf_vxworks_final_write_processing (abfd, linker); + sparc_final_write_processing (abfd); + return elf_vxworks_final_write_processing (abfd); } -#undef TARGET_BIG_SYM +#undef TARGET_BIG_SYM #define TARGET_BIG_SYM sparc_elf32_vxworks_vec -#undef TARGET_BIG_NAME +#undef TARGET_BIG_NAME #define TARGET_BIG_NAME "elf32-sparc-vxworks" -#undef ELF_MINPAGESIZE +#undef ELF_MINPAGESIZE #define ELF_MINPAGESIZE 0x1000 -#undef bfd_elf32_bfd_link_hash_table_create -#define bfd_elf32_bfd_link_hash_table_create \ - elf32_sparc_vxworks_link_hash_table_create +#undef ELF_TARGET_OS +#define ELF_TARGET_OS is_vxworks -#undef elf_backend_want_got_plt +#undef elf_backend_want_got_plt #define elf_backend_want_got_plt 1 -#undef elf_backend_plt_readonly +#undef elf_backend_plt_readonly #define elf_backend_plt_readonly 1 -#undef elf_backend_got_header_size +#undef elf_backend_got_header_size #define elf_backend_got_header_size 12 -#undef elf_backend_add_symbol_hook +#undef elf_backend_dtrel_excludes_plt +#define elf_backend_dtrel_excludes_plt 1 +#undef elf_backend_add_symbol_hook #define elf_backend_add_symbol_hook \ elf_vxworks_add_symbol_hook -#undef elf_backend_link_output_symbol_hook +#undef elf_backend_link_output_symbol_hook #define elf_backend_link_output_symbol_hook \ elf_vxworks_link_output_symbol_hook -#undef elf_backend_emit_relocs +#undef elf_backend_emit_relocs #define elf_backend_emit_relocs \ elf_vxworks_emit_relocs -#undef elf_backend_final_write_processing +#undef elf_backend_final_write_processing #define elf_backend_final_write_processing \ elf32_sparc_vxworks_final_write_processing -#undef elf_backend_static_tls_alignment +#undef elf_backend_static_tls_alignment +#undef elf_backend_strtab_flags +#undef elf_backend_copy_special_section_fields -#undef elf32_bed +#undef elf32_bed #define elf32_bed sparc_elf_vxworks_bed #include "elf32-target.h"