/* ELF executable support for BFD.
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
- Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+ 2003 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
+ along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* SECTION
#include "libiberty.h"
static INLINE struct elf_segment_map *make_mapping
- PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
-static boolean map_sections_to_segments PARAMS ((bfd *));
-static int elf_sort_sections PARAMS ((const PTR, const PTR));
-static boolean assign_file_positions_for_segments PARAMS ((bfd *));
-static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
-static boolean prep_headers PARAMS ((bfd *));
-static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
-static 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 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 boolean assign_section_numbers PARAMS ((bfd *));
-static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
-static boolean elf_map_symbols PARAMS ((bfd *));
-static bfd_size_type get_program_header_size PARAMS ((bfd *));
-static boolean elfcore_read_notes PARAMS ((bfd *, file_ptr, bfd_size_type));
-static boolean elf_find_function PARAMS ((bfd *, asection *, asymbol **,
- bfd_vma, const char **,
- const char **));
-static int elfcore_make_pid PARAMS ((bfd *));
-static boolean elfcore_maybe_make_sect PARAMS ((bfd *, char *, asection *));
-static boolean elfcore_make_note_pseudosection PARAMS ((bfd *, char *,
- Elf_Internal_Note *));
-static boolean elfcore_grok_prfpreg PARAMS ((bfd *, Elf_Internal_Note *));
-static boolean elfcore_grok_prxfpreg PARAMS ((bfd *, Elf_Internal_Note *));
-static boolean elfcore_grok_note PARAMS ((bfd *, Elf_Internal_Note *));
-
-static boolean elfcore_netbsd_get_lwpid PARAMS ((Elf_Internal_Note *, int *));
-static boolean elfcore_grok_netbsd_procinfo PARAMS ((bfd *,
- Elf_Internal_Note *));
-static boolean elfcore_grok_netbsd_note PARAMS ((bfd *, Elf_Internal_Note *));
+ 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 *));
/* Swap version information in and out. The version information is
currently size independent. If that ever changes, this code will
h ^= g;
}
}
- return h;
+ return h & 0xffffffff;
}
/* Read a specified number of bytes at a specified offset in an ELF
return buf;
}
-boolean
+bfd_boolean
bfd_elf_mkobject (abfd)
bfd *abfd;
{
bfd_size_type amt = sizeof (struct elf_obj_tdata);
elf_tdata (abfd) = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
if (elf_tdata (abfd) == 0)
- return false;
+ return FALSE;
/* Since everything is done at close time, do we need any
initialization? */
- return true;
+ return TRUE;
}
-boolean
+bfd_boolean
bfd_elf_mkcorefile (abfd)
bfd *abfd;
{
return intsym_buf;
}
+/* Look up a symbol name. */
+const char *
+bfd_elf_local_sym_name (abfd, isym)
+ bfd *abfd;
+ Elf_Internal_Sym *isym;
+{
+ unsigned int iname = isym->st_name;
+ unsigned int shindex = elf_tdata (abfd)->symtab_hdr.sh_link;
+ if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION)
+ {
+ iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
+ shindex = elf_elfheader (abfd)->e_shstrndx;
+ }
+
+ return bfd_elf_string_from_elf_section (abfd, shindex, iname);
+}
+
/* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
sections. The first element is the flags, the rest are section
pointers. */
unsigned char esym[sizeof (Elf64_External_Sym)];
Elf_External_Sym_Shndx eshndx;
Elf_Internal_Sym isym;
- unsigned int iname;
- unsigned int shindex;
/* First we need to ensure the symbol table is available. */
if (! bfd_section_from_shdr (abfd, ghdr->sh_link))
&isym, esym, &eshndx) == NULL)
return NULL;
- /* Look up the symbol name. */
- iname = isym.st_name;
- shindex = hdr->sh_link;
- if (iname == 0 && ELF_ST_TYPE (isym.st_info) == STT_SECTION)
- {
- iname = elf_elfsections (abfd)[isym.st_shndx]->sh_name;
- shindex = elf_elfheader (abfd)->e_shstrndx;
- }
-
- return bfd_elf_string_from_elf_section (abfd, shindex, iname);
+ return bfd_elf_local_sym_name (abfd, &isym);
}
/* Set next_in_group list pointer, and group name for NEWSECT. */
-static boolean
+static bfd_boolean
setup_group (abfd, hdr, newsect)
bfd *abfd;
Elf_Internal_Shdr *hdr;
bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
if (elf_tdata (abfd)->group_sect_ptr == NULL)
- return false;
+ return FALSE;
num_group = 0;
for (i = 0; i < shnum; i++)
|| bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
|| (bfd_bread (shdr->contents, shdr->sh_size, abfd)
!= shdr->sh_size))
- return false;
+ return FALSE;
/* Translate raw contents, a flag word followed by an
array of elf section indices all in target byte order,
gname = group_signature (abfd, shdr);
if (gname == NULL)
- return false;
+ return FALSE;
elf_group_name (newsect) = gname;
/* Start a circular list with one element. */
(*_bfd_error_handler) (_("%s: no group info for section %s"),
bfd_archive_filename (abfd), newsect->name);
}
- return true;
+ return TRUE;
}
-boolean
+bfd_boolean
bfd_elf_discard_group (abfd, group)
bfd *abfd ATTRIBUTE_UNUSED;
asection *group;
if (s == first)
break;
}
- return true;
+ return TRUE;
}
/* Make a BFD section from an ELF section. We store a pointer to the
BFD section in the bfd_section field of the header. */
-boolean
+bfd_boolean
_bfd_elf_make_section_from_shdr (abfd, hdr, name)
bfd *abfd;
Elf_Internal_Shdr *hdr;
{
BFD_ASSERT (strcmp (name,
bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
- return true;
+ return TRUE;
}
newsect = bfd_make_section_anyway (abfd, name);
if (newsect == NULL)
- return false;
+ return FALSE;
newsect->filepos = hdr->sh_offset;
|| ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
|| ! bfd_set_section_alignment (abfd, newsect,
bfd_log2 ((bfd_vma) hdr->sh_addralign)))
- return false;
+ return FALSE;
flags = SEC_NO_FLAGS;
if (hdr->sh_type != SHT_NOBITS)
}
if (hdr->sh_flags & SHF_GROUP)
if (!setup_group (abfd, hdr, newsect))
- return false;
+ return FALSE;
if ((hdr->sh_flags & SHF_TLS) != 0)
flags |= SEC_THREAD_LOCAL;
bed = get_elf_backend_data (abfd);
if (bed->elf_backend_section_flags)
if (! bed->elf_backend_section_flags (&flags, hdr))
- return false;
+ return FALSE;
if (! bfd_set_section_flags (abfd, newsect, flags))
- return false;
+ return FALSE;
if ((flags & SEC_ALLOC) != 0)
{
hdr->bfd_section = newsect;
elf_section_data (newsect)->this_hdr = *hdr;
- return true;
+ return TRUE;
}
/*
"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,
bfd *abfd ATTRIBUTE_UNUSED;
asection *sec;
{
- struct bfd_elf_section_data *sec_data;
-
- sec_data = elf_section_data (sec);
- BFD_ASSERT (sec_data->sec_info_type == ELF_INFO_TYPE_MERGE);
- sec_data->sec_info_type = ELF_INFO_TYPE_NONE;
+ BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
+ sec->sec_info_type = ELF_INFO_TYPE_NONE;
}
/* Finish SHF_MERGE section merging. */
-boolean
+bfd_boolean
_bfd_elf_merge_sections (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
{
if (!is_elf_hash_table (info))
- return false;
+ return FALSE;
if (elf_hash_table (info)->merge_info)
_bfd_merge_sections (abfd, elf_hash_table (info)->merge_info,
merge_sections_remove_hook);
- return true;
+ return TRUE;
}
void
if (!is_elf_hash_table (info))
return;
- elf_section_data (sec)->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
+ sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
}
\f
/* Copy the program header and other data from one object module to
another. */
-boolean
+bfd_boolean
_bfd_elf_copy_private_bfd_data (ibfd, obfd)
bfd *ibfd;
bfd *obfd;
{
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return true;
+ return TRUE;
BFD_ASSERT (!elf_flags_init (obfd)
|| (elf_elfheader (obfd)->e_flags
elf_gp (obfd) = elf_gp (ibfd);
elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
- elf_flags_init (obfd) = true;
- return true;
+ elf_flags_init (obfd) = TRUE;
+ return TRUE;
}
/* Print out the program headers. */
-boolean
+bfd_boolean
_bfd_elf_print_private_bfd_data (abfd, farg)
bfd *abfd;
PTR farg;
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);
Elf_Internal_Dyn dyn;
const char *name;
char ab[20];
- boolean stringp;
+ bfd_boolean stringp;
(*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
if (dyn.d_tag == DT_NULL)
break;
- stringp = false;
+ stringp = FALSE;
switch (dyn.d_tag)
{
default:
name = ab;
break;
- case DT_NEEDED: name = "NEEDED"; stringp = true; break;
+ case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
case DT_PLTRELSZ: name = "PLTRELSZ"; break;
case DT_PLTGOT: name = "PLTGOT"; break;
case DT_HASH: name = "HASH"; break;
case DT_SYMENT: name = "SYMENT"; break;
case DT_INIT: name = "INIT"; break;
case DT_FINI: name = "FINI"; break;
- case DT_SONAME: name = "SONAME"; stringp = true; break;
- case DT_RPATH: name = "RPATH"; stringp = true; break;
+ case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
+ case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
case DT_SYMBOLIC: name = "SYMBOLIC"; break;
case DT_REL: name = "REL"; break;
case DT_RELSZ: name = "RELSZ"; break;
case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
- case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
+ case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
case DT_FLAGS: name = "FLAGS"; break;
case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
case DT_POSFLAG_1: name = "POSFLAG_1"; break;
case DT_SYMINSZ: name = "SYMINSZ"; break;
case DT_SYMINENT: name = "SYMINENT"; break;
- case DT_CONFIG: name = "CONFIG"; stringp = true; break;
- case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
- case DT_AUDIT: name = "AUDIT"; stringp = true; break;
+ case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
+ case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
+ case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
case DT_PLTPAD: name = "PLTPAD"; break;
case DT_MOVETAB: name = "MOVETAB"; break;
case DT_SYMINFO: name = "SYMINFO"; break;
case DT_VERDEFNUM: name = "VERDEFNUM"; break;
case DT_VERNEED: name = "VERNEED"; break;
case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
- case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
+ case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
case DT_USED: name = "USED"; break;
- case DT_FILTER: name = "FILTER"; stringp = true; break;
+ case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
}
fprintf (f, " %-11s ", name);
|| (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
{
if (! _bfd_elf_slurp_version_tables (abfd))
- return false;
+ return FALSE;
}
if (elf_dynverdef (abfd) != 0)
}
}
- return true;
+ return TRUE;
error_return:
if (dynbuf != NULL)
free (dynbuf);
- return false;
+ return FALSE;
}
/* Display ELF-specific fields of a symbol. */
/* Set local fields. */
ret->indx = -1;
- ret->size = 0;
ret->dynindx = -1;
ret->dynstr_index = 0;
+ ret->elf_hash_value = 0;
ret->weakdef = NULL;
- ret->got.refcount = htab->init_refcount;
- ret->plt.refcount = htab->init_refcount;
ret->linker_section_pointer = NULL;
ret->verinfo.verdef = NULL;
- ret->vtable_entries_used = NULL;
ret->vtable_entries_size = 0;
+ ret->vtable_entries_used = NULL;
ret->vtable_parent = NULL;
+ ret->got = htab->init_refcount;
+ ret->plt = htab->init_refcount;
+ ret->size = 0;
ret->type = STT_NOTYPE;
ret->other = 0;
/* Assume that we have been called by a non-ELF symbol reader.
_bfd_elf_link_hash_hide_symbol (info, h, force_local)
struct bfd_link_info *info;
struct elf_link_hash_entry *h;
- boolean force_local;
+ bfd_boolean force_local;
{
- h->plt.offset = (bfd_vma) -1;
+ h->plt = elf_hash_table (info)->init_offset;
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
if (force_local)
{
/* Initialize an ELF linker hash table. */
-boolean
+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 *));
+ struct bfd_hash_entry *(*newfunc)
+ PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
+ const char *));
{
- boolean ret;
+ bfd_boolean ret;
- table->dynamic_sections_created = false;
+ table->dynamic_sections_created = FALSE;
table->dynobj = NULL;
- table->init_refcount = get_elf_backend_data (abfd)->can_refcount - 1;
+ /* Make sure can_refcount is extended to the width and signedness of
+ init_refcount before we subtract one from it. */
+ table->init_refcount.refcount = get_elf_backend_data (abfd)->can_refcount;
+ table->init_refcount.refcount -= 1;
+ table->init_offset.offset = -(bfd_vma) 1;
/* The first dynamic symbol is a dummy. */
table->dynsymcount = 1;
table->dynstr = NULL;
table->bucketcount = 0;
table->needed = NULL;
- table->runpath = NULL;
- table->loaded = NULL;
table->hgot = NULL;
table->stab_info = NULL;
table->merge_info = NULL;
+ memset (&table->eh_info, 0, sizeof (table->eh_info));
table->dynlocal = NULL;
- ret = _bfd_link_hash_table_init (& table->root, abfd, newfunc);
+ table->runpath = NULL;
+ table->tls_segment = NULL;
+ table->loaded = NULL;
+
+ ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc);
table->root.type = bfd_link_elf_hash_table;
return ret;
bfd *abfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info;
{
- if (info->hash->creator->flavour != bfd_target_elf_flavour)
+ if (! is_elf_hash_table (info))
return NULL;
return elf_hash_table (info)->needed;
}
bfd *abfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info;
{
- if (info->hash->creator->flavour != bfd_target_elf_flavour)
+ if (! is_elf_hash_table (info))
return NULL;
return elf_hash_table (info)->runpath;
}
/* Get the list of DT_NEEDED entries from a BFD. This is a hook for
the ELF linker emulation code. */
-boolean
+bfd_boolean
bfd_elf_get_bfd_needed_list (abfd, pneeded)
bfd *abfd;
struct bfd_link_needed_list **pneeded;
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
|| bfd_get_format (abfd) != bfd_object)
- return true;
+ return TRUE;
s = bfd_get_section_by_name (abfd, ".dynamic");
if (s == NULL || s->_raw_size == 0)
- return true;
+ return TRUE;
dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
if (dynbuf == NULL)
free (dynbuf);
- return true;
+ return TRUE;
error_return:
if (dynbuf != NULL)
free (dynbuf);
- return false;
+ return FALSE;
}
\f
/* Allocate an ELF string table--force the first byte to be zero. */
{
bfd_size_type loc;
- loc = _bfd_stringtab_add (ret, "", true, false);
+ loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
if (loc == (bfd_size_type) -1)
{
/* Create a new bfd section from an ELF section header. */
-boolean
+bfd_boolean
bfd_section_from_shdr (abfd, shindex)
bfd *abfd;
unsigned int shindex;
{
case SHT_NULL:
/* Inactive section. Throw it away. */
- return true;
+ return TRUE;
case SHT_PROGBITS: /* Normal section with contents. */
case SHT_NOBITS: /* .bss section. */
case SHT_DYNAMIC: /* Dynamic linking information. */
if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
- return false;
+ return FALSE;
if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
{
Elf_Internal_Shdr *dynsymhdr;
case SHT_SYMTAB: /* A symbol table */
if (elf_onesymtab (abfd) == shindex)
- return true;
+ return TRUE;
BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
BFD_ASSERT (elf_onesymtab (abfd) == 0);
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_elf_make_section_from_shdr (abfd, hdr, name))
- return false;
+ return FALSE;
- return true;
+ return TRUE;
case SHT_DYNSYM: /* A dynamic symbol table */
if (elf_dynsymtab (abfd) == shindex)
- return true;
+ return TRUE;
BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
BFD_ASSERT (elf_dynsymtab (abfd) == 0);
case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
if (elf_symtab_shndx (abfd) == shindex)
- return true;
+ return TRUE;
/* Get the associated symbol table. */
if (! bfd_section_from_shdr (abfd, hdr->sh_link)
|| hdr->sh_link != elf_onesymtab (abfd))
- return false;
+ return FALSE;
elf_symtab_shndx (abfd) = shindex;
elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
- return true;
+ return TRUE;
case SHT_STRTAB: /* A string table */
if (hdr->bfd_section != NULL)
- return true;
+ return TRUE;
if (ehdr->e_shstrndx == shindex)
{
elf_tdata (abfd)->shstrtab_hdr = *hdr;
elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
- return true;
+ return TRUE;
}
{
unsigned int i, num_sec;
if (hdr2->sh_link == shindex)
{
if (! bfd_section_from_shdr (abfd, i))
- return false;
+ return FALSE;
if (elf_onesymtab (abfd) == i)
{
elf_tdata (abfd)->strtab_hdr = *hdr;
elf_elfsections (abfd)[shindex] =
&elf_tdata (abfd)->strtab_hdr;
- return true;
+ return TRUE;
}
if (elf_dynsymtab (abfd) == i)
{
/* Get the symbol table. */
if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
&& ! bfd_section_from_shdr (abfd, hdr->sh_link))
- return false;
+ return FALSE;
/* If this reloc section does not use the main symbol table we
don't treat it as a reloc section. BFD can't adequately
return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
if (! bfd_section_from_shdr (abfd, hdr->sh_info))
- return false;
+ return FALSE;
target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
if (target_sect == NULL)
- return false;
+ return FALSE;
if ((target_sect->flags & SEC_RELOC) == 0
|| target_sect->reloc_count == 0)
/* In the section to which the relocations apply, mark whether
its relocations are of the REL or RELA variety. */
if (hdr->sh_size != 0)
- elf_section_data (target_sect)->use_rela_p
- = (hdr->sh_type == SHT_RELA);
+ target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
abfd->flags |= HAS_RELOC;
- return true;
+ return TRUE;
}
break;
break;
case SHT_SHLIB:
- return true;
+ return TRUE;
case SHT_GROUP:
/* We need a BFD section for objcopy and relocatable linking,
name. */
name = group_signature (abfd, hdr);
if (name == NULL)
- return false;
+ return FALSE;
if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
- return false;
+ return FALSE;
if (hdr->contents != NULL)
{
Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
break;
}
- return true;
+ return TRUE;
}
/* Return the section for the local symbol specified by ABFD, R_SYMNDX.
return elf_elfsections (abfd)[index]->bfd_section;
}
-boolean
+bfd_boolean
_bfd_elf_new_section_hook (abfd, sec)
bfd *abfd;
asection *sec;
{
struct bfd_elf_section_data *sdata;
- bfd_size_type amt = sizeof (*sdata);
- sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, amt);
- if (!sdata)
- return false;
- sec->used_by_bfd = (PTR) sdata;
+ 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);
+ if (sdata == NULL)
+ return FALSE;
+ sec->used_by_bfd = (PTR) sdata;
+ }
/* Indicate whether or not this section should use RELA relocations. */
- sdata->use_rela_p
- = get_elf_backend_data (abfd)->default_use_rela_p;
+ sec->use_rela_p = get_elf_backend_data (abfd)->default_use_rela_p;
- return true;
+ return TRUE;
}
/* Create a new bfd section from an ELF program header.
*/
-boolean
+bfd_boolean
_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
bfd *abfd;
Elf_Internal_Phdr *hdr;
len = strlen (namebuf) + 1;
name = bfd_alloc (abfd, (bfd_size_type) len);
if (!name)
- return false;
+ return FALSE;
memcpy (name, namebuf, len);
newsect = bfd_make_section (abfd, name);
if (newsect == NULL)
- return false;
+ return FALSE;
newsect->vma = hdr->p_vaddr;
newsect->lma = hdr->p_paddr;
newsect->_raw_size = hdr->p_filesz;
len = strlen (namebuf) + 1;
name = bfd_alloc (abfd, (bfd_size_type) len);
if (!name)
- return false;
+ return FALSE;
memcpy (name, namebuf, len);
newsect = bfd_make_section (abfd, name);
if (newsect == NULL)
- return false;
+ return FALSE;
newsect->vma = hdr->p_vaddr + hdr->p_filesz;
newsect->lma = hdr->p_paddr + hdr->p_filesz;
newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
newsect->flags |= SEC_READONLY;
}
- return true;
+ return TRUE;
}
-boolean
+bfd_boolean
bfd_section_from_phdr (abfd, hdr, index)
bfd *abfd;
Elf_Internal_Phdr *hdr;
case PT_NOTE:
if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
- return false;
+ return FALSE;
if (! elfcore_read_notes (abfd, (file_ptr) hdr->p_offset, hdr->p_filesz))
- return false;
- return true;
+ return FALSE;
+ return TRUE;
case PT_SHLIB:
return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
case PT_PHDR:
return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
+ case PT_GNU_EH_FRAME:
+ 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. */
}
/* Initialize REL_HDR, the section-header for new section, containing
- relocations against ASECT. If USE_RELA_P is true, we use RELA
+ relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
relocations; otherwise, we use REL relocations. */
-boolean
+bfd_boolean
_bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
bfd *abfd;
Elf_Internal_Shdr *rel_hdr;
asection *asect;
- boolean use_rela_p;
+ bfd_boolean use_rela_p;
{
char *name;
struct elf_backend_data *bed = get_elf_backend_data (abfd);
name = bfd_alloc (abfd, amt);
if (name == NULL)
- return false;
+ return FALSE;
sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
rel_hdr->sh_name =
(unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
- false);
+ FALSE);
if (rel_hdr->sh_name == (unsigned int) -1)
- return false;
+ return FALSE;
rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
rel_hdr->sh_entsize = (use_rela_p
? bed->s->sizeof_rela
: bed->s->sizeof_rel);
- rel_hdr->sh_addralign = bed->s->file_align;
+ rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
rel_hdr->sh_flags = 0;
rel_hdr->sh_addr = 0;
rel_hdr->sh_size = 0;
rel_hdr->sh_offset = 0;
- return true;
+ return TRUE;
}
/* Set up an ELF internal section header for a section. */
PTR failedptrarg;
{
struct elf_backend_data *bed = get_elf_backend_data (abfd);
- boolean *failedptr = (boolean *) failedptrarg;
+ bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
Elf_Internal_Shdr *this_hdr;
if (*failedptr)
this_hdr = &elf_section_data (asect)->this_hdr;
- this_hdr->sh_name = (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd),
- asect->name, false);
- if (this_hdr->sh_name == (unsigned long) -1)
+ this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
+ asect->name, FALSE);
+ if (this_hdr->sh_name == (unsigned int) -1)
{
- *failedptr = true;
+ *failedptr = TRUE;
return;
}
if (asect->_raw_size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
{
struct bfd_link_order *o;
-
+
this_hdr->sh_size = 0;
for (o = asect->link_order_head; o != NULL; o = o->next)
if (this_hdr->sh_size < o->offset + o->size)
/* Check for processor-specific section types. */
if (bed->elf_backend_fake_sections
&& !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
- *failedptr = true;
+ *failedptr = TRUE;
/* If the section has relocs, set up a section header for the
SHT_REL[A] section. If two relocation sections are required for
&& !_bfd_elf_init_reloc_shdr (abfd,
&elf_section_data (asect)->rel_hdr,
asect,
- elf_section_data (asect)->use_rela_p))
- *failedptr = true;
+ asect->use_rela_p))
+ *failedptr = TRUE;
}
/* Fill in the contents of a SHT_GROUP section. */
asection *sec;
PTR failedptrarg;
{
- boolean *failedptr = (boolean *) failedptrarg;
+ bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
unsigned long symindx;
asection *elt, *first;
unsigned char *loc;
struct bfd_link_order *l;
- boolean gas;
+ bfd_boolean gas;
if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
|| *failedptr)
elf_section_data (sec)->this_hdr.sh_info = symindx;
/* The contents won't be allocated for "ld -r" or objcopy. */
- gas = true;
+ gas = TRUE;
if (sec->contents == NULL)
{
- gas = false;
+ gas = FALSE;
sec->contents = bfd_alloc (abfd, sec->_raw_size);
/* Arrange for the section to be written out. */
elf_section_data (sec)->this_hdr.contents = sec->contents;
if (sec->contents == NULL)
{
- *failedptr = true;
+ *failedptr = TRUE;
return;
}
}
too. The link/info pointers for the standard section types are filled
in here too, while we're at it. */
-static boolean
+static bfd_boolean
assign_section_numbers (abfd)
bfd *abfd;
{
t->symtab_shndx_section = section_number++;
t->symtab_shndx_hdr.sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
- ".symtab_shndx", false);
+ ".symtab_shndx", FALSE);
if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
- return false;
+ return FALSE;
}
if (section_number == SHN_LORESERVE)
section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
/* 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_alloc (abfd, amt);
+ i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc (abfd, amt);
if (i_shdrp == NULL)
- return false;
+ return FALSE;
amt = sizeof (Elf_Internal_Shdr);
- i_shdrp[0] = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
+ i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd, amt);
if (i_shdrp[0] == NULL)
{
bfd_release (abfd, i_shdrp);
- return false;
+ return FALSE;
}
- memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
elf_elfsections (abfd) = i_shdrp;
len = strlen (sec->name);
alc = (char *) bfd_malloc ((bfd_size_type) (len - 2));
if (alc == NULL)
- return false;
+ return FALSE;
memcpy (alc, sec->name, len - 3);
alc[len - 3] = '\0';
s = bfd_get_section_by_name (abfd, alc);
else
i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
i_shdrp[secn]->sh_name);
- return true;
+ return TRUE;
}
/* Map symbol from it's internal number to the external number, moving
|| bfd_is_com_section (bfd_get_section (sym)));
}
-static boolean
+static bfd_boolean
elf_map_symbols (abfd)
bfd *abfd;
{
amt = max_index * sizeof (asymbol *);
sect_syms = (asymbol **) bfd_zalloc (abfd, amt);
if (sect_syms == NULL)
- return false;
+ return FALSE;
elf_section_syms (abfd) = sect_syms;
elf_num_section_syms (abfd) = max_index;
new_syms = (asymbol **) bfd_alloc (abfd, amt);
if (new_syms == NULL)
- return false;
+ return FALSE;
for (idx = 0; idx < symcount; idx++)
{
elf_num_locals (abfd) = num_locals;
elf_num_globals (abfd) = num_globals;
- return true;
+ return TRUE;
}
/* 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
+ PARAMS ((file_ptr, int));
static INLINE file_ptr
align_file_position (off, align)
file_ptr off;
_bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
Elf_Internal_Shdr *i_shdrp;
file_ptr offset;
- boolean align;
+ bfd_boolean align;
{
if (align)
{
otherwise prepare to begin writing out the ELF file. If LINK_INFO
is not NULL, this is being called by the ELF backend linker. */
-boolean
+bfd_boolean
_bfd_elf_compute_section_file_positions (abfd, link_info)
bfd *abfd;
struct bfd_link_info *link_info;
{
struct elf_backend_data *bed = get_elf_backend_data (abfd);
- boolean failed;
+ bfd_boolean failed;
struct bfd_strtab_hash *strtab;
Elf_Internal_Shdr *shstrtab_hdr;
if (abfd->output_has_begun)
- return true;
+ return TRUE;
/* Do any elf backend specific processing first. */
if (bed->elf_backend_begin_write_processing)
(*bed->elf_backend_begin_write_processing) (abfd, link_info);
if (! prep_headers (abfd))
- return false;
+ return FALSE;
/* Post process the headers if necessary. */
if (bed->elf_backend_post_process_headers)
(*bed->elf_backend_post_process_headers) (abfd, link_info);
- failed = false;
+ failed = FALSE;
bfd_map_over_sections (abfd, elf_fake_sections, &failed);
if (failed)
- return false;
+ return FALSE;
if (!assign_section_numbers (abfd))
- return false;
+ return FALSE;
/* The backend linker builds symbol table information itself. */
if (link_info == NULL && bfd_get_symcount (abfd) > 0)
int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
if (! swap_out_syms (abfd, &strtab, relocatable_p))
- return false;
+ return FALSE;
}
if (link_info == NULL)
{
bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
if (failed)
- return false;
+ return FALSE;
}
shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
shstrtab_hdr->sh_addralign = 1;
if (!assign_file_positions_except_relocs (abfd))
- return false;
+ return FALSE;
if (link_info == NULL && bfd_get_symcount (abfd) > 0)
{
off = elf_tdata (abfd)->next_file_pos;
hdr = &elf_tdata (abfd)->symtab_hdr;
- off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+ off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
if (hdr->sh_size != 0)
- off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+ off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
hdr = &elf_tdata (abfd)->strtab_hdr;
- off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+ off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
elf_tdata (abfd)->next_file_pos = off;
out. */
if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
|| ! _bfd_stringtab_emit (abfd, strtab))
- return false;
+ return FALSE;
_bfd_stringtab_free (strtab);
}
- abfd->output_has_begun = true;
+ abfd->output_has_begun = TRUE;
- return true;
+ return TRUE;
}
/* Create a mapping from a set of sections to a program segment. */
asection **sections;
unsigned int from;
unsigned int to;
- boolean phdr;
+ bfd_boolean phdr;
{
struct elf_segment_map *m;
unsigned int i;
/* Set up a mapping from BFD sections to program segments. */
-static boolean
+static bfd_boolean
map_sections_to_segments (abfd)
bfd *abfd;
{
unsigned int phdr_index;
bfd_vma maxpagesize;
asection **hdrpp;
- boolean phdr_in_segment = true;
- boolean writable;
+ bfd_boolean phdr_in_segment = TRUE;
+ bfd_boolean writable;
int tls_count = 0;
asection *first_tls = NULL;
asection *dynsec, *eh_frame_hdr;
bfd_size_type amt;
if (elf_tdata (abfd)->segment_map != NULL)
- return true;
+ return TRUE;
if (bfd_count_sections (abfd) == 0)
- return true;
+ return TRUE;
/* Select the allocated sections, and sort them. */
last_hdr = NULL;
phdr_index = 0;
maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
- writable = false;
+ writable = FALSE;
dynsec = bfd_get_section_by_name (abfd, ".dynamic");
if (dynsec != NULL
&& (dynsec->flags & SEC_LOAD) == 0)
if ((abfd->flags & D_PAGED) == 0
|| sections[0]->lma < phdr_size
|| sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
- phdr_in_segment = false;
+ phdr_in_segment = FALSE;
}
for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
{
asection *hdr;
- boolean new_segment;
+ bfd_boolean new_segment;
hdr = *hdrpp;
{
/* If we don't have a segment yet, then we don't need a new
one (we build the last one after this loop). */
- new_segment = false;
+ new_segment = FALSE;
}
else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
{
/* If this section has a different relation between the
virtual address and the load address, then we need a new
segment. */
- new_segment = true;
+ new_segment = TRUE;
}
else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
< BFD_ALIGN (hdr->lma, maxpagesize))
{
/* If putting this section in this segment would force us to
skip a page in the segment, then we need a new segment. */
- new_segment = true;
+ new_segment = TRUE;
}
else if ((last_hdr->flags & SEC_LOAD) == 0
&& (hdr->flags & SEC_LOAD) != 0)
{
/* We don't want to put a loadable section after a
nonloadable section in the same segment. */
- new_segment = true;
+ new_segment = TRUE;
}
else if ((abfd->flags & D_PAGED) == 0)
{
/* If the file is not demand paged, which means that we
don't require the sections to be correctly aligned in the
file, then there is no other reason for a new segment. */
- new_segment = false;
+ new_segment = FALSE;
}
else if (! writable
&& (hdr->flags & SEC_READONLY) == 0
- && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
- == hdr->lma))
+ && (((last_hdr->lma + last_hdr->_raw_size - 1)
+ & ~(maxpagesize - 1))
+ != (hdr->lma & ~(maxpagesize - 1))))
{
/* We don't want to put a writable section in a read only
segment, unless they are on the same page in memory
only case in which the new section is not on the same
page as the previous section is when the previous section
ends precisely on a page boundary. */
- new_segment = true;
+ new_segment = TRUE;
}
else
{
/* Otherwise, we can use the same segment. */
- new_segment = false;
+ new_segment = FALSE;
}
if (! new_segment)
{
if ((hdr->flags & SEC_READONLY) == 0)
- writable = true;
+ writable = TRUE;
last_hdr = hdr;
continue;
}
pm = &m->next;
if ((hdr->flags & SEC_READONLY) == 0)
- writable = true;
+ writable = TRUE;
else
- writable = false;
+ writable = FALSE;
last_hdr = hdr;
phdr_index = i;
- phdr_in_segment = false;
+ phdr_in_segment = FALSE;
}
/* Create a final PT_LOAD program segment. */
/* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
segment. */
- eh_frame_hdr = NULL;
- if (elf_tdata (abfd)->eh_frame_hdr)
- eh_frame_hdr = bfd_get_section_by_name (abfd, ".eh_frame_hdr");
- if (eh_frame_hdr != NULL && (eh_frame_hdr->flags & SEC_LOAD))
+ eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
+ if (eh_frame_hdr != 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->next = NULL;
m->p_type = PT_GNU_EH_FRAME;
m->count = 1;
- m->sections[0] = eh_frame_hdr;
+ m->sections[0] = eh_frame_hdr->output_section;
+
+ *pm = m;
+ pm = &m->next;
+ }
+
+ if (elf_tdata (abfd)->stack_flags)
+ {
+ amt = sizeof (struct elf_segment_map);
+ m = (struct elf_segment_map *) 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;
sections = NULL;
elf_tdata (abfd)->segment_map = mfirst;
- return true;
+ return TRUE;
error_return:
if (sections != NULL)
free (sections);
- return false;
+ return FALSE;
}
/* Sort sections by address. */
{
const asection *sec1 = *(const asection **) arg1;
const asection *sec2 = *(const asection **) arg2;
+ bfd_size_type size1, size2;
/* Sort by LMA first, since this is the address used to
place the section into a segment. */
/* Put !SEC_LOAD sections after SEC_LOAD ones. */
-#define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
+#define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
if (TOEND (sec1))
{
/* Sort by size, to put zero sized sections
before others at the same address. */
- if (sec1->_raw_size < sec2->_raw_size)
+ size1 = (sec1->flags & SEC_LOAD) ? sec1->_raw_size : 0;
+ size2 = (sec2->flags & SEC_LOAD) ? sec2->_raw_size : 0;
+
+ if (size1 < size2)
return -1;
- if (sec1->_raw_size > sec2->_raw_size)
+ if (size1 > size2)
return 1;
return sec1->target_index - sec2->target_index;
sections to segments. This function also sets up some fields in
the file header, and writes out the program headers. */
-static boolean
+static bfd_boolean
assign_file_positions_for_segments (abfd)
bfd *abfd;
{
if (elf_tdata (abfd)->segment_map == NULL)
{
if (! map_sections_to_segments (abfd))
- return false;
+ return FALSE;
}
else
{
if (bed->elf_backend_modify_segment_map)
{
if (! (*bed->elf_backend_modify_segment_map) (abfd))
- return false;
+ return FALSE;
}
count = 0;
elf_elfheader (abfd)->e_phnum = count;
if (count == 0)
- return true;
+ return TRUE;
/* If we already counted the number of program segments, make sure
that we allocated enough space. This happens when SIZEOF_HEADERS
(_("%s: Not enough room for program headers (allocated %u, need %u)"),
bfd_get_filename (abfd), alloc, count));
bfd_set_error (bfd_error_bad_value);
- return false;
+ return FALSE;
}
if (alloc == 0)
amt = alloc * sizeof (Elf_Internal_Phdr);
phdrs = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
if (phdrs == NULL)
- return false;
+ return FALSE;
off = bed->s->sizeof_ehdr;
off += alloc * bed->s->sizeof_phdr;
&& (abfd->flags & D_PAGED) != 0)
p->p_align = bed->maxpagesize;
else if (m->count == 0)
- p->p_align = bed->s->file_align;
+ p->p_align = 1 << bed->s->log_file_align;
else
p->p_align = 0;
(_("%s: Not enough room for program headers, try linking with -N"),
bfd_get_filename (abfd));
bfd_set_error (bfd_error_bad_value);
- return false;
+ return FALSE;
}
p->p_vaddr -= off;
bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
p->p_memsz += adjust;
- off += adjust;
- voff += adjust;
- if ((flags & SEC_LOAD) != 0)
+ if (p->p_type == PT_LOAD
+ || (p->p_type == PT_NOTE
+ && bfd_get_format (abfd) == bfd_core))
+ {
+ off += adjust;
+ voff += adjust;
+ }
+ if ((flags & SEC_LOAD) != 0
+ || (flags & SEC_THREAD_LOCAL) != 0)
p->p_filesz += adjust;
}
bfd_section_name (abfd, sec),
sec->lma,
p->p_paddr);
- return false;
+ return FALSE;
}
p->p_memsz += adjust;
off += adjust;
|| (flags & SEC_HAS_CONTENTS) != 0)
off += sec->_raw_size;
- if ((flags & SEC_ALLOC) != 0)
+ if ((flags & SEC_ALLOC) != 0
+ && ((flags & SEC_LOAD) != 0
+ || (flags & SEC_THREAD_LOCAL) == 0))
voff += sec->_raw_size;
}
}
else
{
+ if ((sec->flags & SEC_LOAD) != 0
+ || (sec->flags & SEC_THREAD_LOCAL) == 0
+ || p->p_type == PT_TLS)
p->p_memsz += sec->_raw_size;
if ((flags & SEC_LOAD) != 0)
}
}
- /* If additional nonloadable filepos adjustments are required,
- do them now. */
- if (bed->set_nonloadable_filepos)
- (*bed->set_nonloadable_filepos) (abfd, phdrs);
-
/* Clear out any program headers we allocated but did not use. */
for (; count < alloc; count++, p++)
{
/* Write out the program headers. */
if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
|| bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
- return false;
+ return FALSE;
- return true;
+ return TRUE;
}
/* Get the size of the program header.
++segs;
}
- if (elf_tdata (abfd)->eh_frame_hdr
- && bfd_get_section_by_name (abfd, ".eh_frame_hdr") != NULL)
+ if (elf_tdata (abfd)->eh_frame_hdr)
{
/* We need a PT_GNU_EH_FRAME segment. */
++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 boolean
+static bfd_boolean
assign_file_positions_except_relocs (abfd)
bfd *abfd;
{
hdr->sh_offset = -1;
}
else
- off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+ off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
if (i == SHN_LORESERVE - 1)
{
/* Assign file positions for the loaded sections based on the
assignment of sections to segments. */
if (! assign_file_positions_for_segments (abfd))
- return false;
+ return FALSE;
/* Assign file positions for the other sections. */
else
off += (hdr->sh_addr - off) % hdr->sh_addralign;
off = _bfd_elf_assign_file_position_for_section (hdr, off,
- false);
+ FALSE);
}
else if (hdr->sh_type == SHT_REL
|| hdr->sh_type == SHT_RELA
|| hdr == i_shdrpp[tdata->strtab_section])
hdr->sh_offset = -1;
else
- off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+ off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
if (i == SHN_LORESERVE - 1)
{
}
/* Place the section headers. */
- off = align_file_position (off, bed->s->file_align);
+ off = align_file_position (off, 1 << bed->s->log_file_align);
i_ehdrp->e_shoff = off;
off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
elf_tdata (abfd)->next_file_pos = off;
- return true;
+ return TRUE;
}
-static boolean
+static bfd_boolean
prep_headers (abfd)
bfd *abfd;
{
shstrtab = _bfd_elf_strtab_init ();
if (shstrtab == NULL)
- return false;
+ return FALSE;
elf_shstrtab (abfd) = shstrtab;
}
elf_tdata (abfd)->symtab_hdr.sh_name =
- (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", false);
+ (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
elf_tdata (abfd)->strtab_hdr.sh_name =
- (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", false);
+ (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
elf_tdata (abfd)->shstrtab_hdr.sh_name =
- (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", false);
+ (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
|| elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
|| elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
- return false;
+ return FALSE;
- return true;
+ return TRUE;
}
/* Assign file positions for all the reloc sections which are not part
shdrp = *shdrpp;
if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
&& shdrp->sh_offset == -1)
- off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
+ off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
}
elf_tdata (abfd)->next_file_pos = off;
}
-boolean
+bfd_boolean
_bfd_elf_write_object_contents (abfd)
bfd *abfd;
{
struct elf_backend_data *bed = get_elf_backend_data (abfd);
Elf_Internal_Ehdr *i_ehdrp;
Elf_Internal_Shdr **i_shdrp;
- boolean failed;
+ 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))
- return false;
+ return FALSE;
i_shdrp = elf_elfsections (abfd);
i_ehdrp = elf_elfheader (abfd);
- failed = false;
+ failed = FALSE;
bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
if (failed)
- return false;
+ return FALSE;
_bfd_elf_assign_file_positions_for_relocs (abfd);
if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
|| bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
- return false;
+ return FALSE;
}
if (count == SHN_LORESERVE - 1)
count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
/* Write out the section header names. */
if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
|| ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
- return false;
+ return FALSE;
if (bed->elf_backend_final_write_processing)
(*bed->elf_backend_final_write_processing) (abfd,
return bed->s->write_shdrs_and_ehdr (abfd);
}
-boolean
+bfd_boolean
_bfd_elf_write_corefile_contents (abfd)
bfd *abfd;
{
/* Copy private BFD data. This copies any program header information. */
-static boolean
+static bfd_boolean
copy_private_bfd_data (ibfd, obfd)
bfd *ibfd;
bfd *obfd;
{
- Elf_Internal_Ehdr * iehdr;
- struct elf_segment_map * map;
- struct elf_segment_map * map_first;
- struct elf_segment_map ** pointer_to_map;
- Elf_Internal_Phdr * segment;
- asection * section;
- unsigned int i;
- unsigned int num_segments;
- boolean phdr_included = false;
- bfd_vma maxpagesize;
- struct elf_segment_map * phdr_adjust_seg = NULL;
- unsigned int phdr_adjust_num = 0;
- struct elf_backend_data * bed;
+ Elf_Internal_Ehdr *iehdr;
+ struct elf_segment_map *map;
+ struct elf_segment_map *map_first;
+ struct elf_segment_map **pointer_to_map;
+ Elf_Internal_Phdr *segment;
+ asection *section;
+ unsigned int i;
+ unsigned int num_segments;
+ bfd_boolean phdr_included = FALSE;
+ bfd_vma maxpagesize;
+ struct elf_segment_map *phdr_adjust_seg = NULL;
+ unsigned int phdr_adjust_num = 0;
+ struct elf_backend_data *bed;
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return true;
+ return TRUE;
if (elf_tdata (ibfd)->phdr == NULL)
- return true;
+ return TRUE;
bed = get_elf_backend_data (ibfd);
iehdr = elf_elfheader (ibfd);
(start + (segment->p_memsz > segment->p_filesz \
? segment->p_memsz : segment->p_filesz))
- /* Returns true if the given section is contained within
+#define SECTION_SIZE(section, segment) \
+ (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
+ != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
+ ? section->_raw_size : 0)
+
+ /* Returns TRUE if the given section is contained within
the given segment. VMA addresses are compared. */
#define IS_CONTAINED_BY_VMA(section, segment) \
(section->vma >= segment->p_vaddr \
- && (section->vma + section->_raw_size \
+ && (section->vma + SECTION_SIZE (section, segment) \
<= (SEGMENT_END (segment, segment->p_vaddr))))
- /* Returns true if the given section is contained within
+ /* Returns TRUE if the given section is contained within
the given segment. LMA addresses are compared. */
#define IS_CONTAINED_BY_LMA(section, segment, base) \
(section->lma >= base \
- && (section->lma + section->_raw_size \
+ && (section->lma + SECTION_SIZE (section, segment) \
<= SEGMENT_END (segment, base)))
- /* Returns true if the given section is contained within the
- given segment. Filepos addresses are compared in an elf
- backend function. */
-#define IS_CONTAINED_BY_FILEPOS(sec, seg, bed) \
- (bed->is_contained_by_filepos \
- && (*bed->is_contained_by_filepos) (sec, seg))
-
/* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
#define IS_COREFILE_NOTE(p, s) \
(p->p_type == PT_NOTE \
if that is set for the segment and the VMA otherwise,
2. It is an allocated segment,
3. There is an output section associated with it,
- 4. The section has not already been allocated to a previous segment. */
+ 4. The section has not already been allocated to a previous segment.
+ 5. PT_TLS segment includes only SHF_TLS sections.
+ 6. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. */
#define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
((((segment->p_paddr \
? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
: IS_CONTAINED_BY_VMA (section, segment)) \
&& (section->flags & SEC_ALLOC) != 0) \
- || IS_COREFILE_NOTE (segment, section) \
- || (IS_CONTAINED_BY_FILEPOS (section, segment, bed) \
- && (section->flags & SEC_ALLOC) == 0)) \
+ || IS_COREFILE_NOTE (segment, section)) \
&& section->output_section != NULL \
+ && (segment->p_type != PT_TLS \
+ || (section->flags & SEC_THREAD_LOCAL)) \
+ && (segment->p_type == PT_LOAD \
+ || segment->p_type == PT_TLS \
+ || (section->flags & SEC_THREAD_LOCAL) == 0) \
&& ! section->segment_mark)
- /* Returns true iff seg1 starts after the end of seg2. */
-#define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
- (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
+ /* Returns TRUE iff seg1 starts after the end of seg2. */
+#define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
+ (seg1->field >= SEGMENT_END (seg2, seg2->field))
- /* Returns true iff seg1 and seg2 overlap. */
+ /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
+ their VMA address ranges and their LMA address ranges overlap.
+ It is possible to have overlapping VMA ranges without overlapping LMA
+ ranges. RedBoot images for example can have both .data and .bss mapped
+ to the same VMA range, but with the .data section mapped to a different
+ LMA. */
#define SEGMENT_OVERLAPS(seg1, seg2) \
- (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) \
- || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
+ ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
+ || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
+ && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
+ || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
/* Initialise the segment mark field. */
for (section = ibfd->sections; section != NULL; section = section->next)
- section->segment_mark = false;
+ section->segment_mark = FALSE;
/* Scan through the segments specified in the program header
of the input BFD. For this first scan we look for overlaps
continue;
/* Compute how many sections might be placed into this segment. */
- section_count = 0;
- for (section = ibfd->sections; section != NULL; section = section->next)
+ for (section = ibfd->sections, section_count = 0;
+ section != NULL;
+ section = section->next)
if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
++section_count;
- /* Allocate a segment map big enough to contain all of the
- sections we have selected. */
+ /* Allocate a segment map big enough to contain
+ 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);
if (map == NULL)
- return false;
+ return FALSE;
/* Initialise the fields of the segment map. Default to
using the physical address of the segment in the input BFD. */
+ iehdr->e_phnum * iehdr->e_phentsize)));
if (segment->p_type == PT_LOAD && map->includes_phdrs)
- phdr_included = true;
+ phdr_included = TRUE;
}
if (section_count == 0)
and possibly its LMA changed, and a new segment or segments will
have to be created to contain the other sections.
- 4. The sections have been moved, but not be the same amount.
+ 4. The sections have been moved, but not by the same amount.
In this case we can change the segment's LMA to match the LMA
of the first section and we will have to create a new segment
or segments to contain the other sections.
amt = section_count * sizeof (asection *);
sections = (asection **) bfd_malloc (amt);
if (sections == NULL)
- return false;
+ return FALSE;
/* Step One: Scan for segment vs section LMA conflicts.
Also add the sections to the section array allocated above.
/* Match up the physical address of the segment with the
LMA address of the output section. */
if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
- || IS_CONTAINED_BY_FILEPOS (section, segment, bed)
|| IS_COREFILE_NOTE (segment, section)
|| (bed->want_p_paddr_set_to_zero &&
IS_CONTAINED_BY_VMA (output_section, segment))
map->sections[map->count++] = output_section;
++isec;
sections[j] = NULL;
- section->segment_mark = true;
+ section->segment_mark = TRUE;
}
else if (suggested_lma == 0)
suggested_lma = output_section->lma;
amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
if (map == NULL)
- return false;
+ {
+ free (sections);
+ return FALSE;
+ }
/* Initialise the fields of the segment map. Set the physical
physical address to the LMA of the first section that has
if (map->p_paddr != 0)
break;
if (map == NULL)
- {
- for (map = map_first; map != NULL; map = map->next)
- map->p_paddr_valid = 0;
- }
+ for (map = map_first; map != NULL; map = map->next)
+ map->p_paddr_valid = 0;
elf_tdata (obfd)->segment_map = map_first;
#endif
#undef SEGMENT_END
+#undef SECTION_SIZE
#undef IS_CONTAINED_BY_VMA
#undef IS_CONTAINED_BY_LMA
-#undef IS_CONTAINED_BY_FILEPOS
#undef IS_COREFILE_NOTE
#undef IS_SOLARIS_PT_INTERP
#undef INCLUDE_SECTION_IN_SEGMENT
#undef SEGMENT_AFTER_SEGMENT
#undef SEGMENT_OVERLAPS
- return true;
+ return TRUE;
}
/* Copy private section information. This copies over the entsize
field, and sometimes the info field. */
-boolean
+bfd_boolean
_bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
bfd *ibfd;
asection *isec;
asection *osec;
{
Elf_Internal_Shdr *ihdr, *ohdr;
- const struct elf_backend_data *bed = get_elf_backend_data (ibfd);
if (ibfd->xvec->flavour != bfd_target_elf_flavour
|| obfd->xvec->flavour != bfd_target_elf_flavour)
- return true;
+ return TRUE;
- /* Copy over private BFD data if it has not already been copied.
- This must be done here, rather than in the copy_private_bfd_data
- entry point, because the latter is called after the section
- contents have been set, which means that the program headers have
- already been worked out. The backend function provides a way to
- override the test conditions and code path for the call to
- copy_private_bfd_data. */
- if (bed->copy_private_bfd_data_p)
- {
- if ((*bed->copy_private_bfd_data_p) (ibfd, isec, obfd, osec))
- if (! copy_private_bfd_data (ibfd, obfd))
- return false;
- }
- else if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
+ if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
{
asection *s;
if (s == NULL)
{
if (! copy_private_bfd_data (ibfd, obfd))
- return false;
+ return FALSE;
}
}
elf_next_in_group (osec) = elf_next_in_group (isec);
elf_group_name (osec) = elf_group_name (isec);
- elf_section_data (osec)->use_rela_p
- = elf_section_data (isec)->use_rela_p;
+ osec->use_rela_p = isec->use_rela_p;
- return true;
+ return TRUE;
}
/* Copy private symbol information. If this symbol is in a section
#define MAP_SHSTRTAB (SHN_HIOS + 4)
#define MAP_SYM_SHNDX (SHN_HIOS + 5)
-boolean
+bfd_boolean
_bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
bfd *ibfd;
asymbol *isymarg;
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return true;
+ return TRUE;
isym = elf_symbol_from (ibfd, isymarg);
osym = elf_symbol_from (obfd, osymarg);
osym->internal_elf_sym.st_shndx = shndx;
}
- return true;
+ return TRUE;
}
/* Swap out the symbols. */
-static boolean
+static bfd_boolean
swap_out_syms (abfd, sttp, relocatable_p)
bfd *abfd;
struct bfd_strtab_hash **sttp;
bfd_size_type amt;
if (!elf_map_symbols (abfd))
- return false;
+ return FALSE;
/* Dump out the symtabs. */
stt = _bfd_elf_stringtab_init ();
if (stt == NULL)
- return false;
+ return FALSE;
bed = get_elf_backend_data (abfd);
symcount = bfd_get_symcount (abfd);
symtab_hdr->sh_entsize = bed->s->sizeof_sym;
symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
- symtab_hdr->sh_addralign = bed->s->file_align;
+ symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
symstrtab_hdr->sh_type = SHT_STRTAB;
amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
outbound_syms = bfd_alloc (abfd, amt);
if (outbound_syms == NULL)
- return false;
+ {
+ _bfd_stringtab_free (stt);
+ return FALSE;
+ }
symtab_hdr->contents = (PTR) outbound_syms;
outbound_shndx = NULL;
amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
outbound_shndx = bfd_zalloc (abfd, amt);
if (outbound_shndx == NULL)
- return false;
+ {
+ _bfd_stringtab_free (stt);
+ return FALSE;
+ }
+
symtab_shndx_hdr->contents = outbound_shndx;
symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
symtab_shndx_hdr->sh_size = amt;
symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
}
- /* now generate the data (for "contents") */
+ /* Now generate the data (for "contents"). */
{
/* Fill in zeroth symbol and swap it out. */
Elf_Internal_Sym sym;
{
sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
syms[idx]->name,
- true, false);
+ TRUE, FALSE);
if (sym.st_name == (unsigned long) -1)
- return false;
+ {
+ _bfd_stringtab_free (stt);
+ return FALSE;
+ }
}
type_ptr = elf_symbol_from (abfd, syms[idx]);
value += sec->output_offset;
sec = sec->output_section;
}
+
/* Don't add in the section vma for relocatable output. */
if (! relocatable_p)
value += sec->vma;
section of a symbol to be a section that is
actually in the output file. */
sec2 = bfd_get_section_by_name (abfd, sec->name);
- BFD_ASSERT (sec2 != 0);
+ if (sec2 == NULL)
+ {
+ _bfd_error_handler (_("\
+Unable to find equivalent output section for symbol '%s' from section '%s'"),
+ syms[idx]->name ? syms[idx]->name : "<Local sym>",
+ sec->name);
+ bfd_set_error (bfd_error_invalid_operation);
+ _bfd_stringtab_free (stt);
+ return FALSE;
+ }
+
shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
BFD_ASSERT (shndx != -1);
}
if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
type = STT_TLS;
- /* Processor-specific types */
+ /* Processor-specific types. */
if (type_ptr != NULL
&& bed->elf_backend_get_symbol_type)
type = ((*bed->elf_backend_get_symbol_type)
symstrtab_hdr->sh_info = 0;
symstrtab_hdr->sh_addralign = 1;
- return true;
+ return TRUE;
}
/* Return the number of bytes required to hold the symtab vector.
unsigned int i;
struct elf_backend_data *bed = get_elf_backend_data (abfd);
- if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
+ if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
return -1;
tblptr = section->relocation;
asymbol **alocation;
{
struct elf_backend_data *bed = get_elf_backend_data (abfd);
- long symcount = bed->s->slurp_symbol_table (abfd, alocation, false);
+ long symcount = bed->s->slurp_symbol_table (abfd, alocation, FALSE);
if (symcount >= 0)
bfd_get_symcount (abfd) = symcount;
asymbol **alocation;
{
struct elf_backend_data *bed = get_elf_backend_data (abfd);
- return bed->s->slurp_symbol_table (abfd, alocation, true);
+ long symcount = bed->s->slurp_symbol_table (abfd, alocation, TRUE);
+
+ if (symcount >= 0)
+ bfd_get_dynamic_symcount (abfd) = symcount;
+ return symcount;
}
/* Return the size required for the dynamic reloc entries. Any
arelent **storage;
asymbol **syms;
{
- boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
+ bfd_boolean (*slurp_relocs)
+ PARAMS ((bfd *, asection *, asymbol **, bfd_boolean));
asection *s;
long ret;
arelent *p;
long count, i;
- if (! (*slurp_relocs) (abfd, s, syms, true))
+ if (! (*slurp_relocs) (abfd, s, syms, TRUE))
return -1;
count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
p = s->relocation;
\f
/* Read in the version information. */
-boolean
+bfd_boolean
_bfd_elf_slurp_version_tables (abfd)
bfd *abfd;
{
contents = NULL;
}
- return true;
+ return TRUE;
error_return:
- if (contents == NULL)
+ if (contents != NULL)
free (contents);
- return false;
+ return FALSE;
}
\f
asymbol *
use this function for the is_local_label_name entry point, but some
override it. */
-boolean
+bfd_boolean
_bfd_elf_is_local_label_name (abfd, name)
bfd *abfd ATTRIBUTE_UNUSED;
const char *name;
{
/* Normal local symbols start with ``.L''. */
if (name[0] == '.' && name[1] == 'L')
- return true;
+ return TRUE;
/* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
DWARF debugging symbols starting with ``..''. */
if (name[0] == '.' && name[1] == '.')
- return true;
+ return TRUE;
/* gcc will sometimes generate symbols beginning with ``_.L_'' when
emitting DWARF debugging output. I suspect this is actually a
underscore to be emitted on some ELF targets). For ease of use,
we treat such symbols as local. */
if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
- return true;
+ return TRUE;
- return false;
+ return FALSE;
}
alent *
return NULL;
}
-boolean
+bfd_boolean
_bfd_elf_set_arch_mach (abfd, arch, machine)
bfd *abfd;
enum bfd_architecture arch;
if (arch != get_elf_backend_data (abfd)->arch
&& arch != bfd_arch_unknown
&& get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
- return false;
+ return FALSE;
return bfd_default_set_arch_mach (abfd, arch, machine);
}
/* Find the function to a particular section and offset,
for error reporting. */
-static boolean
+static bfd_boolean
elf_find_function (abfd, section, symbols, offset,
filename_ptr, functionname_ptr)
bfd *abfd ATTRIBUTE_UNUSED;
}
if (func == NULL)
- return false;
+ return FALSE;
if (filename_ptr)
*filename_ptr = filename;
if (functionname_ptr)
*functionname_ptr = bfd_asymbol_name (func);
- return true;
+ return TRUE;
}
/* Find the nearest line to a particular section and offset,
for error reporting. */
-boolean
+bfd_boolean
_bfd_elf_find_nearest_line (abfd, section, symbols, offset,
filename_ptr, functionname_ptr, line_ptr)
bfd *abfd;
const char **functionname_ptr;
unsigned int *line_ptr;
{
- boolean found;
+ bfd_boolean found;
if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
filename_ptr, functionname_ptr,
*filename_ptr ? NULL : filename_ptr,
functionname_ptr);
- return true;
+ return TRUE;
}
if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
*filename_ptr ? NULL : filename_ptr,
functionname_ptr);
- return true;
+ return TRUE;
}
if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
&found, filename_ptr,
functionname_ptr, line_ptr,
&elf_tdata (abfd)->line_info))
- return false;
- if (found)
- return true;
+ return FALSE;
+ if (found && (*functionname_ptr || *line_ptr))
+ return TRUE;
if (symbols == NULL)
- return false;
+ return FALSE;
if (! elf_find_function (abfd, section, symbols, offset,
filename_ptr, functionname_ptr))
- return false;
+ return FALSE;
*line_ptr = 0;
- return true;
+ return TRUE;
}
int
_bfd_elf_sizeof_headers (abfd, reloc)
bfd *abfd;
- boolean reloc;
+ bfd_boolean reloc;
{
int ret;
return ret;
}
-boolean
+bfd_boolean
_bfd_elf_set_section_contents (abfd, section, location, offset, count)
bfd *abfd;
sec_ptr section;
if (! abfd->output_has_begun
&& ! (_bfd_elf_compute_section_file_positions
(abfd, (struct bfd_link_info *) NULL)))
- return false;
+ return FALSE;
hdr = &elf_section_data (section)->this_hdr;
pos = hdr->sh_offset + offset;
if (bfd_seek (abfd, pos, SEEK_SET) != 0
|| bfd_bwrite (location, count, abfd) != count)
- return false;
+ return FALSE;
- return true;
+ return TRUE;
}
void
abort ();
}
-#if 0
-void
-_bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
- bfd *abfd;
- arelent *cache_ptr;
- Elf_Internal_Rel *dst;
-{
- abort ();
-}
-#endif
-
/* Try to convert a non-ELF reloc into an ELF one. */
-boolean
+bfd_boolean
_bfd_elf_validate_reloc (abfd, areloc)
bfd *abfd;
arelent *areloc;
goto fail;
}
- return true;
+ return TRUE;
fail:
(*_bfd_error_handler)
(_("%s: unsupported relocation type %s"),
bfd_archive_filename (abfd), areloc->howto->name);
bfd_set_error (bfd_error_bad_value);
- return false;
+ return FALSE;
}
-boolean
+bfd_boolean
_bfd_elf_close_and_cleanup (abfd)
bfd *abfd;
{
reference to NAME, so you shouldn't deallocate or
overwrite it. */
-static boolean
+static bfd_boolean
elfcore_maybe_make_sect (abfd, name, sect)
bfd *abfd;
char *name;
asection *sect2;
if (bfd_get_section_by_name (abfd, name) != NULL)
- return true;
+ return TRUE;
sect2 = bfd_make_section (abfd, name);
if (sect2 == NULL)
- return false;
+ return FALSE;
sect2->_raw_size = sect->_raw_size;
sect2->filepos = sect->filepos;
sect2->flags = sect->flags;
sect2->alignment_power = sect->alignment_power;
- return true;
+ return TRUE;
}
/* Create a pseudosection containing SIZE bytes at FILEPOS. This
- For the multi-threaded case, a section named "NAME/PID", where
PID is elfcore_make_pid (abfd).
Both pseudosections have identical contents. */
-boolean
+bfd_boolean
_bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
bfd *abfd;
char *name;
len = strlen (buf) + 1;
threaded_name = bfd_alloc (abfd, (bfd_size_type) len);
if (threaded_name == NULL)
- return false;
+ return FALSE;
memcpy (threaded_name, buf, len);
sect = bfd_make_section (abfd, threaded_name);
if (sect == NULL)
- return false;
+ return FALSE;
sect->_raw_size = size;
sect->filepos = filepos;
sect->flags = SEC_HAS_CONTENTS;
*/
#if defined (HAVE_PRSTATUS_T)
-static boolean elfcore_grok_prstatus PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_prstatus
+ PARAMS ((bfd *, Elf_Internal_Note *));
-static boolean
+static bfd_boolean
elfcore_grok_prstatus (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
{
/* Fail - we don't know how to handle any other
note size (ie. data object type). */
- return true;
+ return TRUE;
}
/* Make a ".reg/999" section and a ".reg" section. */
#endif /* defined (HAVE_PRSTATUS_T) */
/* Create a pseudosection containing the exact contents of NOTE. */
-static boolean
+static bfd_boolean
elfcore_make_note_pseudosection (abfd, name, note)
bfd *abfd;
char *name;
but it doesn't matter, because we don't have to pick this
data structure apart. */
-static boolean
+static bfd_boolean
elfcore_grok_prfpreg (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
type of 5 (NT_PRXFPREG). Just include the whole note's contents
literally. */
-static boolean
+static bfd_boolean
elfcore_grok_prxfpreg (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
}
#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
-static boolean elfcore_grok_psinfo PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_psinfo
+ PARAMS ((bfd *, Elf_Internal_Note *));
-static boolean
+static bfd_boolean
elfcore_grok_psinfo (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
{
/* Fail - we don't know how to handle any other
note size (ie. data object type). */
- return true;
+ return TRUE;
}
/* Note that for some reason, a spurious space is tacked
command[n - 1] = '\0';
}
- return true;
+ return TRUE;
}
#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
#if defined (HAVE_PSTATUS_T)
-static boolean elfcore_grok_pstatus PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_pstatus
+ PARAMS ((bfd *, Elf_Internal_Note *));
-static boolean
+static bfd_boolean
elfcore_grok_pstatus (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
NT_LWPSTATUS note, presumably. */
- return true;
+ return TRUE;
}
#endif /* defined (HAVE_PSTATUS_T) */
#if defined (HAVE_LWPSTATUS_T)
-static boolean elfcore_grok_lwpstatus PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_lwpstatus
+ PARAMS ((bfd *, Elf_Internal_Note *));
-static boolean
+static bfd_boolean
elfcore_grok_lwpstatus (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
&& note->descsz != sizeof (lwpxstatus_t)
#endif
)
- return true;
+ return TRUE;
memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
len = strlen (buf) + 1;
name = bfd_alloc (abfd, (bfd_size_type) len);
if (name == NULL)
- return false;
+ return FALSE;
memcpy (name, buf, len);
sect = bfd_make_section (abfd, name);
if (sect == NULL)
- return false;
+ return FALSE;
#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
sect->alignment_power = 2;
if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
- return false;
+ return FALSE;
/* Make a ".reg2/999" section */
len = strlen (buf) + 1;
name = bfd_alloc (abfd, (bfd_size_type) len);
if (name == NULL)
- return false;
+ return FALSE;
memcpy (name, buf, len);
sect = bfd_make_section (abfd, name);
if (sect == NULL)
- return false;
+ return FALSE;
#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
#endif /* defined (HAVE_LWPSTATUS_T) */
#if defined (HAVE_WIN32_PSTATUS_T)
-static boolean
+static bfd_boolean
elfcore_grok_win32pstatus (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
win32_pstatus_t pstatus;
if (note->descsz < sizeof (pstatus))
- return true;
+ return TRUE;
memcpy (&pstatus, note->descdata, sizeof (pstatus));
len = strlen (buf) + 1;
name = bfd_alloc (abfd, (bfd_size_type) len);
if (name == NULL)
- return false;
+ return FALSE;
memcpy (name, buf, len);
sect = bfd_make_section (abfd, name);
if (sect == NULL)
- return false;
+ return FALSE;
sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
sect->filepos = (note->descpos
if (pstatus.data.thread_info.is_active_thread)
if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
- return false;
+ return FALSE;
break;
case NOTE_INFO_MODULE:
len = strlen (buf) + 1;
name = bfd_alloc (abfd, (bfd_size_type) len);
if (name == NULL)
- return false;
+ return FALSE;
memcpy (name, buf, len);
sect = bfd_make_section (abfd, name);
if (sect == NULL)
- return false;
+ return FALSE;
sect->_raw_size = note->descsz;
sect->filepos = note->descpos;
break;
default:
- return true;
+ return TRUE;
}
- return true;
+ return TRUE;
}
#endif /* HAVE_WIN32_PSTATUS_T */
-static boolean
+static bfd_boolean
elfcore_grok_note (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
switch (note->type)
{
default:
- return true;
+ return TRUE;
case NT_PRSTATUS:
if (bed->elf_backend_grok_prstatus)
if ((*bed->elf_backend_grok_prstatus) (abfd, note))
- return true;
+ return TRUE;
#if defined (HAVE_PRSTATUS_T)
return elfcore_grok_prstatus (abfd, note);
#else
- return true;
+ return TRUE;
#endif
#if defined (HAVE_PSTATUS_T)
#endif
case NT_PRXFPREG: /* Linux SSE extension */
- if (note->namesz == 5
- && ! strcmp (note->namedata, "LINUX"))
+ if (note->namesz == 6
+ && strcmp (note->namedata, "LINUX") == 0)
return elfcore_grok_prxfpreg (abfd, note);
else
- return true;
+ return TRUE;
case NT_PRPSINFO:
case NT_PSINFO:
if (bed->elf_backend_grok_psinfo)
if ((*bed->elf_backend_grok_psinfo) (abfd, note))
- return true;
+ return TRUE;
#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
return elfcore_grok_psinfo (abfd, note);
#else
- return true;
+ return TRUE;
#endif
+
+ case NT_AUXV:
+ {
+ asection *sect = bfd_make_section (abfd, ".auxv");
+
+ if (sect == NULL)
+ return FALSE;
+ sect->_raw_size = note->descsz;
+ sect->filepos = note->descpos;
+ sect->flags = SEC_HAS_CONTENTS;
+ sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
+
+ return TRUE;
+ }
}
}
-static boolean
+static bfd_boolean
elfcore_netbsd_get_lwpid (note, lwpidp)
Elf_Internal_Note *note;
int *lwpidp;
if (cp != NULL)
{
*lwpidp = atoi(cp + 1);
- return true;
+ return TRUE;
}
- return false;
+ return FALSE;
}
-static boolean
+static bfd_boolean
elfcore_grok_netbsd_procinfo (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
elf_tdata (abfd)->core_command
= _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
- return true;
+ return TRUE;
}
-static boolean
+static bfd_boolean
elfcore_grok_netbsd_note (abfd, note)
bfd *abfd;
Elf_Internal_Note *note;
understand it. */
if (note->type < NT_NETBSDCORE_FIRSTMACH)
- return true;
+ return TRUE;
switch (bfd_get_arch (abfd))
return elfcore_make_note_pseudosection (abfd, ".reg2", note);
default:
- return true;
+ return TRUE;
}
/* On all other arch's, PT_GETREGS == mach+1 and
return elfcore_make_note_pseudosection (abfd, ".reg2", note);
default:
- return true;
+ return TRUE;
}
}
/* NOTREACHED */
}
+static bfd_boolean
+elfcore_grok_nto_status (abfd, note, tid)
+ bfd *abfd;
+ Elf_Internal_Note *note;
+ pid_t *tid;
+{
+ void *ddata = note->descdata;
+ char buf[100];
+ char *name;
+ asection *sect;
+ short sig;
+ unsigned flags;
+
+ /* nto_procfs_status 'pid' field is at offset 0. */
+ elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
+
+ /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
+ *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
+
+ /* nto_procfs_status 'flags' field is at offset 8. */
+ flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
+
+ /* nto_procfs_status 'what' field is at offset 14. */
+ if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
+ {
+ elf_tdata (abfd)->core_signal = sig;
+ elf_tdata (abfd)->core_lwpid = *tid;
+ }
+
+ /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
+ do not come from signals so we make sure we set the current
+ thread just in case. */
+ if (flags & 0x00000080)
+ elf_tdata (abfd)->core_lwpid = *tid;
+
+ /* Make a ".qnx_core_status/%d" section. */
+ sprintf (buf, ".qnx_core_status/%d", *tid);
+
+ name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
+ if (name == NULL)
+ return FALSE;
+ strcpy (name, buf);
+
+ sect = bfd_make_section (abfd, name);
+ if (sect == NULL)
+ return FALSE;
+
+ sect->_raw_size = note->descsz;
+ sect->filepos = note->descpos;
+ sect->flags = SEC_HAS_CONTENTS;
+ sect->alignment_power = 2;
+
+ return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
+}
+
+static bfd_boolean
+elfcore_grok_nto_gregs (abfd, note, tid)
+ bfd *abfd;
+ Elf_Internal_Note *note;
+ pid_t tid;
+{
+ char buf[100];
+ char *name;
+ asection *sect;
+
+ /* Make a ".reg/%d" section. */
+ sprintf (buf, ".reg/%d", tid);
+
+ name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
+ if (name == NULL)
+ return FALSE;
+ strcpy (name, buf);
+
+ sect = bfd_make_section (abfd, name);
+ if (sect == NULL)
+ return FALSE;
+
+ sect->_raw_size = note->descsz;
+ sect->filepos = note->descpos;
+ sect->flags = SEC_HAS_CONTENTS;
+ sect->alignment_power = 2;
+
+ /* This is the current thread. */
+ if (elf_tdata (abfd)->core_lwpid == tid)
+ return elfcore_maybe_make_sect (abfd, ".reg", sect);
+
+ return TRUE;
+}
+
+#define BFD_QNT_CORE_INFO 7
+#define BFD_QNT_CORE_STATUS 8
+#define BFD_QNT_CORE_GREG 9
+#define BFD_QNT_CORE_FPREG 10
+
+static bfd_boolean
+elfcore_grok_nto_note (abfd, 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
+ function. */
+ static pid_t tid = 1;
+
+ switch (note->type)
+ {
+ case BFD_QNT_CORE_INFO: return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
+ case BFD_QNT_CORE_STATUS: return elfcore_grok_nto_status (abfd, note, &tid);
+ case BFD_QNT_CORE_GREG: return elfcore_grok_nto_gregs (abfd, note, tid);
+ case BFD_QNT_CORE_FPREG: return elfcore_grok_prfpreg (abfd, note);
+ default: return TRUE;
+ }
+}
+
/* Function: elfcore_write_note
Inputs:
namesz = strlen (name) + 1;
bed = get_elf_backend_data (abfd);
- pad = -namesz & (bed->s->file_align - 1);
+ pad = -namesz & ((1 << bed->s->log_file_align) - 1);
}
newspace = sizeof (Elf_External_Note) - 1 + namesz + pad + size;
note_name, NT_PRXFPREG, xfpregs, size);
}
-static boolean
+static bfd_boolean
elfcore_read_notes (abfd, offset, size)
bfd *abfd;
file_ptr offset;
char *p;
if (size <= 0)
- return true;
+ return TRUE;
if (bfd_seek (abfd, offset, SEEK_SET) != 0)
- return false;
+ return FALSE;
buf = bfd_malloc (size);
if (buf == NULL)
- return false;
+ return FALSE;
if (bfd_bread (buf, size, abfd) != size)
{
error:
free (buf);
- return false;
+ return FALSE;
}
p = buf;
if (! elfcore_grok_netbsd_note (abfd, &in))
goto error;
}
+ else if (strncmp (in.namedata, "QNX", 3) == 0)
+ {
+ if (! elfcore_grok_nto_note (abfd, &in))
+ goto error;
+ }
else
{
if (! elfcore_grok_note (abfd, &in))
}
free (buf);
- return true;
+ return TRUE;
}
\f
/* Providing external access to the ELF program header table. */
+ sym->st_value);
if ((sec->flags & SEC_MERGE)
&& ELF_ST_TYPE (sym->st_info) == STT_SECTION
- && elf_section_data (sec)->sec_info_type == ELF_INFO_TYPE_MERGE)
+ && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
{
asection *msec;
{
asection *sec = *psec;
- if (elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_MERGE)
+ if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
return sym->st_value + addend;
return _bfd_merged_section_offset (abfd, psec,
struct bfd_elf_section_data *sec_data;
sec_data = elf_section_data (sec);
- switch (sec_data->sec_info_type)
+ switch (sec->sec_info_type)
{
case ELF_INFO_TYPE_STABS:
- return _bfd_stab_section_offset
- (abfd, &elf_hash_table (info)->merge_info, sec, &sec_data->sec_info,
- offset);
+ return _bfd_stab_section_offset (abfd,
+ &elf_hash_table (info)->merge_info,
+ sec, &sec_data->sec_info, offset);
case ELF_INFO_TYPE_EH_FRAME:
return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);
default:
return offset;
}
}
+\f
+/* Create a new BFD as if by bfd_openr. Rather than opening a file,
+ reconstruct an ELF file by reading the segments out of remote memory
+ based on the ELF file header at EHDR_VMA and the ELF program headers it
+ points to. If not null, *LOADBASEP is filled in with the difference
+ between the VMAs from which the segments were read, and the VMAs the
+ file headers (and hence BFD's idea of each section's VMA) put them at.
+
+ The function TARGET_READ_MEMORY is called to copy LEN bytes from the
+ remote memory at target address VMA into the local buffer at MYADDR; it
+ should return zero on success or an `errno' code on failure. TEMPL must
+ be a BFD for an ELF target with the word size and byte order found in
+ 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));
+{
+ return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
+ (templ, ehdr_vma, loadbasep, target_read_memory);
+}
projects / thirdparty / binutils-gdb.git / blobdiff