{
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
return bed->s->elfclass == ELFCLASS32;
}
if (target != NULL
&& target->flavour == bfd_target_elf_flavour)
{
- const struct elf_backend_data *bed;
-
- bed = xvec_get_elf_backend_data (target);
+ elf_backend_data *bed = xvec_get_elf_backend_data (target);
return bed->commonpagesize;
}
return 0;
ghdr = &elf_section_data (group)->this_hdr;
if (ghdr->sh_link == elf_onesymtab (abfd))
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
Elf_Internal_Shdr *symhdr = &elf_symtab_hdr (abfd);
if (ghdr->sh_info > 0
case bfd_target_elf_flavour:
if ((abfd->flags & BFD_COMPRESS_GABI) != 0)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct bfd_elf_section_data * esd = elf_section_data (sec);
enum compression_type ch_type = (abfd->flags & BFD_COMPRESS_ZSTD
? ch_compress_zstd
&& (elf_section_flags (sec) & SHF_COMPRESSED) != 0)
{
Elf_Internal_Chdr chdr;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (bed->s->elfclass == ELFCLASS32)
{
Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
make a better choice of file name for local symbols by ignoring
file symbols appearing after a given local symbol. */
enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
file = NULL;
state = nothing_seen;
unsigned use_mmap : 1;
};
+#ifndef __cplusplus
+typedef const struct elf_backend_data elf_backend_data;
+#endif
+
/* Information about reloc sections associated with a bfd_elf_section_data
structure. */
struct bfd_elf_section_reloc_data
_bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
asection *sec, bfd_byte *contents)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte cantunwind[8];
bfd_vma addr;
bfd_vma last_addr;
struct elf_link_hash_table *htab;
struct eh_frame_hdr_info *hdr_info;
asection *sec;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_vma count;
bfd_byte contents[8];
unsigned int i;
{
flagword flags, pltflags;
asection *s;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
if (htab->irelifunc != NULL || htab->iplt != NULL)
asection *plt, *gotplt, *relplt;
struct elf_dyn_relocs *p;
unsigned int sizeof_reloc;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_link_hash_table *htab;
/* If AVOID_PLT is TRUE, don't use PLT if possible. */
bool use_plt = !avoid_plt || h->plt.refcount > 0;
flagword pltflags;
asection * s;
struct elf_link_hash_entry * h;
- const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+ elf_backend_data * bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab;
int ptralign;
{
flagword flags;
asection * s;
- const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
int ptralign = 0;
bool
_bfd_elf_parse_gnu_properties (bfd *abfd, Elf_Internal_Note *note)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned int align_size = bed->s->elfclass == ELFCLASS64 ? 8 : 4;
bfd_byte *ptr = (bfd_byte *) note->descdata;
bfd_byte *ptr_end = ptr + note->descsz;
elf_merge_gnu_properties (struct bfd_link_info *info, bfd *abfd, bfd *bbfd,
elf_property *aprop, elf_property *bprop)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
unsigned int number;
bool updated;
elf_property_list *list;
asection *sec;
bool has_properties = false;
- const struct elf_backend_data *bed
- = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
unsigned int elfclass = bed->s->elfclass;
int elf_machine_code = bed->elf_machine_code;
elf_property *p;
_bfd_elf_convert_gnu_property_size (bfd *ibfd, bfd *obfd)
{
unsigned int align_size;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
elf_property_list *list = elf_properties (ibfd);
bed = get_elf_backend_data (obfd);
unsigned int size;
bfd_byte *contents;
unsigned int align_shift;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
elf_property_list *list = elf_properties (ibfd);
bed = get_elf_backend_data (obfd);
{
flagword flags;
asection *s;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
if (htab->iplt != NULL)
asection **srelplt2_out)
{
struct elf_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
asection *s;
htab = elf_hash_table (info);
Elf_Internal_Rela *internal_relocs,
struct elf_link_hash_entry **rel_hash)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
int j;
bed = get_elf_backend_data (output_bfd);
Elf_Internal_Sym *alloc_intsym;
Elf_Internal_Sym *isym;
Elf_Internal_Sym *isymend;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
size_t extsym_size;
size_t amt;
file_ptr pos;
{
asection *newsect;
flagword flags;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int opb = bfd_octets_per_byte (abfd, NULL);
if (hdr->bfd_section != NULL)
Elf_Internal_Shdr *oheader,
const unsigned int secnum)
{
- const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+ elf_backend_data *bed = get_elf_backend_data (obfd);
const Elf_Internal_Shdr **iheaders
= (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
bool changed = false;
{
const Elf_Internal_Shdr **iheaders;
Elf_Internal_Shdr **oheaders;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int i;
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
const char *name = "";
char ab[20];
bool stringp;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
(*swap_dyn_in) (abfd, extdyn, &dyn);
size_t verdef_size = 0;
size_t verneed_size = 0;
size_t extsym_size;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
void *dynbuf_addr = NULL;
void *esymbuf_addr = NULL;
size_t dynbuf_size = 0;
{
const char *section_name;
const char *name = NULL;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned char st_other;
bfd_vma val;
const char *version_string;
{
Elf_Internal_Shdr *hdr;
Elf_Internal_Ehdr *ehdr;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
const char *name;
bool ret = true;
{
int i;
const struct bfd_elf_special_section *spec;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
/* See if this is one of the special sections. */
if (sec->name == NULL)
_bfd_elf_new_section_hook (bfd *abfd, asection *sec)
{
struct bfd_elf_section_data *sdata;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
const struct bfd_elf_special_section *ssect;
sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
bool
bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
switch (hdr->p_type)
{
bool delay_sh_name_p)
{
Elf_Internal_Shdr *rel_hdr;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
BFD_ASSERT (reldata->hdr == NULL);
rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
{
struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct bfd_elf_section_data *esd = elf_section_data (asect);
Elf_Internal_Shdr *this_hdr;
unsigned int sh_type;
const char *name;
unsigned int type;
bfd *abfd;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
type = elf_section_data (reloc_sec)->this_hdr.sh_type;
if (type != SHT_REL && type != SHT_RELA)
sym_is_global (bfd *abfd, asymbol *sym)
{
/* If the backend has a special mapping, use it. */
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (bed->elf_backend_sym_is_global)
return (*bed->elf_backend_sym_is_global) (abfd, sym);
_bfd_elf_compute_section_file_positions (bfd *abfd,
struct bfd_link_info *link_info)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct fake_section_arg fsargs;
bool failed;
struct elf_strtab_hash *strtab = NULL;
{
size_t segs;
asection *s;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
/* Assume we will need exactly two PT_LOAD segments: one for text
and one for data. */
bool remove_empty_load)
{
struct elf_segment_map **m;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
/* The placement algorithm assumes that non allocated sections are
not in PT_LOAD segments. We ensure this here by removing such
unsigned int count;
struct elf_segment_map *m;
asection **sections = NULL;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bool no_user_phdrs;
no_user_phdrs = elf_seg_map (abfd) == NULL;
assign_file_positions_for_load_sections (bfd *abfd,
struct bfd_link_info *link_info)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_segment_map *m;
struct elf_segment_map *phdr_load_seg;
Elf_Internal_Phdr *phdrs;
assign_file_positions_for_non_load_sections (bfd *abfd,
struct bfd_link_info *link_info)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
Elf_Internal_Shdr **i_shdrpp;
Elf_Internal_Shdr **hdrpp, **end_hdrpp;
Elf_Internal_Phdr *phdrs;
{
struct elf_obj_tdata *tdata = elf_tdata (abfd);
Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned int alloc;
if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
{
Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
struct elf_strtab_hash *shstrtab;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
i_ehdrp = elf_elfheader (abfd);
Elf_Internal_Shdr **shdrpp, **end_shdrpp;
Elf_Internal_Shdr *shdrp;
Elf_Internal_Ehdr *i_ehdrp;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
/* Skip non-load sections without section header. */
if ((abfd->flags & BFD_NO_SECTION_HEADER) != 0)
bool
_bfd_elf_write_object_contents (bfd *abfd)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
Elf_Internal_Shdr **i_shdrp;
bool failed;
unsigned int count, num_sec;
unsigned int
_bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int sec_index;
if (elf_section_data (asect) != NULL
bool p_paddr_valid;
struct elf_segment_map *phdr_adjust_seg = NULL;
unsigned int phdr_adjust_num = 0;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int opb = bfd_octets_per_byte (ibfd, NULL);
bed = get_elf_backend_data (ibfd);
unsigned int i;
Elf_Internal_Phdr *segment;
unsigned int num_segments;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_size_type maxpagesize = bed->maxpagesize;
bfd_size_type p_align = bed->p_align;
asection * prev;
unsigned int i, num_segments;
Elf_Internal_Shdr *this_hdr;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bed = get_elf_backend_data (ibfd);
int relocatable_p,
struct bfd_link_info *info)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int symcount;
asymbol **syms;
struct elf_strtab_hash *stt;
{
arelent *tblptr;
unsigned int i;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
return -1;
long
_bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
long symcount = bed->s->slurp_symbol_table (abfd, allocation, false);
if (symcount >= 0)
_bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
asymbol **allocation)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
long symcount = bed->s->slurp_symbol_table (abfd, allocation, true);
if (symcount >= 0)
int
_bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
int ret = bed->s->sizeof_ehdr;
if (!bfd_link_relocatable (info))
static bool
elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
/* Short cut for LINUX notes. */
if (note->namesz == 6 /* strlen (NOTE_NAME_LINUX) + 1 */
static bool
elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
switch (note->type)
{
const char *fname,
const char *psargs)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (bed->elf_backend_write_core_note != NULL)
{
int cursig,
const void *gregs)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (bed->elf_backend_write_core_note != NULL)
{
const void *gregs ATTRIBUTE_UNUSED)
{
#if defined (HAVE_PSTATUS32_T)
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (bed->s->elfclass == ELFCLASS32)
{
if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
{
/* Reverse the offset. */
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_size_type address_size = bed->s->arch_size / 8;
/* address_size and sec->size are in octets. Convert
asymbol **dynsyms,
asymbol **ret)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
asection *relplt;
asymbol *s;
const char *relplt_name;
_bfd_elf_final_write_processing (bfd *abfd)
{
Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE)
i_ehdrp->e_ident[EI_OSABI] = bed->elf_osabi;
asymbol ** symbols,
bool dynamic)
{
- const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
+ elf_backend_data *ebd = get_elf_backend_data (abfd);
asection * relsec;
bool result = true;
bfd_vma (*r_sym) (bfd_vma);
bool
_bfd_elf_write_secondary_reloc_section (bfd *abfd, asection *sec)
{
- const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
+ elf_backend_data *ebd = get_elf_backend_data (abfd);
bfd_vma addr_offset;
asection * relsec;
bfd_vma (*r_info) (bfd_vma, bfd_vma);
elf_mmap_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **buf)
{
#ifdef USE_MMAP
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (bed->use_mmap
&& sec->compress_status == COMPRESS_SECTION_NONE
&& (sec->flags & SEC_LINKER_CREATED) == 0)
static bool
create_ifunc_sections (struct bfd_link_info *info)
{
- struct elf32_arm_link_hash_table *htab;
- const struct elf_backend_data *bed;
- bfd *dynobj;
+ struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
+ bfd *dynobj = htab->root.dynobj;
+ elf_backend_data *bed = get_elf_backend_data (dynobj);
asection *s;
- flagword flags;
-
- htab = elf32_arm_hash_table (info);
- dynobj = htab->root.dynobj;
- bed = get_elf_backend_data (dynobj);
- flags = bed->dynamic_sec_flags;
+ flagword flags = bed->dynamic_sec_flags;
if (htab->root.iplt == NULL)
{
obj_attribute *out_attr, struct elf_link_hash_entry **sym_hashes,
int *cmse_stub_created)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed = get_elf_backend_data (input_bfd);
Elf_Internal_Shdr *symtab_hdr;
unsigned i, j, sym_count, ext_start;
Elf_Internal_Sym *cmse_sym, *local_syms;
struct elf32_arm_stub_hash_entry *stub_entry;
bool is_v8m, new_stub, cmse_invalid, ret = true;
- bed = get_elf_backend_data (input_bfd);
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
sym_count = symtab_hdr->sh_size / bed->s->sizeof_sym;
ext_start = symtab_hdr->sh_info;
{
void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
_arm_elf_section_data *eado;
struct bfd_link_order *p;
bfd_byte *erela_head, *erela;
obj_attribute *out_attr;
Elf_Internal_Shdr *symtab_hdr;
unsigned i, sym_count, ext_start;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_link_hash_entry **sym_hashes;
struct elf32_arm_link_hash_entry *cmse_hash;
bool again, is_v8m, first_bfd_browse = true;
if (tlsbase)
{
struct bfd_link_hash_entry *bh = NULL;
- const struct elf_backend_data *bed
- = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
if (!(_bfd_generic_link_add_one_symbol
(info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
/* Check relocation against STT_GNU_IFUNC symbol if there are
dynamic symbols. */
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
if (r_symndx != STN_UNDEF)
{
flagword flags, pltflags;
asection *s;
struct elf_link_hash_entry *h;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
int ptralign;
/* This function may be called more than once. */
elflink.c:_bfd_elf_create_dynamic_sections(). */
flagword flags;
asection *s;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
| SEC_LINKER_CREATED);
flagword flags;
asection * s;
struct elf_link_hash_entry * h;
- const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+ elf_backend_data * bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
int ptralign;
{
flagword flags;
asection * s;
- const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+ elf_backend_data * bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
int ptralign = 0;
asection *s;
struct elf_link_hash_entry *h;
struct bfd_link_hash_entry *bh;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
int ptralign;
int offset;
elflink.c:_bfd_elf_create_dynamic_sections(). */
flagword flags;
asection *s;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
| SEC_LINKER_CREATED);
elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
{
struct elf_link_hash_table *htab = elf_hash_table (info);
- const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
bfd_vma static_tls_size;
/* If tls_sec is NULL, we should have signalled an error already. */
const Elf_Internal_Rela *rela)
{
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
if (htab->dynsym != NULL
struct elf_lm32_link_hash_table *htab;
flagword flags, pltflags;
asection *s;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
int ptralign = 2; /* 32bit */
htab = lm32_elf_hash_table (info);
struct elf_link_hash_table *htab;
flagword flags, pltflags;
asection *s;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
int ptralign = 2; /* 32bit */
htab = m32r_elf_hash_table (info);
Elf_Internal_Rela *rel, *relend;
const char *name = NULL;
struct m68hc11_page_info *pinfo;
- const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
+ elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
struct m68hc11_elf_link_hash_table *htab;
unsigned long e_flags;
struct elf_metag_link_hash_table *htab;
struct elf_link_hash_entry *eh;
struct bfd_link_hash_entry *bh;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
/* Don't try to create the .plt and .got twice. */
htab = metag_link_hash_table (info);
struct elf_nds32_link_hash_table *htab;
flagword flags, pltflags;
register asection *s;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
int ptralign = 2; /* 32-bit */
const char *secname;
char *relname;
static bool
elf32_rx_modify_headers (bfd *abfd, struct bfd_link_info *info)
{
- const struct elf_backend_data * bed;
+ elf_backend_data *bed;
struct elf_obj_tdata * tdata;
Elf_Internal_Phdr * phdr;
unsigned int count;
const Elf_Internal_Rela *rela)
{
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
Elf_Internal_Sym sym;
if (bfd_link_pic (info))
{
asection * p;
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
for (p = output_bfd->sections; p ; p = p->next)
if ((p->flags & SEC_EXCLUDE) == 0
if (bfd_link_pic (info))
{
asection * p;
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
for (p = output_bfd->sections; p ; p = p->next)
if ((p->flags & SEC_EXCLUDE) == 0
struct elf_sh_link_hash_table *htab;
flagword flags, pltflags;
asection *s;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
int ptralign = 0;
switch (bed->s->arch_size)
const Elf_Internal_Rela *rela)
{
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ 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 (info != NULL)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_obj_tdata *tdata;
Elf_Internal_Phdr *phdr, *last;
struct spu_link_hash_table *htab;
Elf_Internal_Rela rela;
bfd_byte *loc;
asection *plt, *gotplt, *relplt;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bed = get_elf_backend_data (output_bfd);
const Elf_Internal_Rela *rel)
{
Elf_Internal_Shdr *rel_hdr;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
/* To determine which flavor of relocation this is, we depend on the
fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
flagword flags;
asection *s, *s_got;
struct elf_link_hash_entry *h;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
/* This function may be called more than once. */
{
struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
struct bfd_link_hash_entry *bh = &tlsbase->root;
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
tlsbase->type = STT_TLS;
if (!(_bfd_generic_link_add_one_symbol
struct elf64_ia64_link_hash_table *ia64_info;
asection *s;
flagword flags;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
ia64_info = elf64_ia64_hash_table (info);
if (ia64_info == NULL)
asection *dynsec;
asection *dynstrsec;
Elf_Internal_Dyn dyn;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int shl_num = 0;
bfd_vma fixups_off = 0;
bfd_vma strdyn_off;
Elf_Internal_Sym *isymbuf = NULL;
Elf_Internal_Sym *isym;
Elf_Internal_Sym *isymend;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_link_hash_table *htab;
bfd_size_type amt;
const Elf_Internal_Rela *rela)
{
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
unsigned long r_symndx = ELF64_R_SYM (rela->r_info);
Elf_Internal_Sym sym;
{
arelent *tblptr;
unsigned int i;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
return -1;
const Elf_Internal_Rela *rela)
{
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ 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);
elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
int note_type, ...)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
va_list ap;
const char *fname, *psargs;
long pid;
elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
{
struct elf_link_hash_table *htab = elf_hash_table (info);
- const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
bfd_vma static_tls_size;
/* If tls_segment is NULL, we should have signalled an error already. */
Elf_Internal_Rela rela;
bfd_byte *loc;
asection *plt, *gotplt, *relplt, *resolved_plt;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_vma plt_got_pcrel_offset;
/* When building a static executable, use .iplt, .igot.plt and
const Elf_Internal_Rela *rela)
{
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_x86_link_hash_table *htab
= elf_x86_hash_table (info, X86_64_ELF_DATA);
elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info)
{
struct elf_x86_init_table init_table;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_x86_link_hash_table *htab;
if ((int) R_X86_64_standard >= (int) R_X86_64_converted_reloc_bit
const Elf_Internal_Phdr *src,
Elf_External_Phdr *dst)
{
- const struct elf_backend_data *bed;
- bfd_vma p_paddr;
-
- bed = get_elf_backend_data (abfd);
- p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr;
+ elf_backend_data *bed = get_elf_backend_data (abfd);
+ bfd_vma p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr;
/* note that all elements of dst are *arrays of unsigned char* already... */
H_PUT_32 (abfd, src->p_type, dst->p_type);
Elf_Internal_Shdr i_shdr;
Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
unsigned int shindex;
- const struct elf_backend_data *ebd;
+ elf_backend_data *ebd;
asection *s;
const bfd_target *target;
void
elf_write_relocs (bfd *abfd, asection *sec, void *data)
{
- const struct elf_backend_data * const bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bool *failedp = (bool *) data;
Elf_Internal_Shdr *rela_hdr;
bfd_vma addr_offset;
Elf_Internal_Sym *isymbuf = NULL;
Elf_External_Versym *xver;
Elf_External_Versym *xverbuf = NULL;
- const struct elf_backend_data *ebd;
+ elf_backend_data *ebd;
size_t amt;
/* Read each raw ELF symbol, converting from external ELF form to
asymbol **symbols,
bool dynamic)
{
- const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
+ elf_backend_data *ebd = get_elf_backend_data (abfd);
void *allocated = NULL;
bfd_byte *native_relocs;
arelent *relent;
asymbol **symbols,
bool dynamic)
{
- const struct elf_backend_data * const bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct bfd_elf_section_data * const d = elf_section_data (asect);
Elf_Internal_Shdr *rel_hdr;
Elf_Internal_Shdr *rel_hdr2;
Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
Elf_Internal_Phdr *i_phdrp; /* Elf program header, internal form. */
unsigned int phindex;
- const struct elf_backend_data *ebd;
bfd_size_type amt;
ufile_ptr filesize;
elf_debug_file (i_ehdrp);
#endif
- ebd = get_elf_backend_data (abfd);
+ elf_backend_data *ebd = get_elf_backend_data (abfd);
/* Check that the ELF e_machine field matches what this particular
BFD format expects. */
https://sourceware.org/bugzilla/show_bug.cgi?id=31458
this is opt-in by each backend. */
- const struct elf_backend_data *bed
- = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
if (bed != NULL && bed->use_mmap)
return false;
#endif
{
struct elf_link_hash_entry *h;
struct bfd_link_hash_entry *bh;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
h = elf_link_hash_lookup (elf_hash_table (info), name, false, false, false);
if (h != NULL)
flagword flags;
asection *s;
struct elf_link_hash_entry *h;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
/* This function may be called more than once. */
{
flagword flags;
asection *s;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_link_hash_entry *h;
if (! is_elf_hash_table (info->hash))
flagword flags, pltflags;
struct elf_link_hash_entry *h;
asection *s;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
/* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
{
struct elf_link_hash_entry *h, *hv;
struct elf_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
if (!is_elf_hash_table (info->hash))
return true;
if (bfd_link_pic (info)
|| elf_hash_table (info)->is_relocatable_executable)
{
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
asection *p;
for (p = output_bfd->sections; p ; p = p->next)
if ((p->flags & SEC_EXCLUDE) == 0
unsigned int st_other, asection *sec,
bool definition, bool dynamic)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
/* If st_other has a processor-specific meaning, specific
code might be needed here. */
bfd *oldbfd;
bool newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
bool newweak, oldweak, newfunc, oldfunc;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
const char *new_version;
bool default_sym = *matched;
struct elf_link_hash_table *htab;
char *shortname;
struct elf_link_hash_entry *hi;
struct bfd_link_hash_entry *bh;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bool collect;
bool dynamic;
bfd *override;
{
const char *p;
bool hide = false;
- const struct elf_backend_data *bed
- = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
/* Version script only hides symbols defined in regular objects. */
if (!h->def_regular && !ELF_COMMON_DEF_P (h))
{
struct elf_info_failed *sinfo;
struct bfd_link_info *info;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_info_failed eif;
const char *p;
bool hide;
size_t *external_relocs_size,
Elf_Internal_Rela *internal_relocs)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
const bfd_byte *erela;
const bfd_byte *erelaend;
void *alloc1 = NULL;
size_t alloc1_size;
Elf_Internal_Rela *alloc2 = NULL;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct bfd_elf_section_data *esdo = elf_section_data (o);
Elf_Internal_Rela *internal_rela_relocs;
bfd_byte *erel;
struct bfd_elf_section_reloc_data *output_reldata;
asection *output_section;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
struct bfd_elf_section_data *esdo;
_bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
struct elf_info_failed *eif)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
/* If this symbol was mentioned in a non-ELF file, try to set
DEF_REGULAR and REF_REGULAR correctly. This is the only way to
{
struct elf_info_failed *eif = (struct elf_info_failed *) data;
struct elf_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
if (! is_elf_hash_table (eif->info->hash))
return false;
bool not_local_protected)
{
bool binding_stays_local_p;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_link_hash_table *hash_table;
if (h == NULL)
struct bfd_link_info *info,
bool local_protected)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_link_hash_table *hash_table;
/* If it's a local sym, of course we resolve locally. */
is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
Elf_Internal_Sym *sym)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
/* Local symbols do not count, but target specific ones might. */
if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
bfd_vma val)
{
struct elf_link_hash_table *hash_table;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
asection *s;
bfd_size_type newsize;
bfd_byte *newcontents;
_bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info)
{
struct elf_link_hash_table *hash_table;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
asection *s, *sdynamic, **pp;
asection *rela_dyn, *rel_dyn;
Elf_Internal_Dyn dyn;
if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
{
asection *sdyn;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *extdyn;
bed = get_elf_backend_data (hash_table->dynobj);
bfd *dynobj = hash_table->dynobj;
asection *sdyn;
bfd_size_type size;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *extdyn;
_bfd_elf_strtab_finalize (dynstr);
_bfd_elf_relocs_compatible (const bfd_target *input,
const bfd_target *output)
{
- const struct elf_backend_data *obed, *ibed;
+ elf_backend_data *obed, *ibed;
if (input == output)
return true;
bool (*action) (bfd *, struct bfd_link_info *, asection *,
const Elf_Internal_Rela *))
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
/* If this object is the same format as the output object, and it is
bool
_bfd_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (bed->check_relocs != NULL)
return _bfd_elf_link_iterate_on_relocs (abfd, info,
bed->check_relocs);
Elf_Internal_Sym *isymbuf = NULL;
Elf_Internal_Sym *isym;
Elf_Internal_Sym *isymend;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bool add_needed;
struct elf_link_hash_table *htab;
void *alloc_mark = NULL;
carsym *symdefs;
bool loop;
size_t amt;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct bfd_link_hash_entry * (*archive_symbol_lookup)
(bfd *, struct bfd_link_info *, const char *);
struct collect_gnu_hash_codes
{
bfd *output_bfd;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned long int nsyms;
unsigned long int maskbits;
unsigned long int *hashcodes;
uint64_t best_chlen = ~((uint64_t) 0);
bfd *dynobj = elf_hash_table (info)->dynobj;
size_t dynsymcount = elf_hash_table (info)->dynsymcount;
- const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
+ elf_backend_data *bed = get_elf_backend_data (dynobj);
unsigned long int *counts;
bfd_size_type amt;
unsigned int no_improvement_count = 0;
asection **sinterpptr)
{
bfd *dynobj;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
*sinterpptr = NULL;
bool
bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned long section_sym_count;
bfd_size_type dynsymcount = 0;
{
if (is_elf_hash_table (info->hash))
{
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
struct elf_link_hash_entry *eh = (struct elf_link_hash_entry *) h;
eh->def_dynamic = 0;
eh->ref_dynamic = 0;
unsigned int entsize)
{
bool ret;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
int can_refcount = bed->can_refcount;
table->init_got_refcount.refcount = can_refcount - 1;
struct bfd_link_info *info)
{
bfd *bfd1, *bfd2;
- const struct elf_backend_data *bed1, *bed2;
+ elf_backend_data *bed1, *bed2;
Elf_Internal_Shdr *hdr1, *hdr2;
size_t symcount1, symcount2;
Elf_Internal_Sym *isymbuf1, *isymbuf2;
struct bfd_link_info *info)
{
unsigned int i;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_byte *erela;
void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
size_t i, ret, sort_elt, ext_size;
bfd_byte *sort, *s_non_relative, *p;
struct elf_link_sort_rela *sq;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
int i2e = bed->s->int_rels_per_ext_rel;
unsigned int opb = bfd_octets_per_byte (abfd, NULL);
void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
(struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
struct elf_link_hash_entry *);
struct elf_link_hash_table *hash_table;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_size_type strtabsize;
BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
struct elf_link_hash_table *hash_table = elf_hash_table (flinfo->info);
size_t amt;
size_t i;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *symbuf;
Elf_Internal_Shdr *hdr;
file_ptr pos;
static bool
elf_link_check_versioned_symbol (struct bfd_link_info *info,
- const struct elf_backend_data *bed,
+ elf_backend_data *bed,
struct elf_link_hash_entry *h)
{
bfd *abfd;
bool strip;
Elf_Internal_Sym sym;
asection *input_sec;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
long indx;
int ret;
unsigned int type;
static bool
elf_section_ignore_discarded_relocs (asection *sec)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
switch (sec->sec_info_type)
{
long *pindex;
asection **ppsection;
asection *o;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_link_hash_entry **sym_hashes;
bfd_size_type address_size;
bfd_vma r_type_mask;
struct bfd_elf_section_reloc_data *reldata;
struct elf_link_hash_entry **rel_hash_ptr;
Elf_Internal_Shdr *rel_hdr;
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
bfd_byte *erel;
unsigned int i;
{
bool ret = false;
bfd *implib_bfd;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
flagword flags;
enum bfd_architecture arch;
unsigned int mach;
unsigned int i;
Elf_Internal_Shdr *symtab_hdr;
Elf_Internal_Shdr *symtab_shndx_hdr;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_outext_info eoinfo;
bool merged;
size_t relativecount;
init_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
{
Elf_Internal_Shdr *symtab_hdr;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bed = get_elf_backend_data (abfd);
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
{
bfd *sub;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
{
pu = h->u2.vtable->parent->u2.vtable->used;
if (pu != NULL)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int log_file_align;
bed = get_elf_backend_data (h->root.u.def.section->owner);
asection *sec;
bfd_vma hstart, hend;
Elf_Internal_Rela *relstart, *relend, *rel;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int log_file_align;
struct link_info_ok *info = (struct link_info_ok *) ptr;
bool ok = true;
bfd *sub;
elf_gc_mark_hook_fn gc_mark_hook;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab;
struct link_info_ok info_ok;
struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
struct elf_link_hash_entry **search, *child;
size_t extsymcount;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
/* The sh_info field of the symtab header tells us where the
external symbols start. We don't care about the local symbols at
struct elf_link_hash_entry *h,
bfd_vma addend)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned int log_file_align = bed->s->log_file_align;
if (!h || addend > 1u << 28)
if (!flaginfo->flags_initialized)
{
bfd *obfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+ elf_backend_data *bed = get_elf_backend_data (obfd);
struct flag_info_list *tf = flaginfo->flag_list;
int with_hex = 0;
int without_hex = 0;
{
struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
bfd *obfd = gofarg->info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+ elf_backend_data *bed = get_elf_backend_data (obfd);
if (h->got.refcount > 0)
{
struct bfd_link_info *info)
{
bfd *i;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_vma gotoff;
struct alloc_got_off_arg gofarg;
for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
asection *s;
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
bfd *ibfd ATTRIBUTE_UNUSED,
unsigned long symndx ATTRIBUTE_UNUSED)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
return bed->s->arch_size / 8;
}
void
_bfd_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
bed->s->swap_reloca_out (abfd, rel, loc);
void
_bfd_elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
bed->s->swap_reloc_out (abfd, rel, loc);
if (symbol[0] == '.')
{
/* .startof. and .sizeof. symbols are local. */
- const struct elf_backend_data *bed;
- bed = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
(*bed->elf_backend_hide_symbol) (info, h, true);
}
else
#define add_dynamic_entry(TAG, VAL) \
_bfd_elf_add_dynamic_entry (info, TAG, VAL)
- const struct elf_backend_data *bed
- = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
if (bfd_link_executable (info))
{
static bool
aarch64_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
flagword flags;
asection *s;
struct elf_link_hash_entry *h;
/* Check relocation against STT_GNU_IFUNC symbol if there are
dynamic symbols. */
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned long r_symndx = ELFNN_R_SYM (rela->r_info);
if (r_symndx != STN_UNDEF)
{
if (tlsbase)
{
struct bfd_link_hash_entry *h = NULL;
- const struct elf_backend_data *bed =
- get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
if (!(_bfd_generic_link_add_one_symbol
(info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
static bool
kvx_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
flagword flags;
asection *s;
struct elf_link_hash_entry *h;
if (tlsbase)
{
struct bfd_link_hash_entry *h = NULL;
- const struct elf_backend_data *bed =
- get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
if (!(_bfd_generic_link_add_one_symbol
(info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
char *name;
asection *s, *s_got;
struct elf_link_hash_entry *h;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
/* This function may be called more than once. */
asection *plt, *gotplt, *relplt;
struct elf_dyn_relocs *p;
unsigned int sizeof_reloc;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_link_hash_table *htab;
/* If AVOID_PLT is TRUE, don't use PLT if possible. */
bool use_plt = !avoid_plt || h->plt.refcount > 0;
loongarch_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
{
BFD_ASSERT (s && s->contents);
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *loc;
bed = get_elf_backend_data (abfd);
Elf_Internal_Sym *sym)
{
struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
if (h->plt.offset != MINUS_ONE)
{
asection *sdyn)
{
struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
size_t dynsize = bed->s->sizeof_dyn, skipped_size = 0;
bfd_byte *dyncon, *dynconend;
/* Check relocation against STT_GNU_IFUNC symbol if there are
dynamic symbols. */
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned long r_symndx = ELFNN_R_SYM (rela->r_info);
if (r_symndx != STN_UNDEF)
{
static void
riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *loc;
bed = get_elf_backend_data (abfd);
flagword flags;
asection *s, *s_got;
struct elf_link_hash_entry *h;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
/* This function may be called more than once. */
relocs into .rela.iplt, since it may cause the
overwrite problems. This is same as what we did
in the riscv_elf_finish_dynamic_symbol. */
- const struct elf_backend_data *bed =
- get_elf_backend_data (output_bfd);
+ elf_backend_data *bed
+ = get_elf_backend_data (output_bfd);
bfd_vma iplt_idx = htab->last_iplt_index--;
bfd_byte *loc = htab->elf.irelplt->contents
+ iplt_idx * sizeof (ElfNN_External_Rela);
Elf_Internal_Sym *sym)
{
struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
if (h->plt.offset != (bfd_vma) -1)
{
bfd *dynobj, asection *sdyn)
{
struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
size_t dynsize = bed->s->sizeof_dyn;
bfd_byte *dyncon, *dynconend;
/* Check relocation against STT_GNU_IFUNC symbol if there are
dynamic symbols. */
bfd *abfd = info->output_bfd;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned long r_symndx = ELFNN_R_SYM (rela->r_info);
if (r_symndx != STN_UNDEF)
{
} bfd_search_result_t;
static inline bool
-bfd_is_non_dynamic_elf_object (bfd *abfd, const struct elf_backend_data *out_be)
+bfd_is_non_dynamic_elf_object (bfd *abfd, elf_backend_data *out_be)
{
- const struct elf_backend_data *in_be = get_elf_backend_data (abfd);
+ elf_backend_data *in_be = get_elf_backend_data (abfd);
return bfd_get_flavour (abfd) == bfd_target_elf_flavour
&& bfd_count_sections (abfd) != 0
static bfd_search_result_t
bfd_linear_search_one_with_gnu_property (struct bfd_link_info *info)
{
- const struct elf_backend_data *be = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *be = get_elf_backend_data (info->output_bfd);
bfd_search_result_t res = {
.pbfd = NULL,
struct bfd_link_info * info,
const uint32_t outprop)
{
- const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
const int elf_machine_code = bed->elf_machine_code;
const unsigned int elfclass = bed->s->elfclass;
function, or 0 if we can't decide which function that is. */
static unsigned long
-mips16_stub_symndx (const struct elf_backend_data *bed,
+mips16_stub_symndx (elf_backend_data *bed,
asection *sec ATTRIBUTE_UNUSED,
const Elf_Internal_Rela *relocs,
const Elf_Internal_Rela *relend)
if (bfd_link_pic (info))
{
asection *p;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
- bed = get_elf_backend_data (output_bfd);
for (p = output_bfd->sections; p ; p = p->next)
if ((p->flags & SEC_EXCLUDE) == 0
&& (p->flags & SEC_ALLOC) != 0
const Elf_Internal_Rela *rel)
{
Elf_Internal_Shdr *rel_hdr;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
/* To determine which flavor of relocation this is, we depend on the
fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
asection *sreloc;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct mips_elf_link_hash_table *htab;
bfd_byte *contents;
bfd_vma addend;
reloc_howto_type *howto,
bfd_byte *contents)
{
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
int count = bed->s->int_rels_per_ext_rel;
unsigned int r_type;
int i;
Elf32_RegInfo reginfo;
struct ecoff_debug_info debug;
struct mips_htab_traverse_info hti;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
HDRR *symhdr = &debug.symbolic_header;
void *mdebug_handle = NULL;
static const char mipssuffix[] = "@plt";
bool (*slurp_relocs) (bfd *, asection *, asymbol **, bool);
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bool micromips_p = MICROMIPS_P (abfd);
Elf_Internal_Shdr *hdr;
bfd_byte *plt_data;
static void
sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *loc;
bed = get_elf_backend_data (abfd);
static bool
create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
flagword flags, pltflags;
asection *s;
tpoff (struct bfd_link_info *info, bfd_vma address)
{
struct elf_link_hash_table *htab = elf_hash_table (info);
- const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
bfd_vma static_tls_size;
/* If tls_sec is NULL, we should have signalled an error already. */
Elf_Internal_Sym *sym)
{
struct _bfd_sparc_elf_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct _bfd_sparc_elf_link_hash_entry *eh;
bool resolved_to_zero;
asection *splt ATTRIBUTE_UNUSED)
{
struct _bfd_sparc_elf_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *dyncon, *dynconend;
size_t dynsize;
int stt_regidx = -1;
static void
tilegx_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *loc;
bed = get_elf_backend_data (abfd);
flagword flags;
asection *s, *s_got;
struct elf_link_hash_entry *h;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
/* This function may be called more than once. */
Elf_Internal_Rela rela;
bfd_byte *loc;
bfd_vma r_offset;
- const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
int rela_index;
asection *splt ATTRIBUTE_UNUSED)
{
struct tilegx_elf_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_byte *dyncon, *dynconend;
size_t dynsize;
{
struct elf_x86_link_hash_table *htab;
struct bfd_link_hash_entry *base;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
if (!bfd_link_executable (info))
return;
struct elf_dyn_relocs *p;
unsigned int plt_entry_size;
bool resolved_to_zero;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
if (h->root.type == bfd_link_hash_indirect)
return true;
return NULL;
}
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
if (bed->target_id == X86_64_ELF_DATA)
{
ret->is_reloc_section = elf_x86_64_is_reloc_section;
{
/* Check for __tls_get_addr reference. */
struct elf_x86_link_hash_table *htab;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
htab = elf_x86_hash_table (info, bed->target_id);
if (htab)
{
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
asection *sreloc;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bool is_x86_64;
if (bfd_link_relocatable (info))
Elf_Internal_Rela *irel, *irelend;
Elf_Internal_Sym *isymbuf = NULL;
struct elf_link_hash_entry **sym_hashes;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_x86_link_hash_table *htab;
bfd_vma *local_got_offsets;
bool is_x86_64;
unsigned int plt_sec_type)
{
struct elf_x86_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int plt0_entry_size;
unsigned char func_info;
unsigned int plt_sec_type)
{
struct elf_x86_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
sframe_encoder_ctx *ectx;
size_t sec_size;
asection *sec;
bool *need_layout)
{
struct elf_x86_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bool is_x86_64;
bfd_size_type i, count, unaligned_count;
asection *sec, *srel;
_bfd_elf_x86_finish_relative_relocs (struct bfd_link_info *info)
{
struct elf_x86_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
Elf_Internal_Rela outrel;
bool is_x86_64;
bfd_size_type count;
if (bfd_link_pic (info)
&& (h == NULL || SYMBOL_REFERENCES_LOCAL (info, h)))
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int r_type;
Elf_Internal_Rela irel;
asection *s;
bool relocs;
bfd *ibfd;
- const struct elf_backend_data *bed
- = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
htab = elf_x86_hash_table (info, bed->target_id);
if (htab == NULL)
bfd_byte *buf)
{
struct elf_x86_link_hash_table *htab;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd *dynobj;
asection *sdyn;
bfd_byte *dyncon, *dynconend;
{
struct elf_x86_link_hash_table *htab;
struct bfd_link_hash_entry *bh = NULL;
- const struct elf_backend_data *bed
- = get_elf_backend_data (output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (output_bfd);
htab = elf_x86_hash_table (info, bed->target_id);
if (htab == NULL)
enum elf_x86_tls_error_type tls_error)
{
const char *name;
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_x86_link_hash_table *htab
= elf_x86_hash_table (info, bed->target_id);
asection *s, *srel;
struct elf_x86_link_hash_entry *eh;
struct elf_dyn_relocs *p;
- const struct elf_backend_data *bed
- = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
eh = (struct elf_x86_link_hash_entry *) h;
long dynrelcount;
arelent **dynrelbuf, *p;
char *names;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
bfd_vma);
bool (*valid_plt_reloc_p) (unsigned int);
{
unsigned int number, features;
bool updated = false;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
struct elf_x86_link_hash_table *htab;
unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
bfd *pbfd;
bfd *ebfd = NULL;
elf_property *prop;
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
unsigned int got_align;
bfd_elf_linker_x86_set_options (struct bfd_link_info *info,
struct elf_linker_x86_params *params)
{
- const struct elf_backend_data *bed
- = get_elf_backend_data (info->output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
struct elf_x86_link_hash_table *htab
= elf_x86_hash_table (info, bed->target_id);
if (htab != NULL)
pc = bfd_scan_vma (adr, NULL, 16);
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_vma sign = (bfd_vma) 1 << (bed->s->arch_size - 1);
pc &= (sign << 1) - 1;
&& bfd_get_flavour (ibfd) != bfd_target_elf_flavour
&& bfd_get_flavour (obfd) == bfd_target_elf_flavour)
{
- const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+ elf_backend_data *bed = get_elf_backend_data (obfd);
iarch = bed->arch;
imach = 0;
}
static void
disassemble_section (bfd *abfd, asection *section, void *inf)
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed;
bfd_vma sign_adjust = 0;
struct disassemble_info *pinfo = (struct disassemble_info *) inf;
struct objdump_disasm_info *paux;
static void
dump_bfd (bfd *abfd, bool is_mainfile)
{
- const struct elf_backend_data * bed;
+ elf_backend_data *bed;
if (bfd_big_endian (abfd))
byte_get = byte_get_big_endian;
asection *old_sec;
segT sec;
flagword flags;
- const struct elf_backend_data *bed;
const struct bfd_elf_special_section *ssect;
if (match_p == NULL)
group_section_insert (match_p, sec, &group_idx);
}
- bed = get_elf_backend_data (stdoutput);
+ elf_backend_data *bed = get_elf_backend_data (stdoutput);
ssect = (*bed->get_sec_type_attr) (stdoutput, sec);
if (ssect != NULL)
return;
}
- const struct elf_backend_data *bed = get_elf_backend_data (stdoutput);
+ elf_backend_data *bed = get_elf_backend_data (stdoutput);
bool maybe_gnu = (bed->elf_osabi == ELFOSABI_NONE
|| bed->elf_osabi == ELFOSABI_GNU
|| bed->elf_osabi == ELFOSABI_FREEBSD);
|| strcmp (type_name, "10") == 0
|| strcmp (type_name, "STT_GNU_IFUNC") == 0)
{
- const struct elf_backend_data *bed;
-
- bed = get_elf_backend_data (stdoutput);
+ elf_backend_data *bed = get_elf_backend_data (stdoutput);
if (bed->elf_osabi != ELFOSABI_NONE
&& bed->elf_osabi != ELFOSABI_GNU
&& bed->elf_osabi != ELFOSABI_FREEBSD)
}
else if (strcmp (type_name, "gnu_unique_object") == 0)
{
- const struct elf_backend_data *bed;
-
- bed = get_elf_backend_data (stdoutput);
+ elf_backend_data *bed = get_elf_backend_data (stdoutput);
if (bed->elf_osabi != ELFOSABI_NONE
&& bed->elf_osabi != ELFOSABI_GNU)
as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
static void
gld${EMULATION_NAME}_before_allocation (void)
{
- const struct elf_backend_data *bed;
-
if (!is_elf_hash_table (link_info.hash))
return;
- bed = get_elf_backend_data (link_info.output_bfd);
-
/* The backend must work out the sizes of all the other dynamic
sections. */
+ elf_backend_data *bed = get_elf_backend_data (link_info.output_bfd);
if (bed->elf_backend_late_size_sections
&& !bed->elf_backend_late_size_sections (link_info.output_bfd,
&link_info))
}
if (elfbfd)
{
- const struct elf_backend_data *bed;
-
- bed = get_elf_backend_data (elfbfd);
+ elf_backend_data *bed = get_elf_backend_data (elfbfd);
s = bfd_make_section_with_flags (elfbfd, ".eh_frame_hdr",
bed->dynamic_sec_flags
| SEC_READONLY);
static bool
write_build_id (bfd *abfd)
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_obj_tdata *t = elf_tdata (abfd);
const char *style;
asection *asec;
{
/* If we don't have user supplied phdrs, strip zero-sized dynamic
sections and regenerate program headers. */
- const struct elf_backend_data *bed
- = get_elf_backend_data (link_info.output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (link_info.output_bfd);
if (bed->elf_backend_strip_zero_sized_dynamic_sections
&& !bed->elf_backend_strip_zero_sized_dynamic_sections (&link_info))
fatal (_("%P: failed to strip zero-sized dynamic sections\n"));
h->u.undef.abfd = NULL;
if (is_elf_hash_table (link_info.hash))
{
- const struct elf_backend_data *bed;
+ elf_backend_data *bed = get_elf_backend_data (link_info.output_bfd);
struct elf_link_hash_entry *eh = (struct elf_link_hash_entry *) h;
unsigned int was_forced = eh->forced_local;
- bed = get_elf_backend_data (link_info.output_bfd);
(*bed->elf_backend_hide_symbol) (&link_info, eh, true);
if (!eh->ref_regular_nonweak)
h->type = bfd_link_hash_undefweak;
|| h->root.type == bfd_link_hash_undefweak
|| h->root.type == bfd_link_hash_common))
{
- const struct elf_backend_data *bed;
- bed = get_elf_backend_data (link_info.output_bfd);
+ elf_backend_data *bed = get_elf_backend_data (link_info.output_bfd);
(*bed->elf_backend_hide_symbol) (&link_info, h, true);
if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
projects / thirdparty / binutils-gdb.git / commitdiff
