diff options
| -rw-r--r-- | bfd/ChangeLog | 8 | ||||
| -rw-r--r-- | bfd/Makefile.in | 10 | ||||
| -rw-r--r-- | bfd/elfcode.h | 3338 |
3 files changed, 3349 insertions, 7 deletions
diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 96e185c..6c4baff 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,8 +1,10 @@ Fri Jun 18 10:00:14 1993 Jim Kingdon (kingdon@lioth.cygnus.com) - * Makefile.in: Add elf32-{mips,m88k}. - elf32-{mips,m88k}.c: New files. - targets.c (target_vector): Include bfd_elf32_{mips,m88k}_vec. + * Makefile.in: Add elf32-{mips,m88k,generic}. + elf32-{mips,m88k,generic}.c: New files. + targets.c (target_vector): Include bfd_elf32_{mips,m88k,generic}_vec. + elfcode.h (elf_object_p): Match elf32-generic for all machines which + don't match a different target. Fri Jun 18 03:12:12 1993 John Gilmore (gnu@cygnus.com) diff --git a/bfd/Makefile.in b/bfd/Makefile.in index d75ffd8..b570eba 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -84,7 +84,7 @@ BFD32_BACKENDS = aout32.o sunos.o newsos3.o mipsbsd.o aout-adobe.o \ coff-mips.o coff-msym.o \ elf.o \ elf32.o elf32-sparc.o elf32-i386.o elf32-i860.o elf32-m68k.o \ - elf32-hppa.o elf32-mips.o elf32-m88k.o \ + elf32-hppa.o elf32-mips.o elf32-m88k.o elf32-generic.o \ bout.o \ hppa.o oasys.o ieee.o srec.o stab-syms.o coff-alpha.o coff-sh.o \ hp300hpux.o @@ -137,7 +137,7 @@ CFILES = libbfd.c opncls.c bfd.c archive.c targets.c cache.c \ cpu-rs6000.c coff-h8300.c hppa.c cpu-hppa.c cpu-we32k.c reloc16.c \ mipsbsd.c cpu-sh.c \ elf32.c elf32-sparc.c elf32-i386.c elf32-i860.c elf32-m68k.c \ - elf32-hppa.c elf32-m88k.c elf32-mips.c \ + elf32-hppa.c elf32-m88k.c elf32-mips.c elf32-generic.c \ elf64.c \ coff-alpha.c cpu-alpha.c \ hp300hpux.c i386lynx.c @@ -465,9 +465,11 @@ elf32-i386.o : elf32-i386.c libelf.h libbfd.h $(BFD_H) \ $(INCDIR)/obstack.h elf32-hppa.o : elf32-hppa.c $(srcdir)/elf32-hppa.h libelf.h libbfd.h \ $(BFD_H) $(INCDIR)/obstack.h -elf32-m88k.o : elf32-m88k.c $(srcdir)/elf32-hppa.h libelf.h libbfd.h \ +elf32-m88k.o : elf32-m88k.c libelf.h libbfd.h \ $(BFD_H) $(INCDIR)/obstack.h -elf32-mips.o : elf32-mips.c $(srcdir)/elf32-hppa.h libelf.h libbfd.h \ +elf32-mips.o : elf32-mips.c libelf.h libbfd.h \ + $(BFD_H) $(INCDIR)/obstack.h +elf32-generic.o : elf32-generic.c libelf.h libbfd.h \ $(BFD_H) $(INCDIR)/obstack.h elf64.o : elf64.c elfcode.h libelf.h libbfd.h $(BFD_H) \ $(INCDIR)/obstack.h diff --git a/bfd/elfcode.h b/bfd/elfcode.h new file mode 100644 index 0000000..533ad3c --- /dev/null +++ b/bfd/elfcode.h @@ -0,0 +1,3338 @@ +/* ELF executable support for BFD. + Copyright 1991, 1992, 1993 Free Software Foundation, Inc. + + Written by Fred Fish @ Cygnus Support, from information published + in "UNIX System V Release 4, Programmers Guide: ANSI C and + Programming Support Tools". Sufficient support for gdb. + + Rewritten by Mark Eichin @ Cygnus Support, from information + published in "System V Application Binary Interface", chapters 4 + and 5, as well as the various "Processor Supplement" documents + derived from it. Added support for assembler and other object file + utilities. Further work done by Ken Raeburn (Cygnus Support), Michael + Meissner (Open Software Foundation), and Peter Hoogenboom (University + of Utah) to finish and extend this. + +This file is part of BFD, the Binary File Descriptor library. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +/* Problems and other issues to resolve. + + (1) BFD expects there to be some fixed number of "sections" in + the object file. I.E. there is a "section_count" variable in the + bfd structure which contains the number of sections. However, ELF + supports multiple "views" of a file. In particular, with current + implementations, executable files typically have two tables, a + program header table and a section header table, both of which + partition the executable. + + In ELF-speak, the "linking view" of the file uses the section header + table to access "sections" within the file, and the "execution view" + uses the program header table to access "segments" within the file. + "Segments" typically may contain all the data from one or more + "sections". + + Note that the section header table is optional in ELF executables, + but it is this information that is most useful to gdb. If the + section header table is missing, then gdb should probably try + to make do with the program header table. (FIXME) + +*/ + +#include <string.h> /* For strrchr and friends */ +#include "bfd.h" +#include "sysdep.h" +#include "libbfd.h" +#include "libelf.h" + +#define Elf_External_Ehdr NAME(Elf,External_Ehdr) +#define Elf_Internal_Ehdr NAME(Elf,Internal_Ehdr) +#define Elf_External_Sym NAME(Elf,External_Sym) +#define Elf_Internal_Sym NAME(Elf,Internal_Sym) +#define Elf_External_Shdr NAME(Elf,External_Shdr) +#define Elf_Internal_Shdr NAME(Elf,Internal_Shdr) +#define Elf_External_Phdr NAME(Elf,External_Phdr) +#define Elf_Internal_Phdr NAME(Elf,Internal_Phdr) +#define Elf_External_Rel NAME(Elf,External_Rel) +#define Elf_External_Rela NAME(Elf,External_Rela) +#define Elf_Internal_Rel NAME(Elf,Internal_Rel) +#define Elf_Internal_Rela NAME(Elf,Internal_Rela) + +#define elf_symbol_type NAME(elf,symbol_type) +#define elf_internal_shdr NAME(elf,internal_shdr) +#define elf_backend_data NAME(elf,backend_data) + +#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_object_p NAME(bfd_elf,object_p) +#define elf_core_file_p NAME(bfd_elf,core_file_p) +#define elf_mkobject NAME(bfd_elf,mkobject) +#define elf_write_object_contents NAME(bfd_elf,write_object_contents) +#define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound) +#define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound) +#define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc) +#define elf_get_symtab NAME(bfd_elf,get_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_sizeof_headers NAME(bfd_elf,sizeof_headers) +#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_get_sect_thunk NAME(bfd_elf,get_sect_thunk) +#define elf_hash NAME(bfd_elf,hash) + + +#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 + +#ifndef INLINE +#if __GNUC__ >= 2 +#define INLINE __inline__ +#else +#define INLINE +#endif +#endif + +/* Forward declarations of static functions */ + +static char * elf_read PARAMS ((bfd *, long, int)); + +static struct sec * section_from_elf_index PARAMS ((bfd *, int)); + +static int elf_section_from_bfd_section PARAMS ((bfd *, struct sec *)); + +static boolean elf_slurp_symbol_table PARAMS ((bfd *, asymbol **)); + +static char * elf_get_str_section PARAMS ((bfd *, unsigned int)); + +static int elf_symbol_from_bfd_symbol PARAMS ((bfd *, + struct symbol_cache_entry **)); + +static boolean elf_map_symbols PARAMS ((bfd *)); + +/* Some private data is stashed away for future use using the tdata pointer + in the bfd structure. */ + +struct elf_obj_tdata +{ + Elf_Internal_Ehdr elf_header[1]; /* Actual data, but ref like ptr */ + Elf_Internal_Shdr *elf_sect_ptr; + struct strtab *strtab_ptr; + int symtab_section; + int num_locals; + int num_globals; + int *symtab_map; + void *prstatus; /* The raw /proc prstatus structure */ + void *prpsinfo; /* The raw /proc prpsinfo structure */ + Elf_External_Sym *raw_syms; + Elf_Internal_Sym *internal_syms; + elf_symbol_type *symbols; +}; + +#define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data) +#define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header) +#define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr) +#define elf_shstrtab(bfd) (elf_tdata(bfd) -> strtab_ptr) +#define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section) +#define elf_num_locals(bfd) (elf_tdata(bfd) -> num_locals) +#define elf_num_globals(bfd) (elf_tdata(bfd) -> num_globals) +#define elf_symtab_map(bfd) (elf_tdata(bfd) -> symtab_map) +#define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo) +#define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus) +#define obj_symbols(bfd) (elf_tdata(bfd) -> symbols) +#define obj_raw_syms(bfd) (elf_tdata(bfd) -> raw_syms) +#define obj_internal_syms(bfd) (elf_tdata(bfd) -> internal_syms) + +/* 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) +{ + dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name); + dst->st_value = bfd_h_get_32 (abfd, (bfd_byte *) src->st_value); + dst->st_size = bfd_h_get_32 (abfd, (bfd_byte *) src->st_size); + dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info); + dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other); + dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx); +} + +/* 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) +{ + bfd_h_put_32 (abfd, src->st_name, dst->st_name); + bfd_h_put_32 (abfd, src->st_value, dst->st_value); + bfd_h_put_32 (abfd, src->st_size, dst->st_size); + bfd_h_put_8 (abfd, src->st_info, dst->st_info); + bfd_h_put_8 (abfd, src->st_other, dst->st_other); + bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx); +} + + +/* Translate an ELF file header in external format into an ELF file header in + internal format. */ + +static void +DEFUN (elf_swap_ehdr_in, (abfd, src, dst), + bfd * abfd AND + Elf_External_Ehdr * src AND + 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); + dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine); + dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version); + dst->e_entry = bfd_h_get_32 (abfd, (bfd_byte *) src->e_entry); + dst->e_phoff = bfd_h_get_32 (abfd, (bfd_byte *) src->e_phoff); + dst->e_shoff = bfd_h_get_32 (abfd, (bfd_byte *) src->e_shoff); + dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags); + dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize); + dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize); + dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum); + dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize); + dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum); + dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx); +} + +/* Translate an ELF file header in internal format into an ELF file header in + external format. */ + +static void +DEFUN (elf_swap_ehdr_out, (abfd, src, dst), + bfd * abfd AND + Elf_Internal_Ehdr * src AND + 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... */ + bfd_h_put_16 (abfd, src->e_type, dst->e_type); + bfd_h_put_16 (abfd, src->e_machine, dst->e_machine); + bfd_h_put_32 (abfd, src->e_version, dst->e_version); + bfd_h_put_32 (abfd, src->e_entry, dst->e_entry); + bfd_h_put_32 (abfd, src->e_phoff, dst->e_phoff); + bfd_h_put_32 (abfd, src->e_shoff, dst->e_shoff); + bfd_h_put_32 (abfd, src->e_flags, dst->e_flags); + bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize); + bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize); + bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum); + bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize); + bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum); + bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx); +} + + +/* Translate an ELF section header table entry in external format into an + 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) +{ + 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_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_flags); + dst->sh_addr = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_addr); + dst->sh_offset = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_offset); + dst->sh_size = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_size); + dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link); + dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info); + dst->sh_addralign = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_addralign); + dst->sh_entsize = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_entsize); + /* we haven't done any processing on it yet, so... */ + dst->rawdata = (void *) 0; +} + +/* 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) +{ + /* note that all elements of dst are *arrays of unsigned char* already... */ + bfd_h_put_32 (abfd, src->sh_name, dst->sh_name); + bfd_h_put_32 (abfd, src->sh_type, dst->sh_type); + bfd_h_put_32 (abfd, src->sh_flags, dst->sh_flags); + bfd_h_put_32 (abfd, src->sh_addr, dst->sh_addr); + bfd_h_put_32 (abfd, src->sh_offset, dst->sh_offset); + bfd_h_put_32 (abfd, src->sh_size, dst->sh_size); + bfd_h_put_32 (abfd, src->sh_link, dst->sh_link); + bfd_h_put_32 (abfd, src->sh_info, dst->sh_info); + bfd_h_put_32 (abfd, src->sh_addralign, dst->sh_addralign); + bfd_h_put_32 (abfd, src->sh_entsize, dst->sh_entsize); +} + + +/* 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) +{ + dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type); + dst->p_offset = bfd_h_get_32 (abfd, (bfd_byte *) src->p_offset); + dst->p_vaddr = bfd_h_get_32 (abfd, (bfd_byte *) src->p_vaddr); + dst->p_paddr = bfd_h_get_32 (abfd, (bfd_byte *) src->p_paddr); + dst->p_filesz = bfd_h_get_32 (abfd, (bfd_byte *) src->p_filesz); + dst->p_memsz = bfd_h_get_32 (abfd, (bfd_byte *) src->p_memsz); + dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags); + dst->p_align = bfd_h_get_32 (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) +{ + /* note that all elements of dst are *arrays of unsigned char* already... */ + bfd_h_put_32 (abfd, src->p_type, dst->p_type); + bfd_h_put_32 (abfd, src->p_offset, dst->p_offset); + bfd_h_put_32 (abfd, src->p_vaddr, dst->p_vaddr); + bfd_h_put_32 (abfd, src->p_paddr, dst->p_paddr); + bfd_h_put_32 (abfd, src->p_filesz, dst->p_filesz); + bfd_h_put_32 (abfd, src->p_memsz, dst->p_memsz); + bfd_h_put_32 (abfd, src->p_flags, dst->p_flags); + bfd_h_put_32 (abfd, src->p_align, dst->p_align); +} + +/* Translate an ELF reloc from external format to internal format. */ +static void +DEFUN (elf_swap_reloc_in, (abfd, src, dst), + bfd * abfd AND + Elf_External_Rel * src AND + Elf_Internal_Rel * dst) +{ + dst->r_offset = bfd_h_get_32 (abfd, (bfd_byte *) src->r_offset); + dst->r_info = bfd_h_get_32 (abfd, (bfd_byte *) src->r_info); +} + +static void +DEFUN (elf_swap_reloca_in, (abfd, src, dst), + bfd * abfd AND + Elf_External_Rela * src AND + Elf_Internal_Rela * dst) +{ + dst->r_offset = bfd_h_get_32 (abfd, (bfd_byte *) src->r_offset); + dst->r_info = bfd_h_get_32 (abfd, (bfd_byte *) src->r_info); + dst->r_addend = bfd_h_get_32 (abfd, (bfd_byte *) src->r_addend); +} + +/* Translate an ELF reloc from internal format to external format. */ +static void +DEFUN (elf_swap_reloc_out, (abfd, src, dst), + bfd * abfd AND + Elf_Internal_Rel * src AND + Elf_External_Rel * dst) +{ + bfd_h_put_32 (abfd, src->r_offset, dst->r_offset); + bfd_h_put_32 (abfd, src->r_info, dst->r_info); +} + +static void +DEFUN (elf_swap_reloca_out, (abfd, src, dst), + bfd * abfd AND + Elf_Internal_Rela * src AND + Elf_External_Rela * dst) +{ + bfd_h_put_32 (abfd, src->r_offset, dst->r_offset); + bfd_h_put_32 (abfd, src->r_info, dst->r_info); + bfd_h_put_32 (abfd, src->r_addend, dst->r_addend); +} + +/* +INTERNAL_FUNCTION + bfd_elf_find_section + +SYNOPSIS + struct elf32_internal_shdr *bfd_elf32_find_section (bfd *abfd, char *name); + +DESCRIPTION + Helper functions for GDB to locate the string tables. + Since BFD hides string tables from callers, GDB needs to use an + internal hook to find them. Sun's .stabstr, in particular, + isn't even pointed to by the .stab section, so ordinary + mechanisms wouldn't work to find it, even if we had some. +*/ + +struct elf_internal_shdr * +DEFUN (NAME (bfd_elf,find_section), (abfd, name), + bfd * abfd AND + char *name) +{ + Elf_Internal_Shdr *i_shdrp; + Elf_Internal_Shdr *gotit = NULL; + char *shstrtab; + unsigned int max; + unsigned int i; + + i_shdrp = elf_elfsections (abfd); + if (i_shdrp != NULL) + { + shstrtab = elf_get_str_section (abfd, elf_elfheader (abfd)->e_shstrndx); + if (shstrtab != NULL) + { + max = elf_elfheader (abfd)->e_shnum; + for (i = 1; i < max; i++) + { + if (!strcmp (&shstrtab[i_shdrp[i].sh_name], name)) + { + gotit = &i_shdrp[i]; + } + } + } + } + return gotit; +} + +/* End of GDB support. */ + +static char * +DEFUN (elf_get_str_section, (abfd, shindex), + bfd * abfd AND + unsigned int shindex) +{ + Elf_Internal_Shdr *i_shdrp; + char *shstrtab = NULL; + unsigned int offset; + unsigned int shstrtabsize; + + i_shdrp = elf_elfsections (abfd); + if (i_shdrp != NULL) + { + shstrtab = i_shdrp[shindex].rawdata; + if (shstrtab == NULL) + { + /* No cached one, attempt to read, and cache what we read. */ + offset = i_shdrp[shindex].sh_offset; + shstrtabsize = i_shdrp[shindex].sh_size; + shstrtab = elf_read (abfd, offset, shstrtabsize); + i_shdrp[shindex].rawdata = (void *) shstrtab; + } + } + return shstrtab; +} + +static char * +DEFUN (elf_string_from_elf_section, (abfd, shindex, strindex), + bfd * abfd AND + unsigned int shindex AND + unsigned int strindex) +{ + Elf_Internal_Shdr *hdr; + + if (strindex == 0) + return ""; + + hdr = elf_elfsections (abfd) + shindex; + + if (!hdr->rawdata + && elf_get_str_section (abfd, shindex) == NULL) + return NULL; + + return ((char *) hdr->rawdata) + strindex; +} + +static INLINE char * +elf_string_from_elf_strtab (abfd, strindex) + bfd *abfd; + int strindex; +{ + return elf_string_from_elf_section (abfd, elf_elfheader (abfd)->e_shstrndx, + strindex); +} + +/* 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 *i_shdrp = elf_elfsections (abfd); + Elf_Internal_Shdr *hdr = i_shdrp + shindex; + 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->vma = hdr->sh_addr; + newsect->_raw_size = hdr->sh_size; + newsect->filepos = hdr->sh_offset; /* so we can read back the bits */ + newsect->flags |= SEC_HAS_CONTENTS; + newsect->alignment_power = 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; + } + } + 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 = 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 */ + BFD_ASSERT (hdr->sh_entsize == sizeof (Elf_External_Sym)); + elf_onesymtab (abfd) = shindex; + abfd->flags |= HAS_SYMS; + return true; + + case SHT_STRTAB: /* A string table */ + 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; + 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 (Elf32_External_Rela) + : sizeof (Elf32_External_Rel))); + + bfd_section_from_shdr (abfd, hdr->sh_link); /* symbol table */ + bfd_section_from_shdr (abfd, hdr->sh_info); /* target */ + target_sect = section_from_elf_index (abfd, hdr->sh_info); + if (target_sect == NULL) + return false; + +#if 0 + /* FIXME: We are only prepared to read one symbol table, so + do NOT read the dynamic symbol table since it is only a + subset of the full symbol table. Also see comment above. -fnf */ + if (!elf_slurp_symbol_table (abfd, i_shdrp + hdr->sh_link)) + return false; +#endif + + 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; + 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; +} + +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; +} + +int +DEFUN (bfd_add_to_strtab, (abfd, ss, str), + bfd * abfd AND + struct strtab *ss AND + CONST char *str) +{ + /* should search first, but for now: */ + /* include the trailing NUL */ + int ln = strlen (str) + 1; + + /* 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; +} + +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) +{ + /* 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; +} + +/* Create a new ELF section from a bfd section. */ + +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; + + /* figure out out to write the section name from the bfd section name. MWE */ + + sect = abfd->sections; + for (ndx = indx; --ndx;) + { + 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 = 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 (sect->flags & SEC_HAS_CONTENTS) + { + hdr[indx].sh_offset = sect->filepos; + hdr[indx].sh_size = sect->_raw_size; + } + if (sect->flags & SEC_ALLOC) + { + hdr[indx].sh_flags |= SHF_ALLOC; + if (sect->flags & SEC_LOAD) + { + /* do something with sh_type ? */ + } + } + if (!(sect->flags & SEC_READONLY)) + hdr[indx].sh_flags |= SHF_WRITE; + + if (sect->flags & SEC_CODE) + hdr[indx].sh_flags |= SHF_EXECINSTR; + + 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; +} + +#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. + + 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. + + 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. + + */ + +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; + +} + + +/* Read a specified number of bytes at a specified offset in an ELF + file, into a newly allocated buffer, and return a pointer to the + buffer. */ + +static char * +DEFUN (elf_read, (abfd, offset, size), + bfd * abfd AND + long offset AND + int size) +{ + char *buf; + + if ((buf = bfd_alloc (abfd, size)) == NULL) + { + bfd_error = no_memory; + return NULL; + } + if (bfd_seek (abfd, offset, SEEK_SET) == -1) + { + bfd_error = system_call_error; + return NULL; + } + if (bfd_read ((PTR) buf, size, 1, abfd) != size) + { + bfd_error = system_call_error; + return NULL; + } + return buf; +} + +/* Begin processing a given object. + + First we validate the file by reading in the ELF header and checking + the magic number. */ + +static INLINE boolean +DEFUN (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_MAG2] == ELFMAG2) + && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3)); +} + +bfd_target * +DEFUN (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; + char *shstrtab; /* Internal copy of section header stringtab */ + struct elf_backend_data *ebd; /* Use to get ELF_ARCH stored in xvec */ + + /* 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 + 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; + + { + unsigned int class = 0x12345; +#if ARCH_SIZE == 64 + class = ELFCLASS64; +#endif +#if ARCH_SIZE == 32 + class = ELFCLASS32; +#endif + if (x_ehdr.e_ident[EI_CLASS] != class) + goto wrong; + } + + /* Switch xvec to match the specified byte order. */ + switch (x_ehdr.e_ident[EI_DATA]) + { + case ELFDATA2MSB: /* Big-endian */ + if (!abfd->xvec->header_byteorder_big_p) + goto wrong; + break; + case ELFDATA2LSB: /* Little-endian */ + if (abfd->xvec->header_byteorder_big_p) + 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. */ + + 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). */ + + /* 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 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; + + /* 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. */ + + ebd = get_elf_backend_data (abfd); + switch (i_ehdrp->e_machine) + { + default: + case EM_NONE: + case EM_M32: + /* Arguably EM_M32 should be bfd_arch_obscure, but then we would + need both an elf32-obscure target and an elf32-unknown target. + The distinction is probably not worth worrying about. */ + if (ebd->arch != bfd_arch_unknown) + goto wrong; + bfd_default_set_arch_mach (abfd, bfd_arch_unknown, 0); + break; + case EM_SPARC: + if (ebd->arch != bfd_arch_sparc) + goto wrong; + bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 0); + break; + case EM_386: + if (ebd->arch != bfd_arch_i386) + goto wrong; + bfd_default_set_arch_mach (abfd, bfd_arch_i386, 0); + break; + case EM_68K: + if (ebd->arch != bfd_arch_m68k) + goto wrong; + bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0); + break; + case EM_88K: + if (ebd->arch != bfd_arch_m88k) + goto wrong; + bfd_default_set_arch_mach (abfd, bfd_arch_m88k, 0); + break; + case EM_860: + if (ebd->arch != bfd_arch_i860) + goto wrong; + bfd_default_set_arch_mach (abfd, bfd_arch_i860, 0); + break; + case EM_MIPS: + if (ebd->arch != bfd_arch_mips) + goto wrong; + bfd_default_set_arch_mach (abfd, bfd_arch_mips, 0); + break; + case EM_HPPA: + if (ebd->arch != bfd_arch_hppa) + goto wrong; + bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 0); + break; + } + + /* 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); + if (!i_shdrp) + { + bfd_error = no_memory; + return NULL; + } + if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) == -1) + { + bfd_error = system_call_error; + return NULL; + } + 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; + } + elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex); + } + + elf_elfsections (abfd) = i_shdrp; + + /* Read in the string table containing the names of the sections. We + will need the base pointer to this table later. */ + /* We read this inline now, so that we don't have to go through + 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); + if (!shstrtab) + return NULL; + + /* 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. */ + + for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++) + { + bfd_section_from_shdr (abfd, shindex); + } + + /* Remember the entry point specified in the ELF file header. */ + + bfd_get_start_address (abfd) = i_ehdrp->e_entry; + + return abfd->xvec; +} + +/* + 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; +} + +/* 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 ! */ + + switch (x_ehdr.e_ident[EI_CLASS]) + { + case ELFCLASSNONE: /* address size not specified */ + goto wrong; /* No support if can't tell address size */ + case ELFCLASS32: /* 32-bit addresses */ + break; + case ELFCLASS64: /* 64-bit addresses */ + goto wrong; /* FIXME: 64 bits not yet supported */ + default: + goto wrong; /* No support if unknown address class */ + } + + /* 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 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; +} + +boolean +DEFUN (elf_mkobject, (abfd), bfd * abfd) +{ + /* this just does initialization */ + /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */ + elf_tdata (abfd) = (struct elf_obj_tdata *) + bfd_zalloc (abfd, sizeof (struct elf_obj_tdata)); + if (elf_tdata (abfd) == 0) + { + bfd_error = no_memory; + return false; + } + /* since everything is done at close time, do we need any + initialization? */ + + return true; +} + +/* + Create ELF output from BFD sections. + + Essentially, just create the section header and forget about the program + header for now. + +*/ + +static int +elf_idx_of_sym (abfd, sym) + bfd *abfd; + asymbol *sym; +{ + int i; + for (i = 0; i < abfd->symcount; i++) + { + if (sym == (asymbol *) abfd->outsymbols[i]) + { + /* sanity check */ + BFD_ASSERT ((strcmp (sym->name, abfd->outsymbols[i]->name) == 0) + || (strlen (sym->name) == 0)); + return i + 1; + } + } + return STN_UNDEF; +} + +static void +DEFUN (elf_make_sections, (abfd, asect, obj), + bfd * abfd AND + asection * asect AND + PTR obj) +{ + elf_sect_thunk *thunk = (elf_sect_thunk *) 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 this_section; + int idx; + + /* check if we're making a PROGBITS section... */ + /* if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD)) */ + /* this was too strict... what *do* we want to check here? */ + if (1) + { + Elf_Internal_Shdr *this_hdr; + this_section = elf_section_from_bfd_section (abfd, asect); + this_hdr = &thunk->i_shdrp[this_section]; + + 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) + { + /* emit a reloc section, and thus strtab and symtab... */ + Elf_Internal_Shdr *rela_hdr; + Elf_Internal_Shdr *symtab_hdr; + Elf_External_Rela *outbound_relocas; + Elf_External_Rel *outbound_relocs; + int rela_section; + int use_rela_p = get_elf_backend_data (abfd)->use_rela_p; + + symtab_hdr = &thunk->i_shdrp[thunk->symtab_section]; + + if (thunk->symtab_section == this_section + 1) + rela_section = thunk->symtab_section + 2; /* symtab + symstrtab */ + else + rela_section = this_section + 1; + rela_hdr = &thunk->i_shdrp[rela_section]; + rela_hdr->sh_link = thunk->symtab_section; + rela_hdr->sh_info = this_section; + + /* 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); + rela_hdr->sh_size = rela_hdr->sh_entsize * asect->reloc_count; + outbound_relocas = (Elf_External_Rela *) bfd_alloc (abfd, rela_hdr->sh_size); + + for (idx = 0; idx < asect->reloc_count; idx++) + { + Elf_Internal_Rela dst_rela; + Elf_External_Rela *src_rela; + arelent *ptr; + + ptr = asect->orelocation[idx]; + src_rela = outbound_relocas + idx; + if (!(abfd->flags & EXEC_P)) + dst_rela.r_offset = ptr->address - asect->vma; + else + dst_rela.r_offset = ptr->address; + + dst_rela.r_info + = ELF32_R_INFO (elf_symbol_from_bfd_symbol (abfd, ptr->sym_ptr_ptr), + ptr->howto->type); + + dst_rela.r_addend = ptr->addend; + elf_swap_reloca_out (abfd, &dst_rela, src_rela); + } + + rela_hdr->contents = (void *) outbound_relocas; + } + else + /* REL relocations */ + { + rela_hdr->sh_type = SHT_REL; + rela_hdr->sh_entsize = sizeof (Elf_External_Rel); + rela_hdr->sh_size = rela_hdr->sh_entsize * asect->reloc_count; + outbound_relocs = (Elf_External_Rel *) + bfd_alloc (abfd, rela_hdr->sh_size); + + for (idx = 0; idx < asect->reloc_count; idx++) + { + Elf_Internal_Rel dst_rel; + Elf_External_Rel *src_rel; + arelent *ptr; + + ptr = asect->orelocation[idx]; + src_rel = outbound_relocs + idx; + if (!(abfd->flags & EXEC_P)) + dst_rel.r_offset = ptr->address - asect->vma; + else + dst_rel.r_offset = ptr->address; + + dst_rel.r_info + = ELF32_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. */ +#ifdef DEBUG + fprintf (stderr, "Updating addend: 0x%.8lx = %d, this_section = %d\n", + (long) ((unsigned char *) (elf_elfsections (abfd)[this_section].contents) + + dst_rel.r_offset), ptr->addend, this_section); +#endif + + bfd_put_32 (abfd, ptr->addend, + (unsigned char *) (elf_elfsections (abfd)[this_section].contents) + + dst_rel.r_offset); + } + rela_hdr->contents = (void *) outbound_relocs; + } + } + 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; + } +} + +static void +DEFUN (elf_fake_sections, (abfd, asect, obj), + bfd * abfd AND + asection * asect AND + PTR obj) +{ + elf_sect_thunk *thunk = (elf_sect_thunk *) 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 this_section; + + /* check if we're making a PROGBITS section... */ + /* if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD)) */ + /* this was too strict... what *do* we want to check here? */ + if (1) + { + Elf_Internal_Shdr *this_hdr; + this_section = thunk->i_ehdr->e_shnum++; + this_hdr = &thunk->i_shdrp[this_section]; + this_hdr->sh_name = + bfd_add_to_strtab (abfd, thunk->shstrtab, 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 = 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; + + + { + /* Emit a strtab and symtab, and possibly a reloc section. */ + Elf_Internal_Shdr *rela_hdr; + Elf_Internal_Shdr *symtab_hdr; + Elf_Internal_Shdr *symstrtab_hdr; + int rela_section; + int symstrtab_section; + + /* Note that only one symtab is used, so just remember it + for now. */ + if (!thunk->symtab_section) + { + thunk->symtab_section = thunk->i_ehdr->e_shnum++; + symtab_hdr = &thunk->i_shdrp[thunk->symtab_section]; + symtab_hdr->sh_name = + bfd_add_to_strtab (abfd, thunk->shstrtab, ".symtab"); + symtab_hdr->sh_type = SHT_SYMTAB; + symtab_hdr->sh_entsize = sizeof (Elf_External_Sym); + + symstrtab_section = thunk->i_ehdr->e_shnum++; + BFD_ASSERT (symstrtab_section == thunk->symtab_section + 1); + symstrtab_hdr = &thunk->i_shdrp[symstrtab_section]; + symtab_hdr->sh_link = symstrtab_section; + symstrtab_hdr->sh_name = + bfd_add_to_strtab (abfd, thunk->shstrtab, ".strtab"); + symstrtab_hdr->sh_type = SHT_STRTAB; + + symtab_hdr->contents = 0; + symstrtab_hdr->contents = 0; + symstrtab_hdr->sh_size = 0; + } + else + symtab_hdr = &thunk->i_shdrp[thunk->symtab_section]; + + if (asect->flags & SEC_RELOC) + { + int use_rela_p = get_elf_backend_data (abfd)->use_rela_p; + + rela_section = thunk->i_ehdr->e_shnum++; + rela_hdr = &thunk->i_shdrp[rela_section]; + rela_hdr->sh_name = + bfd_add_2_to_strtab (abfd, thunk->shstrtab, + use_rela_p ? ".rela" : ".rel", + asect->name); + rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL; + rela_hdr->sh_link = thunk->symtab_section; + rela_hdr->sh_info = this_section; + rela_hdr->sh_entsize = sizeof (Elf_External_Rela); + } + } + 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; + } +} + + +/* +xxxINTERNAL_FUNCTION + bfd_elf_locate_sh + +xxxSYNOPSIS + struct elf_internal_shdr *bfd_elf_locate_sh (bfd *abfd, + struct strtab *strtab, + struct elf_internal_shdr *shdrp, + CONST char *name); + +xxxDESCRIPTION + Helper function to locate an ELF section header given the + name of a BFD section. +*/ + +struct elf32_internal_shdr * +DEFUN (bfd_elf_locate_sh, (abfd, strtab, shdrp, name), + bfd * abfd AND + struct strtab *strtab AND + struct elf32_internal_shdr *shdrp AND + CONST char *name) +{ + Elf_Internal_Shdr *gotit = NULL; + int max, i; + + if (shdrp != NULL && strtab != NULL) + { + max = elf_elfheader (abfd)->e_shnum; + for (i = 1; i < max; i++) + { + if (!strcmp (strtab->tab + shdrp[i].sh_name, name)) + { + gotit = &shdrp[i]; + } + } + } + return gotit; +} + +/* Map symbol from it's internal number to the external number, moving + all local symbols to be at the head of the list. */ + +static boolean +DEFUN (elf_map_symbols, (abfd), bfd * abfd) +{ + int symcount = bfd_get_symcount (abfd); + asymbol **syms = bfd_get_outsymbols (abfd); + flagword flags; + 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; + +#ifdef DEBUG + fprintf (stderr, "elf_map_symbols\n"); + fflush (stderr); +#endif + + /* 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 (asect->flags & (SEC_LOAD | SEC_DATA | SEC_CODE)) + num_sections++; + } + + if (num_sections) + { + if (syms) + syms = (asymbol **) bfd_realloc (abfd, syms, + ((symcount + num_sections + 1) + * sizeof (asymbol *))); + else + syms = (asymbol **) bfd_alloc (abfd, + (num_sections + 1) * sizeof (asymbol *)); + + for (asect = abfd->sections; asect; asect = asect->next) + { + if (asect->flags & (SEC_LOAD | SEC_DATA | SEC_CODE)) + { + 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; + } + } + + syms[symcount] = (asymbol *) 0; + bfd_set_symtab (abfd, syms, symcount); + } + + elf_symtab_map (abfd) = symtab_map + = (int *) bfd_alloc (abfd, symcount * sizeof (int *)); + + /* Identify and classify all of the symbols. */ + for (idx = 0; idx < symcount; idx++) + { + flags = syms[idx]->flags; + if (flags & (BSF_LOCAL | BSF_SECTION_SYM | BSF_FILE)) + num_locals++; + else + num_globals++; + } + + /* Now provide mapping information. Add +1 for skipping over the + dummy symbol. */ + for (idx = 0; idx < symcount; idx++) + { + flags = syms[idx]->flags; + if (flags & (BSF_LOCAL | BSF_SECTION_SYM | BSF_FILE)) + symtab_map[idx] = 1 + num_locals2++; + else + symtab_map[idx] = 1 + num_locals + num_globals2++; + } + + elf_num_locals (abfd) = num_locals; + elf_num_globals (abfd) = num_globals; +} + + +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; + elf_sect_thunk est; + + if (!elf_shstrtab (abfd)) + { + i_ehdrp = elf_elfheader (abfd); /* build new header in tdata memory */ + shstrtab = bfd_new_strtab (abfd); + + 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; + + i_ehdrp->e_ident[EI_CLASS] = ELFCLASS32; /* FIXME: find out from bfd */ + i_ehdrp->e_ident[EI_DATA] = + abfd->xvec->byteorder_big_p ? ELFDATA2MSB : ELFDATA2LSB; + i_ehdrp->e_ident[EI_VERSION] = EV_CURRENT; + + for (count = EI_PAD; count < EI_NIDENT; count++) + i_ehdrp->e_ident[count] = 0; + + 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; + 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); + + /* no program header, for now. */ + i_ehdrp->e_phoff = 0; + i_ehdrp->e_phentsize = 0; + i_ehdrp->e_phnum = 0; + + /* each bfd section is section header entry */ + i_ehdrp->e_entry = bfd_get_start_address (abfd); + i_ehdrp->e_shentsize = sizeof (Elf_External_Shdr); + + /* figure at most each section can have a rel, strtab, symtab */ + maxsections = 4 * bfd_count_sections (abfd) + 2; + + i_ehdrp->e_shoff = i_ehdrp->e_ehsize; + + /* and we'll just have to fix up the offsets later. */ + /* outbase += i_ehdr.e_shentsize * i_ehdr.e_shnum; */ + + i_shdrp = (Elf_Internal_Shdr *) + bfd_alloc (abfd, sizeof (*i_shdrp) * maxsections); + if (!i_shdrp) + { + bfd_error = no_memory; + return false; + } + for (count = 0; count < maxsections; count++) + { + i_shdrp[count].rawdata = 0; + i_shdrp[count].contents = 0; + } + + + i_shdrp[0].sh_name = 0; + i_shdrp[0].sh_type = SHT_NULL; + i_shdrp[0].sh_flags = 0; + i_shdrp[0].sh_addr = 0; + i_shdrp[0].sh_offset = 0; + i_shdrp[0].sh_size = 0; + i_shdrp[0].sh_link = SHN_UNDEF; + i_shdrp[0].sh_info = 0; + i_shdrp[0].sh_addralign = 0; + i_shdrp[0].sh_entsize = 0; + + i_ehdrp->e_shnum = 1; + + elf_elfsections (abfd) = i_shdrp; + elf_shstrtab (abfd) = shstrtab; + } + est.i_ehdr = elf_elfheader (abfd); + est.i_shdrp = elf_elfsections (abfd); + est.shstrtab = elf_shstrtab (abfd); + est.symtab_section = 0; /* elf_fake_sections fills it in */ + + elf_map_symbols (abfd); + bfd_map_over_sections (abfd, elf_fake_sections, &est); + { + asection *secp; + asection *psecp = (asection *) 0; + int idx; + Elf_Internal_Shdr *shp; + + for (idx = 0, secp = abfd->sections; secp; idx++, secp = secp->next) + { + if (psecp == (asection *) 0) + { + secp->filepos = est.i_ehdr->e_shoff + (est.i_ehdr->e_shnum + 1) * sizeof (Elf_External_Shdr); + } + else + { + secp->filepos = psecp->filepos + psecp->_cooked_size; + } + shp = bfd_elf_locate_sh (abfd, est.shstrtab, est.i_shdrp, secp->name); + if (shp) + shp->sh_offset = secp->filepos; + psecp = secp; + } + } + elf_onesymtab (abfd) = est.symtab_section; + return true; +} + +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; + + 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); + } + + return true; +} + +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 + + phdr_buf = (Elf_Internal_Phdr *) bfd_xmalloc (((*phdr_cnt) + 1) + * + sizeof (Elf_Internal_Phdr)); + + idx = 0; +#ifdef PHDRS_INCLUDED + /* B. Fill in the PT_PHDR entry. */ + + idx++; +#endif + + /* 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 */ + + { + 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; + } + 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. */ + + phdr_buf[idx].p_type = PT_LOAD; + + /* 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 */ + + /* 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 */ + + { + 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; + + idx++; + + /* E. Fill in the PT_LOAD entry for the bss segment. */ + + phdr_buf[idx].p_type = PT_LOAD; + + /* 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 */ + + { + 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; + + idx++; + + /* F. Set up the "end of program header table" sentinel. */ + + bzero ((char *) (phdr_buf + idx), sizeof (Elf_Internal_Phdr)); + idx++; + + BFD_ASSERT (idx - 1 == *phdr_cnt); + + return phdr_buf; +} + +boolean +DEFUN (elf_write_object_contents, (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 */ + asection *nsect; + elf_sect_thunk est; + + int outbase = 0; + int count; + int scnt; + struct strtab *shstrtab; + + if (abfd->output_has_begun == false) + { + elf_compute_section_file_positions (abfd); + abfd->output_has_begun = true; + } + + i_ehdrp = elf_elfheader (abfd); + i_shdrp = elf_elfsections (abfd); + shstrtab = elf_shstrtab (abfd); + + est.i_ehdr = i_ehdrp; + est.i_shdrp = i_shdrp; + est.shstrtab = shstrtab; + est.symtab_section = elf_onesymtab (abfd); /* filled in by elf_fake */ + + bfd_map_over_sections (abfd, elf_make_sections, &est); + + /* 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; + int symstrtab_section; + Elf_External_Sym *outbound_syms; + int idx; + + symtab_hdr = &i_shdrp[est.symtab_section]; + 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_section = est.symtab_section + 1; + symstrtab_hdr = &i_shdrp[symstrtab_section]; + symtab_hdr->sh_link = symstrtab_section; + 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; + + sym.st_name = bfd_add_to_strtab (abfd, stt, syms[idx]->name); + + value += syms[idx]->section->output_section->vma + + syms[idx]->section->output_offset; + sym.st_value = value; + + sym.st_size = (Elf32_Word) (elf_symbol_from (abfd, syms[idx]))->internal_elf_sym.st_size; + + if (syms[idx]->flags & BSF_WEAK) + sym.st_info = ELF_ST_INFO (STB_WEAK, 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 if (syms[idx]->flags & BSF_GLOBAL) + { + 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_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_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 + sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_OBJECT); + + sym.st_other = 0; + if (syms[idx]->section) + sym.st_shndx = + elf_section_from_bfd_section (abfd, + syms[idx]->section->output_section); + else + sym.st_shndx = SHN_UNDEF; + + elf_swap_symbol_out (abfd, &sym, + outbound_syms + elf_symtab_map (abfd)[idx]); + } + + symtab_hdr->contents = (void *) outbound_syms; + symstrtab_hdr->contents = (void *) stt->tab; + symstrtab_hdr->sh_size = stt->length; + symstrtab_hdr->sh_type = SHT_STRTAB; + } + + /* put the strtab out too... */ + { + Elf_Internal_Shdr *this_hdr; + int this_section; + + this_section = i_ehdrp->e_shnum++; + i_ehdrp->e_shstrndx = this_section; + this_hdr = &i_shdrp[this_section]; + this_hdr->sh_name = bfd_add_to_strtab (abfd, shstrtab, ".shstrtab"); + this_hdr->sh_type = SHT_STRTAB; + this_hdr->sh_size = shstrtab->length; + this_hdr->contents = (void *) shstrtab->tab; + } + + outbase = i_ehdrp->e_ehsize; + + /* if we're building an executable, we'll need a program header table */ + if (abfd->flags & EXEC_P) + { + i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr); + + /* 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 = i_ehdrp->e_ehsize; + i_ehdrp->e_shoff = i_ehdrp->e_phoff + (i_ehdrp->e_phentsize + * i_ehdrp->e_phnum); + } + + /* swap the header before spitting it out... */ + 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 0 + outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum; + outbase += i_ehdrp->e_shentsize * i_ehdrp->e_shnum; +#endif + /* find the next available location in the file + (just beyond the sections that have already been written). */ + outbase = 0; + for (count = 1; count < i_ehdrp->e_shnum; count++) + { + if (i_shdrp[count].sh_offset && outbase < i_shdrp[count].sh_offset) + outbase = i_shdrp[count].sh_offset + i_shdrp[count].sh_size; + } + + /* now we fix up the offsets... */ + for (count = 1; count < i_ehdrp->e_shnum; count++) + { + if (i_shdrp[count].sh_offset == 0) + i_shdrp[count].sh_offset = outbase; + outbase += i_shdrp[count].sh_size; + } + + /* 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, scnt = 0; count < i_ehdrp->e_shnum; count++) + { + elf_swap_shdr_out (abfd, i_shdrp + count, x_shdrp + scnt); + scnt++; + } + bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd); + /* need to dump the string table too... */ + + /* after writing the headers, we need to write the sections too... */ + nsect = abfd->sections; + 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 true; +} + +/* 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; + if (index == SHN_COMMON) + return &bfd_com_section; + + { + Elf_Internal_Shdr *i_shdrp = elf_elfsections (abfd); + Elf_Internal_Shdr *hdr = i_shdrp + 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; + + 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 0; +} + +/* 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; + flagword flags = asym_ptr->flags; + 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)) + break; + } + + BFD_ASSERT (idx < symcount); + idx = elf_symtab_map (abfd)[idx]; + +#ifdef DEBUG + fprintf (stderr, "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags =", + (long) asym_ptr, asym_ptr->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_IMPORT) + fprintf (stderr, " import"); + + if (flags & BSF_EXPORT) + fprintf (stderr, " export"); + + if (flags & BSF_UNDEFINED_OBS) + fprintf (stderr, " undefined_obs"); + + if (flags & BSF_FORT_COMM_OBS) + fprintf (stderr, " fort_comm_obs"); + + 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_CTOR) + fprintf (stderr, " ctor"); + + 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"); + + putc ('\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 *i_shdrp = elf_elfsections (abfd); + Elf_Internal_Shdr *hdr = i_shdrp + elf_onesymtab (abfd); + 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 0 + /* FIXME -- this is almost certainly bogus. It's from Pace + Willisson's hasty Solaris support, to pass the sizes of + object files or functions down into GDB via the back door, to + circumvent some other kludge in how Sun hacked stabs. -- + gnu@cygnus.com */ + /* XXX Size is now stored via a pointer in an elf_symbol_type; + should fix gdb then turn this off. */ + sym->symbol.udata = (PTR) i_sym.st_size; + /* FIXME -- end of bogosity. */ +#endif + 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; + } + 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 = sym; + } + sym++; + } + + /* We rely on the zalloc to clear out the final symbol entry. */ + + obj_raw_syms (abfd) = 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 *i_shdrp; + Elf_Internal_Shdr *hdr; + + i_shdrp = elf_elfsections (abfd); + if (i_shdrp != NULL) + { + hdr = i_shdrp + elf_onesymtab (abfd); + 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 asect->_raw_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 + ELF32_R_SYM (dst.r_info) - 1; + 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\n", (long) hdr->sh_name); + fprintf (stderr, "sh_type = %ld\n", (long) hdr->sh_type); + fprintf (stderr, "sh_flags = %ld\n", (long) hdr->sh_flags); + fprintf (stderr, "sh_addr = %ld\n", (long) hdr->sh_addr); + fprintf (stderr, "sh_offset = %ld\n", (long) hdr->sh_offset); + fprintf (stderr, "sh_size = %ld\n", (long) hdr->sh_size); + fprintf (stderr, "sh_link = %ld\n", (long) hdr->sh_link); + fprintf (stderr, "sh_info = %ld\n", (long) hdr->sh_info); + fprintf (stderr, "sh_addralign = %ld\n", (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); +} + +#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 *i_shdrp; + 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. */ + i_shdrp = elf_elfsections (abfd); + data_hdr = i_shdrp + elf_section_from_bfd_section (abfd, asect); + data_off = data_hdr->sh_offset; + data_max = data_hdr->sh_size - sizeof (buf) + 1; + +#ifdef DEBUG + elf_debug_section ("data section", data_hdr - i_shdrp, 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 + ELF32_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 %lx %lx", + symbol->value, + (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) +{ + fprintf (stderr, "elf_find_nearest_line unimplemented\n"); + fflush (stderr); + BFD_FAIL (); + 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) +{ + int dest_sect; + + if (abfd->output_has_begun == false) /* set by bfd.c handler? */ + { + /* do setup calculations (FIXME) */ + elf_compute_section_file_positions (abfd); + abfd->output_has_begun = true; + } + + dest_sect = elf_section_from_bfd_section (abfd, section); + if (!dest_sect) + return false; + + if (bfd_seek (abfd, elf_elfsections (abfd)[dest_sect].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 (); +} + +boolean +DEFUN (elf_get_sect_thunk, (abfd, est), + bfd * abfd AND + elf_sect_thunk * est) +{ + if (est == (elf_sect_thunk *) NULL) + return false; + + est->i_ehdr = elf_elfheader (abfd); + est->i_shdrp = elf_elfsections (abfd); + est->shstrtab = elf_shstrtab (abfd); + est->symtab_section = elf_onesymtab (abfd); /* filled in by elf_fake */ + + return true; +} |