/* ELF executable support for BFD.
- Copyright 1991, 1992, 1993 Free Software Foundation, Inc.
+ Copyright 1991, 92, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
Written by Fred Fish @ Cygnus Support, from information published
in "UNIX System V Release 4, Programmers Guide: ANSI C and
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* Problems and other issues to resolve.
once in 64-bit mode. More of it should be made size-independent
and moved into elf.c.
-*/
+ (3) ELF section symbols are handled rather sloppily now. This should
+ be cleaned up, and ELF section symbols reconciled with BFD section
+ symbols.
+
+ (4) We need a published spec for 64-bit ELF. We've got some stuff here
+ that we're using for SPARC V9 64-bit chips, but don't assume that
+ it's cast in stone.
+ */
-#include <assert.h>
-#include <string.h> /* For strrchr and friends */
#include "bfd.h"
#include "sysdep.h"
+#include "bfdlink.h"
#include "libbfd.h"
-#include "libelf.h"
+#include "elf-bfd.h"
+#include "fnmatch.h"
/* Renaming structures, typedefs, macros and functions to be size-specific. */
#define Elf_External_Ehdr NAME(Elf,External_Ehdr)
#define Elf_External_Phdr NAME(Elf,External_Phdr)
#define Elf_External_Rel NAME(Elf,External_Rel)
#define Elf_External_Rela NAME(Elf,External_Rela)
-
-#define elf_symbol_type NAME(elf,symbol_type)
+#define Elf_External_Dyn NAME(Elf,External_Dyn)
#define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
#define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
-#define elf_core_file_matches_executable_p NAME(bfd_elf,core_file_matches_executable_p)
+#define elf_core_file_matches_executable_p \
+ NAME(bfd_elf,core_file_matches_executable_p)
#define elf_object_p NAME(bfd_elf,object_p)
#define elf_core_file_p NAME(bfd_elf,core_file_p)
#define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
+#define elf_get_dynamic_symtab_upper_bound \
+ NAME(bfd_elf,get_dynamic_symtab_upper_bound)
+#define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
+#define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
+#define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
+#define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
+#define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
+#define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
+#define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
+#define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
+#define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
+#define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
#define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
#define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
+#define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
#define elf_get_symtab NAME(bfd_elf,get_symtab)
+#define elf_canonicalize_dynamic_symtab \
+ NAME(bfd_elf,canonicalize_dynamic_symtab)
#define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
#define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
-#define elf_print_symbol NAME(bfd_elf,print_symbol)
#define elf_get_lineno NAME(bfd_elf,get_lineno)
#define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
#define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
#define elf_set_section_contents NAME(bfd_elf,set_section_contents)
#define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
#define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
-#define elf_hash NAME(bfd_elf,hash)
-#define elf_new_section_hook NAME(bfd_elf,new_section_hook)
-#define write_relocs NAME(bfd_elf,_write_relocs)
+#define elf_find_section NAME(bfd_elf,find_section)
+#define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
+#define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
+#define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
+#define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
+#define elf_link_create_dynamic_sections \
+ NAME(bfd_elf,link_create_dynamic_sections)
+#define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
+#define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
+#define elf_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
+#define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
#if ARCH_SIZE == 64
#define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
#define ELF_R_SYM(X) ELF64_R_SYM(X)
+#define ELF_R_TYPE(X) ELF64_R_TYPE(X)
#define ELFCLASS ELFCLASS64
+#define FILE_ALIGN 8
+#define LOG_FILE_ALIGN 3
#endif
#if ARCH_SIZE == 32
#define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
#define ELF_R_SYM(X) ELF32_R_SYM(X)
+#define ELF_R_TYPE(X) ELF32_R_TYPE(X)
#define ELFCLASS ELFCLASS32
+#define FILE_ALIGN 4
+#define LOG_FILE_ALIGN 2
#endif
-static int shstrtab_length_fixed;
-
-struct elf_sect_data {
- int reloc_sec;
- /* more? */
-};
+/* Static functions */
-/* Forward declarations of static functions */
+static void elf_swap_ehdr_in
+ PARAMS ((bfd *, const Elf_External_Ehdr *, Elf_Internal_Ehdr *));
+static void elf_swap_ehdr_out
+ PARAMS ((bfd *, const Elf_Internal_Ehdr *, Elf_External_Ehdr *));
+static void elf_swap_shdr_in
+ PARAMS ((bfd *, const Elf_External_Shdr *, Elf_Internal_Shdr *));
+static void elf_swap_shdr_out
+ PARAMS ((bfd *, const Elf_Internal_Shdr *, Elf_External_Shdr *));
-static struct sec * section_from_elf_index PARAMS ((bfd *, int));
+#define elf_stringtab_init _bfd_elf_stringtab_init
-static int elf_section_from_bfd_section PARAMS ((bfd *, struct sec *));
+#define section_from_elf_index bfd_section_from_elf_index
-static boolean elf_slurp_symbol_table PARAMS ((bfd *, asymbol **));
+static boolean elf_slurp_reloc_table
+ PARAMS ((bfd *, asection *, asymbol **, boolean));
-static int elf_symbol_from_bfd_symbol PARAMS ((bfd *,
- struct symbol_cache_entry **));
+static void write_relocs PARAMS ((bfd *, asection *, PTR));
-static void elf_map_symbols PARAMS ((bfd *));
-static void swap_out_syms PARAMS ((bfd *));
+static boolean elf_file_p PARAMS ((Elf_External_Ehdr *));
#ifdef DEBUG
-static void elf_debug_section PARAMS ((char *, int, Elf_Internal_Shdr *));
+static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
+static char *elf_symbol_flags PARAMS ((flagword));
#endif
-
-#define elf_string_from_elf_strtab(abfd,strindex) \
- elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
-
\f
/* Structure swapping routines */
can be handled by explicitly specifying 32 bits or "the long type". */
#if ARCH_SIZE == 64
#define put_word bfd_h_put_64
+#define put_signed_word bfd_h_put_signed_64
#define get_word bfd_h_get_64
+#define get_signed_word bfd_h_get_signed_64
#endif
#if ARCH_SIZE == 32
#define put_word bfd_h_put_32
+#define put_signed_word bfd_h_put_signed_32
#define get_word bfd_h_get_32
+#define get_signed_word bfd_h_get_signed_32
#endif
/* Translate an ELF symbol in external format into an ELF symbol in internal
format. */
-static void
-DEFUN (elf_swap_symbol_in, (abfd, src, dst),
- bfd * abfd AND
- Elf_External_Sym * src AND
- Elf_Internal_Sym * dst)
+void
+elf_swap_symbol_in (abfd, src, dst)
+ bfd *abfd;
+ const Elf_External_Sym *src;
+ Elf_Internal_Sym *dst;
{
dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name);
dst->st_value = get_word (abfd, (bfd_byte *) src->st_value);
/* Translate an ELF symbol in internal format into an ELF symbol in external
format. */
-static void
-DEFUN (elf_swap_symbol_out, (abfd, src, dst),
- bfd * abfd AND
- Elf_Internal_Sym * src AND
- Elf_External_Sym * dst)
+void
+elf_swap_symbol_out (abfd, src, cdst)
+ bfd *abfd;
+ const Elf_Internal_Sym *src;
+ PTR cdst;
{
+ Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
bfd_h_put_32 (abfd, src->st_name, dst->st_name);
put_word (abfd, src->st_value, dst->st_value);
put_word (abfd, src->st_size, dst->st_size);
internal format. */
static void
-DEFUN (elf_swap_ehdr_in, (abfd, src, dst),
- bfd * abfd AND
- Elf_External_Ehdr * src AND
- Elf_Internal_Ehdr * dst)
+elf_swap_ehdr_in (abfd, src, dst)
+ bfd *abfd;
+ const Elf_External_Ehdr *src;
+ Elf_Internal_Ehdr *dst;
{
memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type);
external format. */
static void
-DEFUN (elf_swap_ehdr_out, (abfd, src, dst),
- bfd * abfd AND
- Elf_Internal_Ehdr * src AND
- Elf_External_Ehdr * dst)
+elf_swap_ehdr_out (abfd, src, dst)
+ bfd *abfd;
+ const Elf_Internal_Ehdr *src;
+ Elf_External_Ehdr *dst;
{
memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
/* note that all elements of dst are *arrays of unsigned char* already... */
ELF section header table entry in internal format. */
static void
-DEFUN (elf_swap_shdr_in, (abfd, src, dst),
- bfd * abfd AND
- Elf_External_Shdr * src AND
- Elf_Internal_Shdr * dst)
+elf_swap_shdr_in (abfd, src, dst)
+ bfd *abfd;
+ const Elf_External_Shdr *src;
+ Elf_Internal_Shdr *dst;
{
dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name);
dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type);
dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info);
dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign);
dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize);
- /* we haven't done any processing on it yet, so... */
- dst->rawdata = (void *) 0;
+ dst->bfd_section = NULL;
+ dst->contents = NULL;
}
/* Translate an ELF section header table entry in internal format into an
ELF section header table entry in external format. */
static void
-DEFUN (elf_swap_shdr_out, (abfd, src, dst),
- bfd * abfd AND
- Elf_Internal_Shdr * src AND
- Elf_External_Shdr * dst)
+elf_swap_shdr_out (abfd, src, dst)
+ bfd *abfd;
+ const Elf_Internal_Shdr *src;
+ Elf_External_Shdr *dst;
{
/* note that all elements of dst are *arrays of unsigned char* already... */
bfd_h_put_32 (abfd, src->sh_name, dst->sh_name);
/* Translate an ELF program header table entry in external format into an
ELF program header table entry in internal format. */
-static void
-DEFUN (elf_swap_phdr_in, (abfd, src, dst),
- bfd * abfd AND
- Elf_External_Phdr * src AND
- Elf_Internal_Phdr * dst)
+void
+elf_swap_phdr_in (abfd, src, dst)
+ bfd *abfd;
+ const Elf_External_Phdr *src;
+ Elf_Internal_Phdr *dst;
{
dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type);
dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags);
dst->p_align = get_word (abfd, (bfd_byte *) src->p_align);
}
-static void
-DEFUN (elf_swap_phdr_out, (abfd, src, dst),
- bfd * abfd AND
- Elf_Internal_Phdr * src AND
- Elf_External_Phdr * dst)
+void
+elf_swap_phdr_out (abfd, src, dst)
+ bfd *abfd;
+ const Elf_Internal_Phdr *src;
+ Elf_External_Phdr *dst;
{
/* note that all elements of dst are *arrays of unsigned char* already... */
bfd_h_put_32 (abfd, src->p_type, dst->p_type);
}
/* Translate an ELF reloc from external format to internal format. */
-static INLINE void
-DEFUN (elf_swap_reloc_in, (abfd, src, dst),
- bfd * abfd AND
- Elf_External_Rel * src AND
- Elf_Internal_Rel * dst)
+INLINE void
+elf_swap_reloc_in (abfd, src, dst)
+ bfd *abfd;
+ const Elf_External_Rel *src;
+ Elf_Internal_Rel *dst;
{
dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
}
-static INLINE void
-DEFUN (elf_swap_reloca_in, (abfd, src, dst),
- bfd * abfd AND
- Elf_External_Rela * src AND
- Elf_Internal_Rela * dst)
+INLINE void
+elf_swap_reloca_in (abfd, src, dst)
+ bfd *abfd;
+ const Elf_External_Rela *src;
+ Elf_Internal_Rela *dst;
{
dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
- dst->r_addend = get_word (abfd, (bfd_byte *) src->r_addend);
+ dst->r_addend = get_signed_word (abfd, (bfd_byte *) src->r_addend);
}
/* Translate an ELF reloc from internal format to external format. */
-static INLINE void
-DEFUN (elf_swap_reloc_out, (abfd, src, dst),
- bfd * abfd AND
- Elf_Internal_Rel * src AND
- Elf_External_Rel * dst)
+INLINE void
+elf_swap_reloc_out (abfd, src, dst)
+ bfd *abfd;
+ const Elf_Internal_Rel *src;
+ Elf_External_Rel *dst;
{
put_word (abfd, src->r_offset, dst->r_offset);
put_word (abfd, src->r_info, dst->r_info);
}
-static INLINE void
-DEFUN (elf_swap_reloca_out, (abfd, src, dst),
- bfd * abfd AND
- Elf_Internal_Rela * src AND
- Elf_External_Rela * dst)
+INLINE void
+elf_swap_reloca_out (abfd, src, dst)
+ bfd *abfd;
+ const Elf_Internal_Rela *src;
+ Elf_External_Rela *dst;
{
put_word (abfd, src->r_offset, dst->r_offset);
put_word (abfd, src->r_info, dst->r_info);
- put_word (abfd, src->r_addend, dst->r_addend);
-}
-
-\f
-
-/* String table creation/manipulation routines */
-
-static struct strtab *
-DEFUN (bfd_new_strtab, (abfd),
- bfd * abfd)
-{
- struct strtab *ss;
-
- ss = (struct strtab *) bfd_xmalloc (sizeof (struct strtab));
- ss->tab = bfd_xmalloc (1);
- BFD_ASSERT (ss->tab != 0);
- *ss->tab = 0;
- ss->nentries = 0;
- ss->length = 1;
-
- return ss;
+ put_signed_word (abfd, src->r_addend, dst->r_addend);
}
-static int
-DEFUN (bfd_add_to_strtab, (abfd, ss, str),
- bfd * abfd AND
- struct strtab *ss AND
- CONST char *str)
+INLINE void
+elf_swap_dyn_in (abfd, p, dst)
+ bfd *abfd;
+ const PTR p;
+ Elf_Internal_Dyn *dst;
{
- /* should search first, but for now: */
- /* include the trailing NUL */
- int ln = strlen (str) + 1;
+ const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
- /* should this be using obstacks? */
- ss->tab = realloc (ss->tab, ss->length + ln);
-
- BFD_ASSERT (ss->tab != 0);
- strcpy (ss->tab + ss->length, str);
- ss->nentries++;
- ss->length += ln;
-
- return ss->length - ln;
+ dst->d_tag = get_word (abfd, src->d_tag);
+ dst->d_un.d_val = get_word (abfd, src->d_un.d_val);
}
-static int
-DEFUN (bfd_add_2_to_strtab, (abfd, ss, str, str2),
- bfd * abfd AND
- struct strtab *ss AND
- char *str AND
- CONST char *str2)
+INLINE void
+elf_swap_dyn_out (abfd, src, dst)
+ bfd *abfd;
+ const Elf_Internal_Dyn *src;
+ Elf_External_Dyn *dst;
{
- /* should search first, but for now: */
- /* include the trailing NUL */
- int ln = strlen (str) + strlen (str2) + 1;
-
- /* should this be using obstacks? */
- if (ss->length)
- ss->tab = realloc (ss->tab, ss->length + ln);
- else
- ss->tab = bfd_xmalloc (ln);
-
- BFD_ASSERT (ss->tab != 0);
- strcpy (ss->tab + ss->length, str);
- strcpy (ss->tab + ss->length + strlen (str), str2);
- ss->nentries++;
- ss->length += ln;
-
- return ss->length - ln;
+ put_word (abfd, src->d_tag, dst->d_tag);
+ put_word (abfd, src->d_un.d_val, dst->d_un.d_val);
}
-
\f
/* ELF .o/exec file reading */
-/* Create a new bfd section from an ELF section header. */
-
-static boolean
-DEFUN (bfd_section_from_shdr, (abfd, shindex),
- bfd * abfd AND
- unsigned int shindex)
-{
- Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
- Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
- asection *newsect;
- char *name;
-
- name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
-
- switch (hdr->sh_type)
- {
-
- case SHT_NULL:
- /* inactive section. Throw it away. */
- return true;
-
- case SHT_PROGBITS:
- /* Bits that get saved. This one is real. */
- if (!hdr->rawdata)
- {
- newsect = bfd_make_section (abfd, name);
- if (newsect != NULL)
- {
- newsect->filepos = hdr->sh_offset; /* so we can read back the bits */
- newsect->flags |= SEC_HAS_CONTENTS;
- newsect->vma = hdr->sh_addr;
- newsect->_raw_size = hdr->sh_size;
- newsect->alignment_power = bfd_log2 (hdr->sh_addralign);
-
- if (hdr->sh_flags & SHF_ALLOC)
- {
- newsect->flags |= SEC_ALLOC;
- newsect->flags |= SEC_LOAD;
- }
-
- if (!(hdr->sh_flags & SHF_WRITE))
- newsect->flags |= SEC_READONLY;
-
- if (hdr->sh_flags & SHF_EXECINSTR)
- newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
- else
- newsect->flags |= SEC_DATA;
-
- hdr->rawdata = (void *) newsect;
- }
- else
- hdr->rawdata = (void *) bfd_get_section_by_name (abfd, name);
- }
- return true;
-
- case SHT_NOBITS:
- /* Bits that get saved. This one is real. */
- if (!hdr->rawdata)
- {
- newsect = bfd_make_section (abfd, name);
- if (newsect != NULL)
- {
- newsect->vma = hdr->sh_addr;
- newsect->_raw_size = hdr->sh_size;
- newsect->filepos = hdr->sh_offset; /* fake */
- newsect->alignment_power = bfd_log2 (hdr->sh_addralign);
- if (hdr->sh_flags & SHF_ALLOC)
- newsect->flags |= SEC_ALLOC;
-
- if (!(hdr->sh_flags & SHF_WRITE))
- newsect->flags |= SEC_READONLY;
-
- if (hdr->sh_flags & SHF_EXECINSTR)
- newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
- else
- newsect->flags |= SEC_DATA;
-
- hdr->rawdata = (void *) newsect;
- }
- }
- return true;
-
- case SHT_SYMTAB: /* A symbol table */
- if (elf_onesymtab (abfd) == shindex)
- return true;
-
- BFD_ASSERT (hdr->sh_entsize == sizeof (Elf_External_Sym));
- BFD_ASSERT (elf_onesymtab (abfd) == 0);
- elf_onesymtab (abfd) = shindex;
- elf_tdata(abfd)->symtab_hdr = *hdr;
- elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->symtab_hdr;
- abfd->flags |= HAS_SYMS;
- return true;
-
- case SHT_STRTAB: /* A string table */
- if (hdr->rawdata)
- return true;
- if (ehdr->e_shstrndx == shindex)
- {
- elf_tdata(abfd)->shstrtab_hdr = *hdr;
- elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->shstrtab_hdr;
- hdr->rawdata = (PTR) &elf_tdata(abfd)->shstrtab_hdr;
- return true;
- }
- {
- int i;
-
- for (i = 1; i < ehdr->e_shnum; i++)
- {
- Elf_Internal_Shdr *hdr2 = elf_elfsections(abfd)[i];
- if (hdr2->sh_link == shindex)
- {
- bfd_section_from_shdr (abfd, i);
- if (elf_onesymtab (abfd) == i)
- {
- elf_tdata(abfd)->strtab_hdr = *hdr;
- elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->strtab_hdr;
- return true;
- }
-#if 0 /* Not handling other string tables specially right now. */
- hdr2 = elf_elfsections(abfd)[i]; /* in case it moved */
- /* We have a strtab for some random other section. */
- newsect = (asection *) hdr2->rawdata;
- if (!newsect)
- break;
- hdr->rawdata = (PTR) newsect;
- hdr2 = &elf_section_data (newsect)->str_hdr;
- *hdr2 = *hdr;
- elf_elfsections(abfd)[shindex] = hdr2;
-#endif
- }
- }
- }
-
- newsect = bfd_make_section (abfd, name);
- if (newsect)
- {
- newsect->flags = SEC_HAS_CONTENTS;
- hdr->rawdata = (PTR) newsect;
- newsect->_raw_size = hdr->sh_size;
- newsect->alignment_power = 0;
- newsect->vma = 0;
-
- if (hdr->sh_flags & SHF_ALLOC)
- newsect->flags |= SEC_ALLOC|SEC_LOAD;
- if (!(hdr->sh_flags & SHF_WRITE))
- newsect->flags |= SEC_READONLY;
- if (hdr->sh_flags & SHF_EXECINSTR)
- newsect->flags |= SEC_CODE;
- else
- newsect->flags |= SEC_DATA;
- }
-
- return true;
-
- case SHT_REL:
- case SHT_RELA:
- /* *These* do a lot of work -- but build no sections!
- The spec says there can be multiple strtabs, but only one symtab,
- but there can be lots of REL* sections. */
- /* FIXME: The above statement is wrong! There are typically at least
- two symbol tables in a dynamically linked executable, ".dynsym"
- which is the dynamic linkage symbol table and ".symtab", which is
- the "traditional" symbol table. -fnf */
-
- {
- asection *target_sect;
- Elf_Internal_Shdr *hdr2;
- int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
-
- /* Don't allow REL relocations on a machine that uses RELA and
- vice versa. */
- /* @@ Actually, the generic ABI does suggest that both might be
- used in one file. But the four ABI Processor Supplements I
- have access to right now all specify that only one is used on
- each of those architectures. It's conceivable that, e.g., a
- bunch of absolute 32-bit relocs might be more compact in REL
- form even on a RELA machine... */
- BFD_ASSERT (!(use_rela_p && (hdr->sh_type == SHT_REL)));
- BFD_ASSERT (!(!use_rela_p && (hdr->sh_type == SHT_RELA)));
- BFD_ASSERT (hdr->sh_entsize ==
- (use_rela_p
- ? sizeof (Elf_External_Rela)
- : sizeof (Elf_External_Rel)));
-
- bfd_section_from_shdr (abfd, hdr->sh_info); /* target */
- bfd_section_from_shdr (abfd, hdr->sh_link); /* symbol table */
- target_sect = section_from_elf_index (abfd, hdr->sh_info);
- if (target_sect == NULL)
- return false;
-
- hdr2 = &elf_section_data (target_sect)->rel_hdr;
- *hdr2 = *hdr;
- elf_elfsections(abfd)[shindex] = hdr2;
- target_sect->reloc_count = hdr->sh_size / hdr->sh_entsize;
- target_sect->flags |= SEC_RELOC;
- target_sect->relocation = 0;
- target_sect->rel_filepos = hdr->sh_offset;
- abfd->flags |= HAS_RELOC;
- return true;
- }
- break;
-
- case SHT_HASH:
- case SHT_DYNAMIC:
- case SHT_DYNSYM: /* could treat this like symtab... */
-#if 0
- fprintf (stderr, "Dynamic Linking sections not yet supported.\n");
- BFD_FAIL ();
-#endif
- break;
-
- case SHT_NOTE:
-#if 0
- fprintf (stderr, "Note Sections not yet supported.\n");
- BFD_FAIL ();
-#endif
- break;
-
- case SHT_SHLIB:
-#if 0
- fprintf (stderr, "SHLIB Sections not supported (and non conforming.)\n");
-#endif
- return true;
-
- default:
- break;
- }
-
- return true;
-}
-
-boolean
-DEFUN (elf_new_section_hook, (abfd, sec),
- bfd *abfd
- AND asection *sec)
-{
- struct bfd_elf_section_data *sdata;
- sec->used_by_bfd = sdata = bfd_alloc (abfd, sizeof (*sdata));
- memset (sdata, 0, sizeof (*sdata));
- return true;
-}
-
-/* Create a new bfd section from an ELF program header.
-
- Since program segments have no names, we generate a synthetic name
- of the form segment<NUM>, where NUM is generally the index in the
- program header table. For segments that are split (see below) we
- generate the names segment<NUM>a and segment<NUM>b.
-
- Note that some program segments may have a file size that is different than
- (less than) the memory size. All this means is that at execution the
- system must allocate the amount of memory specified by the memory size,
- but only initialize it with the first "file size" bytes read from the
- file. This would occur for example, with program segments consisting
- of combined data+bss.
-
- To handle the above situation, this routine generates TWO bfd sections
- for the single program segment. The first has the length specified by
- the file size of the segment, and the second has the length specified
- by the difference between the two sizes. In effect, the segment is split
- into it's initialized and uninitialized parts.
-
- */
-
-static boolean
-DEFUN (bfd_section_from_phdr, (abfd, hdr, index),
- bfd * abfd AND
- Elf_Internal_Phdr * hdr AND
- int index)
-{
- asection *newsect;
- char *name;
- char namebuf[64];
- int split;
-
- split = ((hdr->p_memsz > 0) &&
- (hdr->p_filesz > 0) &&
- (hdr->p_memsz > hdr->p_filesz));
- sprintf (namebuf, split ? "segment%da" : "segment%d", index);
- name = bfd_alloc (abfd, strlen (namebuf) + 1);
- strcpy (name, namebuf);
- newsect = bfd_make_section (abfd, name);
- newsect->vma = hdr->p_vaddr;
- newsect->_raw_size = hdr->p_filesz;
- newsect->filepos = hdr->p_offset;
- newsect->flags |= SEC_HAS_CONTENTS;
- if (hdr->p_type == PT_LOAD)
- {
- newsect->flags |= SEC_ALLOC;
- newsect->flags |= SEC_LOAD;
- if (hdr->p_flags & PF_X)
- {
- /* FIXME: all we known is that it has execute PERMISSION,
- may be data. */
- newsect->flags |= SEC_CODE;
- }
- }
- if (!(hdr->p_flags & PF_W))
- {
- newsect->flags |= SEC_READONLY;
- }
-
- if (split)
- {
- sprintf (namebuf, "segment%db", index);
- name = bfd_alloc (abfd, strlen (namebuf) + 1);
- strcpy (name, namebuf);
- newsect = bfd_make_section (abfd, name);
- newsect->vma = hdr->p_vaddr + hdr->p_filesz;
- newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
- if (hdr->p_type == PT_LOAD)
- {
- newsect->flags |= SEC_ALLOC;
- if (hdr->p_flags & PF_X)
- newsect->flags |= SEC_CODE;
- }
- if (!(hdr->p_flags & PF_W))
- newsect->flags |= SEC_READONLY;
- }
-
- return true;
-}
/* Begin processing a given object.
the magic number. */
static INLINE boolean
-DEFUN (elf_file_p, (x_ehdrp), Elf_External_Ehdr * x_ehdrp)
+elf_file_p (x_ehdrp)
+ Elf_External_Ehdr *x_ehdrp;
{
return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
&& (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
&& (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
}
-bfd_target *
-DEFUN (elf_object_p, (abfd), bfd * abfd)
+/* Check to see if the file associated with ABFD matches the target vector
+ that ABFD points to.
+
+ Note that we may be called several times with the same ABFD, but different
+ target vectors, most of which will not match. We have to avoid leaving
+ any side effects in ABFD, or any data it points to (like tdata), if the
+ file does not match the target vector. */
+
+const bfd_target *
+elf_object_p (abfd)
+ bfd *abfd;
{
Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
Elf_External_Shdr x_shdr; /* Section header table entry, external form */
- Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
- int shindex;
+ Elf_Internal_Shdr *i_shdrp = NULL; /* Section header table, internal form */
+ unsigned int shindex;
char *shstrtab; /* Internal copy of section header stringtab */
- struct elf_backend_data *ebd; /* Use to get ELF_ARCH stored in xvec */
+ struct elf_backend_data *ebd;
+ struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
+ struct elf_obj_tdata *new_tdata = NULL;
+ asection *s;
/* Read in the ELF header in external format. */
if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
{
- bfd_error = system_call_error;
- return NULL;
+ if (bfd_get_error () != bfd_error_system_call)
+ goto got_wrong_format_error;
+ else
+ goto got_no_match;
}
/* Now check to see if we have a valid ELF file, and one that BFD can
section header table (FIXME: See comments re sections at top of this
file). */
- if (elf_file_p (&x_ehdr) == false)
- {
- wrong:
- bfd_error = wrong_format;
- return NULL;
- }
-
- if (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT)
- goto wrong;
-
- if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
- goto wrong;
+ if ((elf_file_p (&x_ehdr) == false) ||
+ (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT) ||
+ (x_ehdr.e_ident[EI_CLASS] != ELFCLASS))
+ goto got_wrong_format_error;
- /* Switch xvec to match the specified byte order. */
+ /* Check that file's byte order matches xvec's */
switch (x_ehdr.e_ident[EI_DATA])
{
case ELFDATA2MSB: /* Big-endian */
- if (!abfd->xvec->header_byteorder_big_p)
- goto wrong;
+ if (! bfd_header_big_endian (abfd))
+ goto got_wrong_format_error;
break;
case ELFDATA2LSB: /* Little-endian */
- if (abfd->xvec->header_byteorder_big_p)
- goto wrong;
+ if (! bfd_header_little_endian (abfd))
+ goto got_wrong_format_error;
break;
case ELFDATANONE: /* No data encoding specified */
default: /* Unknown data encoding specified */
- goto wrong;
+ goto got_wrong_format_error;
}
/* Allocate an instance of the elf_obj_tdata structure and hook it up to
- the tdata pointer in the bfd. */
+ the tdata pointer in the bfd. */
- if (NULL == (elf_tdata (abfd) = (struct elf_obj_tdata *)
- bfd_zalloc (abfd, sizeof (struct elf_obj_tdata))))
- {
- bfd_error = no_memory;
- return NULL;
- }
-
- /* FIXME: Any `wrong' exits below here will leak memory (tdata). */
+ new_tdata = ((struct elf_obj_tdata *)
+ bfd_zalloc (abfd, sizeof (struct elf_obj_tdata)));
+ if (new_tdata == NULL)
+ goto got_no_match;
+ elf_tdata (abfd) = new_tdata;
/* Now that we know the byte order, swap in the rest of the header */
i_ehdrp = elf_elfheader (abfd);
/* If there is no section header table, we're hosed. */
if (i_ehdrp->e_shoff == 0)
- goto wrong;
-
- if (i_ehdrp->e_type == ET_EXEC || i_ehdrp->e_type == ET_DYN)
- abfd->flags |= EXEC_P;
+ goto got_wrong_format_error;
- /* Retrieve the architecture information from the xvec and verify
- that it matches the machine info stored in the ELF header.
- This allows us to resolve ambiguous formats that might not
- otherwise be distinguishable. */
+ /* As a simple sanity check, verify that the what BFD thinks is the
+ size of each section header table entry actually matches the size
+ recorded in the file. */
+ if (i_ehdrp->e_shentsize != sizeof (x_shdr))
+ goto got_wrong_format_error;
ebd = get_elf_backend_data (abfd);
- /* Perhaps the elf architecture value should be another field in the
- elf backend data? If you change this to work that way, make sure
- that you still get bfd_arch_unknown for unknown architecture types,
- and that it still gets accepted by the `generic' elf target. */
- {
- int i;
- enum bfd_architecture arch = bfd_arch_unknown;
+ /* Check that the ELF e_machine field matches what this particular
+ BFD format expects. */
+ if (ebd->elf_machine_code != i_ehdrp->e_machine
+ && (ebd->elf_machine_alt1 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
+ && (ebd->elf_machine_alt2 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
+ {
+ const bfd_target * const *target_ptr;
- for (i = 0; i < bfd_elf_arch_map_size; i++)
- {
- if (bfd_elf_arch_map[i].elf_arch == i_ehdrp->e_machine)
- {
- arch = bfd_elf_arch_map[i].bfd_arch;
- break;
- }
- }
- /* start-sanitize-v9 */
- if (i_ehdrp->e_machine == EM_SPARC64)
- arch = bfd_arch_sparc;
- /* end-sanitize-v9 */
- if (ebd->arch != arch)
- goto wrong;
- bfd_default_set_arch_mach (abfd, arch, 0);
- }
+ if (ebd->elf_machine_code != EM_NONE)
+ goto got_wrong_format_error;
+
+ /* This is the generic ELF target. Let it match any ELF target
+ for which we do not have a specific backend. */
+ for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
+ {
+ struct elf_backend_data *back;
+
+ if ((*target_ptr)->flavour != bfd_target_elf_flavour)
+ continue;
+ back = (struct elf_backend_data *) (*target_ptr)->backend_data;
+ if (back->elf_machine_code == i_ehdrp->e_machine
+ || (back->elf_machine_alt1 != 0
+ && back->elf_machine_alt1 == i_ehdrp->e_machine)
+ || (back->elf_machine_alt2 != 0
+ && back->elf_machine_alt2 == i_ehdrp->e_machine))
+ {
+ /* target_ptr is an ELF backend which matches this
+ object file, so reject the generic ELF target. */
+ goto got_wrong_format_error;
+ }
+ }
+ }
+
+ if (i_ehdrp->e_type == ET_EXEC)
+ abfd->flags |= EXEC_P;
+ else if (i_ehdrp->e_type == ET_DYN)
+ abfd->flags |= DYNAMIC;
+
+ if (i_ehdrp->e_phnum > 0)
+ abfd->flags |= D_PAGED;
+
+ if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
+ goto got_no_match;
+
+ /* Remember the entry point specified in the ELF file header. */
+ bfd_get_start_address (abfd) = i_ehdrp->e_entry;
/* Allocate space for a copy of the section header table in
internal form, seek to the section header table in the file,
- read it in, and convert it to internal form. As a simple sanity
- check, verify that the what BFD thinks is the size of each section
- header table entry actually matches the size recorded in the file. */
-
- if (i_ehdrp->e_shentsize != sizeof (x_shdr))
- goto wrong;
- i_shdrp = (Elf_Internal_Shdr *)
- bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum);
- elf_elfsections (abfd) = bfd_alloc (abfd, sizeof (i_shdrp) * i_ehdrp->e_shnum);
- if (!i_shdrp || !elf_elfsections(abfd))
- {
- bfd_error = no_memory;
- return NULL;
- }
- if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) == -1)
- {
- bfd_error = system_call_error;
- return NULL;
- }
+ read it in, and convert it to internal form. */
+ i_shdrp = ((Elf_Internal_Shdr *)
+ bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum));
+ elf_elfsections (abfd) = ((Elf_Internal_Shdr **)
+ bfd_alloc (abfd,
+ sizeof (i_shdrp) * i_ehdrp->e_shnum));
+ if (!i_shdrp || !elf_elfsections (abfd))
+ goto got_no_match;
+ if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) != 0)
+ goto got_no_match;
for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
{
- if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd)
- != sizeof (x_shdr))
- {
- bfd_error = system_call_error;
- return NULL;
- }
+ if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr))
+ goto got_no_match;
elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
- elf_elfsections(abfd)[shindex] = i_shdrp + shindex;
+ elf_elfsections (abfd)[shindex] = i_shdrp + shindex;
+
+ /* If the section is loaded, but not page aligned, clear
+ D_PAGED. */
+ if ((i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
+ && i_shdrp[shindex].sh_type != SHT_NOBITS
+ && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
+ % ebd->maxpagesize)
+ != 0))
+ abfd->flags &= ~D_PAGED;
}
if (i_ehdrp->e_shstrndx)
{
- bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx);
+ if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
+ goto got_no_match;
}
-#if 0
- for (shindex = i_ehdrp->e_shnum - 1; shindex >= 0; shindex--)
+ /* Read in the program headers. */
+ if (i_ehdrp->e_phnum == 0)
+ elf_tdata (abfd)->phdr = NULL;
+ else
{
- if (!strcmp (elf_string_from_elf_strtab (abfd,
- i_shdrp[shindex].sh_name),
- ".strtab"))
- {
- elf_tdata(abfd)->strtab_hdr = i_shdrp[shindex];
- elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->strtab_hdr;
- }
- else if (!strcmp (elf_string_from_elf_strtab (abfd,
- i_shdrp[shindex].sh_name),
- ".symtab"))
+ Elf_Internal_Phdr *i_phdr;
+ unsigned int i;
+
+ elf_tdata (abfd)->phdr = ((Elf_Internal_Phdr *)
+ bfd_alloc (abfd,
+ (i_ehdrp->e_phnum
+ * sizeof (Elf_Internal_Phdr))));
+ if (elf_tdata (abfd)->phdr == NULL)
+ goto got_no_match;
+ if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) != 0)
+ goto got_no_match;
+ i_phdr = elf_tdata (abfd)->phdr;
+ for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
{
- elf_tdata(abfd)->symtab_hdr = i_shdrp[shindex];
- elf_elfsections(abfd)[shindex] = &elf_tdata(abfd)->symtab_hdr;
- elf_onesymtab (abfd) = shindex;
+ Elf_External_Phdr x_phdr;
+
+ if (bfd_read ((PTR) &x_phdr, sizeof x_phdr, 1, abfd)
+ != sizeof x_phdr)
+ goto got_no_match;
+ elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
}
}
-#endif
/* Read in the string table containing the names of the sections. We
will need the base pointer to this table later. */
bfd_section_from_shdr with it (since this particular strtab is
used to find all of the ELF section names.) */
- shstrtab = elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
+ shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
if (!shstrtab)
- return NULL;
+ goto got_no_match;
/* Once all of the section headers have been read and converted, we
can start processing them. Note that the first section header is
- a dummy placeholder entry, so we ignore it.
-
- We also watch for the symbol table section and remember the file
- offset and section size for both the symbol table section and the
- associated string table section. */
+ a dummy placeholder entry, so we ignore it. */
for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
{
- bfd_section_from_shdr (abfd, shindex);
+ if (! bfd_section_from_shdr (abfd, shindex))
+ goto got_no_match;
}
- /* Remember the entry point specified in the ELF file header. */
-
- bfd_get_start_address (abfd) = i_ehdrp->e_entry;
-
- return abfd->xvec;
-}
-
-\f
-/* ELF .o/exec file writing */
-
-/* Create a new ELF section from a bfd section. */
-
-#if 0 /* not used */
-static boolean
-DEFUN (bfd_shdr_from_section, (abfd, hdr, shstrtab, indx),
- bfd * abfd AND
- Elf_Internal_Shdr * hdr AND
- struct strtab *shstrtab AND
- int indx)
-{
- asection *sect;
- int ndx;
-
- sect = abfd->sections;
- for (ndx = indx; --ndx;)
+ /* Let the backend double check the format and override global
+ information. */
+ if (ebd->elf_backend_object_p)
{
- sect = sect->next;
- }
- hdr[indx].sh_name = bfd_add_to_strtab (abfd, shstrtab,
- bfd_section_name (abfd, sect));
- hdr[indx].sh_addr = sect->vma;
- hdr[indx].sh_size = sect->_raw_size;
- hdr[indx].sh_addralign = 1 << sect->alignment_power;
- hdr[indx].sh_flags = 0;
- /* these need to be preserved on */
- hdr[indx].sh_link = 0;
- hdr[indx].sh_info = 0;
- hdr[indx].sh_entsize = 0;
-
- hdr[indx].sh_type = 0;
- if (sect->flags & SEC_RELOC)
- {
- int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
- hdr[indx].sh_type = use_rela_p ? SHT_RELA : SHT_REL;
+ if ((*ebd->elf_backend_object_p) (abfd) == false)
+ goto got_wrong_format_error;
}
- if (sect->flags & SEC_HAS_CONTENTS)
- {
- hdr[indx].sh_offset = sect->filepos;
- hdr[indx].sh_size = sect->_raw_size;
- }
- if (sect->flags & SEC_ALLOC)
+ /* If we have created any reloc sections that are associated with
+ debugging sections, mark the reloc sections as debugging as well. */
+ for (s = abfd->sections; s != NULL; s = s->next)
{
- hdr[indx].sh_flags |= SHF_ALLOC;
- if (sect->flags & SEC_LOAD)
+ if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
+ || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
+ && elf_section_data (s)->this_hdr.sh_info > 0)
{
- /* do something with sh_type ? */
+ unsigned long targ_index;
+ asection *targ_sec;
+
+ targ_index = elf_section_data (s)->this_hdr.sh_info;
+ targ_sec = bfd_section_from_elf_index (abfd, targ_index);
+ if (targ_sec != NULL
+ && (targ_sec->flags & SEC_DEBUGGING) != 0)
+ s->flags |= SEC_DEBUGGING;
}
}
- if (!(sect->flags & SEC_READONLY))
- hdr[indx].sh_flags |= SHF_WRITE;
- if (sect->flags & SEC_CODE)
- hdr[indx].sh_flags |= SHF_EXECINSTR;
+ return (abfd->xvec);
- return true;
-}
-#endif
-
-/*
- Takes a bfd and a symbol, returns a pointer to the elf specific area
- of the symbol if there is one.
- */
-static INLINE elf_symbol_type *
-DEFUN (elf_symbol_from, (ignore_abfd, symbol),
- bfd * ignore_abfd AND
- asymbol * symbol)
-{
- if (symbol->the_bfd->xvec->flavour != bfd_target_elf_flavour)
- return 0;
-
- if (symbol->the_bfd->tdata.elf_obj_data == (struct elf_obj_tdata *) NULL)
- return 0;
-
- return (elf_symbol_type *) symbol;
+got_wrong_format_error:
+ bfd_set_error (bfd_error_wrong_format);
+ goto got_no_match;
+got_no_match:
+ if (new_tdata != NULL
+ && new_tdata->elf_sect_ptr != NULL)
+ bfd_release (abfd, new_tdata->elf_sect_ptr);
+ if (i_shdrp != NULL)
+ bfd_release (abfd, i_shdrp);
+ if (new_tdata != NULL)
+ bfd_release (abfd, new_tdata);
+ elf_tdata (abfd) = preserved_tdata;
+ return (NULL);
}
+\f
+/* ELF .o/exec file writing */
-/*
- Create ELF output from BFD sections.
-
- Essentially, just create the section header and forget about the program
- header for now.
-
-*/
+/* Write out the relocs. */
static void
-DEFUN (elf_make_sections, (abfd, asect, obj),
- bfd * abfd AND
- asection * asect AND
- PTR obj)
-{
- /* most of what is in bfd_shdr_from_section goes in here... */
- /* and all of these sections generate at *least* one ELF section. */
- int idx;
-
- Elf_Internal_Shdr *this_hdr;
- this_hdr = &elf_section_data (asect)->this_hdr;
-
- this_hdr->sh_addr = asect->vma;
- this_hdr->sh_size = asect->_raw_size;
- /* contents already set by elf_set_section_contents */
-
- if ((asect->flags & SEC_RELOC)
-#if 0
- /* The flags are sometimes inconsistent. */
- && asect->reloc_count > 0
-#endif
- )
- {
- /* emit a reloc section, and thus strtab and symtab... */
- Elf_Internal_Shdr *rela_hdr;
- Elf_External_Rela *outbound_relocas;
- Elf_External_Rel *outbound_relocs;
- int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
-
- rela_hdr = &elf_section_data (asect)->rel_hdr;
-
- /* orelocation has the data, reloc_count has the count... */
- if (use_rela_p)
- {
- rela_hdr->sh_type = SHT_RELA;
- rela_hdr->sh_entsize = sizeof (Elf_External_Rela);
- }
- else
- /* REL relocations */
- {
- rela_hdr->sh_type = SHT_REL;
- rela_hdr->sh_entsize = sizeof (Elf_External_Rel);
- }
- rela_hdr->sh_flags = 0;
- rela_hdr->sh_addr = 0;
- rela_hdr->sh_offset = 0;
- rela_hdr->sh_addralign = 0;
- rela_hdr->size = 0;
- }
- if (asect->flags & SEC_ALLOC)
- {
- this_hdr->sh_flags |= SHF_ALLOC;
- if (asect->flags & SEC_LOAD)
- {
- /* @@ Do something with sh_type? */
- }
- }
- if (!(asect->flags & SEC_READONLY))
- this_hdr->sh_flags |= SHF_WRITE;
-
- if (asect->flags & SEC_CODE)
- this_hdr->sh_flags |= SHF_EXECINSTR;
-}
-
-void
-write_relocs (abfd, sec, xxx)
+write_relocs (abfd, sec, data)
bfd *abfd;
asection *sec;
- PTR xxx;
+ PTR data;
{
+ boolean *failedp = (boolean *) data;
Elf_Internal_Shdr *rela_hdr;
Elf_External_Rela *outbound_relocas;
Elf_External_Rel *outbound_relocs;
- int idx;
+ unsigned int idx;
int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
+ asymbol *last_sym = 0;
+ int last_sym_idx = 0;
+
+ /* If we have already failed, don't do anything. */
+ if (*failedp)
+ return;
-malloc(0);
if ((sec->flags & SEC_RELOC) == 0)
return;
- /* Flags are sometimes inconsistent. */
+
+ /* The linker backend writes the relocs out itself, and sets the
+ reloc_count field to zero to inhibit writing them here. Also,
+ sometimes the SEC_RELOC flag gets set even when there aren't any
+ relocs. */
if (sec->reloc_count == 0)
return;
rela_hdr = &elf_section_data (sec)->rel_hdr;
rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
- rela_hdr->contents = (void *) bfd_alloc (abfd, rela_hdr->sh_size);
+ rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
+ if (rela_hdr->contents == NULL)
+ {
+ *failedp = true;
+ return;
+ }
/* orelocation has the data, reloc_count has the count... */
- if (use_rela_p)
+ if (use_rela_p)
+ {
+ outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
+
+ for (idx = 0; idx < sec->reloc_count; idx++)
{
- outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
+ Elf_Internal_Rela dst_rela;
+ Elf_External_Rela *src_rela;
+ arelent *ptr;
+ asymbol *sym;
+ int n;
+
+ ptr = sec->orelocation[idx];
+ src_rela = outbound_relocas + idx;
+
+ /* The address of an ELF reloc is section relative for an object
+ file, and absolute for an executable file or shared library.
+ The address of a BFD reloc is always section relative. */
+ if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
+ dst_rela.r_offset = ptr->address;
+ else
+ dst_rela.r_offset = ptr->address + sec->vma;
- for (idx = 0; idx < sec->reloc_count; idx++)
+ sym = *ptr->sym_ptr_ptr;
+ if (sym == last_sym)
+ n = last_sym_idx;
+ else if (bfd_is_abs_section (sym->section) && sym->value == 0)
+ n = STN_UNDEF;
+ else
{
- Elf_Internal_Rela dst_rela;
- Elf_External_Rela *src_rela;
- arelent *ptr;
- asymbol *sym;
-
- ptr = sec->orelocation[idx];
- src_rela = outbound_relocas + idx;
- if (!(abfd->flags & EXEC_P))
- dst_rela.r_offset = ptr->address - sec->vma;
- else
- dst_rela.r_offset = ptr->address;
-
- sym = *ptr->sym_ptr_ptr;
-#if 0
- /* I think this bit is wrong. But doing it right here means
- fixing bfd_perform_relocation, and verifying that it doesn't
- break other targets. Sigh.
-
- Problem I'm trying to solve here: `ld -r' tends to get
- offset of target symbol in output-file section put into
- addend, but retains the original symbol, so the net
- result is doubling of that offset. */
- if (!bfd_is_com_section (sym->section)
- && sym->section != &bfd_und_section)
+ last_sym = sym;
+ n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
+ if (n < 0)
{
- /* Could adjust either the offset or the symbol here.
- I'm pretty indifferent. */
- sym = sym->section->symbol;
+ *failedp = true;
+ return;
}
-#endif
- dst_rela.r_info
- = ELF_R_INFO (elf_symbol_from_bfd_symbol (abfd, &sym),
- ptr->howto->type);
+ last_sym_idx = n;
+ }
- dst_rela.r_addend = ptr->addend;
- elf_swap_reloca_out (abfd, &dst_rela, src_rela);
-malloc(0);
+ if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
+ && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
+ && ! _bfd_elf_validate_reloc (abfd, ptr))
+ {
+ *failedp = true;
+ return;
}
+
+ dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
+
+ dst_rela.r_addend = ptr->addend;
+ elf_swap_reloca_out (abfd, &dst_rela, src_rela);
}
- else
- /* REL relocations */
+ }
+ else
+ /* REL relocations */
+ {
+ outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
+
+ for (idx = 0; idx < sec->reloc_count; idx++)
{
- outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
+ Elf_Internal_Rel dst_rel;
+ Elf_External_Rel *src_rel;
+ arelent *ptr;
+ int n;
+ asymbol *sym;
+
+ ptr = sec->orelocation[idx];
+ sym = *ptr->sym_ptr_ptr;
+ src_rel = outbound_relocs + idx;
+
+ /* The address of an ELF reloc is section relative for an object
+ file, and absolute for an executable file or shared library.
+ The address of a BFD reloc is always section relative. */
+ if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
+ dst_rel.r_offset = ptr->address;
+ else
+ dst_rel.r_offset = ptr->address + sec->vma;
+
+ if (sym == last_sym)
+ n = last_sym_idx;
+ else
+ {
+ last_sym = sym;
+ n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
+ if (n < 0)
+ {
+ *failedp = true;
+ return;
+ }
+ last_sym_idx = n;
+ }
- for (idx = 0; idx < sec->reloc_count; idx++)
+ if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
+ && ! _bfd_elf_validate_reloc (abfd, ptr))
{
- Elf_Internal_Rel dst_rel;
- Elf_External_Rel *src_rel;
- arelent *ptr;
-
- ptr = sec->orelocation[idx];
- src_rel = outbound_relocs + idx;
- if (!(abfd->flags & EXEC_P))
- dst_rel.r_offset = ptr->address - sec->vma;
- else
- dst_rel.r_offset = ptr->address;
-
- dst_rel.r_info
- = ELF_R_INFO (elf_symbol_from_bfd_symbol (abfd, ptr->sym_ptr_ptr),
- ptr->howto->type);
-
- elf_swap_reloc_out (abfd, &dst_rel, src_rel);
-
- /* Update the addend -- FIXME add 64 bit support. */
- bfd_put_32 (abfd, ptr->addend,
- (unsigned char *) (elf_section_data (sec)->this_hdr.contents)
- + dst_rel.r_offset);
+ *failedp = true;
+ return;
}
+
+ dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
+
+ elf_swap_reloc_out (abfd, &dst_rel, src_rel);
}
+ }
}
-static void
-fix_up_strtabs (abfd, asect, obj)
+/* Write out the program headers. */
+
+int
+elf_write_out_phdrs (abfd, phdr, count)
bfd *abfd;
- asection *asect;
- PTR obj;
+ const Elf_Internal_Phdr *phdr;
+ int count;
{
- Elf_Internal_Shdr *this_hdr = &elf_section_data (asect)->this_hdr;
- int this_idx = elf_section_data(asect)->this_idx;
-
- /* @@ Check flags! */
- if (!strncmp (asect->name, ".stab", 5)
- && !strcmp ("str", asect->name + strlen (asect->name) - 3))
+ while (count--)
{
- size_t len = strlen (asect->name) + 1;
- char *s = alloca (len);
- strcpy (s, asect->name);
- s[len - 4] = 0;
- asect = bfd_get_section_by_name (abfd, s);
- if (!asect)
- abort ();
- elf_section_data(asect)->this_hdr.sh_link = this_idx;
-
- /* @@ Assuming 32 bits! */
- this_hdr->sh_entsize = 0xc;
+ Elf_External_Phdr extphdr;
+ elf_swap_phdr_out (abfd, phdr, &extphdr);
+ if (bfd_write (&extphdr, sizeof (Elf_External_Phdr), 1, abfd)
+ != sizeof (Elf_External_Phdr))
+ return -1;
+ phdr++;
}
+ return 0;
}
-static void
-DEFUN (elf_fake_sections, (abfd, asect, obj),
- bfd * abfd AND
- asection * asect AND
- PTR obj)
-{
- /* most of what is in bfd_shdr_from_section goes in here... */
- /* and all of these sections generate at *least* one ELF section. */
-
- Elf_Internal_Shdr *this_hdr;
- this_hdr = &elf_section_data (asect)->this_hdr;
- this_hdr->sh_name =
- bfd_add_to_strtab (abfd, elf_shstrtab (abfd), asect->name);
- /* We need to log the type *now* so that elf_section_from_bfd_section
- can find us... have to set rawdata too. */
- this_hdr->rawdata = (void *) asect;
- this_hdr->sh_addralign = 1 << asect->alignment_power;
- if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD))
- this_hdr->sh_type = SHT_PROGBITS;
- /* @@ Select conditions correctly! */
- else if (!strcmp (asect->name, ".bss"))
- this_hdr->sh_type = SHT_NOBITS;
- else
- /* what *do* we put here? */
- this_hdr->sh_type = SHT_PROGBITS;
-
- this_hdr->sh_flags = 0;
- this_hdr->sh_addr = 0;
- this_hdr->sh_size = 0;
- this_hdr->sh_entsize = 0;
- this_hdr->sh_info = 0;
- this_hdr->sh_link = 0;
- this_hdr->sh_offset = 0;
- this_hdr->size = 0;
-
- {
- /* Emit a strtab and symtab, and possibly a reloc section. */
- Elf_Internal_Shdr *rela_hdr;
- Elf_Internal_Shdr *symstrtab_hdr;
-
- /* Note that only one symtab is used, so just remember it
- for now. */
-
- if ((asect->flags & SEC_RELOC)
- /* inconsistent flags... */
- && asect->reloc_count > 0)
- {
- int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
-
- rela_hdr = &elf_section_data (asect)->rel_hdr;
- rela_hdr->sh_name =
- bfd_add_2_to_strtab (abfd, elf_shstrtab (abfd),
- use_rela_p ? ".rela" : ".rel",
- asect->name);
- rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
- rela_hdr->sh_entsize = (use_rela_p
- ? sizeof (Elf_External_Rela)
- : sizeof (Elf_External_Rel));
-
- rela_hdr->sh_flags = 0;
- rela_hdr->sh_addr = 0;
- rela_hdr->sh_size = 0;
- rela_hdr->sh_offset = 0;
- rela_hdr->sh_addralign = 0;
- rela_hdr->size = 0;
- }
- }
- if (asect->flags & SEC_ALLOC)
- {
- this_hdr->sh_flags |= SHF_ALLOC;
- if (asect->flags & SEC_LOAD)
- {
- /* @@ Do something with sh_type? */
- }
- }
- if (!(asect->flags & SEC_READONLY))
- this_hdr->sh_flags |= SHF_WRITE;
- if (asect->flags & SEC_CODE)
- this_hdr->sh_flags |= SHF_EXECINSTR;
-}
+/* Write out the section headers and the ELF file header. */
+boolean
+elf_write_shdrs_and_ehdr (abfd)
+ bfd *abfd;
+{
+ Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
+ Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
+ Elf_External_Shdr *x_shdrp; /* Section header table, external form */
+ Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
+ unsigned int count;
-/*
-xxxINTERNAL_FUNCTION
- bfd_elf_locate_sh
+ i_ehdrp = elf_elfheader (abfd);
+ i_shdrp = elf_elfsections (abfd);
-xxxSYNOPSIS
- struct elf_internal_shdr *bfd_elf_locate_sh (bfd *abfd,
- struct strtab *strtab,
- struct elf_internal_shdr *shdrp,
- CONST char *name);
+ /* swap the header before spitting it out... */
-xxxDESCRIPTION
- Helper function to locate an ELF section header given the
- name of a BFD section.
-*/
+#if DEBUG & 1
+ elf_debug_file (i_ehdrp);
+#endif
+ elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
+ || (bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd)
+ != sizeof (x_ehdr)))
+ return false;
-static struct elfNAME (internal_shdr) *
-DEFUN (elf_locate_sh, (abfd, strtab, shdrp, name),
- bfd * abfd AND
- struct strtab *strtab AND
- struct elfNAME (internal_shdr) *shdrp AND
- CONST char *name)
-{
- Elf_Internal_Shdr *gotit = NULL;
- int max, i;
+ /* at this point we've concocted all the ELF sections... */
+ x_shdrp = (Elf_External_Shdr *)
+ bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
+ if (!x_shdrp)
+ return false;
- if (shdrp != NULL && strtab != NULL)
+ for (count = 0; count < i_ehdrp->e_shnum; count++)
{
- max = elf_elfheader (abfd)->e_shnum;
- for (i = 1; i < max; i++)
- {
- if (!strcmp (strtab->tab + shdrp[i].sh_name, name))
- {
- gotit = &shdrp[i];
- }
- }
+#if DEBUG & 2
+ elf_debug_section (count, i_shdrp[count]);
+#endif
+ elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
}
- return gotit;
-}
+ if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
+ || (bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd)
+ != sizeof (*x_shdrp) * i_ehdrp->e_shnum))
+ return false;
-/* Map symbol from it's internal number to the external number, moving
- all local symbols to be at the head of the list. */
+ /* need to dump the string table too... */
-static INLINE int
-sym_is_global (sym)
- asymbol *sym;
-{
- if (sym->flags & BSF_GLOBAL)
- {
- if (sym->flags & BSF_LOCAL)
- abort ();
- return 1;
- }
- if (sym->section == &bfd_und_section)
- return 1;
- if (bfd_is_com_section (sym->section))
- return 1;
- if (sym->flags & (BSF_LOCAL | BSF_SECTION_SYM | BSF_FILE))
- return 0;
- return 0;
+ return true;
}
-static void
-DEFUN (elf_map_symbols, (abfd), bfd * abfd)
+long
+elf_slurp_symbol_table (abfd, symptrs, dynamic)
+ bfd *abfd;
+ asymbol **symptrs; /* Buffer for generated bfd symbols */
+ boolean dynamic;
{
- int symcount = bfd_get_symcount (abfd);
- asymbol **syms = bfd_get_outsymbols (abfd);
- int num_locals = 0;
- int num_globals = 0;
- int num_locals2 = 0;
- int num_globals2 = 0;
- int num_sections = 0;
- int *symtab_map;
- int idx;
- asection *asect;
+ Elf_Internal_Shdr *hdr;
+ Elf_Internal_Shdr *verhdr;
+ unsigned long symcount; /* Number of external ELF symbols */
+ elf_symbol_type *sym; /* Pointer to current bfd symbol */
+ elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
+ Elf_Internal_Sym i_sym;
+ Elf_External_Sym *x_symp = NULL;
+ Elf_External_Versym *x_versymp = NULL;
-#ifdef DEBUG
- fprintf (stderr, "elf_map_symbols\n");
- fflush (stderr);
-#endif
+ /* Read each raw ELF symbol, converting from external ELF form to
+ internal ELF form, and then using the information to create a
+ canonical bfd symbol table entry.
+
+ Note that we allocate the initial bfd canonical symbol buffer
+ based on a one-to-one mapping of the ELF symbols to canonical
+ symbols. We actually use all the ELF symbols, so there will be no
+ space left over at the end. When we have all the symbols, we
+ build the caller's pointer vector. */
- /* Add local symbols for each allocated section
- FIXME -- we should only put out symbols for sections that
- are actually relocated against. */
- for (asect = abfd->sections; asect; asect = asect->next)
+ if (! dynamic)
{
- if (/*asect->flags & (SEC_LOAD | SEC_DATA | SEC_CODE)*/1)
- num_sections++;
+ hdr = &elf_tdata (abfd)->symtab_hdr;
+ verhdr = NULL;
}
-
- if (num_sections)
+ else
{
- if (syms)
- syms = (asymbol **) bfd_realloc (abfd, syms,
- ((symcount + num_sections + 1)
- * sizeof (asymbol *)));
+ hdr = &elf_tdata (abfd)->dynsymtab_hdr;
+ if (elf_dynversym (abfd) == 0)
+ verhdr = NULL;
else
- syms = (asymbol **) bfd_alloc (abfd,
- (num_sections + 1) * sizeof (asymbol *));
-
- for (asect = abfd->sections; asect; asect = asect->next)
+ verhdr = &elf_tdata (abfd)->dynversym_hdr;
+ if ((elf_tdata (abfd)->dynverdef_section != 0
+ && elf_tdata (abfd)->verdef == NULL)
+ || (elf_tdata (abfd)->dynverref_section != 0
+ && elf_tdata (abfd)->verref == NULL))
{
- if (/* asect->flags & (SEC_LOAD | SEC_DATA | SEC_CODE) */ 1)
- {
- asymbol *sym = syms[symcount++] = bfd_make_empty_symbol (abfd);
- sym->the_bfd = abfd;
- sym->name = asect->name;
- sym->value = asect->vma;
- sym->flags = BSF_SECTION_SYM;
- sym->section = asect;
- }
+ if (! _bfd_elf_slurp_version_tables (abfd))
+ return -1;
}
-
- syms[symcount] = (asymbol *) 0;
- bfd_set_symtab (abfd, syms, symcount);
}
- elf_symtab_map (abfd) = symtab_map
- = (int *) bfd_alloc (abfd, symcount * sizeof (int *));
+ if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
+ return -1;
- /* Identify and classify all of the symbols. */
- for (idx = 0; idx < symcount; idx++)
- {
- if (!sym_is_global (syms[idx]))
- num_locals++;
- else
- num_globals++;
- }
+ symcount = hdr->sh_size / sizeof (Elf_External_Sym);
- /* Now provide mapping information. Add +1 for skipping over the
- dummy symbol. */
- for (idx = 0; idx < symcount; idx++)
+ if (symcount == 0)
+ sym = symbase = NULL;
+ else
{
- if (!sym_is_global (syms[idx]))
- symtab_map[idx] = 1 + num_locals2++;
- else
- symtab_map[idx] = 1 + num_locals + num_globals2++;
- }
+ unsigned long i;
- elf_num_locals (abfd) = num_locals;
- elf_num_globals (abfd) = num_globals;
-}
+ if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
+ return -1;
-static void assign_section_numbers ();
-static void assign_file_positions_except_relocs ();
+ symbase = ((elf_symbol_type *)
+ bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type)));
+ if (symbase == (elf_symbol_type *) NULL)
+ return -1;
+ sym = symbase;
-static boolean
-DEFUN (elf_compute_section_file_positions, (abfd), bfd * abfd)
-{
- Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
- Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
- struct strtab *shstrtab;
- int count, maxsections;
+ /* Temporarily allocate room for the raw ELF symbols. */
+ x_symp = ((Elf_External_Sym *)
+ bfd_malloc (symcount * sizeof (Elf_External_Sym)));
+ if (x_symp == NULL && symcount != 0)
+ goto error_return;
- bfd_map_over_sections (abfd, elf_fake_sections, 0);
+ if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
+ != symcount * sizeof (Elf_External_Sym))
+ goto error_return;
- assign_section_numbers (abfd);
+ /* Read the raw ELF version symbol information. */
- bfd_map_over_sections (abfd, elf_make_sections, 0);
+ if (verhdr != NULL
+ && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
+ {
+ (*_bfd_error_handler)
+ (_("%s: version count (%ld) does not match symbol count (%ld)"),
+ abfd->filename,
+ (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
+ symcount);
+
+ /* Slurp in the symbols without the version information,
+ since that is more helpful than just quitting. */
+ verhdr = NULL;
+ }
- bfd_map_over_sections (abfd, fix_up_strtabs, 0); /* .stab/.stabstr &c */
+ if (verhdr != NULL)
+ {
+ if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
+ goto error_return;
- swap_out_syms (abfd);
+ x_versymp = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
+ if (x_versymp == NULL && verhdr->sh_size != 0)
+ goto error_return;
- assign_file_positions_except_relocs (abfd);
+ if (bfd_read ((PTR) x_versymp, 1, verhdr->sh_size, abfd)
+ != verhdr->sh_size)
+ goto error_return;
+ }
- return true;
-}
+ /* Skip first symbol, which is a null dummy. */
+ for (i = 1; i < symcount; i++)
+ {
+ elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
+ memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
+#ifdef ELF_KEEP_EXTSYM
+ memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
+#endif
+ sym->symbol.the_bfd = abfd;
-static boolean
-DEFUN (elf_write_phdrs, (abfd, i_ehdrp, i_phdrp, phdr_cnt),
- bfd * abfd AND
- Elf_Internal_Ehdr * i_ehdrp AND
- Elf_Internal_Phdr * i_phdrp AND
- Elf32_Half phdr_cnt)
-{
- /* first program header entry goes after the file header */
- int outbase = i_ehdrp->e_ehsize;
- int i;
- Elf_External_Phdr x_phdr;
+ sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
+ hdr->sh_link,
+ i_sym.st_name);
- for (i = 0; i < phdr_cnt; i++)
- {
- elf_swap_phdr_out (abfd, i_phdrp + i, &x_phdr);
- bfd_seek (abfd, outbase, SEEK_SET);
- bfd_write ((PTR) & x_phdr, sizeof (x_phdr), 1, abfd);
- outbase += sizeof (x_phdr);
- }
+ sym->symbol.value = i_sym.st_value;
- return true;
-}
+ if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
+ {
+ sym->symbol.section = section_from_elf_index (abfd,
+ i_sym.st_shndx);
+ if (sym->symbol.section == NULL)
+ {
+ /* This symbol is in a section for which we did not
+ create a BFD section. Just use bfd_abs_section,
+ although it is wrong. FIXME. */
+ sym->symbol.section = bfd_abs_section_ptr;
+ }
+ }
+ else if (i_sym.st_shndx == SHN_ABS)
+ {
+ sym->symbol.section = bfd_abs_section_ptr;
+ }
+ else if (i_sym.st_shndx == SHN_COMMON)
+ {
+ sym->symbol.section = bfd_com_section_ptr;
+ /* Elf puts the alignment into the `value' field, and
+ the size into the `size' field. BFD wants to see the
+ size in the value field, and doesn't care (at the
+ moment) about the alignment. */
+ sym->symbol.value = i_sym.st_size;
+ }
+ else if (i_sym.st_shndx == SHN_UNDEF)
+ {
+ sym->symbol.section = bfd_und_section_ptr;
+ }
+ else
+ sym->symbol.section = bfd_abs_section_ptr;
-static Elf_Internal_Phdr *
-DEFUN (elf_build_phdrs, (abfd, i_ehdrp, i_shdrp, phdr_cnt),
- bfd * abfd AND
- Elf_Internal_Ehdr * i_ehdrp AND
- Elf_Internal_Shdr * i_shdrp AND
- Elf32_Half * phdr_cnt)
-{
- Elf_Internal_Phdr *phdr_buf;
- int idx;
- /* NOTES:
- 1. The program header table is *not* loaded as part
- of the memory image of the program. If this
- changes later, the PT_PHDR entry must come first.
- 2. there is currently no support for program header
- entries of type PT_PHDR, PT_DYNAMIC, PT_INTERP,
- or PT_SHLIB. */
-
- /* A. Figure out how many program header table entries are needed
- 1. PT_LOAD for the text segment
- 2. PT_LOAD for the data segment
- Then, reserve space for one more pointer. This will be NULL
- to indicate the end of the program header table. */
-
-#ifdef PHDRS_INCLUDED
- *phdr_cnt = 4;
-#else
- /* XXX right now, execve() expects exactly 3 PT entries on HPPA-OSF. */
- *phdr_cnt = 3;
-#endif
+ /* If this is a relocateable file, then the symbol value is
+ already section relative. */
+ if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
+ sym->symbol.value -= sym->symbol.section->vma;
+
+ switch (ELF_ST_BIND (i_sym.st_info))
+ {
+ case STB_LOCAL:
+ sym->symbol.flags |= BSF_LOCAL;
+ break;
+ case STB_GLOBAL:
+ if (i_sym.st_shndx != SHN_UNDEF
+ && i_sym.st_shndx != SHN_COMMON)
+ sym->symbol.flags |= BSF_GLOBAL;
+ break;
+ case STB_WEAK:
+ sym->symbol.flags |= BSF_WEAK;
+ break;
+ }
+
+ switch (ELF_ST_TYPE (i_sym.st_info))
+ {
+ case STT_SECTION:
+ sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
+ break;
+ case STT_FILE:
+ sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
+ break;
+ case STT_FUNC:
+ sym->symbol.flags |= BSF_FUNCTION;
+ break;
+ case STT_OBJECT:
+ sym->symbol.flags |= BSF_OBJECT;
+ break;
+ }
+
+ if (dynamic)
+ sym->symbol.flags |= BSF_DYNAMIC;
- phdr_buf = (Elf_Internal_Phdr *) bfd_xmalloc (((*phdr_cnt) + 1)
- *
- sizeof (Elf_Internal_Phdr));
+ if (x_versymp != NULL)
+ {
+ Elf_Internal_Versym iversym;
- idx = 0;
-#ifdef PHDRS_INCLUDED
- /* B. Fill in the PT_PHDR entry. */
+ _bfd_elf_swap_versym_in (abfd, x_versymp + i, &iversym);
+ sym->version = iversym.vs_vers;
+ }
- idx++;
-#endif
+ /* Do some backend-specific processing on this symbol. */
+ {
+ struct elf_backend_data *ebd = get_elf_backend_data (abfd);
+ if (ebd->elf_backend_symbol_processing)
+ (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
+ }
- /* C. Fill in the PT_LOAD entry for the text segment. */
-
- phdr_buf[idx].p_type = PT_LOAD;
-
- /* get virtual/physical address from .text section */
- phdr_buf[idx].p_vaddr = bfd_get_section_by_name (abfd, ".text")->vma;
- phdr_buf[idx].p_paddr = 0; /* XXX */
-
- /* Ultimately, we would like the size of the .text load
- segment to be the sum of the following sections:
- the program header table itself
- .interp
- .hash
- .dynsym
- .dynstr
- .rela.bss
- .rela.plt
- .init
- .text
- .fini
- .rodata
- But, right now, it will be the sum of the following sections:
- .text
- .rodata */
+ sym++;
+ }
+ }
+ /* Do some backend-specific processing on this symbol table. */
{
- static char *CONST ld_sect_names[] =
- {".text", ".rodata", NULL};
- int i;
- int ld_size = 0;
-
- for (i = 0; ld_sect_names[i]; i++)
- {
- asection *asect = bfd_get_section_by_name (abfd,
- ld_sect_names[i]);
-
- if (asect)
- ld_size += bfd_section_size (abfd, asect);
- }
- phdr_buf[idx].p_filesz = ld_size;
- /* XXX: need to fix this */
- phdr_buf[idx].p_memsz = ld_size;
+ struct elf_backend_data *ebd = get_elf_backend_data (abfd);
+ if (ebd->elf_backend_symbol_table_processing)
+ (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
}
- phdr_buf[idx].p_flags = PF_R + PF_X;
- phdr_buf[idx].p_align =
- bfd_get_section_by_name (abfd, ".text")->alignment_power;
- idx++;
-
- /* D. Fill in the PT_LOAD entry for the data segment. */
+ /* We rely on the zalloc to clear out the final symbol entry. */
- phdr_buf[idx].p_type = PT_LOAD;
+ symcount = sym - symbase;
- /* get virtual/physical address from .data section */
- phdr_buf[idx].p_vaddr = bfd_get_section_by_name (abfd, ".data")->vma;
- phdr_buf[idx].p_paddr = 0; /* XXX */
+ /* Fill in the user's symbol pointer vector if needed. */
+ if (symptrs)
+ {
+ long l = symcount;
- /* Ultimately, we would like the size of the data load segment
- to be the sum of the following sections:
- the PT_DYNAMIC program header table entry
- .plt
- .data
- .data1
- .got
- .dynamic
- But, right now, it will be the sum of the following sections:
- .data */
+ sym = symbase;
+ while (l-- > 0)
+ {
+ *symptrs++ = &sym->symbol;
+ sym++;
+ }
+ *symptrs = 0; /* Final null pointer */
+ }
- {
- static char *CONST ld_sect_names[] =
- {".data", NULL};
- int i;
- int ld_size = 0;
-
- for (i = 0; ld_sect_names[i]; i++)
- {
- asection *asect = bfd_get_section_by_name (abfd,
- ld_sect_names[i]);
-
- if (asect)
- ld_size += bfd_section_size (abfd, asect);
- }
- phdr_buf[idx].p_filesz = ld_size;
- /* XXX: need to fix this */
- phdr_buf[idx].p_memsz = ld_size;
- }
- phdr_buf[idx].p_flags = PF_R + PF_W + PF_X;
- phdr_buf[idx].p_align
- = bfd_get_section_by_name (abfd, ".data")->alignment_power;
+ if (x_versymp != NULL)
+ free (x_versymp);
+ if (x_symp != NULL)
+ free (x_symp);
+ return symcount;
+error_return:
+ if (x_versymp != NULL)
+ free (x_versymp);
+ if (x_symp != NULL)
+ free (x_symp);
+ return -1;
+}
- idx++;
+/* Read in and swap the external relocs. */
- /* E. Fill in the PT_LOAD entry for the bss segment. */
+static boolean
+elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
+ bfd *abfd;
+ asection *asect;
+ asymbol **symbols;
+ boolean dynamic;
+{
+ struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
+ struct bfd_elf_section_data * const d = elf_section_data (asect);
+ Elf_Internal_Shdr *rel_hdr;
+ bfd_size_type reloc_count;
+ PTR allocated = NULL;
+ bfd_byte *native_relocs;
+ arelent *relents;
+ arelent *relent;
+ unsigned int i;
+ int entsize;
+
+ if (asect->relocation != NULL)
+ return true;
- phdr_buf[idx].p_type = PT_LOAD;
+ if (! dynamic)
+ {
+ if ((asect->flags & SEC_RELOC) == 0
+ || asect->reloc_count == 0)
+ return true;
- /* get virtual/physical address from .data section */
- phdr_buf[idx].p_vaddr = bfd_get_section_by_name (abfd, ".bss")->vma;
- phdr_buf[idx].p_paddr = 0; /* XXX */
+ rel_hdr = &d->rel_hdr;
+ reloc_count = asect->reloc_count;
- {
- static char *CONST ld_sect_names[] =
- {".bss", NULL};
- int i;
- int ld_size = 0;
-
- for (i = 0; ld_sect_names[i]; i++)
- {
- asection *asect = bfd_get_section_by_name (abfd,
- ld_sect_names[i]);
-
- if (asect)
- ld_size += bfd_section_size (abfd, asect);
- }
- phdr_buf[idx].p_filesz = 0;
- /* XXX: need to fix this */
- phdr_buf[idx].p_memsz = ld_size;
- }
- phdr_buf[idx].p_flags = PF_R + PF_W + PF_X;
- phdr_buf[idx].p_align
- = bfd_get_section_by_name (abfd, ".bss")->alignment_power;
+ BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
+ && reloc_count == rel_hdr->sh_size / rel_hdr->sh_entsize);
+ }
+ else
+ {
+ if (asect->_raw_size == 0)
+ return true;
- idx++;
+ rel_hdr = &d->this_hdr;
+ reloc_count = rel_hdr->sh_size / rel_hdr->sh_entsize;
+ }
- /* F. Set up the "end of program header table" sentinel. */
+ allocated = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
+ if (allocated == NULL)
+ goto error_return;
- memset ((char *) (phdr_buf + idx), 0, sizeof (Elf_Internal_Phdr));
- idx++;
+ if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
+ || (bfd_read (allocated, 1, rel_hdr->sh_size, abfd)
+ != rel_hdr->sh_size))
+ goto error_return;
- BFD_ASSERT (idx - 1 == *phdr_cnt);
+ native_relocs = (bfd_byte *) allocated;
- return phdr_buf;
-}
+ relents = (arelent *) bfd_alloc (abfd, reloc_count * sizeof (arelent));
+ if (relents == NULL)
+ goto error_return;
-static const Elf_Internal_Shdr null_shdr;
+ entsize = rel_hdr->sh_entsize;
+ BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
+ || entsize == sizeof (Elf_External_Rela));
-/* Assign all ELF section numbers. The dummy first section is handled here
- too. The link/info pointers for the standard section types are filled
- in here too, while we're at it. (Link pointers for .stab sections are
- not filled in here.) */
-static void
-assign_section_numbers (abfd)
- bfd *abfd;
-{
- struct elf_obj_tdata *t = elf_tdata (abfd);
- asection *sec;
- int section_number = 1;
- int i;
- Elf_Internal_Shdr **i_shdrp;
-
- t->shstrtab_hdr.sh_size = elf_shstrtab(abfd)->length;
- t->shstrtab_hdr.contents = (void *) elf_shstrtab(abfd)->tab;
- shstrtab_length_fixed = 1;
-
- t->shstrtab_section = section_number++;
- elf_elfheader(abfd)->e_shstrndx = t->shstrtab_section;
- if (abfd->symcount)
- {
- t->symtab_section = section_number++;
- t->strtab_section = section_number++;
- t->symtab_hdr.sh_link = t->strtab_section;
- }
- for (sec = abfd->sections; sec; sec = sec->next)
+ for (i = 0, relent = relents;
+ i < reloc_count;
+ i++, relent++, native_relocs += entsize)
{
- struct bfd_elf_section_data *d = elf_section_data (sec);
- d->this_idx = section_number++;
- if (sec->reloc_count != 0)
+ Elf_Internal_Rela rela;
+ Elf_Internal_Rel rel;
+
+ if (entsize == sizeof (Elf_External_Rela))
+ elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
+ else
{
- d->rel_idx = section_number++;
- d->rel_hdr.sh_link = t->symtab_section;
- d->rel_hdr.sh_info = d->this_idx;
+ elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
+ rela.r_offset = rel.r_offset;
+ rela.r_info = rel.r_info;
+ rela.r_addend = 0;
}
+
+ /* The address of an ELF reloc is section relative for an object
+ file, and absolute for an executable file or shared library.
+ The address of a normal BFD reloc is always section relative,
+ and the address of a dynamic reloc is absolute.. */
+ if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
+ relent->address = rela.r_offset;
else
- d->rel_idx = 0;
- /* No handling for per-section string tables currently. */
- }
- elf_elfheader(abfd)->e_shnum = section_number;
-
- /* Set up the list of section header pointers, in agreement with the
- indices. */
- i_shdrp = bfd_alloc (abfd,
- section_number * sizeof (Elf_Internal_Shdr *));
- elf_elfsections(abfd) = i_shdrp;
- for (i = 0; i < section_number; i++)
- i_shdrp[i] = 0;
-
- i_shdrp[0] = (Elf_Internal_Shdr *) &null_shdr;
- i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
- if (abfd->symcount)
- {
- i_shdrp[t->symtab_section] = &t->symtab_hdr;
- i_shdrp[t->strtab_section] = &t->strtab_hdr;
- }
- for (sec = abfd->sections; sec; sec = sec->next)
- {
- struct bfd_elf_section_data *d = elf_section_data (sec);
- i_shdrp[d->this_idx] = &d->this_hdr;
- if (d->rel_idx)
- i_shdrp[d->rel_idx] = &d->rel_hdr;
+ relent->address = rela.r_offset - asect->vma;
+
+ if (ELF_R_SYM (rela.r_info) == 0)
+ relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
+ else
+ {
+ asymbol **ps, *s;
+
+ ps = symbols + ELF_R_SYM (rela.r_info) - 1;
+ s = *ps;
+
+ /* Canonicalize ELF section symbols. FIXME: Why? */
+ if ((s->flags & BSF_SECTION_SYM) == 0)
+ relent->sym_ptr_ptr = ps;
+ else
+ relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
+ }
+
+ relent->addend = rela.r_addend;
+
+ if (entsize == sizeof (Elf_External_Rela))
+ (*ebd->elf_info_to_howto) (abfd, relent, &rela);
+ else
+ (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
}
- /* Make sure we got everything.... */
- for (i = 0; i < section_number; i++)
- if (i_shdrp[i] == 0)
- abort ();
+
+ asect->relocation = relents;
+
+ if (allocated != NULL)
+ free (allocated);
+
+ return true;
+
+ error_return:
+ if (allocated != NULL)
+ free (allocated);
+ return false;
}
-static INLINE file_ptr
-assign_file_position_for_section (i_shdrp, offset)
- Elf_Internal_Shdr *i_shdrp;
- file_ptr offset;
+#ifdef DEBUG
+static void
+elf_debug_section (num, hdr)
+ int num;
+ Elf_Internal_Shdr *hdr;
{
- i_shdrp->sh_offset = offset;
- offset += i_shdrp->sh_size;
- return offset;
+ fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
+ hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
+ (long) hdr);
+ fprintf (stderr,
+ "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
+ (long) hdr->sh_name,
+ (long) hdr->sh_type,
+ (long) hdr->sh_flags);
+ fprintf (stderr,
+ "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
+ (long) hdr->sh_addr,
+ (long) hdr->sh_offset,
+ (long) hdr->sh_size);
+ fprintf (stderr,
+ "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
+ (long) hdr->sh_link,
+ (long) hdr->sh_info,
+ (long) hdr->sh_addralign);
+ fprintf (stderr, "sh_entsize = %ld\n",
+ (long) hdr->sh_entsize);
+ fflush (stderr);
}
static void
-assign_file_positions_except_relocs (abfd)
- bfd *abfd;
+elf_debug_file (ehdrp)
+ Elf_Internal_Ehdr *ehdrp;
{
- /* For now, we ignore the possibility of having program segments, which
- may require some alignment in the file. That'll require padding, and
- some interesting calculations to optimize file space usage.
-
- Also, since the application may change the list of relocations for
- a given section, we don't figure them in here. We'll put them at the
- end of the file, at positions computed during bfd_close.
-
- The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ... */
-
- file_ptr off;
- int i;
- Elf_Internal_Shdr **i_shdrpp = elf_elfsections (abfd);
- Elf_Internal_Shdr *i_shdrp;
- Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
-
- off = i_ehdrp->e_ehsize;
- i_ehdrp->e_shoff = off;
- off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
- off = assign_file_position_for_section (&elf_tdata(abfd)->shstrtab_hdr, off);
- off = assign_file_position_for_section (&elf_tdata(abfd)->symtab_hdr, off);
- off = assign_file_position_for_section (&elf_tdata(abfd)->strtab_hdr, off);
- for (i = 0; i < i_ehdrp->e_shnum; i++)
- {
- i_shdrp = i_shdrpp[i];
- if (i_shdrp->sh_type == SHT_REL || i_shdrp->sh_type == SHT_RELA)
- {
- i_shdrp->sh_offset = -1;
- continue;
- }
- off = assign_file_position_for_section (i_shdrp, off);
- }
- elf_tdata (abfd)->next_file_pos = off;
+ fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
+ fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
+ fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
+ fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
+ fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
+ fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
+ fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
}
-static boolean
-prep_headers (abfd)
- bfd *abfd;
+static char *
+elf_symbol_flags (flags)
+ flagword flags;
{
- Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
- Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
- Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
- Elf_External_Shdr *x_shdrp; /* Section header table, external form */
- Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
+ static char buffer[1024];
- int count;
- int scnt;
- struct strtab *shstrtab;
+ buffer[0] = '\0';
+ if (flags & BSF_LOCAL)
+ strcat (buffer, " local");
- i_ehdrp = elf_elfheader (abfd);
- i_shdrp = elf_elfsections (abfd);
+ if (flags & BSF_GLOBAL)
+ strcat (buffer, " global");
- shstrtab = bfd_new_strtab (abfd);
- elf_shstrtab (abfd) = shstrtab;
+ if (flags & BSF_DEBUGGING)
+ strcat (buffer, " debug");
- i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
- i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
- i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
- i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
+ if (flags & BSF_FUNCTION)
+ strcat (buffer, " function");
- i_ehdrp->e_ident[EI_CLASS] = ELFCLASS;
- i_ehdrp->e_ident[EI_DATA] =
- abfd->xvec->byteorder_big_p ? ELFDATA2MSB : ELFDATA2LSB;
- i_ehdrp->e_ident[EI_VERSION] = EV_CURRENT;
+ if (flags & BSF_KEEP)
+ strcat (buffer, " keep");
- for (count = EI_PAD; count < EI_NIDENT; count++)
- i_ehdrp->e_ident[count] = 0;
+ if (flags & BSF_KEEP_G)
+ strcat (buffer, " keep_g");
- i_ehdrp->e_type = (abfd->flags & EXEC_P) ? ET_EXEC : ET_REL;
- switch (bfd_get_arch (abfd))
- {
- case bfd_arch_unknown:
- i_ehdrp->e_machine = EM_NONE;
- break;
- case bfd_arch_sparc:
- i_ehdrp->e_machine = EM_SPARC;
- /* start-sanitize-v9 */
-#if ARCH_SIZE == 64
- i_ehdrp->e_machine = EM_SPARC64;
-#endif
- /* end-sanitize-v9 */
- break;
- case bfd_arch_i386:
- i_ehdrp->e_machine = EM_386;
- break;
- case bfd_arch_m68k:
- i_ehdrp->e_machine = EM_68K;
- break;
- case bfd_arch_m88k:
- i_ehdrp->e_machine = EM_88K;
- break;
- case bfd_arch_i860:
- i_ehdrp->e_machine = EM_860;
- break;
- case bfd_arch_mips: /* MIPS Rxxxx */
- i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
- break;
- case bfd_arch_hppa:
- i_ehdrp->e_machine = EM_HPPA;
- break;
- /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
- default:
- i_ehdrp->e_machine = EM_NONE;
- }
- i_ehdrp->e_version = EV_CURRENT;
- i_ehdrp->e_ehsize = sizeof (Elf_External_Ehdr);
+ if (flags & BSF_WEAK)
+ strcat (buffer, " weak");
- /* no program header, for now. */
- i_ehdrp->e_phoff = 0;
- i_ehdrp->e_phentsize = 0;
- i_ehdrp->e_phnum = 0;
+ if (flags & BSF_SECTION_SYM)
+ strcat (buffer, " section-sym");
- /* each bfd section is section header entry */
- i_ehdrp->e_entry = bfd_get_start_address (abfd);
- i_ehdrp->e_shentsize = sizeof (Elf_External_Shdr);
+ if (flags & BSF_OLD_COMMON)
+ strcat (buffer, " old-common");
- /* if we're building an executable, we'll need a program header table */
- if (abfd->flags & EXEC_P)
- {
- abort ();
+ if (flags & BSF_NOT_AT_END)
+ strcat (buffer, " not-at-end");
-#if 0
- i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
+ if (flags & BSF_CONSTRUCTOR)
+ strcat (buffer, " constructor");
- /* elf_build_phdrs() returns a (NULL-terminated) array of
- Elf_Internal_Phdrs */
- i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
- i_ehdrp->e_phoff = outbase;
- outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
-#endif
- }
- else
- {
- i_ehdrp->e_phentsize = 0;
- i_phdrp = 0;
- i_ehdrp->e_phoff = 0;
- }
-
- elf_tdata (abfd)->symtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
- ".symtab");
- elf_tdata (abfd)->strtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
- ".strtab");
- elf_tdata (abfd)->shstrtab_hdr.sh_name = bfd_add_to_strtab (abfd, shstrtab,
- ".shstrtab");
-
-}
-
-static void
-swap_out_syms (abfd)
- bfd *abfd;
-{
- struct strtab *shstrtab = elf_shstrtab (abfd);
-
- elf_map_symbols (abfd);
-
- /* Dump out the symtabs. */
- {
- int symcount = bfd_get_symcount (abfd);
- asymbol **syms = bfd_get_outsymbols (abfd);
- struct strtab *stt = bfd_new_strtab (abfd);
- Elf_Internal_Shdr *symtab_hdr;
- Elf_Internal_Shdr *symstrtab_hdr;
- Elf_External_Sym *outbound_syms;
- int idx;
-
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- symtab_hdr->sh_type = SHT_SYMTAB;
- symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
- symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
- symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
-
- /* see assert in elf_fake_sections that supports this: */
- symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
- symstrtab_hdr->sh_type = SHT_STRTAB;
-
- outbound_syms = (Elf_External_Sym *)
- bfd_alloc (abfd, (1 + symcount) * sizeof (Elf_External_Sym));
- /* now generate the data (for "contents") */
- {
- /* Fill in zeroth symbol and swap it out. */
- Elf_Internal_Sym sym;
- sym.st_name = 0;
- sym.st_value = 0;
- sym.st_size = 0;
- sym.st_info = 0;
- sym.st_other = 0;
- sym.st_shndx = SHN_UNDEF;
- elf_swap_symbol_out (abfd, &sym, outbound_syms);
- }
- for (idx = 0; idx < symcount; idx++)
- {
- Elf_Internal_Sym sym;
- bfd_vma value = syms[idx]->value;
-
- if (syms[idx]->flags & BSF_SECTION_SYM)
- /* Section symbols have no names. */
- sym.st_name = 0;
- else
- sym.st_name = bfd_add_to_strtab (abfd, stt, syms[idx]->name);
-
- if (bfd_is_com_section (syms[idx]->section))
- {
- /* ELF common symbols put the alignment into the `value' field,
- and the size into the `size' field. This is backwards from
- how BFD handles it, so reverse it here. */
- sym.st_size = value;
- /* Should retrieve this from somewhere... */
- sym.st_value = 16;
- sym.st_shndx = SHN_COMMON;
- }
- else
- {
- asection *sec = syms[idx]->section;
- int shndx;
-
- if (sec->output_section)
- {
- value += sec->output_offset;
- sec = sec->output_section;
- }
- value += sec->vma;
- sym.st_value = value;
- sym.st_size = (elf_symbol_from (abfd, syms[idx]))->internal_elf_sym.st_size;
- sym.st_shndx = shndx = elf_section_from_bfd_section (abfd, sec);
- if (shndx == -1)
- {
- asection *sec2;
- /* Writing this would be a hell of a lot easier if we had
- some decent documentation on bfd, and knew what to expect
- of the library, and what to demand of applications. For
- example, it appears that `objcopy' might not set the
- section of a symbol to be a section that is actually in
- the output file. */
- sec2 = bfd_get_section_by_name (abfd, sec->name);
- assert (sec2 != 0);
- sym.st_shndx = shndx = elf_section_from_bfd_section (abfd, sec2);
- assert (shndx != -1);
- }
- }
-
- if (bfd_is_com_section (syms[idx]->section))
- sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_NOTYPE);
- else if (syms[idx]->section == &bfd_und_section)
- sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_NOTYPE);
- else if (syms[idx]->flags & BSF_WEAK)
- sym.st_info = ELF_ST_INFO (STB_WEAK, STT_OBJECT);
- else if (syms[idx]->flags & BSF_SECTION_SYM)
- sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
- else if (syms[idx]->flags & BSF_FILE)
- sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
- else if (syms[idx]->flags & (BSF_GLOBAL | BSF_EXPORT))
- {
- if (syms[idx]->flags & BSF_FUNCTION)
- sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_FUNC);
- else
- sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_OBJECT);
- }
- else if (syms[idx]->flags & BSF_LOCAL)
- {
- if (syms[idx]->flags & BSF_FUNCTION)
- sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
- else
- sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_OBJECT);
- }
- else
- /* Default to local if flag isn't set at all. */
- sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_OBJECT);
-
- sym.st_other = 0;
- elf_swap_symbol_out (abfd, &sym,
- outbound_syms + elf_symtab_map (abfd)[idx]);
- }
-
- symtab_hdr->contents = (PTR) outbound_syms;
- symstrtab_hdr->contents = (PTR) stt->tab;
- symstrtab_hdr->sh_size = stt->length;
- symstrtab_hdr->sh_type = SHT_STRTAB;
-
- symstrtab_hdr->sh_flags = 0;
- symstrtab_hdr->sh_addr = 0;
- symstrtab_hdr->sh_entsize = 0;
- symstrtab_hdr->sh_link = 0;
- symstrtab_hdr->sh_info = 0;
- symstrtab_hdr->sh_addralign = 0;
- symstrtab_hdr->size = 0;
- }
-
- /* put the strtab out too... */
- {
- Elf_Internal_Shdr *this_hdr;
-
- this_hdr = &elf_tdata(abfd)->shstrtab_hdr;
- this_hdr->contents = (PTR) elf_shstrtab (abfd)->tab;
- this_hdr->sh_size = elf_shstrtab (abfd)->length;
- this_hdr->sh_type = SHT_STRTAB;
- this_hdr->sh_flags = 0;
- this_hdr->sh_addr = 0;
- this_hdr->sh_entsize = 0;
- this_hdr->sh_addralign = 0;
- this_hdr->size = 0;
- }
-}
-
-static boolean
-write_shdrs_and_ehdr (abfd)
- bfd *abfd;
-{
- Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
- Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
- Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
- Elf_External_Shdr *x_shdrp; /* Section header table, external form */
- Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
-
- int count;
- int scnt;
- struct strtab *shstrtab;
-
- i_ehdrp = elf_elfheader (abfd);
- i_shdrp = elf_elfsections (abfd);
- shstrtab = elf_shstrtab (abfd);
-
- /* swap the header before spitting it out... */
-
-#if DEBUG & 1
- elf_debug_file (i_ehdrp);
-#endif
- elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
- bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
- bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd);
-
- /* If we're building an executable, fixup the program header table
- offsets.
-
- @@ For now, assume that the entries are in a fixed order: text,
- data, bss. FIXME */
-
- if (abfd->flags & EXEC_P)
- {
- static char *CONST section_name[] =
- {".text", ".data", ".bss"};
-
- for (count = 0; count < 3; count++)
- {
- asection *asect = bfd_get_section_by_name (abfd,
- section_name[count]);
- int sh_idx = elf_section_from_bfd_section (abfd, asect);
-
- i_phdrp[count].p_offset = i_shdrp[sh_idx]->sh_offset;
- }
-
- /* write out the program header table entries */
- elf_write_phdrs (abfd, i_ehdrp, i_phdrp, i_ehdrp->e_phnum);
- }
-
- /* at this point we've concocted all the ELF sections... */
- x_shdrp = (Elf_External_Shdr *)
- bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
- if (!x_shdrp)
- {
- bfd_error = no_memory;
- return false;
- }
-
- for (count = 0; count < i_ehdrp->e_shnum; count++)
- {
-#if DEBUG & 2
- elf_debug_section (shstrtab->tab + i_shdrp[count]->sh_name, count,
- i_shdrp[count]);
-#endif
- elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
- }
- bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET);
- bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd);
- /* need to dump the string table too... */
-
- return true;
-}
-
-static void
-assign_file_positions_for_relocs (abfd)
- bfd *abfd;
-{
- file_ptr off = elf_tdata(abfd)->next_file_pos;
- int i;
- Elf_Internal_Shdr **shdrpp = elf_elfsections (abfd);
- Elf_Internal_Shdr *shdrp;
- for (i = 0; i < elf_elfheader(abfd)->e_shnum; i++)
- {
- shdrp = shdrpp[i];
- if (shdrp->sh_type != SHT_REL && shdrp->sh_type != SHT_RELA)
- continue;
- off = assign_file_position_for_section (shdrp, off);
- }
- elf_tdata(abfd)->next_file_pos = off;
-}
-
-boolean
-DEFUN (NAME(bfd_elf,write_object_contents), (abfd), bfd * abfd)
-{
- Elf_Internal_Ehdr *i_ehdrp;
- Elf_Internal_Shdr **i_shdrp;
- int count;
-
- if (abfd->output_has_begun == false)
- {
- malloc (0);
- prep_headers (abfd);
-malloc(0);
- elf_compute_section_file_positions (abfd);
-malloc(0);
- abfd->output_has_begun = true;
- }
-
- i_shdrp = elf_elfsections (abfd);
- i_ehdrp = elf_elfheader (abfd);
-
- bfd_map_over_sections (abfd, write_relocs, (PTR) 0);
-malloc(0);
- assign_file_positions_for_relocs (abfd);
-
- /* After writing the headers, we need to write the sections too... */
- for (count = 0; count < i_ehdrp->e_shnum; count++)
- if (i_shdrp[count]->contents)
- {
- bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET);
- bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size, 1, abfd);
- }
- return write_shdrs_and_ehdr (abfd);
-}
-
-/* Given an index of a section, retrieve a pointer to it. Note
- that for our purposes, sections are indexed by {1, 2, ...} with
- 0 being an illegal index. */
-
-/* In the original, each ELF section went into exactly one BFD
- section. This doesn't really make sense, so we need a real mapping.
- The mapping has to hide in the Elf_Internal_Shdr since asection
- doesn't have anything like a tdata field... */
-
-static struct sec *
-DEFUN (section_from_elf_index, (abfd, index),
- bfd * abfd AND
- int index)
-{
- /* @@ Is bfd_com_section really correct in all the places it could
- be returned from this routine? */
-
- if (index == SHN_ABS)
- return &bfd_com_section; /* not abs? */
- if (index == SHN_COMMON)
- return &bfd_com_section;
-
- if (index > elf_elfheader (abfd)->e_shnum)
- return 0;
-
- {
- Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[index];
-
- switch (hdr->sh_type)
- {
- /* ELF sections that map to BFD sections */
- case SHT_PROGBITS:
- case SHT_NOBITS:
- if (!hdr->rawdata)
- bfd_section_from_shdr (abfd, index);
- return (struct sec *) hdr->rawdata;
-
- default:
- return (struct sec *) &bfd_abs_section;
- }
- }
-}
-
-/* given a section, search the header to find them... */
-static int
-DEFUN (elf_section_from_bfd_section, (abfd, asect),
- bfd * abfd AND
- struct sec *asect)
-{
- Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
- int index;
- Elf_Internal_Shdr *hdr;
- int maxindex = elf_elfheader (abfd)->e_shnum;
-
- if (asect == &bfd_abs_section)
- return SHN_ABS;
- if (asect == &bfd_com_section)
- return SHN_COMMON;
- if (asect == &bfd_und_section)
- return SHN_UNDEF;
-
- for (index = 0; index < maxindex; index++)
- {
- hdr = i_shdrp[index];
- switch (hdr->sh_type)
- {
- /* ELF sections that map to BFD sections */
- case SHT_PROGBITS:
- case SHT_NOBITS:
- if (hdr->rawdata)
- {
- if (((struct sec *) (hdr->rawdata)) == asect)
- return index;
- }
- break;
- default:
- break;
- }
- }
- return -1;
-}
-
-/* given a symbol, return the bfd index for that symbol. */
-static int
-DEFUN (elf_symbol_from_bfd_symbol, (abfd, asym_ptr_ptr),
- bfd * abfd AND
- struct symbol_cache_entry **asym_ptr_ptr)
-{
- struct symbol_cache_entry *asym_ptr = *asym_ptr_ptr;
- CONST char *name = asym_ptr->name;
- int idx;
- int symcount = bfd_get_symcount (abfd);
- asymbol **syms = bfd_get_outsymbols (abfd);
-
- /* FIXME -- there has to be a better way than linear search. */
- for (idx = 0; idx < symcount; idx++)
- {
- if (syms[idx] == asym_ptr
- || (name == syms[idx]->name && name)
- || ((asym_ptr->flags & BSF_SECTION_SYM)
- && (syms[idx]->flags & BSF_SECTION_SYM)
- && asym_ptr->section == syms[idx]->section))
- break;
- }
-
- if (idx >= symcount)
- {
- /* badness... */
- fprintf (stderr, "bfd app err: can't find sym `%s' in symtab\n",
- name);
- abort ();
- }
- idx = elf_symtab_map (abfd)[idx];
-
-#if DEBUG & 4
- {
- flagword flags = asym_ptr->flags;
-
- fprintf (stderr,
- "elfsym<-bfdsym %.8lx `%s' sec=%s symnum=%d {",
- (long) asym_ptr, asym_ptr->name, asym_ptr->section->name, idx);
-
- if (flags == BSF_NO_FLAGS)
- fprintf (stderr, " none");
-
- if (flags & BSF_LOCAL)
- fprintf (stderr, " local");
-
- if (flags & BSF_GLOBAL)
- fprintf (stderr, " global");
-
- if (flags & BSF_EXPORT)
- fprintf (stderr, " export");
-
- if (flags & BSF_DEBUGGING)
- fprintf (stderr, " debugging");
-
- if (flags & BSF_KEEP)
- fprintf (stderr, " keep");
-
- if (flags & BSF_KEEP_G)
- fprintf (stderr, " keep_g");
-
- if (flags & BSF_WEAK)
- fprintf (stderr, " weak");
-
- if (flags & BSF_SECTION_SYM)
- fprintf (stderr, " section_sym");
-
- if (flags & BSF_OLD_COMMON)
- fprintf (stderr, " old_common");
-
- if (flags & BSF_NOT_AT_END)
- fprintf (stderr, " not_at_end");
-
- if (flags & BSF_CONSTRUCTOR)
- fprintf (stderr, " constructor");
-
- if (flags & BSF_WARNING)
- fprintf (stderr, " warning");
-
- if (flags & BSF_INDIRECT)
- fprintf (stderr, " indirect");
-
- if (flags & BSF_FILE)
- fprintf (stderr, " file");
-
- if (flags & BSF_FUNCTION)
- fprintf (stderr, " function");
-
- fputs (" }\n", stderr);
- fflush (stderr);
- }
-#endif
-
- return idx;
-}
-
-static boolean
-DEFUN (elf_slurp_symbol_table, (abfd, symptrs),
- bfd * abfd AND
- asymbol ** symptrs) /* Buffer for generated bfd symbols */
-{
- Elf_Internal_Shdr *hdr = &elf_tdata(abfd)->symtab_hdr;
- int symcount; /* Number of external ELF symbols */
- int i;
- elf_symbol_type *sym; /* Pointer to current bfd symbol */
- elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
- Elf_Internal_Sym i_sym;
- Elf_External_Sym *x_symp;
-
- /* this is only valid because there is only one symtab... */
- /* FIXME: This is incorrect, there may also be a dynamic symbol
- table which is a subset of the full symbol table. We either need
- to be prepared to read both (and merge them) or ensure that we
- only read the full symbol table. Currently we only get called to
- read the full symbol table. -fnf */
- if (bfd_get_outsymbols (abfd) != NULL)
- {
- return true;
- }
-
- /* Read each raw ELF symbol, converting from external ELF form to
- internal ELF form, and then using the information to create a
- canonical bfd symbol table entry.
-
- Note that we allocate the initial bfd canonical symbol buffer
- based on a one-to-one mapping of the ELF symbols to canonical
- symbols. We actually use all the ELF symbols, so there will be no
- space left over at the end. When we have all the symbols, we
- build the caller's pointer vector. */
-
- if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
- {
- bfd_error = system_call_error;
- return false;
- }
-
- symcount = hdr->sh_size / sizeof (Elf_External_Sym);
- symbase = (elf_symbol_type *) bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type));
- sym = symbase;
-
- /* Temporarily allocate room for the raw ELF symbols. */
- x_symp = (Elf_External_Sym *) bfd_xmalloc (symcount * sizeof (Elf_External_Sym));
-
- if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
- != symcount * sizeof (Elf_External_Sym))
- {
- free ((PTR) x_symp);
- bfd_error = system_call_error;
- return false;
- }
- /* Skip first symbol, which is a null dummy. */
- for (i = 1; i < symcount; i++)
- {
- elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
- memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
- memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
- sym->symbol.the_bfd = abfd;
-
- sym->symbol.name = elf_string_from_elf_section (abfd, hdr->sh_link,
- i_sym.st_name);
-
- sym->symbol.value = i_sym.st_value;
-
- if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERV)
- {
- sym->symbol.section = section_from_elf_index (abfd, i_sym.st_shndx);
- }
- else if (i_sym.st_shndx == SHN_ABS)
- {
- sym->symbol.section = &bfd_abs_section;
- }
- else if (i_sym.st_shndx == SHN_COMMON)
- {
- sym->symbol.section = &bfd_com_section;
- /* Elf puts the alignment into the `value' field, and the size
- into the `size' field. BFD wants to see the size in the
- value field, and doesn't care (at the moment) about the
- alignment. */
- sym->symbol.value = i_sym.st_size;
- }
- else if (i_sym.st_shndx == SHN_UNDEF)
- {
- sym->symbol.section = &bfd_und_section;
- }
- else
- sym->symbol.section = &bfd_abs_section;
-
- sym->symbol.value -= sym->symbol.section->vma;
-
- switch (ELF_ST_BIND (i_sym.st_info))
- {
- case STB_LOCAL:
- sym->symbol.flags |= BSF_LOCAL;
- break;
- case STB_GLOBAL:
- sym->symbol.flags |= (BSF_GLOBAL | BSF_EXPORT);
- break;
- case STB_WEAK:
- sym->symbol.flags |= BSF_WEAK;
- break;
- }
-
- switch (ELF_ST_TYPE (i_sym.st_info))
- {
- case STT_SECTION:
- sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
- break;
- case STT_FILE:
- sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
- break;
- case STT_FUNC:
- sym->symbol.flags |= BSF_FUNCTION;
- break;
- }
- /* Is this a definition of $global$? If so, keep it because it will be
- needd if any relocations are performed. */
- if (!strcmp (sym->symbol.name, "$global$")
- && sym->symbol.section != &bfd_und_section)
- {
- /* @@ Why is this referring to backend data and not a field of
- abfd? FIXME */
- struct elf_backend_data *be_data = (struct elf_backend_data *) abfd->xvec->backend_data;
-
- be_data->global_sym = (PTR) sym;
- }
- sym++;
- }
-
- /* We rely on the zalloc to clear out the final symbol entry. */
-
- /* obj_raw_syms macro uses a cast... */
- elf_tdata (abfd)->raw_syms = (PTR) x_symp;
-
- bfd_get_symcount (abfd) = symcount = sym - symbase;
-
- /* Fill in the user's symbol pointer vector if needed. */
- if (symptrs)
- {
- sym = symbase;
- while (symcount-- > 0)
- {
- *symptrs++ = &sym->symbol;
- sym++;
- }
- *symptrs = 0; /* Final null pointer */
- }
-
- return true;
-}
-
-/* Return the number of bytes required to hold the symtab vector.
-
- Note that we base it on the count plus 1, since we will null terminate
- the vector allocated based on this size. However, the ELF symbol table
- always has a dummy entry as symbol #0, so it ends up even. */
-
-unsigned int
-DEFUN (elf_get_symtab_upper_bound, (abfd), bfd * abfd)
-{
- unsigned int symcount;
- unsigned int symtab_size = 0;
-
- Elf_Internal_Shdr *hdr = &elf_tdata(abfd)->symtab_hdr;
- symcount = hdr->sh_size / sizeof (Elf_External_Sym);
- symtab_size = (symcount - 1 + 1) * (sizeof (asymbol));
-
- return symtab_size;
-}
-
-/*
- This function return the number of bytes required to store the
- relocation information associated with section <<sect>>
- attached to bfd <<abfd>>
-
-*/
-unsigned int
-elf_get_reloc_upper_bound (abfd, asect)
- bfd *abfd;
- sec_ptr asect;
-{
- if (asect->flags & SEC_RELOC)
- {
- /* either rel or rela */
- return elf_section_data(asect)->rel_hdr.sh_size;
- }
- else
- return 0;
-}
-
-static boolean
-DEFUN (elf_slurp_reloca_table, (abfd, asect, symbols),
- bfd * abfd AND
- sec_ptr asect AND
- asymbol ** symbols)
-{
- Elf_External_Rela *native_relocs;
- arelent *reloc_cache;
- arelent *cache_ptr;
-
- unsigned int idx;
-
- if (asect->relocation)
- return true;
- if (asect->reloc_count == 0)
- return true;
- if (asect->flags & SEC_CONSTRUCTOR)
- return true;
-
- bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
- native_relocs = (Elf_External_Rela *)
- bfd_alloc (abfd, asect->reloc_count * sizeof (Elf_External_Rela));
- bfd_read ((PTR) native_relocs,
- sizeof (Elf_External_Rela), asect->reloc_count, abfd);
-
- reloc_cache = (arelent *)
- bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
-
- if (!reloc_cache)
- {
- bfd_error = no_memory;
- return false;
- }
-
- for (idx = 0; idx < asect->reloc_count; idx++)
- {
-#ifdef RELOC_PROCESSING
- Elf_Internal_Rela dst;
- Elf_External_Rela *src;
-
- cache_ptr = reloc_cache + idx;
- src = native_relocs + idx;
- elf_swap_reloca_in (abfd, src, &dst);
-
- RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
-#else
- Elf_Internal_Rela dst;
- Elf_External_Rela *src;
-
- cache_ptr = reloc_cache + idx;
- src = native_relocs + idx;
-
- elf_swap_reloca_in (abfd, src, &dst);
-
- if (asect->flags & SEC_RELOC)
- {
- /* relocatable, so the offset is off of the section */
- cache_ptr->address = dst.r_offset + asect->vma;
- }
- else
- {
- /* non-relocatable, so the offset a virtual address */
- cache_ptr->address = dst.r_offset;
- }
- /* ELF_R_SYM(dst.r_info) is the symbol table offset; subtract 1
- because the first entry is NULL. */
- cache_ptr->sym_ptr_ptr = symbols + ELF_R_SYM (dst.r_info) - 1;
- {
- /* Is it an ELF section symbol? If so, translate it into a
- BFD section symbol. */
- asymbol *s = *(cache_ptr->sym_ptr_ptr);
- if (s->flags & BSF_SECTION_SYM)
- cache_ptr->sym_ptr_ptr = s->section->symbol_ptr_ptr;
- }
- cache_ptr->addend = dst.r_addend;
-
- /* Fill in the cache_ptr->howto field from dst.r_type */
- {
- struct elf_backend_data *ebd = get_elf_backend_data (abfd);
- (*ebd->elf_info_to_howto) (abfd, cache_ptr, &dst);
- }
-#endif
- }
-
- asect->relocation = reloc_cache;
- return true;
-}
-
-#ifdef DEBUG
-static void
-elf_debug_section (str, num, hdr)
- char *str;
- int num;
- Elf_Internal_Shdr *hdr;
-{
- fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num, str, (long) hdr);
- fprintf (stderr,
- "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
- (long) hdr->sh_name,
- (long) hdr->sh_type,
- (long) hdr->sh_flags);
- fprintf (stderr,
- "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
- (long) hdr->sh_addr,
- (long) hdr->sh_offset,
- (long) hdr->sh_size);
- fprintf (stderr,
- "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
- (long) hdr->sh_link,
- (long) hdr->sh_info,
- (long) hdr->sh_addralign);
- fprintf (stderr, "sh_entsize = %ld\n",
- (long) hdr->sh_entsize);
- fprintf (stderr, "rawdata = 0x%.8lx\n", (long) hdr->rawdata);
- fprintf (stderr, "contents = 0x%.8lx\n", (long) hdr->contents);
- fprintf (stderr, "size = %ld\n", (long) hdr->size);
- fflush (stderr);
-}
-
-static void
-elf_debug_file (ehdrp)
- Elf_Internal_Ehdr *ehdrp;
-{
- fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
- fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
- fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
- fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
- fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
- fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
- fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
-}
-#endif
-
-static boolean
-DEFUN (elf_slurp_reloc_table, (abfd, asect, symbols),
- bfd * abfd AND
- sec_ptr asect AND
- asymbol ** symbols)
-{
- Elf_External_Rel *native_relocs;
- arelent *reloc_cache;
- arelent *cache_ptr;
- Elf_Internal_Shdr *data_hdr;
- ElfNAME (Off) data_off;
- ElfNAME (Word) data_max;
- char buf[4]; /* FIXME -- might be elf64 */
-
- unsigned int idx;
-
- if (asect->relocation)
- return true;
- if (asect->reloc_count == 0)
- return true;
- if (asect->flags & SEC_CONSTRUCTOR)
- return true;
-
- bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
- native_relocs = (Elf_External_Rel *)
- bfd_alloc (abfd, asect->reloc_count * sizeof (Elf_External_Rel));
- bfd_read ((PTR) native_relocs,
- sizeof (Elf_External_Rel), asect->reloc_count, abfd);
-
- reloc_cache = (arelent *)
- bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
-
- if (!reloc_cache)
- {
- bfd_error = no_memory;
- return false;
- }
-
- /* Get the offset of the start of the segment we are relocating to read in
- the implicit addend. */
- data_hdr = &elf_section_data(asect)->this_hdr;
- data_off = data_hdr->sh_offset;
- data_max = data_hdr->sh_size - sizeof (buf) + 1;
-
-#if DEBUG & 2
- elf_debug_section ("data section", -1, data_hdr);
-#endif
-
- for (idx = 0; idx < asect->reloc_count; idx++)
- {
-#ifdef RELOC_PROCESSING
- Elf_Internal_Rel dst;
- Elf_External_Rel *src;
-
- cache_ptr = reloc_cache + idx;
- src = native_relocs + idx;
- elf_swap_reloc_in (abfd, src, &dst);
-
- RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
-#else
- Elf_Internal_Rel dst;
- Elf_External_Rel *src;
-
- cache_ptr = reloc_cache + idx;
- src = native_relocs + idx;
-
- elf_swap_reloc_in (abfd, src, &dst);
-
- if (asect->flags & SEC_RELOC)
- {
- /* relocatable, so the offset is off of the section */
- cache_ptr->address = dst.r_offset + asect->vma;
- }
- else
- {
- /* non-relocatable, so the offset a virtual address */
- cache_ptr->address = dst.r_offset;
- }
- /* ELF_R_SYM(dst.r_info) is the symbol table offset...
- -1 is to skip the dummy symbol table entry */
- cache_ptr->sym_ptr_ptr = symbols + ELF_R_SYM (dst.r_info) - 1;
- BFD_ASSERT (dst.r_offset <= data_max);
- if (bfd_seek (abfd, data_off + dst.r_offset, SEEK_SET) != 0
- || bfd_read ((PTR) buf, sizeof (buf), 1, abfd) != sizeof (buf))
- {
- bfd_error = system_call_error;
- return false;
- }
-
- cache_ptr->addend = (*abfd->xvec->bfd_getx_signed_32) ((bfd_byte *) buf);
-
- /* Fill in the cache_ptr->howto field from dst.r_type */
- {
- struct elf_backend_data *ebd = get_elf_backend_data (abfd);
- (*ebd->elf_info_to_howto_rel) (abfd, cache_ptr, &dst);
- }
-#endif
- }
-
- asect->relocation = reloc_cache;
- return true;
-}
-
-unsigned int
-elf_canonicalize_reloc (abfd, section, relptr, symbols)
- bfd *abfd;
- sec_ptr section;
- arelent **relptr;
- asymbol **symbols;
-{
- arelent *tblptr = section->relocation;
- unsigned int count = 0;
- int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
-
- /* snarfed from coffcode.h */
- if (use_rela_p)
- elf_slurp_reloca_table (abfd, section, symbols);
- else
- elf_slurp_reloc_table (abfd, section, symbols);
-
- tblptr = section->relocation;
- if (!tblptr)
- return 0;
-
- for (; count++ < section->reloc_count;)
- *relptr++ = tblptr++;
-
- *relptr = 0;
- return section->reloc_count;
-}
-
-unsigned int
-DEFUN (elf_get_symtab, (abfd, alocation),
- bfd * abfd AND
- asymbol ** alocation)
-{
-
- if (!elf_slurp_symbol_table (abfd, alocation))
- return 0;
- else
- return bfd_get_symcount (abfd);
-}
-
-asymbol *
-DEFUN (elf_make_empty_symbol, (abfd),
- bfd * abfd)
-{
- elf_symbol_type *newsym;
-
- newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
- if (!newsym)
- {
- bfd_error = no_memory;
- return NULL;
- }
- else
- {
- newsym->symbol.the_bfd = abfd;
- return &newsym->symbol;
- }
-}
-
-void
-DEFUN (elf_get_symbol_info, (ignore_abfd, symbol, ret),
- bfd * ignore_abfd AND
- asymbol * symbol AND
- symbol_info * ret)
-{
- bfd_symbol_info (symbol, ret);
-}
-
-void
-DEFUN (elf_print_symbol, (ignore_abfd, filep, symbol, how),
- bfd * ignore_abfd AND
- PTR filep AND
- asymbol * symbol AND
- bfd_print_symbol_type how)
-{
- FILE *file = (FILE *) filep;
- switch (how)
- {
- case bfd_print_symbol_name:
- fprintf (file, "%s", symbol->name);
- break;
- case bfd_print_symbol_more:
- fprintf (file, "elf ");
- fprintf_vma (file, symbol->value);
- fprintf (file, " %lx", (long) symbol->flags);
- break;
- case bfd_print_symbol_all:
- {
- CONST char *section_name;
- section_name = symbol->section ? symbol->section->name : "(*none*)";
- bfd_print_symbol_vandf ((PTR) file, symbol);
- fprintf (file, " %s\t%s",
- section_name,
- symbol->name);
- }
- break;
- }
-
-}
-
-alent *
-DEFUN (elf_get_lineno, (ignore_abfd, symbol),
- bfd * ignore_abfd AND
- asymbol * symbol)
-{
- fprintf (stderr, "elf_get_lineno unimplemented\n");
- fflush (stderr);
- BFD_FAIL ();
- return NULL;
-}
-
-boolean
-DEFUN (elf_set_arch_mach, (abfd, arch, machine),
- bfd * abfd AND
- enum bfd_architecture arch AND
- unsigned long machine)
-{
- /* Allow any architecture to be supported by the elf backend */
- switch (arch)
- {
- case bfd_arch_unknown: /* EM_NONE */
- case bfd_arch_sparc: /* EM_SPARC */
- case bfd_arch_i386: /* EM_386 */
- case bfd_arch_m68k: /* EM_68K */
- case bfd_arch_m88k: /* EM_88K */
- case bfd_arch_i860: /* EM_860 */
- case bfd_arch_mips: /* EM_MIPS (MIPS R3000) */
- case bfd_arch_hppa: /* EM_HPPA (HP PA_RISC) */
- return bfd_default_set_arch_mach (abfd, arch, machine);
- default:
- return false;
- }
-}
-
-boolean
-DEFUN (elf_find_nearest_line, (abfd,
- section,
- symbols,
- offset,
- filename_ptr,
- functionname_ptr,
- line_ptr),
- bfd * abfd AND
- asection * section AND
- asymbol ** symbols AND
- bfd_vma offset AND
- CONST char **filename_ptr AND
- CONST char **functionname_ptr AND
- unsigned int *line_ptr)
-{
- return false;
-}
-
-int
-DEFUN (elf_sizeof_headers, (abfd, reloc),
- bfd * abfd AND
- boolean reloc)
-{
- fprintf (stderr, "elf_sizeof_headers unimplemented\n");
- fflush (stderr);
- BFD_FAIL ();
- return 0;
-}
-
-boolean
-DEFUN (elf_set_section_contents, (abfd, section, location, offset, count),
- bfd * abfd AND
- sec_ptr section AND
- PTR location AND
- file_ptr offset AND
- bfd_size_type count)
-{
- Elf_Internal_Shdr *hdr;
-
- if (abfd->output_has_begun == false) /* set by bfd.c handler? */
- {
- /* do setup calculations (FIXME) */
- prep_headers (abfd);
- elf_compute_section_file_positions (abfd);
- abfd->output_has_begun = true;
- }
-
- hdr = &elf_section_data(section)->this_hdr;
-
- if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
- return false;
- if (bfd_write (location, 1, count, abfd) != count)
- return false;
-
- return true;
-}
-
-void
-DEFUN (elf_no_info_to_howto, (abfd, cache_ptr, dst),
- bfd * abfd AND
- arelent * cache_ptr AND
- Elf_Internal_Rela * dst)
-{
- fprintf (stderr, "elf RELA relocation support for target machine unimplemented\n");
- fflush (stderr);
- BFD_FAIL ();
-}
-
-void
-DEFUN (elf_no_info_to_howto_rel, (abfd, cache_ptr, dst),
- bfd * abfd AND
- arelent * cache_ptr AND
- Elf_Internal_Rel * dst)
-{
- fprintf (stderr, "elf REL relocation support for target machine unimplemented\n");
- fflush (stderr);
- BFD_FAIL ();
-}
-
-\f
-/* Core file support */
-
-#ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
-#include <sys/procfs.h>
-#else
-#define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
-#define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
-#define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
-#endif
-
-#ifdef HAVE_PROCFS
-
-static void
-DEFUN (bfd_prstatus, (abfd, descdata, descsz, filepos),
- bfd * abfd AND
- char *descdata AND
- int descsz AND
- long filepos)
-{
- asection *newsect;
- prstatus_t *status = (prstatus_t *) 0;
-
- if (descsz == sizeof (prstatus_t))
- {
- newsect = bfd_make_section (abfd, ".reg");
- newsect->_raw_size = sizeof (status->pr_reg);
- newsect->filepos = filepos + (long) &status->pr_reg;
- newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
- newsect->alignment_power = 2;
- if ((core_prstatus (abfd) = bfd_alloc (abfd, descsz)) != NULL)
- {
- memcpy (core_prstatus (abfd), descdata, descsz);
- }
- }
-}
-
-/* Stash a copy of the prpsinfo structure away for future use. */
-
-static void
-DEFUN (bfd_prpsinfo, (abfd, descdata, descsz, filepos),
- bfd * abfd AND
- char *descdata AND
- int descsz AND
- long filepos)
-{
- asection *newsect;
-
- if (descsz == sizeof (prpsinfo_t))
- {
- if ((core_prpsinfo (abfd) = bfd_alloc (abfd, descsz)) != NULL)
- {
- memcpy (core_prpsinfo (abfd), descdata, descsz);
- }
- }
-}
-
-static void
-DEFUN (bfd_fpregset, (abfd, descdata, descsz, filepos),
- bfd * abfd AND
- char *descdata AND
- int descsz AND
- long filepos)
-{
- asection *newsect;
-
- newsect = bfd_make_section (abfd, ".reg2");
- newsect->_raw_size = descsz;
- newsect->filepos = filepos;
- newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
- newsect->alignment_power = 2;
-}
-
-#endif /* HAVE_PROCFS */
-
-/* Return a pointer to the args (including the command name) that were
- seen by the program that generated the core dump. Note that for
- some reason, a spurious space is tacked onto the end of the args
- in some (at least one anyway) implementations, so strip it off if
- it exists. */
-
-char *
-DEFUN (elf_core_file_failing_command, (abfd),
- bfd * abfd)
-{
-#ifdef HAVE_PROCFS
- if (core_prpsinfo (abfd))
- {
- prpsinfo_t *p = core_prpsinfo (abfd);
- char *scan = p->pr_psargs;
- while (*scan++)
- {;
- }
- scan -= 2;
- if ((scan > p->pr_psargs) && (*scan == ' '))
- {
- *scan = '\000';
- }
- return p->pr_psargs;
- }
-#endif
- return NULL;
-}
-
-/* Return the number of the signal that caused the core dump. Presumably,
- since we have a core file, we got a signal of some kind, so don't bother
- checking the other process status fields, just return the signal number.
- */
-
-int
-DEFUN (elf_core_file_failing_signal, (abfd),
- bfd * abfd)
-{
-#ifdef HAVE_PROCFS
- if (core_prstatus (abfd))
- {
- return ((prstatus_t *) (core_prstatus (abfd)))->pr_cursig;
- }
-#endif
- return -1;
-}
-
-/* Check to see if the core file could reasonably be expected to have
- come for the current executable file. Note that by default we return
- true unless we find something that indicates that there might be a
- problem.
- */
-
-boolean
-DEFUN (elf_core_file_matches_executable_p, (core_bfd, exec_bfd),
- bfd * core_bfd AND
- bfd * exec_bfd)
-{
-#ifdef HAVE_PROCFS
- char *corename;
- char *execname;
-#endif
-
- /* First, xvecs must match since both are ELF files for the same target. */
-
- if (core_bfd->xvec != exec_bfd->xvec)
- {
- bfd_error = system_call_error;
- return false;
- }
-
-#ifdef HAVE_PROCFS
-
- /* If no prpsinfo, just return true. Otherwise, grab the last component
- of the exec'd pathname from the prpsinfo. */
-
- if (core_prpsinfo (core_bfd))
- {
- corename = (((struct prpsinfo *) core_prpsinfo (core_bfd))->pr_fname);
- }
- else
- {
- return true;
- }
-
- /* Find the last component of the executable pathname. */
-
- if ((execname = strrchr (exec_bfd->filename, '/')) != NULL)
- {
- execname++;
- }
- else
- {
- execname = (char *) exec_bfd->filename;
- }
-
- /* See if they match */
-
- return strcmp (execname, corename) ? false : true;
-
-#else
-
- return true;
-
-#endif /* HAVE_PROCFS */
-}
-
-/* ELF core files contain a segment of type PT_NOTE, that holds much of
- the information that would normally be available from the /proc interface
- for the process, at the time the process dumped core. Currently this
- includes copies of the prstatus, prpsinfo, and fpregset structures.
+ if (flags & BSF_WARNING)
+ strcat (buffer, " warning");
- Since these structures are potentially machine dependent in size and
- ordering, bfd provides two levels of support for them. The first level,
- available on all machines since it does not require that the host
- have /proc support or the relevant include files, is to create a bfd
- section for each of the prstatus, prpsinfo, and fpregset structures,
- without any interpretation of their contents. With just this support,
- the bfd client will have to interpret the structures itself. Even with
- /proc support, it might want these full structures for it's own reasons.
+ if (flags & BSF_INDIRECT)
+ strcat (buffer, " indirect");
- In the second level of support, where HAVE_PROCFS is defined, bfd will
- pick apart the structures to gather some additional information that
- clients may want, such as the general register set, the name of the
- exec'ed file and its arguments, the signal (if any) that caused the
- core dump, etc.
+ if (flags & BSF_FILE)
+ strcat (buffer, " file");
- */
+ if (flags & DYNAMIC)
+ strcat (buffer, " dynamic");
-static boolean
-DEFUN (elf_corefile_note, (abfd, hdr),
- bfd * abfd AND
- Elf_Internal_Phdr * hdr)
-{
- Elf_External_Note *x_note_p; /* Elf note, external form */
- Elf_Internal_Note i_note; /* Elf note, internal form */
- char *buf = NULL; /* Entire note segment contents */
- char *namedata; /* Name portion of the note */
- char *descdata; /* Descriptor portion of the note */
- char *sectname; /* Name to use for new section */
- long filepos; /* File offset to descriptor data */
- asection *newsect;
-
- if (hdr->p_filesz > 0
- && (buf = (char *) bfd_xmalloc (hdr->p_filesz)) != NULL
- && bfd_seek (abfd, hdr->p_offset, SEEK_SET) != -1
- && bfd_read ((PTR) buf, hdr->p_filesz, 1, abfd) == hdr->p_filesz)
- {
- x_note_p = (Elf_External_Note *) buf;
- while ((char *) x_note_p < (buf + hdr->p_filesz))
- {
- i_note.namesz = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->namesz);
- i_note.descsz = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->descsz);
- i_note.type = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->type);
- namedata = x_note_p->name;
- descdata = namedata + BFD_ALIGN (i_note.namesz, 4);
- filepos = hdr->p_offset + (descdata - buf);
- switch (i_note.type)
- {
- case NT_PRSTATUS:
- /* process descdata as prstatus info */
- bfd_prstatus (abfd, descdata, i_note.descsz, filepos);
- sectname = ".prstatus";
- break;
- case NT_FPREGSET:
- /* process descdata as fpregset info */
- bfd_fpregset (abfd, descdata, i_note.descsz, filepos);
- sectname = ".fpregset";
- break;
- case NT_PRPSINFO:
- /* process descdata as prpsinfo */
- bfd_prpsinfo (abfd, descdata, i_note.descsz, filepos);
- sectname = ".prpsinfo";
- break;
- default:
- /* Unknown descriptor, just ignore it. */
- sectname = NULL;
- break;
- }
- if (sectname != NULL)
- {
- newsect = bfd_make_section (abfd, sectname);
- newsect->_raw_size = i_note.descsz;
- newsect->filepos = filepos;
- newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
- newsect->alignment_power = 2;
- }
- x_note_p = (Elf_External_Note *)
- (descdata + BFD_ALIGN (i_note.descsz, 4));
- }
- }
- if (buf != NULL)
- {
- free (buf);
- }
- return true;
+ if (flags & ~(BSF_LOCAL
+ | BSF_GLOBAL
+ | BSF_DEBUGGING
+ | BSF_FUNCTION
+ | BSF_KEEP
+ | BSF_KEEP_G
+ | BSF_WEAK
+ | BSF_SECTION_SYM
+ | BSF_OLD_COMMON
+ | BSF_NOT_AT_END
+ | BSF_CONSTRUCTOR
+ | BSF_WARNING
+ | BSF_INDIRECT
+ | BSF_FILE
+ | BSF_DYNAMIC))
+ strcat (buffer, " unknown-bits");
+ return buffer;
}
-
-/* Core files are simply standard ELF formatted files that partition
- the file using the execution view of the file (program header table)
- rather than the linking view. In fact, there is no section header
- table in a core file.
-
- The process status information (including the contents of the general
- register set) and the floating point register set are stored in a
- segment of type PT_NOTE. We handcraft a couple of extra bfd sections
- that allow standard bfd access to the general registers (.reg) and the
- floating point registers (.reg2).
-
- */
-
-bfd_target *
-DEFUN (elf_core_file_p, (abfd), bfd * abfd)
-{
- Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
- Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
- Elf_External_Phdr x_phdr; /* Program header table entry, external form */
- Elf_Internal_Phdr *i_phdrp; /* Program header table, internal form */
- unsigned int phindex;
-
- /* Read in the ELF header in external format. */
-
- if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
- {
- bfd_error = system_call_error;
- return NULL;
- }
-
- /* Now check to see if we have a valid ELF file, and one that BFD can
- make use of. The magic number must match, the address size ('class')
- and byte-swapping must match our XVEC entry, and it must have a
- program header table (FIXME: See comments re segments at top of this
- file). */
-
- if (elf_file_p (&x_ehdr) == false)
- {
- wrong:
- bfd_error = wrong_format;
- return NULL;
- }
-
- /* FIXME, Check EI_VERSION here ! */
-
- {
-#if ARCH_SIZE == 32
- int desired_address_size = ELFCLASS32;
-#endif
-#if ARCH_SIZE == 64
- int desired_address_size = ELFCLASS64;
-#endif
-
- if (x_ehdr.e_ident[EI_CLASS] != desired_address_size)
- goto wrong;
- }
-
- /* Switch xvec to match the specified byte order. */
- switch (x_ehdr.e_ident[EI_DATA])
- {
- case ELFDATA2MSB: /* Big-endian */
- if (abfd->xvec->byteorder_big_p == false)
- goto wrong;
- break;
- case ELFDATA2LSB: /* Little-endian */
- if (abfd->xvec->byteorder_big_p == true)
- goto wrong;
- break;
- case ELFDATANONE: /* No data encoding specified */
- default: /* Unknown data encoding specified */
- goto wrong;
- }
-
- /* Allocate an instance of the elf_obj_tdata structure and hook it up to
- the tdata pointer in the bfd. */
-
- elf_tdata (abfd) =
- (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
- if (elf_tdata (abfd) == NULL)
- {
- bfd_error = no_memory;
- return NULL;
- }
-
- /* FIXME, `wrong' returns from this point onward, leak memory. */
-
- /* Now that we know the byte order, swap in the rest of the header */
- i_ehdrp = elf_elfheader (abfd);
- elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
-#if DEBUG & 1
- elf_debug_file (i_ehdrp);
#endif
-
- /* If there is no program header, or the type is not a core file, then
- we are hosed. */
- if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
- goto wrong;
-
- /* Allocate space for a copy of the program header table in
- internal form, seek to the program header table in the file,
- read it in, and convert it to internal form. As a simple sanity
- check, verify that the what BFD thinks is the size of each program
- header table entry actually matches the size recorded in the file. */
-
- if (i_ehdrp->e_phentsize != sizeof (x_phdr))
- goto wrong;
- i_phdrp = (Elf_Internal_Phdr *)
- bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
- if (!i_phdrp)
- {
- bfd_error = no_memory;
- return NULL;
- }
- if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) == -1)
- {
- bfd_error = system_call_error;
- return NULL;
- }
- for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
- {
- if (bfd_read ((PTR) & x_phdr, sizeof (x_phdr), 1, abfd)
- != sizeof (x_phdr))
- {
- bfd_error = system_call_error;
- return NULL;
- }
- elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
- }
-
- /* Once all of the program headers have been read and converted, we
- can start processing them. */
-
- for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
- {
- bfd_section_from_phdr (abfd, i_phdrp + phindex, phindex);
- if ((i_phdrp + phindex)->p_type == PT_NOTE)
- {
- elf_corefile_note (abfd, i_phdrp + phindex);
- }
- }
-
- /* Remember the entry point specified in the ELF file header. */
-
- bfd_get_start_address (abfd) = i_ehdrp->e_entry;
-
- return abfd->xvec;
-}
+\f
+#include "elfcore.h"
+#include "elflink.h"
+\f
+/* Size-dependent data and functions. */
+const struct elf_size_info NAME(_bfd_elf,size_info) = {
+ sizeof (Elf_External_Ehdr),
+ sizeof (Elf_External_Phdr),
+ sizeof (Elf_External_Shdr),
+ sizeof (Elf_External_Rel),
+ sizeof (Elf_External_Rela),
+ sizeof (Elf_External_Sym),
+ sizeof (Elf_External_Dyn),
+ sizeof (Elf_External_Note),
+
+ ARCH_SIZE, FILE_ALIGN,
+ ELFCLASS, EV_CURRENT,
+ elf_write_out_phdrs,
+ elf_write_shdrs_and_ehdr,
+ write_relocs,
+ elf_swap_symbol_out,
+ elf_slurp_reloc_table,
+ elf_slurp_symbol_table,
+ elf_swap_dyn_in
+};
projects / binutils-gdb.git / blobdiff