#include "elf-bfd.h"
#include "libiberty.h"
-static INLINE struct elf_segment_map *make_mapping
- PARAMS ((bfd *, asection **, unsigned int, unsigned int, bfd_boolean));
-static bfd_boolean map_sections_to_segments
- PARAMS ((bfd *));
-static int elf_sort_sections
- PARAMS ((const PTR, const PTR));
-static bfd_boolean assign_file_positions_for_segments
- PARAMS ((bfd *));
-static bfd_boolean assign_file_positions_except_relocs
- PARAMS ((bfd *));
-static bfd_boolean prep_headers
- PARAMS ((bfd *));
-static bfd_boolean swap_out_syms
- PARAMS ((bfd *, struct bfd_strtab_hash **, int));
-static bfd_boolean copy_private_bfd_data
- PARAMS ((bfd *, bfd *));
-static char *elf_read
- PARAMS ((bfd *, file_ptr, bfd_size_type));
-static const char *group_signature
- PARAMS ((bfd *, Elf_Internal_Shdr *));
-static bfd_boolean setup_group
- PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
-static void merge_sections_remove_hook
- PARAMS ((bfd *, asection *));
-static void elf_fake_sections
- PARAMS ((bfd *, asection *, PTR));
-static bfd_boolean assign_section_numbers
- PARAMS ((bfd *));
-static INLINE int sym_is_global
- PARAMS ((bfd *, asymbol *));
-static bfd_boolean elf_map_symbols
- PARAMS ((bfd *));
-static bfd_size_type get_program_header_size
- PARAMS ((bfd *));
-static bfd_boolean elfcore_read_notes
- PARAMS ((bfd *, file_ptr, bfd_size_type));
-static bfd_boolean elf_find_function
- PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
- const char **));
-static int elfcore_make_pid
- PARAMS ((bfd *));
-static bfd_boolean elfcore_maybe_make_sect
- PARAMS ((bfd *, char *, asection *));
-static bfd_boolean elfcore_make_note_pseudosection
- PARAMS ((bfd *, char *, Elf_Internal_Note *));
-static bfd_boolean elfcore_grok_prfpreg
- PARAMS ((bfd *, Elf_Internal_Note *));
-static bfd_boolean elfcore_grok_prxfpreg
- PARAMS ((bfd *, Elf_Internal_Note *));
-static bfd_boolean elfcore_grok_note
- PARAMS ((bfd *, Elf_Internal_Note *));
-static bfd_boolean elfcore_netbsd_get_lwpid
- PARAMS ((Elf_Internal_Note *, int *));
-static bfd_boolean elfcore_grok_netbsd_procinfo
- PARAMS ((bfd *, Elf_Internal_Note *));
-static bfd_boolean elfcore_grok_netbsd_note
- PARAMS ((bfd *, Elf_Internal_Note *));
-static bfd_boolean elfcore_grok_nto_gregs
- PARAMS ((bfd *, Elf_Internal_Note *, pid_t));
-static bfd_boolean elfcore_grok_nto_status
- PARAMS ((bfd *, Elf_Internal_Note *, pid_t *));
-static bfd_boolean elfcore_grok_nto_note
- PARAMS ((bfd *, Elf_Internal_Note *));
+static int elf_sort_sections (const void *, const void *);
+static bfd_boolean assign_file_positions_except_relocs (bfd *);
+static bfd_boolean prep_headers (bfd *);
+static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
+static bfd_boolean elfcore_read_notes (bfd *, file_ptr, bfd_size_type) ;
/* Swap version information in and out. The version information is
currently size independent. If that ever changes, this code will
/* Swap in a Verdef structure. */
void
-_bfd_elf_swap_verdef_in (abfd, src, dst)
- bfd *abfd;
- const Elf_External_Verdef *src;
- Elf_Internal_Verdef *dst;
+_bfd_elf_swap_verdef_in (bfd *abfd,
+ const Elf_External_Verdef *src,
+ Elf_Internal_Verdef *dst)
{
dst->vd_version = H_GET_16 (abfd, src->vd_version);
dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
/* Swap out a Verdef structure. */
void
-_bfd_elf_swap_verdef_out (abfd, src, dst)
- bfd *abfd;
- const Elf_Internal_Verdef *src;
- Elf_External_Verdef *dst;
+_bfd_elf_swap_verdef_out (bfd *abfd,
+ const Elf_Internal_Verdef *src,
+ Elf_External_Verdef *dst)
{
H_PUT_16 (abfd, src->vd_version, dst->vd_version);
H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
/* Swap in a Verdaux structure. */
void
-_bfd_elf_swap_verdaux_in (abfd, src, dst)
- bfd *abfd;
- const Elf_External_Verdaux *src;
- Elf_Internal_Verdaux *dst;
+_bfd_elf_swap_verdaux_in (bfd *abfd,
+ const Elf_External_Verdaux *src,
+ Elf_Internal_Verdaux *dst)
{
dst->vda_name = H_GET_32 (abfd, src->vda_name);
dst->vda_next = H_GET_32 (abfd, src->vda_next);
/* Swap out a Verdaux structure. */
void
-_bfd_elf_swap_verdaux_out (abfd, src, dst)
- bfd *abfd;
- const Elf_Internal_Verdaux *src;
- Elf_External_Verdaux *dst;
+_bfd_elf_swap_verdaux_out (bfd *abfd,
+ const Elf_Internal_Verdaux *src,
+ Elf_External_Verdaux *dst)
{
H_PUT_32 (abfd, src->vda_name, dst->vda_name);
H_PUT_32 (abfd, src->vda_next, dst->vda_next);
/* Swap in a Verneed structure. */
void
-_bfd_elf_swap_verneed_in (abfd, src, dst)
- bfd *abfd;
- const Elf_External_Verneed *src;
- Elf_Internal_Verneed *dst;
+_bfd_elf_swap_verneed_in (bfd *abfd,
+ const Elf_External_Verneed *src,
+ Elf_Internal_Verneed *dst)
{
dst->vn_version = H_GET_16 (abfd, src->vn_version);
dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
/* Swap out a Verneed structure. */
void
-_bfd_elf_swap_verneed_out (abfd, src, dst)
- bfd *abfd;
- const Elf_Internal_Verneed *src;
- Elf_External_Verneed *dst;
+_bfd_elf_swap_verneed_out (bfd *abfd,
+ const Elf_Internal_Verneed *src,
+ Elf_External_Verneed *dst)
{
H_PUT_16 (abfd, src->vn_version, dst->vn_version);
H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
/* Swap in a Vernaux structure. */
void
-_bfd_elf_swap_vernaux_in (abfd, src, dst)
- bfd *abfd;
- const Elf_External_Vernaux *src;
- Elf_Internal_Vernaux *dst;
+_bfd_elf_swap_vernaux_in (bfd *abfd,
+ const Elf_External_Vernaux *src,
+ Elf_Internal_Vernaux *dst)
{
dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
/* Swap out a Vernaux structure. */
void
-_bfd_elf_swap_vernaux_out (abfd, src, dst)
- bfd *abfd;
- const Elf_Internal_Vernaux *src;
- Elf_External_Vernaux *dst;
+_bfd_elf_swap_vernaux_out (bfd *abfd,
+ const Elf_Internal_Vernaux *src,
+ Elf_External_Vernaux *dst)
{
H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
/* Swap in a Versym structure. */
void
-_bfd_elf_swap_versym_in (abfd, src, dst)
- bfd *abfd;
- const Elf_External_Versym *src;
- Elf_Internal_Versym *dst;
+_bfd_elf_swap_versym_in (bfd *abfd,
+ const Elf_External_Versym *src,
+ Elf_Internal_Versym *dst)
{
dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
}
/* Swap out a Versym structure. */
void
-_bfd_elf_swap_versym_out (abfd, src, dst)
- bfd *abfd;
- const Elf_Internal_Versym *src;
- Elf_External_Versym *dst;
+_bfd_elf_swap_versym_out (bfd *abfd,
+ const Elf_Internal_Versym *src,
+ Elf_External_Versym *dst)
{
H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
}
cause invalid hash tables to be generated. */
unsigned long
-bfd_elf_hash (namearg)
- const char *namearg;
+bfd_elf_hash (const char *namearg)
{
const unsigned char *name = (const unsigned char *) namearg;
unsigned long h = 0;
buffer. */
static char *
-elf_read (abfd, offset, size)
- bfd *abfd;
- file_ptr offset;
- bfd_size_type size;
+elf_read (bfd *abfd, file_ptr offset, bfd_size_type size)
{
char *buf;
return NULL;
if (bfd_seek (abfd, offset, SEEK_SET) != 0)
return NULL;
- if (bfd_bread ((PTR) buf, size, abfd) != size)
+ if (bfd_bread (buf, size, abfd) != size)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_set_error (bfd_error_file_truncated);
}
bfd_boolean
-bfd_elf_mkobject (abfd)
- bfd *abfd;
+bfd_elf_mkobject (bfd *abfd)
{
/* This just does initialization. */
/* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
- bfd_size_type amt = sizeof (struct elf_obj_tdata);
- elf_tdata (abfd) = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
+ elf_tdata (abfd) = bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
if (elf_tdata (abfd) == 0)
return FALSE;
/* Since everything is done at close time, do we need any
}
bfd_boolean
-bfd_elf_mkcorefile (abfd)
- bfd *abfd;
+bfd_elf_mkcorefile (bfd *abfd)
{
/* I think this can be done just like an object file. */
return bfd_elf_mkobject (abfd);
}
char *
-bfd_elf_get_str_section (abfd, shindex)
- bfd *abfd;
- unsigned int shindex;
+bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
{
Elf_Internal_Shdr **i_shdrp;
char *shstrtab = NULL;
offset = i_shdrp[shindex]->sh_offset;
shstrtabsize = i_shdrp[shindex]->sh_size;
shstrtab = elf_read (abfd, offset, shstrtabsize);
- i_shdrp[shindex]->contents = (PTR) shstrtab;
+ i_shdrp[shindex]->contents = shstrtab;
}
return shstrtab;
}
char *
-bfd_elf_string_from_elf_section (abfd, shindex, strindex)
- bfd *abfd;
- unsigned int shindex;
- unsigned int strindex;
+bfd_elf_string_from_elf_section (bfd *abfd,
+ unsigned int shindex,
+ unsigned int strindex)
{
Elf_Internal_Shdr *hdr;
symbols, and symbol section index extensions, respectively. */
Elf_Internal_Sym *
-bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, symoffset,
- intsym_buf, extsym_buf, extshndx_buf)
- bfd *ibfd;
- Elf_Internal_Shdr *symtab_hdr;
- size_t symcount;
- size_t symoffset;
- Elf_Internal_Sym *intsym_buf;
- PTR extsym_buf;
- Elf_External_Sym_Shndx *extshndx_buf;
+bfd_elf_get_elf_syms (bfd *ibfd,
+ Elf_Internal_Shdr *symtab_hdr,
+ size_t symcount,
+ size_t symoffset,
+ Elf_Internal_Sym *intsym_buf,
+ void *extsym_buf,
+ Elf_External_Sym_Shndx *extshndx_buf)
{
Elf_Internal_Shdr *shndx_hdr;
- PTR alloc_ext;
+ void *alloc_ext;
const bfd_byte *esym;
Elf_External_Sym_Shndx *alloc_extshndx;
Elf_External_Sym_Shndx *shndx;
Elf_Internal_Sym *isym;
Elf_Internal_Sym *isymend;
- struct elf_backend_data *bed;
+ const struct elf_backend_data *bed;
size_t extsym_size;
bfd_size_type amt;
file_ptr pos;
pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
if (extshndx_buf == NULL)
{
- alloc_extshndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
+ alloc_extshndx = bfd_malloc (amt);
extshndx_buf = alloc_extshndx;
}
if (extshndx_buf == NULL
if (intsym_buf == NULL)
{
bfd_size_type amt = symcount * sizeof (Elf_Internal_Sym);
- intsym_buf = (Elf_Internal_Sym *) bfd_malloc (amt);
+ intsym_buf = bfd_malloc (amt);
if (intsym_buf == NULL)
goto out;
}
for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
isym < isymend;
esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
- (*bed->s->swap_symbol_in) (ibfd, esym, (const PTR) shndx, isym);
+ (*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym);
out:
if (alloc_ext != NULL)
/* Look up a symbol name. */
const char *
-bfd_elf_local_sym_name (abfd, isym)
- bfd *abfd;
- Elf_Internal_Sym *isym;
+bfd_elf_local_sym_name (bfd *abfd, Elf_Internal_Sym *isym)
{
unsigned int iname = isym->st_name;
unsigned int shindex = elf_tdata (abfd)->symtab_hdr.sh_link;
signature just a string? */
static const char *
-group_signature (abfd, ghdr)
- bfd *abfd;
- Elf_Internal_Shdr *ghdr;
+group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
{
Elf_Internal_Shdr *hdr;
unsigned char esym[sizeof (Elf64_External_Sym)];
/* Set next_in_group list pointer, and group name for NEWSECT. */
static bfd_boolean
-setup_group (abfd, hdr, newsect)
- bfd *abfd;
- Elf_Internal_Shdr *hdr;
- asection *newsect;
+setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
{
unsigned int num_group = elf_tdata (abfd)->num_group;
}
bfd_boolean
-bfd_elf_discard_group (abfd, group)
- bfd *abfd ATTRIBUTE_UNUSED;
- asection *group;
+bfd_elf_discard_group (bfd *abfd ATTRIBUTE_UNUSED, asection *group)
{
asection *first = elf_next_in_group (group);
asection *s = first;
BFD section in the bfd_section field of the header. */
bfd_boolean
-_bfd_elf_make_section_from_shdr (abfd, hdr, name)
- bfd *abfd;
- Elf_Internal_Shdr *hdr;
- const char *name;
+_bfd_elf_make_section_from_shdr (bfd *abfd,
+ Elf_Internal_Shdr *hdr,
+ const char *name)
{
asection *newsect;
flagword flags;
- struct elf_backend_data *bed;
+ const struct elf_backend_data *bed;
if (hdr->bfd_section != NULL)
{
if (newsect == NULL)
return FALSE;
+ /* Always use the real type/flags. */
+ elf_section_type (newsect) = hdr->sh_type;
+ elf_section_flags (newsect) = hdr->sh_flags;
+
newsect->filepos = hdr->sh_offset;
if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
*/
struct elf_internal_shdr *
-bfd_elf_find_section (abfd, name)
- bfd *abfd;
- char *name;
+bfd_elf_find_section (bfd *abfd, char *name)
{
Elf_Internal_Shdr **i_shdrp;
char *shstrtab;
"SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
};
-/* ELF relocs are against symbols. If we are producing relocateable
+/* ELF relocs are against symbols. If we are producing relocatable
output, and the reloc is against an external symbol, and nothing
has given us any additional addend, the resulting reloc will also
be against the same symbol. In such a case, we don't want to
all be done at final link time. Rather than put special case code
into bfd_perform_relocation, all the reloc types use this howto
function. It just short circuits the reloc if producing
- relocateable output against an external symbol. */
+ relocatable output against an external symbol. */
bfd_reloc_status_type
-bfd_elf_generic_reloc (abfd,
- reloc_entry,
- symbol,
- data,
- input_section,
- output_bfd,
- error_message)
- bfd *abfd ATTRIBUTE_UNUSED;
- arelent *reloc_entry;
- asymbol *symbol;
- PTR data ATTRIBUTE_UNUSED;
- asection *input_section;
- bfd *output_bfd;
- char **error_message ATTRIBUTE_UNUSED;
-{
- if (output_bfd != (bfd *) NULL
+bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
+ arelent *reloc_entry,
+ asymbol *symbol,
+ void *data ATTRIBUTE_UNUSED,
+ asection *input_section,
+ bfd *output_bfd,
+ char **error_message ATTRIBUTE_UNUSED)
+{
+ if (output_bfd != NULL
&& (symbol->flags & BSF_SECTION_SYM) == 0
&& (! reloc_entry->howto->partial_inplace
|| reloc_entry->addend == 0))
/* Make sure sec_info_type is cleared if sec_info is cleared too. */
static void
-merge_sections_remove_hook (abfd, sec)
- bfd *abfd ATTRIBUTE_UNUSED;
- asection *sec;
+merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *sec)
{
BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
sec->sec_info_type = ELF_INFO_TYPE_NONE;
/* Finish SHF_MERGE section merging. */
bfd_boolean
-_bfd_elf_merge_sections (abfd, info)
- bfd *abfd;
- struct bfd_link_info *info;
+_bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
{
if (!is_elf_hash_table (info))
return FALSE;
}
void
-_bfd_elf_link_just_syms (sec, info)
- asection *sec;
- struct bfd_link_info *info;
+_bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
{
sec->output_section = bfd_abs_section_ptr;
sec->output_offset = sec->vma;
another. */
bfd_boolean
-_bfd_elf_copy_private_bfd_data (ibfd, obfd)
- bfd *ibfd;
- bfd *obfd;
+_bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
{
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
/* Print out the program headers. */
bfd_boolean
-_bfd_elf_print_private_bfd_data (abfd, farg)
- bfd *abfd;
- PTR farg;
+_bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
{
- FILE *f = (FILE *) farg;
+ FILE *f = farg;
Elf_Internal_Phdr *p;
asection *s;
bfd_byte *dynbuf = NULL;
case PT_PHDR: pt = "PHDR"; break;
case PT_TLS: pt = "TLS"; break;
case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
+ case PT_GNU_STACK: pt = "STACK"; break;
default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
}
fprintf (f, "%8s off 0x", pt);
unsigned long shlink;
bfd_byte *extdyn, *extdynend;
size_t extdynsize;
- void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
+ void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
fprintf (f, _("\nDynamic Section:\n"));
- dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
+ dynbuf = bfd_malloc (s->_raw_size);
if (dynbuf == NULL)
goto error_return;
- if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
- s->_raw_size))
+ if (! bfd_get_section_contents (abfd, s, dynbuf, 0, s->_raw_size))
goto error_return;
elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
char ab[20];
bfd_boolean stringp;
- (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
+ (*swap_dyn_in) (abfd, extdyn, &dyn);
if (dyn.d_tag == DT_NULL)
break;
/* Display ELF-specific fields of a symbol. */
void
-bfd_elf_print_symbol (abfd, filep, symbol, how)
- bfd *abfd;
- PTR filep;
- asymbol *symbol;
- bfd_print_symbol_type how;
+bfd_elf_print_symbol (bfd *abfd,
+ void *filep,
+ asymbol *symbol,
+ bfd_print_symbol_type how)
{
- FILE *file = (FILE *) filep;
+ FILE *file = filep;
switch (how)
{
case bfd_print_symbol_name:
{
const char *section_name;
const char *name = NULL;
- struct elf_backend_data *bed;
+ const struct elf_backend_data *bed;
unsigned char st_other;
bfd_vma val;
if (name == NULL)
{
name = symbol->name;
- bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
+ bfd_print_symbol_vandf (abfd, file, symbol);
}
fprintf (file, " %s\t", section_name);
/* Create an entry in an ELF linker hash table. */
struct bfd_hash_entry *
-_bfd_elf_link_hash_newfunc (entry, table, string)
- struct bfd_hash_entry *entry;
- struct bfd_hash_table *table;
- const char *string;
+_bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
+ struct bfd_hash_table *table,
+ const char *string)
{
/* Allocate the structure if it has not already been allocated by a
subclass. */
ret->dynstr_index = 0;
ret->elf_hash_value = 0;
ret->weakdef = NULL;
- ret->linker_section_pointer = NULL;
ret->verinfo.verdef = NULL;
ret->vtable_entries_size = 0;
ret->vtable_entries_used = NULL;
old indirect symbol. Also used for copying flags to a weakdef. */
void
-_bfd_elf_link_hash_copy_indirect (bed, dir, ind)
- struct elf_backend_data *bed;
- struct elf_link_hash_entry *dir, *ind;
+_bfd_elf_link_hash_copy_indirect (const struct elf_backend_data *bed,
+ struct elf_link_hash_entry *dir,
+ struct elf_link_hash_entry *ind)
{
bfd_signed_vma tmp;
bfd_signed_vma lowest_valid = bed->can_refcount;
}
void
-_bfd_elf_link_hash_hide_symbol (info, h, force_local)
- struct bfd_link_info *info;
- struct elf_link_hash_entry *h;
- bfd_boolean force_local;
+_bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
+ struct elf_link_hash_entry *h,
+ bfd_boolean force_local)
{
h->plt = elf_hash_table (info)->init_offset;
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
/* Initialize an ELF linker hash table. */
bfd_boolean
-_bfd_elf_link_hash_table_init (table, abfd, newfunc)
- struct elf_link_hash_table *table;
- bfd *abfd;
- struct bfd_hash_entry *(*newfunc)
- PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
- const char *));
+_bfd_elf_link_hash_table_init
+ (struct elf_link_hash_table *table,
+ bfd *abfd,
+ struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
+ struct bfd_hash_table *,
+ const char *))
{
bfd_boolean ret;
/* Create an ELF linker hash table. */
struct bfd_link_hash_table *
-_bfd_elf_link_hash_table_create (abfd)
- bfd *abfd;
+_bfd_elf_link_hash_table_create (bfd *abfd)
{
struct elf_link_hash_table *ret;
bfd_size_type amt = sizeof (struct elf_link_hash_table);
- ret = (struct elf_link_hash_table *) bfd_malloc (amt);
- if (ret == (struct elf_link_hash_table *) NULL)
+ ret = bfd_malloc (amt);
+ if (ret == NULL)
return NULL;
if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
empty string to indicate that no DT_NEEDED entry should be made. */
void
-bfd_elf_set_dt_needed_name (abfd, name)
- bfd *abfd;
- const char *name;
+bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
{
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
&& bfd_get_format (abfd) == bfd_object)
}
void
-bfd_elf_set_dt_needed_soname (abfd, name)
- bfd *abfd;
- const char *name;
+bfd_elf_set_dt_needed_soname (bfd *abfd, const char *name)
{
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
&& bfd_get_format (abfd) == bfd_object)
the linker ELF emulation code. */
struct bfd_link_needed_list *
-bfd_elf_get_needed_list (abfd, info)
- bfd *abfd ATTRIBUTE_UNUSED;
- struct bfd_link_info *info;
+bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
+ struct bfd_link_info *info)
{
if (! is_elf_hash_table (info))
return NULL;
hook for the linker ELF emulation code. */
struct bfd_link_needed_list *
-bfd_elf_get_runpath_list (abfd, info)
- bfd *abfd ATTRIBUTE_UNUSED;
- struct bfd_link_info *info;
+bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
+ struct bfd_link_info *info)
{
if (! is_elf_hash_table (info))
return NULL;
passed to bfd_elf_set_dt_needed_name, or it is the filename. */
const char *
-bfd_elf_get_dt_soname (abfd)
- bfd *abfd;
+bfd_elf_get_dt_soname (bfd *abfd)
{
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
&& bfd_get_format (abfd) == bfd_object)
the ELF linker emulation code. */
bfd_boolean
-bfd_elf_get_bfd_needed_list (abfd, pneeded)
- bfd *abfd;
- struct bfd_link_needed_list **pneeded;
+bfd_elf_get_bfd_needed_list (bfd *abfd,
+ struct bfd_link_needed_list **pneeded)
{
asection *s;
bfd_byte *dynbuf = NULL;
unsigned long shlink;
bfd_byte *extdyn, *extdynend;
size_t extdynsize;
- void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
+ void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
*pneeded = NULL;
if (s == NULL || s->_raw_size == 0)
return TRUE;
- dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
+ dynbuf = bfd_malloc (s->_raw_size);
if (dynbuf == NULL)
goto error_return;
- if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
- s->_raw_size))
+ if (! bfd_get_section_contents (abfd, s, dynbuf, 0, s->_raw_size))
goto error_return;
elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
{
Elf_Internal_Dyn dyn;
- (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
+ (*swap_dyn_in) (abfd, extdyn, &dyn);
if (dyn.d_tag == DT_NULL)
break;
goto error_return;
amt = sizeof *l;
- l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
+ l = bfd_alloc (abfd, amt);
if (l == NULL)
goto error_return;
/* Allocate an ELF string table--force the first byte to be zero. */
struct bfd_strtab_hash *
-_bfd_elf_stringtab_init ()
+_bfd_elf_stringtab_init (void)
{
struct bfd_strtab_hash *ret;
/* Create a new bfd section from an ELF section header. */
bfd_boolean
-bfd_section_from_shdr (abfd, shindex)
- bfd *abfd;
- unsigned int shindex;
+bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
{
Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
const char *name;
name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
SHF_ALLOC is set, and this is a shared object, then we also
treat this section as a BFD section. We can not base the
decision purely on SHF_ALLOC, because that flag is sometimes
- set in a relocateable object file, which would confuse the
+ set in a relocatable object file, which would confuse the
linker. */
if ((hdr->sh_flags & SHF_ALLOC) != 0
&& (abfd->flags & DYNAMIC) != 0
bfd_size_type amt;
BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
amt = sizeof (*hdr2);
- hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
+ hdr2 = bfd_alloc (abfd, amt);
elf_section_data (target_sect)->rel_hdr2 = hdr2;
}
*hdr2 = *hdr;
Return SEC for sections that have no elf section, and NULL on error. */
asection *
-bfd_section_from_r_symndx (abfd, cache, sec, r_symndx)
- bfd *abfd;
- struct sym_sec_cache *cache;
- asection *sec;
- unsigned long r_symndx;
+bfd_section_from_r_symndx (bfd *abfd,
+ struct sym_sec_cache *cache,
+ asection *sec,
+ unsigned long r_symndx)
{
Elf_Internal_Shdr *symtab_hdr;
unsigned char esym[sizeof (Elf64_External_Sym)];
}
cache->indx[ent] = r_symndx;
cache->sec[ent] = sec;
- if (isym.st_shndx < SHN_LORESERVE || isym.st_shndx > SHN_HIRESERVE)
+ if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
+ || isym.st_shndx > SHN_HIRESERVE)
{
asection *s;
s = bfd_section_from_elf_index (abfd, isym.st_shndx);
section. */
asection *
-bfd_section_from_elf_index (abfd, index)
- bfd *abfd;
- unsigned int index;
+bfd_section_from_elf_index (bfd *abfd, unsigned int index)
{
if (index >= elf_numsections (abfd))
return NULL;
return elf_elfsections (abfd)[index]->bfd_section;
}
+static struct bfd_elf_special_section const special_sections[] =
+{
+ { ".bss", 4, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
+ { ".comment", 8, 0, SHT_PROGBITS, 0 },
+ { ".data", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
+ { ".data1", 6, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
+ { ".debug", 6, 0, SHT_PROGBITS, 0 },
+ { ".fini", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
+ { ".init", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
+ { ".line", 5, 0, SHT_PROGBITS, 0 },
+ { ".rodata", 7, -2, SHT_PROGBITS, SHF_ALLOC },
+ { ".rodata1", 8, 0, SHT_PROGBITS, SHF_ALLOC },
+ { ".tbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
+ { ".tdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
+ { ".text", 5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
+ { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
+ { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
+ { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
+ { ".debug_line", 11, 0, SHT_PROGBITS, 0 },
+ { ".debug_info", 11, 0, SHT_PROGBITS, 0 },
+ { ".debug_abbrev", 13, 0, SHT_PROGBITS, 0 },
+ { ".debug_aranges", 14, 0, SHT_PROGBITS, 0 },
+ { ".dynamic", 8, 0, SHT_DYNAMIC, SHF_ALLOC },
+ { ".dynstr", 7, 0, SHT_STRTAB, SHF_ALLOC },
+ { ".dynsym", 7, 0, SHT_DYNSYM, SHF_ALLOC },
+ { ".got", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
+ { ".hash", 5, 0, SHT_HASH, SHF_ALLOC },
+ { ".interp", 7, 0, SHT_PROGBITS, 0 },
+ { ".plt", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
+ { ".shstrtab", 9, 0, SHT_STRTAB, 0 },
+ { ".strtab", 7, 0, SHT_STRTAB, 0 },
+ { ".symtab", 7, 0, SHT_SYMTAB, 0 },
+ { ".gnu.version", 12, 0, SHT_GNU_versym, 0 },
+ { ".gnu.version_d", 14, 0, SHT_GNU_verdef, 0 },
+ { ".gnu.version_r", 14, 0, SHT_GNU_verneed, 0 },
+ { ".note", 5, -1, SHT_NOTE, 0 },
+ { ".rela", 5, -1, SHT_RELA, 0 },
+ { ".rel", 4, -1, SHT_REL, 0 },
+ { ".stabstr", 5, 3, SHT_STRTAB, 0 },
+ { NULL, 0, 0, 0, 0 }
+};
+
+static const struct bfd_elf_special_section *
+get_special_section (const char *name,
+ const struct bfd_elf_special_section *special_sections,
+ unsigned int rela)
+{
+ int i;
+ int len = strlen (name);
+
+ for (i = 0; special_sections[i].prefix != NULL; i++)
+ {
+ int suffix_len;
+ int prefix_len = special_sections[i].prefix_length;
+
+ if (len < prefix_len)
+ continue;
+ if (memcmp (name, special_sections[i].prefix, prefix_len) != 0)
+ continue;
+
+ suffix_len = special_sections[i].suffix_length;
+ if (suffix_len <= 0)
+ {
+ if (name[prefix_len] != 0)
+ {
+ if (suffix_len == 0)
+ continue;
+ if (name[prefix_len] != '.'
+ && (suffix_len == -2
+ || (rela && special_sections[i].type == SHT_REL)))
+ continue;
+ }
+ }
+ else
+ {
+ if (len < prefix_len + suffix_len)
+ continue;
+ if (memcmp (name + len - suffix_len,
+ special_sections[i].prefix + prefix_len,
+ suffix_len) != 0)
+ continue;
+ }
+ return &special_sections[i];
+ }
+
+ return NULL;
+}
+
+const struct bfd_elf_special_section *
+_bfd_elf_get_sec_type_attr (bfd *abfd, const char *name)
+{
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct bfd_elf_special_section *ssect = NULL;
+
+ /* See if this is one of the special sections. */
+ if (name)
+ {
+ unsigned int rela = bed->default_use_rela_p;
+
+ if (bed->special_sections)
+ ssect = get_special_section (name, bed->special_sections, rela);
+
+ if (! ssect)
+ ssect = get_special_section (name, special_sections, rela);
+ }
+
+ return ssect;
+}
+
bfd_boolean
-_bfd_elf_new_section_hook (abfd, sec)
- bfd *abfd;
- asection *sec;
+_bfd_elf_new_section_hook (bfd *abfd, asection *sec)
{
struct bfd_elf_section_data *sdata;
+ const struct bfd_elf_special_section *ssect;
sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
if (sdata == NULL)
{
- bfd_size_type amt = sizeof (*sdata);
- sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, amt);
+ sdata = bfd_zalloc (abfd, sizeof (*sdata));
if (sdata == NULL)
return FALSE;
- sec->used_by_bfd = (PTR) sdata;
+ sec->used_by_bfd = sdata;
+ }
+
+ elf_section_type (sec) = SHT_NULL;
+ ssect = _bfd_elf_get_sec_type_attr (abfd, sec->name);
+ if (ssect != NULL)
+ {
+ elf_section_type (sec) = ssect->type;
+ elf_section_flags (sec) = ssect->attr;
}
/* Indicate whether or not this section should use RELA relocations. */
*/
bfd_boolean
-_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
- bfd *abfd;
- Elf_Internal_Phdr *hdr;
- int index;
- const char *typename;
+_bfd_elf_make_section_from_phdr (bfd *abfd,
+ Elf_Internal_Phdr *hdr,
+ int index,
+ const char *typename)
{
asection *newsect;
char *name;
&& (hdr->p_memsz > hdr->p_filesz));
sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
len = strlen (namebuf) + 1;
- name = bfd_alloc (abfd, (bfd_size_type) len);
+ name = bfd_alloc (abfd, len);
if (!name)
return FALSE;
memcpy (name, namebuf, len);
newsect->_raw_size = hdr->p_filesz;
newsect->filepos = hdr->p_offset;
newsect->flags |= SEC_HAS_CONTENTS;
+ newsect->alignment_power = bfd_log2 (hdr->p_align);
if (hdr->p_type == PT_LOAD)
{
newsect->flags |= SEC_ALLOC;
{
sprintf (namebuf, "%s%db", typename, index);
len = strlen (namebuf) + 1;
- name = bfd_alloc (abfd, (bfd_size_type) len);
+ name = bfd_alloc (abfd, len);
if (!name)
return FALSE;
memcpy (name, namebuf, len);
}
bfd_boolean
-bfd_section_from_phdr (abfd, hdr, index)
- bfd *abfd;
- Elf_Internal_Phdr *hdr;
- int index;
+bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
{
- struct elf_backend_data *bed;
+ const struct elf_backend_data *bed;
switch (hdr->p_type)
{
case PT_NOTE:
if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
return FALSE;
- if (! elfcore_read_notes (abfd, (file_ptr) hdr->p_offset, hdr->p_filesz))
+ if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
return FALSE;
return TRUE;
return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
"eh_frame_hdr");
+ case PT_GNU_STACK:
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
+
default:
/* Check for any processor-specific program segment types.
If no handler for them, default to making "segment" sections. */
relocations; otherwise, we use REL relocations. */
bfd_boolean
-_bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
- bfd *abfd;
- Elf_Internal_Shdr *rel_hdr;
- asection *asect;
- bfd_boolean use_rela_p;
+_bfd_elf_init_reloc_shdr (bfd *abfd,
+ Elf_Internal_Shdr *rel_hdr,
+ asection *asect,
+ bfd_boolean use_rela_p)
{
char *name;
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
name = bfd_alloc (abfd, amt);
/* Set up an ELF internal section header for a section. */
static void
-elf_fake_sections (abfd, asect, failedptrarg)
- bfd *abfd;
- asection *asect;
- PTR failedptrarg;
+elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
{
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
- bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ bfd_boolean *failedptr = failedptrarg;
Elf_Internal_Shdr *this_hdr;
if (*failedptr)
this_hdr->bfd_section = asect;
this_hdr->contents = NULL;
- /* FIXME: This should not be based on section names. */
- if (strcmp (asect->name, ".dynstr") == 0)
- this_hdr->sh_type = SHT_STRTAB;
- else if (strcmp (asect->name, ".hash") == 0)
+ /* If the section type is unspecified, we set it based on
+ asect->flags. */
+ if (this_hdr->sh_type == SHT_NULL)
{
- this_hdr->sh_type = SHT_HASH;
- this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
+ if ((asect->flags & SEC_ALLOC) != 0
+ && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
+ || (asect->flags & SEC_NEVER_LOAD) != 0))
+ this_hdr->sh_type = SHT_NOBITS;
+ else
+ this_hdr->sh_type = SHT_PROGBITS;
}
- else if (strcmp (asect->name, ".dynsym") == 0)
+
+ switch (this_hdr->sh_type)
{
- this_hdr->sh_type = SHT_DYNSYM;
+ default:
+ break;
+
+ case SHT_STRTAB:
+ case SHT_INIT_ARRAY:
+ case SHT_FINI_ARRAY:
+ case SHT_PREINIT_ARRAY:
+ case SHT_NOTE:
+ case SHT_NOBITS:
+ case SHT_PROGBITS:
+ break;
+
+ case SHT_HASH:
+ this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
+ break;
+
+ case SHT_DYNSYM:
this_hdr->sh_entsize = bed->s->sizeof_sym;
- }
- else if (strcmp (asect->name, ".dynamic") == 0)
- {
- this_hdr->sh_type = SHT_DYNAMIC;
+ break;
+
+ case SHT_DYNAMIC:
this_hdr->sh_entsize = bed->s->sizeof_dyn;
- }
- else if (strncmp (asect->name, ".rela", 5) == 0
- && get_elf_backend_data (abfd)->may_use_rela_p)
- {
- this_hdr->sh_type = SHT_RELA;
- this_hdr->sh_entsize = bed->s->sizeof_rela;
- }
- else if (strncmp (asect->name, ".rel", 4) == 0
- && get_elf_backend_data (abfd)->may_use_rel_p)
- {
- this_hdr->sh_type = SHT_REL;
- this_hdr->sh_entsize = bed->s->sizeof_rel;
- }
- else if (strcmp (asect->name, ".init_array") == 0)
- this_hdr->sh_type = SHT_INIT_ARRAY;
- else if (strcmp (asect->name, ".fini_array") == 0)
- this_hdr->sh_type = SHT_FINI_ARRAY;
- else if (strcmp (asect->name, ".preinit_array") == 0)
- this_hdr->sh_type = SHT_PREINIT_ARRAY;
- else if (strncmp (asect->name, ".note", 5) == 0)
- this_hdr->sh_type = SHT_NOTE;
- else if (strncmp (asect->name, ".stab", 5) == 0
- && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
- this_hdr->sh_type = SHT_STRTAB;
- else if (strcmp (asect->name, ".gnu.version") == 0)
- {
- this_hdr->sh_type = SHT_GNU_versym;
+ break;
+
+ case SHT_RELA:
+ if (get_elf_backend_data (abfd)->may_use_rela_p)
+ this_hdr->sh_entsize = bed->s->sizeof_rela;
+ break;
+
+ case SHT_REL:
+ if (get_elf_backend_data (abfd)->may_use_rel_p)
+ this_hdr->sh_entsize = bed->s->sizeof_rel;
+ break;
+
+ case SHT_GNU_versym:
this_hdr->sh_entsize = sizeof (Elf_External_Versym);
- }
- else if (strcmp (asect->name, ".gnu.version_d") == 0)
- {
- this_hdr->sh_type = SHT_GNU_verdef;
+ break;
+
+ case SHT_GNU_verdef:
this_hdr->sh_entsize = 0;
/* objcopy or strip will copy over sh_info, but may not set
cverdefs. The linker will set cverdefs, but sh_info will be
else
BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
|| this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
- }
- else if (strcmp (asect->name, ".gnu.version_r") == 0)
- {
- this_hdr->sh_type = SHT_GNU_verneed;
+ break;
+
+ case SHT_GNU_verneed:
this_hdr->sh_entsize = 0;
/* objcopy or strip will copy over sh_info, but may not set
cverrefs. The linker will set cverrefs, but sh_info will be
else
BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
|| this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
- }
- else if ((asect->flags & SEC_GROUP) != 0)
- {
- this_hdr->sh_type = SHT_GROUP;
+ break;
+
+ case SHT_GROUP:
this_hdr->sh_entsize = 4;
+ break;
}
- else if ((asect->flags & SEC_ALLOC) != 0
- && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
- || (asect->flags & SEC_NEVER_LOAD) != 0))
- this_hdr->sh_type = SHT_NOBITS;
- else
- this_hdr->sh_type = SHT_PROGBITS;
if ((asect->flags & SEC_ALLOC) != 0)
this_hdr->sh_flags |= SHF_ALLOC;
/* Fill in the contents of a SHT_GROUP section. */
void
-bfd_elf_set_group_contents (abfd, sec, failedptrarg)
- bfd *abfd;
- asection *sec;
- PTR failedptrarg;
+bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
{
- bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
+ bfd_boolean *failedptr = failedptrarg;
unsigned long symindx;
asection *elt, *first;
unsigned char *loc;
in here too, while we're at it. */
static bfd_boolean
-assign_section_numbers (abfd)
- bfd *abfd;
+assign_section_numbers (bfd *abfd)
{
struct elf_obj_tdata *t = elf_tdata (abfd);
asection *sec;
/* Set up the list of section header pointers, in agreement with the
indices. */
amt = section_number * sizeof (Elf_Internal_Shdr *);
- i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc (abfd, amt);
+ i_shdrp = bfd_zalloc (abfd, amt);
if (i_shdrp == NULL)
return FALSE;
amt = sizeof (Elf_Internal_Shdr);
- i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd, amt);
+ i_shdrp[0] = bfd_zalloc (abfd, amt);
if (i_shdrp[0] == NULL)
{
bfd_release (abfd, i_shdrp);
char *alc;
len = strlen (sec->name);
- alc = (char *) bfd_malloc ((bfd_size_type) (len - 2));
+ alc = bfd_malloc (len - 2);
if (alc == NULL)
return FALSE;
memcpy (alc, sec->name, len - 3);
/* Map symbol from it's internal number to the external number, moving
all local symbols to be at the head of the list. */
-static INLINE int
-sym_is_global (abfd, sym)
- bfd *abfd;
- asymbol *sym;
+static int
+sym_is_global (bfd *abfd, asymbol *sym)
{
/* If the backend has a special mapping, use it. */
- if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
- return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
- (abfd, sym));
+ const struct 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);
return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
|| bfd_is_und_section (bfd_get_section (sym))
}
static bfd_boolean
-elf_map_symbols (abfd)
- bfd *abfd;
+elf_map_symbols (bfd *abfd)
{
unsigned int symcount = bfd_get_symcount (abfd);
asymbol **syms = bfd_get_outsymbols (abfd);
max_index++;
amt = max_index * sizeof (asymbol *);
- sect_syms = (asymbol **) bfd_zalloc (abfd, amt);
+ sect_syms = bfd_zalloc (abfd, amt);
if (sect_syms == NULL)
return FALSE;
elf_section_syms (abfd) = sect_syms;
/* Now sort the symbols so the local symbols are first. */
amt = (num_locals + num_globals) * sizeof (asymbol *);
- new_syms = (asymbol **) bfd_alloc (abfd, amt);
+ new_syms = bfd_alloc (abfd, amt);
if (new_syms == NULL)
return FALSE;
/* Align to the maximum file alignment that could be required for any
ELF data structure. */
-static INLINE file_ptr align_file_position
- PARAMS ((file_ptr, int));
-static INLINE file_ptr
-align_file_position (off, align)
- file_ptr off;
- int align;
+static inline file_ptr
+align_file_position (file_ptr off, int align)
{
return (off + align - 1) & ~(align - 1);
}
/* Assign a file position to a section, optionally aligning to the
required section alignment. */
-INLINE file_ptr
-_bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
- Elf_Internal_Shdr *i_shdrp;
- file_ptr offset;
- bfd_boolean align;
+file_ptr
+_bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
+ file_ptr offset,
+ bfd_boolean align)
{
if (align)
{
is not NULL, this is being called by the ELF backend linker. */
bfd_boolean
-_bfd_elf_compute_section_file_positions (abfd, link_info)
- bfd *abfd;
- struct bfd_link_info *link_info;
+_bfd_elf_compute_section_file_positions (bfd *abfd,
+ struct bfd_link_info *link_info)
{
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_boolean failed;
struct bfd_strtab_hash *strtab;
Elf_Internal_Shdr *shstrtab_hdr;
/* Create a mapping from a set of sections to a program segment. */
-static INLINE struct elf_segment_map *
-make_mapping (abfd, sections, from, to, phdr)
- bfd *abfd;
- asection **sections;
- unsigned int from;
- unsigned int to;
- bfd_boolean phdr;
+static struct elf_segment_map *
+make_mapping (bfd *abfd,
+ asection **sections,
+ unsigned int from,
+ unsigned int to,
+ bfd_boolean phdr)
{
struct elf_segment_map *m;
unsigned int i;
amt = sizeof (struct elf_segment_map);
amt += (to - from - 1) * sizeof (asection *);
- m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+ m = bfd_zalloc (abfd, amt);
if (m == NULL)
return NULL;
m->next = NULL;
/* Set up a mapping from BFD sections to program segments. */
static bfd_boolean
-map_sections_to_segments (abfd)
- bfd *abfd;
+map_sections_to_segments (bfd *abfd)
{
asection **sections = NULL;
asection *s;
/* Select the allocated sections, and sort them. */
amt = bfd_count_sections (abfd) * sizeof (asection *);
- sections = (asection **) bfd_malloc (amt);
+ sections = bfd_malloc (amt);
if (sections == NULL)
goto error_return;
if (s != NULL && (s->flags & SEC_LOAD) != 0)
{
amt = sizeof (struct elf_segment_map);
- m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+ m = bfd_zalloc (abfd, amt);
if (m == NULL)
goto error_return;
m->next = NULL;
pm = &m->next;
amt = sizeof (struct elf_segment_map);
- m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+ m = bfd_zalloc (abfd, amt);
if (m == NULL)
goto error_return;
m->next = NULL;
if (dynsec != NULL)
{
amt = sizeof (struct elf_segment_map);
- m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+ m = bfd_zalloc (abfd, amt);
if (m == NULL)
goto error_return;
m->next = NULL;
&& strncmp (s->name, ".note", 5) == 0)
{
amt = sizeof (struct elf_segment_map);
- m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+ m = bfd_zalloc (abfd, amt);
if (m == NULL)
goto error_return;
m->next = NULL;
amt = sizeof (struct elf_segment_map);
amt += (tls_count - 1) * sizeof (asection *);
- m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+ m = bfd_zalloc (abfd, amt);
if (m == NULL)
goto error_return;
m->next = NULL;
&& (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
{
amt = sizeof (struct elf_segment_map);
- m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+ m = bfd_zalloc (abfd, amt);
if (m == NULL)
goto error_return;
m->next = NULL;
pm = &m->next;
}
+ if (elf_tdata (abfd)->stack_flags)
+ {
+ amt = sizeof (struct elf_segment_map);
+ m = bfd_zalloc (abfd, amt);
+ if (m == NULL)
+ goto error_return;
+ m->next = NULL;
+ m->p_type = PT_GNU_STACK;
+ m->p_flags = elf_tdata (abfd)->stack_flags;
+ m->p_flags_valid = 1;
+
+ *pm = m;
+ pm = &m->next;
+ }
+
free (sections);
sections = NULL;
/* Sort sections by address. */
static int
-elf_sort_sections (arg1, arg2)
- const PTR arg1;
- const PTR arg2;
+elf_sort_sections (const void *arg1, const void *arg2)
{
const asection *sec1 = *(const asection **) arg1;
const asection *sec2 = *(const asection **) arg2;
the file header, and writes out the program headers. */
static bfd_boolean
-assign_file_positions_for_segments (abfd)
- bfd *abfd;
+assign_file_positions_for_segments (bfd *abfd)
{
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
unsigned int count;
alloc = count;
amt = alloc * sizeof (Elf_Internal_Phdr);
- phdrs = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
+ phdrs = bfd_alloc (abfd, amt);
if (phdrs == NULL)
return FALSE;
will be two segments. */
static bfd_size_type
-get_program_header_size (abfd)
- bfd *abfd;
+get_program_header_size (bfd *abfd)
{
size_t segs;
asection *s;
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
/* We can't return a different result each time we're called. */
if (elf_tdata (abfd)->program_header_size != 0)
++segs;
}
+ if (elf_tdata (abfd)->stack_flags)
+ {
+ /* We need a PT_GNU_STACK segment. */
+ ++segs;
+ }
+
for (s = abfd->sections; s != NULL; s = s->next)
{
if ((s->flags & SEC_LOAD) != 0
We also don't set the positions of the .symtab and .strtab here. */
static bfd_boolean
-assign_file_positions_except_relocs (abfd)
- bfd *abfd;
+assign_file_positions_except_relocs (bfd *abfd)
{
struct elf_obj_tdata * const tdata = elf_tdata (abfd);
Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
unsigned int num_sec = elf_numsections (abfd);
file_ptr off;
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
&& bfd_get_format (abfd) != bfd_core)
}
static bfd_boolean
-prep_headers (abfd)
- bfd *abfd;
+prep_headers (bfd *abfd)
{
Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
struct elf_strtab_hash *shstrtab;
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
i_ehdrp = elf_elfheader (abfd);
i_shdrp = elf_elfsections (abfd);
Such need can generally be supplied by replacing the tests for
e_machine with the conditions used to determine it. */
default:
- if (get_elf_backend_data (abfd) != NULL)
- i_ehdrp->e_machine = get_elf_backend_data (abfd)->elf_machine_code;
- else
- i_ehdrp->e_machine = EM_NONE;
- }
+ i_ehdrp->e_machine = bed->elf_machine_code;
+ }
i_ehdrp->e_version = bed->s->ev_current;
i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
of the loadable file image. */
void
-_bfd_elf_assign_file_positions_for_relocs (abfd)
- bfd *abfd;
+_bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
{
file_ptr off;
unsigned int i, num_sec;
}
bfd_boolean
-_bfd_elf_write_object_contents (abfd)
- bfd *abfd;
+_bfd_elf_write_object_contents (bfd *abfd)
{
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
Elf_Internal_Ehdr *i_ehdrp;
Elf_Internal_Shdr **i_shdrp;
bfd_boolean failed;
unsigned int count, num_sec;
if (! abfd->output_has_begun
- && ! _bfd_elf_compute_section_file_positions
- (abfd, (struct bfd_link_info *) NULL))
+ && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
return FALSE;
i_shdrp = elf_elfsections (abfd);
}
bfd_boolean
-_bfd_elf_write_corefile_contents (abfd)
- bfd *abfd;
+_bfd_elf_write_corefile_contents (bfd *abfd)
{
/* Hopefully this can be done just like an object file. */
return _bfd_elf_write_object_contents (abfd);
/* Given a section, search the header to find them. */
int
-_bfd_elf_section_from_bfd_section (abfd, asect)
- bfd *abfd;
- struct sec *asect;
+_bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
{
- struct elf_backend_data *bed;
+ const struct elf_backend_data *bed;
int index;
if (elf_section_data (asect) != NULL
on error. */
int
-_bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
- bfd *abfd;
- asymbol **asym_ptr_ptr;
+_bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
{
asymbol *asym_ptr = *asym_ptr_ptr;
int idx;
/* Copy private BFD data. This copies any program header information. */
static bfd_boolean
-copy_private_bfd_data (ibfd, obfd)
- bfd *ibfd;
- bfd *obfd;
+copy_private_bfd_data (bfd *ibfd, bfd *obfd)
{
Elf_Internal_Ehdr *iehdr;
struct elf_segment_map *map;
bfd_vma maxpagesize;
struct elf_segment_map *phdr_adjust_seg = NULL;
unsigned int phdr_adjust_num = 0;
- struct elf_backend_data *bed;
+ const struct elf_backend_data *bed;
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
all of the sections we have selected. */
amt = sizeof (struct elf_segment_map);
amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
- map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
+ map = bfd_alloc (obfd, amt);
if (map == NULL)
return FALSE;
/* Gcc 2.96 miscompiles this code on mips. Don't do casting here
to work around this long long bug. */
amt = section_count * sizeof (asection *);
- sections = (asection **) bfd_malloc (amt);
+ sections = bfd_malloc (amt);
if (sections == NULL)
return FALSE;
and carry on looping. */
amt = sizeof (struct elf_segment_map);
amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
- map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
+ map = bfd_alloc (obfd, amt);
if (map == NULL)
{
free (sections);
field, and sometimes the info field. */
bfd_boolean
-_bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
- bfd *ibfd;
- asection *isec;
- bfd *obfd;
- asection *osec;
+_bfd_elf_copy_private_section_data (bfd *ibfd,
+ asection *isec,
+ bfd *obfd,
+ asection *osec)
{
Elf_Internal_Shdr *ihdr, *ohdr;
#define MAP_SYM_SHNDX (SHN_HIOS + 5)
bfd_boolean
-_bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
- bfd *ibfd;
- asymbol *isymarg;
- bfd *obfd;
- asymbol *osymarg;
+_bfd_elf_copy_private_symbol_data (bfd *ibfd,
+ asymbol *isymarg,
+ bfd *obfd,
+ asymbol *osymarg)
{
elf_symbol_type *isym, *osym;
/* Swap out the symbols. */
static bfd_boolean
-swap_out_syms (abfd, sttp, relocatable_p)
- bfd *abfd;
- struct bfd_strtab_hash **sttp;
- int relocatable_p;
+swap_out_syms (bfd *abfd,
+ struct bfd_strtab_hash **sttp,
+ int relocatable_p)
{
- struct elf_backend_data *bed;
+ const struct elf_backend_data *bed;
int symcount;
asymbol **syms;
struct bfd_strtab_hash *stt;
_bfd_stringtab_free (stt);
return FALSE;
}
- symtab_hdr->contents = (PTR) outbound_syms;
+ symtab_hdr->contents = outbound_syms;
outbound_shndx = NULL;
symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
always has a dummy entry as symbol #0, so it ends up even. */
long
-_bfd_elf_get_symtab_upper_bound (abfd)
- bfd *abfd;
+_bfd_elf_get_symtab_upper_bound (bfd *abfd)
{
long symcount;
long symtab_size;
}
long
-_bfd_elf_get_dynamic_symtab_upper_bound (abfd)
- bfd *abfd;
+_bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
{
long symcount;
long symtab_size;
}
long
-_bfd_elf_get_reloc_upper_bound (abfd, asect)
- bfd *abfd ATTRIBUTE_UNUSED;
- sec_ptr asect;
+_bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
+ sec_ptr asect)
{
return (asect->reloc_count + 1) * sizeof (arelent *);
}
/* Canonicalize the relocs. */
long
-_bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
- bfd *abfd;
- sec_ptr section;
- arelent **relptr;
- asymbol **symbols;
+_bfd_elf_canonicalize_reloc (bfd *abfd,
+ sec_ptr section,
+ arelent **relptr,
+ asymbol **symbols)
{
arelent *tblptr;
unsigned int i;
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
return -1;
}
long
-_bfd_elf_get_symtab (abfd, alocation)
- bfd *abfd;
- asymbol **alocation;
+_bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
{
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
- long symcount = bed->s->slurp_symbol_table (abfd, alocation, FALSE);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
if (symcount >= 0)
bfd_get_symcount (abfd) = symcount;
}
long
-_bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
- bfd *abfd;
- asymbol **alocation;
+_bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
+ asymbol **allocation)
{
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
- long symcount = bed->s->slurp_symbol_table (abfd, alocation, TRUE);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
if (symcount >= 0)
bfd_get_dynamic_symcount (abfd) = symcount;
considered to be a dynamic reloc section. */
long
-_bfd_elf_get_dynamic_reloc_upper_bound (abfd)
- bfd *abfd;
+_bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
{
long ret;
asection *s;
section. */
long
-_bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
- bfd *abfd;
- arelent **storage;
- asymbol **syms;
+_bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
+ arelent **storage,
+ asymbol **syms)
{
- bfd_boolean (*slurp_relocs)
- PARAMS ((bfd *, asection *, asymbol **, bfd_boolean));
+ bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
asection *s;
long ret;
/* Read in the version information. */
bfd_boolean
-_bfd_elf_slurp_version_tables (abfd)
- bfd *abfd;
+_bfd_elf_slurp_version_tables (bfd *abfd)
{
bfd_byte *contents = NULL;
bfd_size_type amt;
hdr = &elf_tdata (abfd)->dynverdef_hdr;
- contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
+ contents = bfd_malloc (hdr->sh_size);
if (contents == NULL)
goto error_return;
if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
- || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
+ || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
goto error_return;
/* We know the number of entries in the section but not the maximum
}
amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
- elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) bfd_zalloc (abfd, amt);
+ elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
if (elf_tdata (abfd)->verdef == NULL)
goto error_return;
iverdef->vd_bfd = abfd;
amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
- iverdef->vd_auxptr = (Elf_Internal_Verdaux *) bfd_alloc (abfd, amt);
+ iverdef->vd_auxptr = bfd_alloc (abfd, amt);
if (iverdef->vd_auxptr == NULL)
goto error_return;
hdr = &elf_tdata (abfd)->dynverref_hdr;
amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
- elf_tdata (abfd)->verref =
- (Elf_Internal_Verneed *) bfd_zalloc (abfd, amt);
+ elf_tdata (abfd)->verref = bfd_zalloc (abfd, amt);
if (elf_tdata (abfd)->verref == NULL)
goto error_return;
elf_tdata (abfd)->cverrefs = hdr->sh_info;
- contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
+ contents = bfd_malloc (hdr->sh_size);
if (contents == NULL)
goto error_return;
if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
- || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
+ || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
goto error_return;
everneed = (Elf_External_Verneed *) contents;
amt = iverneed->vn_cnt;
amt *= sizeof (Elf_Internal_Vernaux);
- iverneed->vn_auxptr = (Elf_Internal_Vernaux *) bfd_alloc (abfd, amt);
+ iverneed->vn_auxptr = bfd_alloc (abfd, amt);
evernaux = ((Elf_External_Vernaux *)
((bfd_byte *) everneed + iverneed->vn_aux));
}
\f
asymbol *
-_bfd_elf_make_empty_symbol (abfd)
- bfd *abfd;
+_bfd_elf_make_empty_symbol (bfd *abfd)
{
elf_symbol_type *newsym;
bfd_size_type amt = sizeof (elf_symbol_type);
- newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
+ newsym = bfd_zalloc (abfd, amt);
if (!newsym)
return NULL;
else
}
void
-_bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
- bfd *ignore_abfd ATTRIBUTE_UNUSED;
- asymbol *symbol;
- symbol_info *ret;
+_bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
+ asymbol *symbol,
+ symbol_info *ret)
{
bfd_symbol_info (symbol, ret);
}
override it. */
bfd_boolean
-_bfd_elf_is_local_label_name (abfd, name)
- bfd *abfd ATTRIBUTE_UNUSED;
- const char *name;
+_bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
+ const char *name)
{
/* Normal local symbols start with ``.L''. */
if (name[0] == '.' && name[1] == 'L')
}
alent *
-_bfd_elf_get_lineno (ignore_abfd, symbol)
- bfd *ignore_abfd ATTRIBUTE_UNUSED;
- asymbol *symbol ATTRIBUTE_UNUSED;
+_bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
+ asymbol *symbol ATTRIBUTE_UNUSED)
{
abort ();
return NULL;
}
bfd_boolean
-_bfd_elf_set_arch_mach (abfd, arch, machine)
- bfd *abfd;
- enum bfd_architecture arch;
- unsigned long machine;
+_bfd_elf_set_arch_mach (bfd *abfd,
+ enum bfd_architecture arch,
+ unsigned long machine)
{
/* If this isn't the right architecture for this backend, and this
isn't the generic backend, fail. */
for error reporting. */
static bfd_boolean
-elf_find_function (abfd, section, symbols, offset,
- filename_ptr, functionname_ptr)
- bfd *abfd ATTRIBUTE_UNUSED;
- asection *section;
- asymbol **symbols;
- bfd_vma offset;
- const char **filename_ptr;
- const char **functionname_ptr;
+elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *section,
+ asymbol **symbols,
+ bfd_vma offset,
+ const char **filename_ptr,
+ const char **functionname_ptr)
{
const char *filename;
asymbol *func;
for error reporting. */
bfd_boolean
-_bfd_elf_find_nearest_line (abfd, section, symbols, offset,
- filename_ptr, functionname_ptr, line_ptr)
- bfd *abfd;
- asection *section;
- asymbol **symbols;
- bfd_vma offset;
- const char **filename_ptr;
- const char **functionname_ptr;
- unsigned int *line_ptr;
+_bfd_elf_find_nearest_line (bfd *abfd,
+ asection *section,
+ asymbol **symbols,
+ bfd_vma offset,
+ const char **filename_ptr,
+ const char **functionname_ptr,
+ unsigned int *line_ptr)
{
bfd_boolean found;
}
int
-_bfd_elf_sizeof_headers (abfd, reloc)
- bfd *abfd;
- bfd_boolean reloc;
+_bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
{
int ret;
}
bfd_boolean
-_bfd_elf_set_section_contents (abfd, section, location, offset, count)
- bfd *abfd;
- sec_ptr section;
- PTR location;
- file_ptr offset;
- bfd_size_type count;
+_bfd_elf_set_section_contents (bfd *abfd,
+ sec_ptr section,
+ void *location,
+ file_ptr offset,
+ bfd_size_type count)
{
Elf_Internal_Shdr *hdr;
bfd_signed_vma pos;
if (! abfd->output_has_begun
- && ! (_bfd_elf_compute_section_file_positions
- (abfd, (struct bfd_link_info *) NULL)))
+ && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
return FALSE;
hdr = &elf_section_data (section)->this_hdr;
}
void
-_bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
- bfd *abfd ATTRIBUTE_UNUSED;
- arelent *cache_ptr ATTRIBUTE_UNUSED;
- Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
+_bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
+ arelent *cache_ptr ATTRIBUTE_UNUSED,
+ Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
{
abort ();
}
/* Try to convert a non-ELF reloc into an ELF one. */
bfd_boolean
-_bfd_elf_validate_reloc (abfd, areloc)
- bfd *abfd;
- arelent *areloc;
+_bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
{
/* Check whether we really have an ELF howto. */
}
bfd_boolean
-_bfd_elf_close_and_cleanup (abfd)
- bfd *abfd;
+_bfd_elf_close_and_cleanup (bfd *abfd)
{
if (bfd_get_format (abfd) == bfd_object)
{
this reloc. */
bfd_reloc_status_type
-_bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
- bfd *abfd ATTRIBUTE_UNUSED;
- arelent *re ATTRIBUTE_UNUSED;
- struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
- PTR data ATTRIBUTE_UNUSED;
- asection *is ATTRIBUTE_UNUSED;
- bfd *obfd ATTRIBUTE_UNUSED;
- char **errmsg ATTRIBUTE_UNUSED;
+_bfd_elf_rel_vtable_reloc_fn
+ (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
+ struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
+ bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
{
return bfd_reloc_ok;
}
/* FIXME: this is kinda wrong, but it's what gdb wants. */
static int
-elfcore_make_pid (abfd)
- bfd *abfd;
+elfcore_make_pid (bfd *abfd)
{
return ((elf_tdata (abfd)->core_lwpid << 16)
+ (elf_tdata (abfd)->core_pid));
overwrite it. */
static bfd_boolean
-elfcore_maybe_make_sect (abfd, name, sect)
- bfd *abfd;
- char *name;
- asection *sect;
+elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
{
asection *sect2;
PID is elfcore_make_pid (abfd).
Both pseudosections have identical contents. */
bfd_boolean
-_bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
- bfd *abfd;
- char *name;
- size_t size;
- ufile_ptr filepos;
+_bfd_elfcore_make_pseudosection (bfd *abfd,
+ char *name,
+ size_t size,
+ ufile_ptr filepos)
{
char buf[100];
char *threaded_name;
sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
len = strlen (buf) + 1;
- threaded_name = bfd_alloc (abfd, (bfd_size_type) len);
+ threaded_name = bfd_alloc (abfd, len);
if (threaded_name == NULL)
return FALSE;
memcpy (threaded_name, buf, len);
- sect = bfd_make_section (abfd, threaded_name);
+ sect = bfd_make_section_anyway (abfd, threaded_name);
if (sect == NULL)
return FALSE;
sect->_raw_size = size;
*/
#if defined (HAVE_PRSTATUS_T)
-static bfd_boolean elfcore_grok_prstatus
- PARAMS ((bfd *, Elf_Internal_Note *));
static bfd_boolean
-elfcore_grok_prstatus (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
size_t raw_size;
int offset;
/* Create a pseudosection containing the exact contents of NOTE. */
static bfd_boolean
-elfcore_make_note_pseudosection (abfd, name, note)
- bfd *abfd;
- char *name;
- Elf_Internal_Note *note;
+elfcore_make_note_pseudosection (bfd *abfd,
+ char *name,
+ Elf_Internal_Note *note)
{
return _bfd_elfcore_make_pseudosection (abfd, name,
note->descsz, note->descpos);
data structure apart. */
static bfd_boolean
-elfcore_grok_prfpreg (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
{
return elfcore_make_note_pseudosection (abfd, ".reg2", note);
}
literally. */
static bfd_boolean
-elfcore_grok_prxfpreg (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
{
return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
}
the copy will always have a terminating '\0'. */
char *
-_bfd_elfcore_strndup (abfd, start, max)
- bfd *abfd;
- char *start;
- size_t max;
+_bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
{
char *dups;
char *end = memchr (start, '\0', max);
else
len = end - start;
- dups = bfd_alloc (abfd, (bfd_size_type) len + 1);
+ dups = bfd_alloc (abfd, len + 1);
if (dups == NULL)
return NULL;
}
#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
-static bfd_boolean elfcore_grok_psinfo
- PARAMS ((bfd *, Elf_Internal_Note *));
-
static bfd_boolean
-elfcore_grok_psinfo (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
if (note->descsz == sizeof (elfcore_psinfo_t))
{
#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
#if defined (HAVE_PSTATUS_T)
-static bfd_boolean elfcore_grok_pstatus
- PARAMS ((bfd *, Elf_Internal_Note *));
-
static bfd_boolean
-elfcore_grok_pstatus (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
{
if (note->descsz == sizeof (pstatus_t)
#if defined (HAVE_PXSTATUS_T)
#endif /* defined (HAVE_PSTATUS_T) */
#if defined (HAVE_LWPSTATUS_T)
-static bfd_boolean elfcore_grok_lwpstatus
- PARAMS ((bfd *, Elf_Internal_Note *));
-
static bfd_boolean
-elfcore_grok_lwpstatus (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
{
lwpstatus_t lwpstat;
char buf[100];
sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
len = strlen (buf) + 1;
- name = bfd_alloc (abfd, (bfd_size_type) len);
+ name = bfd_alloc (abfd, len);
if (name == NULL)
return FALSE;
memcpy (name, buf, len);
- sect = bfd_make_section (abfd, name);
+ sect = bfd_make_section_anyway (abfd, name);
if (sect == NULL)
return FALSE;
sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
len = strlen (buf) + 1;
- name = bfd_alloc (abfd, (bfd_size_type) len);
+ name = bfd_alloc (abfd, len);
if (name == NULL)
return FALSE;
memcpy (name, buf, len);
- sect = bfd_make_section (abfd, name);
+ sect = bfd_make_section_anyway (abfd, name);
if (sect == NULL)
return FALSE;
#if defined (HAVE_WIN32_PSTATUS_T)
static bfd_boolean
-elfcore_grok_win32pstatus (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
{
char buf[30];
char *name;
sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
len = strlen (buf) + 1;
- name = bfd_alloc (abfd, (bfd_size_type) len);
+ name = bfd_alloc (abfd, len);
if (name == NULL)
return FALSE;
memcpy (name, buf, len);
- sect = bfd_make_section (abfd, name);
+ sect = bfd_make_section_anyway (abfd, name);
if (sect == NULL)
return FALSE;
sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
len = strlen (buf) + 1;
- name = bfd_alloc (abfd, (bfd_size_type) len);
+ name = bfd_alloc (abfd, len);
if (name == NULL)
return FALSE;
memcpy (name, buf, len);
- sect = bfd_make_section (abfd, name);
+ sect = bfd_make_section_anyway (abfd, name);
if (sect == NULL)
return FALSE;
#endif /* HAVE_WIN32_PSTATUS_T */
static bfd_boolean
-elfcore_grok_note (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
{
- struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
switch (note->type)
{
case NT_AUXV:
{
- asection *sect = bfd_make_section (abfd, ".auxv");
+ asection *sect = bfd_make_section_anyway (abfd, ".auxv");
if (sect == NULL)
return FALSE;
}
static bfd_boolean
-elfcore_netbsd_get_lwpid (note, lwpidp)
- Elf_Internal_Note *note;
- int *lwpidp;
+elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
{
char *cp;
}
static bfd_boolean
-elfcore_grok_netbsd_procinfo (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
{
/* Signal number at offset 0x08. */
}
static bfd_boolean
-elfcore_grok_netbsd_note (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
{
int lwp;
}
static bfd_boolean
-elfcore_grok_nto_status (abfd, note, tid)
- bfd *abfd;
- Elf_Internal_Note *note;
- pid_t *tid;
+elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
{
void *ddata = note->descdata;
char buf[100];
/* Make a ".qnx_core_status/%d" section. */
sprintf (buf, ".qnx_core_status/%d", *tid);
- name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
+ name = bfd_alloc (abfd, strlen (buf) + 1);
if (name == NULL)
return FALSE;
strcpy (name, buf);
- sect = bfd_make_section (abfd, name);
+ sect = bfd_make_section_anyway (abfd, name);
if (sect == NULL)
return FALSE;
}
static bfd_boolean
-elfcore_grok_nto_gregs (abfd, note, tid)
- bfd *abfd;
- Elf_Internal_Note *note;
- pid_t tid;
+elfcore_grok_nto_gregs (bfd *abfd, Elf_Internal_Note *note, pid_t tid)
{
char buf[100];
char *name;
/* Make a ".reg/%d" section. */
sprintf (buf, ".reg/%d", tid);
- name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
+ name = bfd_alloc (abfd, strlen (buf) + 1);
if (name == NULL)
return FALSE;
strcpy (name, buf);
- sect = bfd_make_section (abfd, name);
+ sect = bfd_make_section_anyway (abfd, name);
if (sect == NULL)
return FALSE;
#define BFD_QNT_CORE_FPREG 10
static bfd_boolean
-elfcore_grok_nto_note (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
{
/* Every GREG section has a STATUS section before it. Store the
tid from the previous call to pass down to the next gregs
End of buffer containing note. */
char *
-elfcore_write_note (abfd, buf, bufsiz, name, type, input, size)
- bfd *abfd;
- char *buf;
- int *bufsiz;
- const char *name;
- int type;
- const PTR input;
- int size;
+elfcore_write_note (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ const char *name,
+ int type,
+ const void *input,
+ int size)
{
Elf_External_Note *xnp;
size_t namesz;
pad = 0;
if (name != NULL)
{
- struct elf_backend_data *bed;
+ const struct elf_backend_data *bed;
namesz = strlen (name) + 1;
bed = get_elf_backend_data (abfd);
pad = -namesz & ((1 << bed->s->log_file_align) - 1);
}
- newspace = sizeof (Elf_External_Note) - 1 + namesz + pad + size;
+ newspace = 12 + namesz + pad + size;
p = realloc (buf, *bufsiz + newspace);
dest = p + *bufsiz;
#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
char *
-elfcore_write_prpsinfo (abfd, buf, bufsiz, fname, psargs)
- bfd *abfd;
- char *buf;
- int *bufsiz;
- const char *fname;
- const char *psargs;
+elfcore_write_prpsinfo (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ const char *fname,
+ const char *psargs)
{
int note_type;
char *note_name = "CORE";
#if defined (HAVE_PRSTATUS_T)
char *
-elfcore_write_prstatus (abfd, buf, bufsiz, pid, cursig, gregs)
- bfd *abfd;
- char *buf;
- int *bufsiz;
- long pid;
- int cursig;
- const PTR gregs;
+elfcore_write_prstatus (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ long pid,
+ int cursig,
+ const void *gregs)
{
prstatus_t prstat;
char *note_name = "CORE";
#if defined (HAVE_LWPSTATUS_T)
char *
-elfcore_write_lwpstatus (abfd, buf, bufsiz, pid, cursig, gregs)
- bfd *abfd;
- char *buf;
- int *bufsiz;
- long pid;
- int cursig;
- const PTR gregs;
+elfcore_write_lwpstatus (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ long pid,
+ int cursig,
+ const void *gregs)
{
lwpstatus_t lwpstat;
char *note_name = "CORE";
#if defined (HAVE_PSTATUS_T)
char *
-elfcore_write_pstatus (abfd, buf, bufsiz, pid, cursig, gregs)
- bfd *abfd;
- char *buf;
- int *bufsiz;
- long pid;
- int cursig;
- const PTR gregs;
+elfcore_write_pstatus (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ long pid,
+ int cursig,
+ const void *gregs)
{
pstatus_t pstat;
char *note_name = "CORE";
#endif /* HAVE_PSTATUS_T */
char *
-elfcore_write_prfpreg (abfd, buf, bufsiz, fpregs, size)
- bfd *abfd;
- char *buf;
- int *bufsiz;
- const PTR fpregs;
- int size;
+elfcore_write_prfpreg (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ const void *fpregs,
+ int size)
{
char *note_name = "CORE";
return elfcore_write_note (abfd, buf, bufsiz,
}
char *
-elfcore_write_prxfpreg (abfd, buf, bufsiz, xfpregs, size)
- bfd *abfd;
- char *buf;
- int *bufsiz;
- const PTR xfpregs;
- int size;
+elfcore_write_prxfpreg (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ const void *xfpregs,
+ int size)
{
char *note_name = "LINUX";
return elfcore_write_note (abfd, buf, bufsiz,
}
static bfd_boolean
-elfcore_read_notes (abfd, offset, size)
- bfd *abfd;
- file_ptr offset;
- bfd_size_type size;
+elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
{
char *buf;
char *p;
occurs; bfd_get_error will return an appropriate code. */
long
-bfd_get_elf_phdr_upper_bound (abfd)
- bfd *abfd;
+bfd_get_elf_phdr_upper_bound (bfd *abfd)
{
if (abfd->xvec->flavour != bfd_target_elf_flavour)
{
error occurs; bfd_get_error will return an appropriate code. */
int
-bfd_get_elf_phdrs (abfd, phdrs)
- bfd *abfd;
- void *phdrs;
+bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
{
int num_phdrs;
}
void
-_bfd_elf_sprintf_vma (abfd, buf, value)
- bfd *abfd ATTRIBUTE_UNUSED;
- char *buf;
- bfd_vma value;
+_bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
{
#ifdef BFD64
Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
}
void
-_bfd_elf_fprintf_vma (abfd, stream, value)
- bfd *abfd ATTRIBUTE_UNUSED;
- PTR stream;
- bfd_vma value;
+_bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
{
#ifdef BFD64
Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
}
enum elf_reloc_type_class
-_bfd_elf_reloc_type_class (rela)
- const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED;
+_bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
{
return reloc_class_normal;
}
relocation against a local symbol. */
bfd_vma
-_bfd_elf_rela_local_sym (abfd, sym, sec, rel)
- bfd *abfd;
- Elf_Internal_Sym *sym;
- asection *sec;
- Elf_Internal_Rela *rel;
+_bfd_elf_rela_local_sym (bfd *abfd,
+ Elf_Internal_Sym *sym,
+ asection *sec,
+ Elf_Internal_Rela *rel)
{
bfd_vma relocation;
_bfd_merged_section_offset (abfd, &msec,
elf_section_data (sec)->sec_info,
sym->st_value + rel->r_addend,
- (bfd_vma) 0)
+ 0)
- relocation;
rel->r_addend += msec->output_section->vma + msec->output_offset;
}
}
bfd_vma
-_bfd_elf_rel_local_sym (abfd, sym, psec, addend)
- bfd *abfd;
- Elf_Internal_Sym *sym;
- asection **psec;
- bfd_vma addend;
+_bfd_elf_rel_local_sym (bfd *abfd,
+ Elf_Internal_Sym *sym,
+ asection **psec,
+ bfd_vma addend)
{
asection *sec = *psec;
return _bfd_merged_section_offset (abfd, psec,
elf_section_data (sec)->sec_info,
- sym->st_value + addend, (bfd_vma) 0);
+ sym->st_value + addend, 0);
}
bfd_vma
-_bfd_elf_section_offset (abfd, info, sec, offset)
- bfd *abfd;
- struct bfd_link_info *info;
- asection *sec;
- bfd_vma offset;
+_bfd_elf_section_offset (bfd *abfd,
+ struct bfd_link_info *info,
+ asection *sec,
+ bfd_vma offset)
{
struct bfd_elf_section_data *sec_data;
the remote memory. */
bfd *
-bfd_elf_bfd_from_remote_memory (templ, ehdr_vma, loadbasep, target_read_memory)
- bfd *templ;
- bfd_vma ehdr_vma;
- bfd_vma *loadbasep;
- int (*target_read_memory) PARAMS ((bfd_vma vma, char *myaddr, int len));
+bfd_elf_bfd_from_remote_memory
+ (bfd *templ,
+ bfd_vma ehdr_vma,
+ bfd_vma *loadbasep,
+ int (*target_read_memory) (bfd_vma, char *, int))
{
return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
(templ, ehdr_vma, loadbasep, target_read_memory);
projects / deliverable / binutils-gdb.git / blobdiff