{
if (elf_local_got_ents (abfd) == NULL)
{
- bfd_size_type amt = (elf_tdata (abfd)->symtab_hdr.sh_info
+ bfd_size_type amt = (elf_symtab_hdr (abfd).sh_info
* sizeof (*elf_local_got_ents (abfd)));
elf_local_got_ents (abfd) = bfd_zmalloc (amt);
if (elf_local_got_ents (abfd) == NULL)
struct elf_link_hash_entry **sym_hashes;
Elf_Internal_Rela *rel, *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
}
/* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
{
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
/* Examine all the local symbols. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
{
if (isym->st_shndx == sec_shndx
relocatable,
symbols);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
bfd_byte *orig_data = data;
if (data == NULL)
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
sym_hashes = elf_sym_hashes (abfd);
Elf_Internal_Rela *rel, *relend;
Elf_Internal_Rela * trel;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
region are moved to the address of the start of the region, which
actually means that they will address the byte beyond the end of
the region once the deletion has been completed. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
{
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
/* Examine all the symbols. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
if (isym->st_shndx == sec_shndx
&& isym->st_value == addr)
input_bfd = input_bfd->link.next)
{
/* We're going to need all the symbols for each bfd. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info != 0)
{
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
input_bfd = input_bfd->link.next)
{
/* We're going to need all the local symbols for each bfd. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info != 0)
{
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
relocatable,
symbols);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
bfd_byte *orig_data = data;
if (data == NULL)
return NULL;
/* Go read the symbol. */
- hdr = &elf_tdata (abfd)->symtab_hdr;
+ hdr = &elf_symtab_hdr (abfd);
if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
&isym, esym, &eshndx) == NULL)
return NULL;
unsigned char esym[sizeof (Elf64_External_Sym)];
Elf_External_Sym_Shndx eshndx;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
&cache->sym[ent], esym, &eshndx) == NULL)
return NULL;
{
Elf_Internal_Shdr *symtab_hdr;
- symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (igroup->owner);
extsymoff = symtab_hdr->sh_info;
}
h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
bed = get_elf_backend_data (abfd);
symcount = bfd_get_symcount (abfd);
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
symtab_hdr->sh_type = SHT_SYMTAB;
symtab_hdr->sh_entsize = bed->s->sizeof_sym;
symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
{
bfd_size_type symcount;
long symtab_size;
- Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *hdr = &elf_symtab_hdr (abfd);
symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
if (symcount > LONG_MAX / sizeof (asymbol *))
Elf_Internal_Rela * relend;
struct elf_link_hash_table * htab = elf_hash_table (info);
- symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr);
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = wrel = relocs;
htab->dynobj = abfd;
dynobj = (elf_hash_table (info))->dynobj;
- symtab_hdr = &((elf_tdata (abfd))->symtab_hdr);
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
structure, this interferes with the work of memory checkers looking
for buffer overruns. So allocate each array individually. */
- num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
+ num_syms = elf_symtab_hdr (abfd).sh_info;
elf_local_got_refcounts (abfd) = bfd_zalloc
(abfd, num_syms * sizeof (* elf_local_got_refcounts (abfd)));
if (!elf32_arm_allocate_local_sym_info (abfd))
return NULL;
- BFD_ASSERT (r_symndx < elf_tdata (abfd)->symtab_hdr.sh_info);
+ BFD_ASSERT (r_symndx < elf_symtab_hdr (abfd).sh_info);
BFD_ASSERT (r_symndx < elf32_arm_num_entries (abfd));
ptr = &elf32_arm_local_iplt (abfd)[r_symndx];
if (*ptr == NULL)
struct elf32_arm_stub_hash_entry *stub_entry;
bool is_v8m, new_stub, cmse_invalid, ret = true;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_count = symtab_hdr->sh_size / bed->s->sizeof_sym;
ext_start = symtab_hdr->sh_info;
is_v8m = (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V8M_BASE
num_a8_relocs = 0;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
sym_hashes = elf_sym_hashes (sub);
bed = get_elf_backend_data (sub);
- symtab_hdr = &elf_tdata (sub)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (sub);
sym_count = symtab_hdr->sh_size / bed->s->sizeof_sym;
ext_start = symtab_hdr->sh_info;
if (htab == NULL)
return false;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
bool did_shrink = false;
bool did_pad = false;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
contents = elf_section_data (sec)->this_hdr.contents;
relax_info = get_avr_relax_info (sec);
Elf_Internal_Sym *isymbuf;
size_t locsymcount;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
locsymcount = symtab_hdr->sh_info;
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
static asection *
get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
asection *target_sec = NULL;
if (r_symndx < symtab_hdr->sh_info)
{
static bfd_vma
get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
bfd_vma offset = 0;
if (r_symndx < symtab_hdr->sh_info)
if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
link_order, data,
relocatable,
symbols);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
bfd_byte *orig_data = data;
if (data == NULL)
Elf_Internal_Shdr *symtab_hdr;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
Elf_Internal_Sym *local_syms;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
return true;
dynobj = elf_hash_table (info)->dynobj;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
local_got_refcounts = elf_local_got_refcounts (abfd);
Elf_Internal_Rela *relend;
dynobj = elf_hash_table (info)->dynobj;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
local_got_offsets = elf_local_got_offsets (input_bfd);
check_segment[2];
int silence_segment_error = !bfd_link_pic (info);
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
|| sec->reloc_count == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel = elf_section_data (sec)->relocs;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
dynobj = elf_hash_table (info)->dynobj;
if (datasec->reloc_count == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
dynobj = elf_hash_table (info)->dynobj;
irel->r_offset -= count;
/* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
{
struct elf_link_hash_entry **sym_hashes;
Elf_Internal_Rela *rel, *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
relocatable,
symbols);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
bfd_byte *orig_data = data;
if (data == NULL)
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
if (datasec->reloc_count == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
dynobj = htab->root.dynobj;
local_got_offsets = elf_local_got_offsets (input_bfd);
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
return false;
dynobj = elf_hash_table (info)->dynobj;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
local_got_refcounts = elf_local_got_refcounts (abfd);
entries. */
if (h == NULL)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (ibfd);
BFD_ASSERT (local_got_refcounts != NULL);
}
/* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
{
relocatable,
symbols);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
bfd_byte *orig_data = data;
if (data == NULL)
struct elf_link_hash_entry **sym_hashes;
Elf_Internal_Rela *rel, *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
if (!local_got_refcounts)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got_refcounts + locsymcount;
local_tls_type = csky_elf_local_got_tls_type (ibfd);
if (htab == NULL)
return false;
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
Elf_Internal_Sym *local_syms = NULL;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
Elf_Internal_Rela *rel, *relend;
const char *name;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
link_info->keep_memory);
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
int silence_segment_error = !bfd_link_pic (info);
unsigned long insn;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
|| sec->reloc_count == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel = elf_section_data (sec)->relocs;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
dynobj = elf_hash_table (info)->dynobj;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
r_type = ELF32_R_TYPE (irel->r_info);
howto = &ft32_elf_howto_table [r_type];
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get the value of the symbol referred to by the reloc. */
if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
unsigned int symcount;
Elf_Internal_Sym *isymbuf = NULL;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
contents = elf_section_data (sec)->this_hdr.contents;
}
/* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
if (isym)
{
struct elf_link_hash_entry **start_hashes;
unsigned int symcount;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Now we check for relocations pointing to ret. */
for (isec = abfd->sections; isec; isec = isec->next)
elf_section_data (sec)->this_hdr.contents = contents;
}
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Read this BFD's local symbols if we haven't done so already. */
if (isymbuf == NULL && symtab_hdr->sh_info != 0)
struct elf_link_hash_entry **sym_hashes;
Elf_Internal_Rela *rel, *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
}
/* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
isymend = isym + symtab_hdr->sh_info;
for (; isym < isymend; isym++)
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
/* Examine all the symbols. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
isymend = isym + symtab_hdr->sh_info;
for (; isym < isymend; isym++)
relocatable,
symbols);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
bfd_byte *orig_data = data;
if (data == NULL)
bfd_hash_lookup ((table), (string), (create), (copy)))
#define hppa_elf_local_got_tls_type(abfd) \
- ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
+ ((char *)(elf_local_got_offsets (abfd) + (elf_symtab_hdr (abfd).sh_info * 2)))
#define hh_name(hh) \
(hh ? hh->eh.root.root.string : "<undef>")
static bfd_signed_vma *
hppa32_elf_local_refcounts (bfd *abfd)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
bfd_signed_vma *local_refcounts;
local_refcounts = elf_local_got_refcounts (abfd);
htab = hppa_link_hash_table (info);
if (htab == NULL)
return false;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
eh_syms = elf_sym_hashes (abfd);
sreloc = NULL;
if (!local_got)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
local_tls_type = hppa_elf_local_got_tls_type (ibfd);
Elf_Internal_Shdr *symtab_hdr;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
Elf_Internal_Sym *local_syms;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
Elf_Internal_Rela *rela;
Elf_Internal_Rela *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
htab = hppa_link_hash_table (info);
if (htab == NULL)
unsigned int symcount;
asection *stab;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
link_info->keep_memory);
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
Elf_Internal_Rela * rel;
Elf_Internal_Rela * relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
Elf_Internal_Sym *local_syms,
asection **local_sections)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
Elf_Internal_Rela *rel, *relend;
struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
sgot = htab->root.sgot;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
htab = lm32_elf_hash_table (info);
if (!local_got)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
s = htab->root.sgot;
end = internal_relocs + s->reloc_count;
while (internal_relocs < end)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
- struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
+ Elf_Internal_Shdr *symtab_hdr;
+ struct elf_link_hash_entry **sym_hashes;
unsigned long r_symndx;
struct elf_link_hash_entry *h;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
sym_hashes = elf_sym_hashes (ibfd);
r_symndx = ELF32_R_SYM (internal_relocs->r_info);
h = NULL;
Elf_Internal_Rela * relend;
asection *splt;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
local_plt_offsets = elf_local_got_offsets (abfd);
splt = NULL;
free_external = 1;
}
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
if (free_internal)
isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
if (! local_plt_offsets)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
if (symtab_hdr->sh_info != 0)
{
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
{
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
- unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
+ unsigned int nlocals = elf_symtab_hdr (ibfd).sh_info;
unsigned int idx;
if (! local_plt_offsets)
}
/* Adjust the local symbols defined in this section. */
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
isym = intsyms;
isymend = isym + symtab_hdr->sh_info;
if (!local_got)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
s = htab->sgot;
Elf_Internal_Sym *local_syms,
asection **local_sections)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
Elf_Internal_Rela *rel, *relend;
/* Assume success. */
return true;
sreloc = NULL;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
htab = m32r_elf_hash_table (info);
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
struct elf_link_hash_entry **end_hashes;
unsigned int symcount;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
Elf_Internal_Shdr *symtab_hdr;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
sym_hashes = elf_sym_hashes (input_bfd);
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
struct m68hc11_elf_link_hash_table *htab;
unsigned long e_flags;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
e_flags = elf_elfheader (input_bfd)->e_flags;
return true;
dynobj = elf_hash_table (info)->dynobj;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
sreloc = NULL;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
sgot = NULL;
if (datasec->reloc_count == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
Elf_Internal_Sym * local_syms,
asection ** local_sections)
{
- Elf_Internal_Shdr * symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ Elf_Internal_Shdr * symtab_hdr = &elf_symtab_hdr (input_bfd);
struct elf_link_hash_entry ** sym_hashes = elf_sym_hashes (input_bfd);
Elf_Internal_Rela * rel = relocs;
Elf_Internal_Rela * relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
Elf_Internal_Rela * rel;
Elf_Internal_Rela * relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
bfd_hash_lookup ((table), (string), (create), (copy)))
#define metag_elf_local_got_tls_type(abfd) \
- ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info)))
+ ((char *)(elf_local_got_offsets (abfd) + elf_symtab_hdr (abfd).sh_info))
/* Assorted hash table functions. */
Elf_Internal_Rela *relend;
asection *sreloc;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
eh_syms = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
htab = metag_link_hash_table (info);
dynobj = htab->etab.dynobj;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
eh_syms = elf_sym_hashes (abfd);
sreloc = NULL;
if (!local_got)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
local_tls_type = metag_elf_local_got_tls_type (ibfd);
Elf_Internal_Shdr *symtab_hdr;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
Elf_Internal_Sym *local_syms;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
asection **local_sections)
{
struct elf32_mb_link_hash_table *htab;
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
Elf_Internal_Rela *rel, *relend;
int endian = (bfd_little_endian (output_bfd)) ? 0 : 2;
sec->size = sec->rawsize;
/* Get symbols for this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
symcount = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
if (isymbuf == NULL)
if (htab == NULL)
return false;
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
if (!local_got)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
lgot_masks = (unsigned char *) end_local_got;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
/* Examine all the local symbols. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
if (isym->st_shndx == sec_shndx && isym->st_value == addr)
return true;
return true;
irelend = irel + sec->reloc_count;
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (;irel < irelend; irel++)
sec->size -= count;
/* Adjust all the relocs. */
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (; irel < irelend; irel++)
{
msp430_elf_relax_adjust_locals (abfd,p,addr,count,sec_shndx,toaddr);
/* Adjust the local symbols defined in this section. */
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
{
sec_shndx, sec_end);
/* Adjust the global symbols affected by the move. */
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
if (isym->st_shndx == sec_shndx
printf ("Relaxing %s (%p), output_offset: 0x%lx sec size: 0x%lx\n",
sec->name, sec, (long) sec->output_offset, (long) sec->size);
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs =
Elf_Internal_Rela * rel;
Elf_Internal_Rela * relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
if (!local_got)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
sgot = elf_hash_table (info)->sgot;
int eliminate_gc_relocs;
bfd_vma fpbase_addr;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
ehtab = elf_hash_table (info);
htab = nds32_elf_hash_table (info);
bfd_size_type size;
char *data;
- num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
+ num_syms = elf_symtab_hdr (abfd).sh_info;
/* This space is for got_refcounts, got_tls_type, tlsdesc_gotent, and
gp_offset. The details can refer to struct elf_nds32_obj_tdata. */
size = num_syms * (sizeof (bfd_signed_vma) + sizeof (char)
return true;
}
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
ehtab = elf_hash_table (info);
else
return false;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
if (!nds32_get_local_syms (abfd, sec, &isymbuf))
return false;
/* The deletion must stop at the next ALIGN reloc for an alignment
power larger than the number of bytes we are deleting. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
if (!nds32_get_local_syms (abfd, sec, &isym))
return false;
Elf_Internal_Sym **isymbuf_p)
{
Elf_Internal_Shdr *symtab_hdr;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Read this BFD's local symbols if we haven't done so already. */
if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
relax_range_measurement (abfd, link_info);
}
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Relocations MUST be kept in memory, because relaxation adjust them. */
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
true /* keep_memory */);
To suppress the conversion, we simply NOT to apply
R_NDS32_INSN16_FP7U2_FLAG flag. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
contents = NULL;
if (!nds32_get_section_contents (abfd, sec, &contents, true)
R_NDS32_17IFC_PCREL_RELA
R_NDS32_10IFCU_PCREL_RELA. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
nds32_get_section_contents (abfd, sec, &contents, true);
for (irel = internal_relocs; irel < irelend; irel++)
relax_group_list_t chain = { .id = -1, .next = NULL, .next_sibling = NULL };
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (inbfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (inbfd);
struct elf_link_hash_entry **sym_hashes;
sym_hashes = elf_sym_hashes (inbfd);
got_base = sgot->output_section->vma + sgot->output_offset;
}
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
htab = or1k_elf_hash_table (info);
if (!local_got)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
s = htab->root.sgot;
Elf_Internal_Rela *relend;
bool is_rel_reloc;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
struct elf_link_hash_entry **end_hashes;
unsigned int symcount;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
contents = elf_section_data (sec)->this_hdr.contents;
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
asection *splt;
bool ret;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
local_plt_offsets = elf_local_got_offsets (abfd);
dynobj = elf_hash_table(info)->dynobj;
if (! local_plt_offsets)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
if (symtab_hdr->sh_info != 0)
{
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
{
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
- unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
+ unsigned int nlocals = elf_symtab_hdr (ibfd).sh_info;
unsigned int idx;
if (! local_plt_offsets)
}
/* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
isymend = isym + symtab_hdr->sh_info;
else
pid_mode = false;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
for (rel = relocs; rel < relend; rel ++)
}
/* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
isymend = isym + symtab_hdr->sh_info;
char * st_other_str;
char * st_shndx_str;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
if (!internal_syms)
isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
size_t extsymoff;
r_symndx = ELF32_R_SYM (relocation->r_info);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
if (r_symndx < extsymoff)
return false;
}
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
rel = relocs;
relend = relocs + input_section->reloc_count;
return true;
dynobj = elf_hash_table (info)->dynobj;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
size_t extsymoff;
r_symndx = ELF32_R_SYM (relocation->r_info);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
if (r_symndx < extsymoff)
return false;
}
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
rel = relocs;
relend = relocs + input_section->reloc_count;
return true;
dynobj = elf_hash_table (info)->dynobj;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
unsigned long r_symndx,
bfd *ibfd)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
if (r_symndx >= symtab_hdr->sh_info)
{
else
{
Elf_Internal_Shdr *symtab_hdr;
- symtab_hdr = &elf_tdata (input_section->owner)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_section->owner);
sym_name = bfd_elf_sym_name (input_section->owner,
symtab_hdr,
sym,
{
if (elf_local_got_ents (ibfd) == NULL)
{
- bfd_size_type amt = (elf_tdata (ibfd)->symtab_hdr.sh_info
+ bfd_size_type amt = (elf_symtab_hdr (ibfd).sh_info
* sizeof (*elf_local_got_ents (ibfd)));
elf_local_got_ents (ibfd) = bfd_zmalloc (amt);
if (elf_local_got_ents (ibfd) == NULL)
continue;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
if (symtab_hdr->sh_info == 0)
continue;
return name;
}
ibfd = sec->owner;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
return bfd_elf_sym_name (ibfd, symtab_hdr, fun->u.sym, sec);
}
if (internal_relocs == NULL)
return false;
- symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (sec->owner);
psyms = &symtab_hdr->contents;
irela = internal_relocs;
irelaend = irela + sec->reloc_count;
continue;
/* Read all the symbols. */
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
if (symcount == 0)
{
psecs = sec_arr[bfd_idx];
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
syms = (Elf_Internal_Sym *) symtab_hdr->contents;
gaps = false;
&& maybe_needs_stubs (input_section));
iovl = overlay_index (input_section);
ea = bfd_get_section_by_name (output_bfd, "._ea");
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = (struct elf_link_hash_entry **) (elf_sym_hashes (input_bfd));
rel = relocs;
return true;
htab = tilepro_elf_hash_table (info);
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
sreloc = NULL;
sec, abfd);
#endif
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
/* Reset the list of remembered HI16S relocs to empty. */
struct elf_link_hash_entry *sym_hash;
Elf_External_Sym_Shndx *shndx;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
|| sec->reloc_count == 0)
return true;
- symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
internal_relocs = (_bfd_elf_link_read_relocs
(abfd, sec, NULL, NULL, link_info->keep_memory));
return true;
dynobj = elf_hash_table (info)->dynobj;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
sreloc = NULL;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
sgot = NULL;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
local_plt_offsets = elf_local_got_offsets (abfd);
dynobj = elf_hash_table(info)->dynobj;
if (! local_plt_offsets)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
if (symtab_hdr->sh_info != 0)
{
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
{
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
- unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
+ unsigned int nlocals = elf_symtab_hdr (ibfd).sh_info;
unsigned int idx;
if (! local_plt_offsets)
Elf_Internal_Rela * relend;
asection *splt;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
if (htab == NULL)
return false;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
rel_end = relocs + sec->reloc_count;
if (!local_got_refcounts)
continue;
- symtab_hdr = &elf_tdata (i)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (i);
cnt = symtab_hdr->sh_info;
for (j = 0; j < cnt; ++j)
if (htab == NULL)
return false;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
Elf_Internal_Sym *isymbuf;
size_t locsymcount;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
locsymcount = symtab_hdr->sh_info;
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
if (htab == NULL)
return;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
r_type = ELF32_R_TYPE (rel->r_info);
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isymbuf = retrieve_local_syms (abfd);
num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
static asection *
get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
asection *target_sec = NULL;
if (r_symndx < symtab_hdr->sh_info)
{
{
unsigned long indx;
struct elf_link_hash_entry *h;
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
if (r_symndx < symtab_hdr->sh_info)
return NULL;
static bfd_vma
get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
bfd_vma offset = 0;
if (r_symndx < symtab_hdr->sh_info)
struct elf_link_hash_entry **sym_hashes;
Elf_Internal_Rela *rel, *relend;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
bfd_size_type size;
Elf_Internal_Shdr *symtab_hdr;
- symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
size = symtab_hdr->sh_info;
size *= sizeof (struct alpha_elf_got_entry *);
for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
{
struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (bsub);
int i, n;
n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
if (local_got_entries)
{
- n = elf_tdata (bsub)->symtab_hdr.sh_info;
+ n = elf_symtab_hdr (bsub).sh_info;
for (i = 0; i < n; ++i)
{
struct alpha_elf_got_entry *ent;
/* Merge the global .got entries. */
hashes = alpha_elf_sym_hashes (bsub);
- symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (bsub);
n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
for (i = 0; i < n; ++i)
if (!local_got_entries)
continue;
- for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
+ for (k = 0, n = elf_symtab_hdr (j).sh_info; k < n; ++k)
for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
if (gotent->use_count > 0)
{
if (!local_got_entries)
continue;
- for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
+ for (k = 0, n = elf_symtab_hdr (j).sh_info; k < n; ++k)
for (gotent = local_got_entries[k];
gotent ; gotent = gotent->next)
if (gotent->use_count > 0)
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
static bfd_signed_vma *
hppa64_elf_local_refcounts (bfd *abfd)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
bfd_signed_vma *local_refcounts;
local_refcounts = elf_local_got_refcounts (abfd);
hppa_info = hppa_link_hash_table (info);
if (hppa_info == NULL)
return false;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* If necessary, build a new table holding section symbols indices
for this BFD. */
if (!start_local_dlt)
continue;
- symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (ibfd);
locsymcount = symtab_hdr->sh_info;
end_local_dlt = start_local_dlt + locsymcount;
if (hppa_info == NULL)
return bfd_reloc_notsupported;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
local_offsets = elf_local_got_offsets (input_bfd);
insn = bfd_get_32 (input_bfd, hit_data);
if (hppa_info == NULL)
return false;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
rel = relocs;
relend = relocs + input_section->reloc_count;
if (ia64_info == NULL)
return false;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Load the relocations for this section. */
internal_relocs = (_bfd_elf_link_read_relocs
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
ia64_info = elf64_ia64_hash_table (info);
if (ia64_info == NULL)
return false;
bool ret_val = true; /* for non-fatal errors */
bfd_vma gp_val;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
ia64_info = elf64_ia64_hash_table (info);
if (ia64_info == NULL)
return false;
This should be harmless and shouldn't happen in practice. */
}
- hdr = &elf_tdata (abfd)->symtab_hdr;
+ hdr = &elf_symtab_hdr (abfd);
symcount = hdr->sh_size / bed->s->sizeof_sym;
/* The sh_info field of the symtab header tells us where the
size_t pjsno = 0;
size = input_section->rawsize ? input_section->rawsize : input_section->size;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
relend = relocs + input_section->reloc_count;
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
/* First we sort the relocs so that any register relocs come before
&& mmix_elf_section_data (sec)->pjs.n_pushj_relocs == 0))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
if (bpodata != NULL)
{
if (! dynamic)
{
- hdr = &elf_tdata (abfd)->symtab_hdr;
+ hdr = &elf_symtab_hdr (abfd);
verhdr = NULL;
symcount = hdr->sh_size / ebd->s->sizeof_sym;
}
bfd *abfd = cookie->abfd;
if (elf_loc_shndx (abfd) == NULL)
{
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
Elf_Internal_Sym *locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
cookie->locsymcount, 0,
NULL, NULL, NULL);
return 0;
/* Go find the symbol, so that we can find it's name. */
- if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
+ if (!bfd_elf_get_elf_syms (input_bfd, &elf_symtab_hdr (input_bfd),
1, input_indx, &entry->isym, esym, &eshndx))
{
bfd_release (input_bfd, entry);
}
name = (bfd_elf_string_from_elf_section
- (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
+ (input_bfd, elf_symtab_hdr (input_bfd).sh_link,
entry->isym.st_name));
dynstr = elf_hash_table (info)->dynstr;
external_relocs_addr, abfd, true))
return false;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
bed = get_elf_backend_data (abfd);
/* Use the IR symbol table if the object has been claimed by
plugin. */
abfd = abfd->plugin_dummy_bfd;
- hdr = &elf_tdata (abfd)->symtab_hdr;
+ hdr = &elf_symtab_hdr (abfd);
}
else
{
}
if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
- hdr = &elf_tdata (abfd)->symtab_hdr;
+ hdr = &elf_symtab_hdr (abfd);
else
hdr = &elf_tdata (abfd)->dynsymtab_hdr;
}
look at .symtab for a dynamic object. */
if (! dynamic || elf_dynsymtab (abfd) == 0)
- hdr = &elf_tdata (abfd)->symtab_hdr;
+ hdr = &elf_symtab_hdr (abfd);
else
hdr = &elf_tdata (abfd)->dynsymtab_hdr;
bed1 = get_elf_backend_data (bfd1);
bed2 = get_elf_backend_data (bfd2);
- hdr1 = &elf_tdata (bfd1)->symtab_hdr;
+ hdr1 = &elf_symtab_hdr (bfd1);
symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
- hdr2 = &elf_tdata (bfd2)->symtab_hdr;
+ hdr2 = &elf_symtab_hdr (bfd2);
symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
if (symcount1 == 0 || symcount2 == 0)
Elf_Internal_Shdr *symtab_hdr;
size_t i;
- symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
for (i = 0; i < locsymcount; ++ i)
{
elfsym->dest_index));
}
- hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr;
+ hdr = &elf_symtab_hdr (flinfo->output_bfd);
pos = hdr->sh_offset + hdr->sh_size;
amt = bed->s->sizeof_sym * flinfo->output_bfd->symcount;
if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) == 0
/* We are interested in just local symbols, not all
symbols. */
if (elf_bad_symtab (sec->owner))
- sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
+ sym_count = (elf_symtab_hdr (sec->owner).sh_size
/ bed->s->sizeof_sym);
else
- sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
+ sym_count = elf_symtab_hdr (sec->owner).sh_info;
if (sym_count > max_sym_count)
max_sym_count = sym_count;
the .symtab section at the current file position, and write directly to it.
We build the .strtab section in memory. */
abfd->symcount = 0;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* sh_name is set in prep_headers. */
symtab_hdr->sh_type = SHT_SYMTAB;
/* sh_flags, sh_addr and sh_size all start off zero. */
elf_backend_data *bed;
bed = get_elf_backend_data (abfd);
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
cookie->abfd = abfd;
cookie->num_sym = symtab_hdr->sh_size / bed->s->sizeof_sym;
/* The sh_info field of the symtab header tells us where the
external symbols start. We don't care about the local symbols at
this point. */
- extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
+ extsymcount = elf_symtab_hdr (abfd).sh_size / bed->s->sizeof_sym;
if (!elf_bad_symtab (abfd))
- extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
+ extsymcount -= elf_symtab_hdr (abfd).sh_info;
sym_hashes = elf_sym_hashes (abfd);
sym_hashes_end = PTR_ADD (sym_hashes, extsymcount);
if (!local_got)
continue;
- symtab_hdr = &elf_tdata (i)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (i);
if (elf_bad_symtab (i))
locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
else
continue;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
if (ia64_info == NULL)
return false;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Load the relocations for this section. */
internal_relocs = (_bfd_elf_link_read_relocs
if (bfd_link_relocatable (info))
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
return false;
for (p = elf_sym_hashes (obj); *p != h; ++p)
continue;
- return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
+ return p - elf_sym_hashes (obj) + elf_symtab_hdr (obj).sh_info;
}
/* Allocate function descriptors. We can do these for every function
bool ret_val = true; /* for non-fatal errors */
bfd_vma gp_val;
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
return false;
continue;
/* We'll need the symbol table in a second. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (symtab_hdr->sh_info == 0)
continue;
bool with_relax_reloc)
{
struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
/* This is a global offset table entry for a local symbol. */
if (elf_local_got_refcounts (abfd) == NULL)
return true;
htab = loongarch_elf_hash_table (info);
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
if (htab->elf.dynobj == NULL)
unsigned int i, symcount;
bfd_vma toaddr = sec->size;
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
struct bfd_elf_section_data *data = elf_section_data (sec);
bfd_byte *contents = data->this_hdr.contents, *contents_end = NULL;
struct elf_link_hash_entry *h, long symndx)
{
struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
if (htab->elf.sgot == NULL)
{
return true;
htab = riscv_elf_hash_table (info);
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
if (htab->elf.dynobj == NULL)
{
unsigned int i, symcount;
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
- Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
struct bfd_elf_section_data *data = elf_section_data (sec);
bfd_byte *contents = data->this_hdr.contents;
size_t extsymoff;
r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
if (r_symndx < extsymoff)
/* Figure out whether or not the symbol is local, and get the offset
used in the array of hash table entries. */
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
local_p = mips_elf_local_relocation_p (input_bfd, relocation,
local_sections);
was_local_p = local_p;
BFD_ASSERT (htab != NULL);
dynobj = elf_hash_table (info)->dynobj;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
- symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (input_bfd);
if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
{
sec = local_sections[r_symndx];
BFD_ASSERT (count % 2 == 0);
/* Adjust the local symbols defined in this section. */
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
if (isym->st_shndx == sec_shndx && isym->st_value > addr)
|| (sec->flags & SEC_CODE) == 0)
return true;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
return true;
htab = tilegx_elf_hash_table (info);
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
sreloc = NULL;
is_x86_64 = bed->target_id == X86_64_ELF_DATA;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
local_got_offsets = elf_local_got_offsets (abfd);
projects / thirdparty / binutils-gdb.git / commitdiff
