-/* ELF support for BFD.
- Copyright (C) 1991 Free Software Foundation, Inc.
+/* ELF executable support for BFD.
+ Copyright (C) 1991, 1992 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".
-
+ 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.
+
This file is part of BFD, the Binary File Descriptor library.
This program is free software; you can redistribute it and/or modify
} elf_symbol_type;
/* Some private data is stashed away for future use using the tdata pointer
- in the bfd structure. This information is different for ELF core files
- and other ELF files. */
+ in the bfd structure. */
-typedef struct elf_core_tdata_struct
+struct elf_obj_tdata
{
- void *prstatus; /* The raw /proc prstatus structure */
- void *prpsinfo; /* The raw /proc prpsinfo structure */
-} elf_core_tdata;
-
-#define core_prpsinfo(bfd) (((bfd)->tdata.elf_core_data) -> prpsinfo)
-#define core_prstatus(bfd) (((bfd)->tdata.elf_core_data) -> prstatus)
-
-
-typedef struct elf_obj_tdata_struct
-{
- file_ptr symtab_filepos; /* Offset to start of ELF symtab section */
- long symtab_filesz; /* Size of ELF symtab section */
- file_ptr strtab_filepos; /* Offset to start of ELF string tbl section */
- long strtab_filesz; /* Size of ELF string tbl section */
-} 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;
+ void *prstatus; /* The raw /proc prstatus structure */
+ void *prpsinfo; /* The raw /proc prpsinfo structure */
+};
#define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data)
-#define elf_symtab_filepos(bfd) (elf_tdata(bfd) -> symtab_filepos)
-#define elf_symtab_filesz(bfd) (elf_tdata(bfd) -> symtab_filesz)
-#define elf_strtab_filepos(bfd) (elf_tdata(bfd) -> strtab_filepos)
-#define elf_strtab_filesz(bfd) (elf_tdata(bfd) -> strtab_filesz)
+#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 core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo)
+#define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus)
/* Translate an ELF symbol in external format into an ELF symbol in internal
format. */
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. */
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. */
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);
+ 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);
}
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);
+ 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);
}
-/* Create a new bfd section from an ELF section header. */
+/* 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 boolean
-DEFUN(bfd_section_from_shdr, (abfd, hdr, shstrtab),
- bfd *abfd AND
- Elf_Internal_Shdr *hdr AND
- char *shstrtab)
+static void
+DEFUN(elf_swap_reloca_in,(abfd, src, dst),
+ bfd *abfd AND
+ Elf_External_Rela *src AND
+ Elf_Internal_Rela *dst)
{
- asection *newsect;
- char *name;
+ 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);
+}
- name = hdr -> sh_name ? shstrtab + hdr -> sh_name : "unnamed";
- newsect = bfd_make_section (abfd, name);
- if (!newsect) return false;
- newsect -> vma = hdr -> sh_addr;
- newsect -> _raw_size = hdr -> sh_size;
- if (!(hdr -> sh_type == SHT_NOBITS))
+/* 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);
+}
+
+static char *EXFUN(elf_read, (bfd *, long, int));
+static struct sec * EXFUN(section_from_elf_index, (bfd *, int));
+static int EXFUN(elf_section_from_bfd_section, (bfd *, struct sec *));
+static boolean EXFUN(elf_slurp_symbol_table, (bfd *, asymbol **));
+static void EXFUN(elf_info_to_howto, (bfd *, arelent *, Elf_Internal_Rela *));
+static char *EXFUN(elf_get_str_section, (bfd *, unsigned int));
+
+/*
+INTERNAL_FUNCTION
+ bfd_elf_find_section
+
+SYNOPSIS
+ struct elf_internal_shdr *bfd_elf_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(bfd_elf_find_section, (abfd, name),
+ bfd *abfd AND
+ char *name)
+{
+ Elf_Internal_Shdr *i_shdrp = elf_elfsections (abfd);
+ char *shstrtab = elf_get_str_section (abfd, elf_elfheader (abfd)->e_shstrndx);
+ unsigned int max = elf_elfheader (abfd)->e_shnum;
+ unsigned int i;
+
+ for (i = 1; i < max; i++)
+ if (!strcmp (&shstrtab[i_shdrp[i].sh_name], name))
+ return &i_shdrp[i];
+ return 0;
+}
+
+/* End of GDB support. */
+
+static char *
+DEFUN(elf_get_str_section, (abfd, shindex),
+ bfd *abfd AND
+ unsigned int shindex)
+{
+ Elf_Internal_Shdr *i_shdrp = elf_elfsections (abfd);
+ unsigned int shstrtabsize = i_shdrp[shindex].sh_size;
+ unsigned int offset = i_shdrp[shindex].sh_offset;
+ char *shstrtab = i_shdrp[shindex].rawdata;
+
+ if (shstrtab)
+ return shstrtab;
+
+ if ((shstrtab = elf_read (abfd, offset, shstrtabsize)) == NULL)
{
- newsect -> filepos = hdr -> sh_offset;
- newsect -> flags |= SEC_HAS_CONTENTS;
+ return (NULL);
}
- if (hdr -> sh_flags & SHF_ALLOC)
+ 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 *i_shdrp = elf_elfsections (abfd);
+ Elf_Internal_Shdr *hdr = i_shdrp + shindex;
+
+ if (! hdr->rawdata)
{
- newsect -> flags |= SEC_ALLOC;
- if (hdr -> sh_type != SHT_NOBITS)
+ if (elf_get_str_section (abfd, shindex) == NULL)
{
- newsect -> flags |= SEC_LOAD;
+ return NULL;
}
}
- if (!(hdr -> sh_flags & SHF_WRITE))
+ return ((char*)hdr->rawdata)+strindex;
+}
+
+#define elf_string_from_elf_strtab(abfd, strindex) \
+ 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 = hdr->sh_name ?
+ elf_string_from_elf_strtab (abfd, hdr->sh_name) : "unnamed";
+
+ switch(hdr->sh_type) {
+
+ case SHT_NULL:
+ /* inactive section. Throw it away. */
+ return true;
+
+ case SHT_PROGBITS:
+ case SHT_NOBITS:
+ /* Bits that get saved. This one is real. */
+ if (! hdr->rawdata )
+ {
+ newsect = bfd_make_section (abfd, name);
+ 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;
+
+ if (hdr->sh_flags & SHF_ALLOC)
+ {
+ newsect->flags |= SEC_ALLOC;
+ if (hdr->sh_type != SHT_NOBITS)
+ 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;
+ break;
+
+ 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 */
+
{
- newsect -> flags |= SEC_READONLY;
+ asection *target_sect;
+
+ 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;
}
- if (hdr -> sh_flags & SHF_EXECINSTR)
+ 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");
+ abort ();
+#endif
+ break;
+
+ case SHT_NOTE:
+#if 0
+ fprintf(stderr, "Note Sections not yet supported.\n");
+ abort ();
+#endif
+ break;
+
+ case SHT_SHLIB:
+#if 0
+ fprintf(stderr, "SHLIB Sections not supported (and non conforming.)\n");
+#endif
+ return true;
+
+ default:
+ break;
+ }
+
+ return (true);
+}
+
+
+
+
+struct strtab {
+ char *tab;
+ int nentries;
+ int length;
+};
+
+
+static struct strtab *
+DEFUN(bfd_new_strtab, (abfd),
+ bfd *abfd)
+{
+ struct strtab *ss;
+
+ ss = (struct strtab *)malloc(sizeof(struct strtab));
+ ss->tab = malloc(1);
+ BFD_ASSERT(ss->tab != 0);
+ *ss->tab = 0;
+ ss->nentries = 0;
+ ss->length = 1;
+
+ return ss;
+}
+
+static 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 = malloc(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; )
{
- newsect -> flags |= SEC_CODE; /* FIXME: may only contain SOME code */
+ sect = sect->next;
}
- else
+ 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_flags = 0;
+ /* these need to be preserved on */
+ hdr[indx].sh_link = 0;
+ hdr[indx].sh_info = 0;
+ hdr[indx].sh_addralign = 0;
+ hdr[indx].sh_entsize = 0;
+
+ hdr[indx].sh_type = 0;
+ if (sect->flags & SEC_RELOC) {
+ hdr[indx].sh_type = SHT_RELA; /* FIXME -- sparc specific */
+ }
+
+ if (sect->flags & SEC_HAS_CONTENTS)
{
- newsect -> flags |= SEC_DATA;
+ hdr[indx].sh_offset = sect->filepos;
+ hdr[indx].sh_size = sect->_raw_size;
}
- if (hdr -> sh_type == SHT_SYMTAB)
+ if (sect->flags & SEC_ALLOC)
{
- abfd -> flags |= HAS_SYMS;
+ 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);
}
(hdr -> p_memsz > hdr -> p_filesz));
sprintf (namebuf, split ? "segment%da" : "segment%d", index);
name = bfd_alloc (abfd, strlen (namebuf) + 1);
- (void) strcpy (name, namebuf);
+ strcpy (name, namebuf);
newsect = bfd_make_section (abfd, name);
newsect -> vma = hdr -> p_vaddr;
newsect -> _raw_size = hdr -> p_filesz;
{
sprintf (namebuf, "segment%db", index);
name = bfd_alloc (abfd, strlen (namebuf) + 1);
- (void) strcpy (name, namebuf);
+ 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;
{
newsect -> flags |= SEC_ALLOC;
if (hdr -> p_flags & PF_X)
- {
- newsect -> flags |= SEC_CODE;
- }
+ newsect -> flags |= SEC_CODE;
}
if (!(hdr -> p_flags & PF_W))
- {
- newsect -> flags |= SEC_READONLY;
- }
+ newsect -> flags |= SEC_READONLY;
}
return (true);
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 (gregset_t);
- newsect -> filepos = filepos + (long) (((prstatus_t *)0) -> pr_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)
{
if ((core_prpsinfo (abfd) = bfd_alloc (abfd, descsz)) != NULL)
{
- bcopy (descdata, core_prpsinfo (abfd), descsz);
+ memcpy (core_prpsinfo (abfd), descdata, descsz);
}
}
}
{
asection *newsect;
- if (descsz == sizeof (fpregset_t))
- {
- newsect = bfd_make_section (abfd, ".reg2");
- newsect -> _raw_size = sizeof (fpregset_t);
- newsect -> filepos = filepos;
- newsect -> flags = SEC_ALLOC | SEC_HAS_CONTENTS;
- newsect -> alignment_power = 2;
- }
+ 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 */
if (hdr -> p_filesz > 0
&& (buf = (char *) bfd_xmalloc (hdr -> p_filesz)) != NULL
- && bfd_seek (abfd, hdr -> p_offset, SEEK_SET) != -1L
+ && 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;
DEFUN (elf_object_p, (abfd), bfd *abfd)
{
Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
- Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal 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 */
- int shstrtabsize; /* Size of section header string table */
- Elf_Off offset; /* Temp place to stash file offsets */
/* Read in the ELF header in external format. */
/* 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 (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->header_byteorder_big_p)
- goto wrong;
- break;
- case ELFDATA2LSB: /* Little-endian */
- if (abfd->xvec->header_byteorder_big_p)
+ 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;
- 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 ((abfd -> tdata.elf_obj_data =
- (elf_obj_tdata*) bfd_zalloc (abfd, sizeof (elf_obj_tdata)))
- == NULL)
+ if (NULL == (elf_tdata (abfd) = (struct elf_obj_tdata *)
+ bfd_zalloc (abfd, sizeof (struct elf_obj_tdata))))
{
bfd_error = no_memory;
return (NULL);
}
- /* Now that we know the byte order, swap in the rest of the header */
- elf_swap_ehdr_in (abfd, &x_ehdr, &i_ehdr);
+ /* 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_ehdr.e_shoff == 0)
+ if (i_ehdrp->e_shoff == 0)
goto wrong;
- if (i_ehdr.e_type == ET_EXEC || i_ehdr.e_type == ET_DYN)
+ if (i_ehdrp->e_type == ET_EXEC || i_ehdrp->e_type == ET_DYN)
+ abfd -> flags |= EXEC_P;
+
+ switch (i_ehdrp->e_machine)
{
- abfd -> flags |= EXEC_P;
+ case EM_NONE:
+ case EM_M32: /* or should this be bfd_arch_obscure? */
+ bfd_default_set_arch_mach(abfd, bfd_arch_unknown, 0);
+ break;
+ case EM_SPARC:
+ bfd_default_set_arch_mach(abfd, bfd_arch_sparc, 0);
+ break;
+ case EM_386:
+ bfd_default_set_arch_mach(abfd, bfd_arch_i386, 0);
+ break;
+ case EM_68K:
+ bfd_default_set_arch_mach(abfd, bfd_arch_m68k, 0);
+ break;
+ case EM_88K:
+ bfd_default_set_arch_mach(abfd, bfd_arch_m88k, 0);
+ break;
+ case EM_860:
+ bfd_default_set_arch_mach(abfd, bfd_arch_i860, 0);
+ break;
+ case EM_MIPS:
+ bfd_default_set_arch_mach(abfd, bfd_arch_mips, 0);
+ break;
+ default:
+ goto wrong;
}
-
- /* Allocate space for copies of the section header table in external
- and internal form, seek to the section header table in the file,
+
+ /* 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_ehdr.e_shentsize != sizeof (x_shdr))
+ if (i_ehdrp->e_shentsize != sizeof (x_shdr))
goto wrong;
- if ((i_shdrp = (Elf_Internal_Shdr *)
- bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdr.e_shnum)) == NULL)
+ 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_ehdr.e_shoff, SEEK_SET) == -1)
+ if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) == -1)
{
bfd_error = system_call_error;
return (NULL);
}
- for (shindex = 0; shindex < i_ehdr.e_shnum; shindex++)
+ for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
{
- if (bfd_read ((PTR) &x_shdr, sizeof (x_shdr), 1, abfd)
+ if (bfd_read ((PTR) &x_shdr, sizeof x_shdr, 1, abfd)
!= sizeof (x_shdr))
{
bfd_error = system_call_error;
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.) */
- shstrtabsize = i_shdrp[i_ehdr.e_shstrndx].sh_size;
- offset = i_shdrp[i_ehdr.e_shstrndx].sh_offset;
- if ((shstrtab = elf_read (abfd, offset, shstrtabsize)) == NULL)
- {
- return (NULL);
- }
-
+ 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.
offset and section size for both the symbol table section and the
associated string table section. */
- for (shindex = 1; shindex < i_ehdr.e_shnum; shindex++)
+ for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
{
- Elf_Internal_Shdr *hdr = i_shdrp + shindex;
- bfd_section_from_shdr (abfd, hdr, shstrtab);
- if (hdr -> sh_type == SHT_SYMTAB)
- {
- elf_symtab_filepos (abfd) = hdr -> sh_offset;
- elf_symtab_filesz (abfd) = hdr -> sh_size;
- elf_strtab_filepos (abfd) = (i_shdrp + hdr -> sh_link) -> sh_offset;
- elf_strtab_filesz (abfd) = (i_shdrp + hdr -> sh_link) -> sh_size;
- }
+ bfd_section_from_shdr (abfd, shindex);
}
/* Remember the entry point specified in the ELF file header. */
- bfd_get_start_address (abfd) = i_ehdr.e_entry;
+ bfd_get_start_address (abfd) = i_ehdrp->e_entry;
return (abfd->xvec);
}
DEFUN (elf_core_file_p, (abfd), bfd *abfd)
{
Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
- Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal 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 */
- int phindex;
+ unsigned int phindex;
/* Read in the ELF header in external format. */
/* 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 (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 */
- abfd->xvec = &elf_big_vec;
- break;
- case ELFDATA2LSB: /* Little-endian */
- abfd->xvec = &elf_little_vec;
- break;
- case ELFDATANONE: /* No data encoding specified */
- default: /* Unknown data encoding specified */
- goto wrong;
- }
+ switch (x_ehdr.e_ident[EI_DATA])
+ {
+ case ELFDATA2MSB: /* Big-endian */
+ abfd->xvec = &elf_big_vec;
+ break;
+ case ELFDATA2LSB: /* Little-endian */
+ abfd->xvec = &elf_little_vec;
+ break;
+ case ELFDATANONE: /* No data encoding specified */
+ default: /* Unknown data encoding specified */
+ goto wrong;
+ }
- /* Now that we know the byte order, swap in the rest of the header */
- elf_swap_ehdr_in (abfd, &x_ehdr, &i_ehdr);
-
- /* If there is no program header, or the type is not a core file, then
- we are hosed. */
- if (i_ehdr.e_phoff == 0 || i_ehdr.e_type != ET_CORE)
- goto wrong;
-
- /* Allocate an instance of the elf_core_tdata structure and hook it up to
+ /* Allocate an instance of the elf_obj_tdata structure and hook it up to
the tdata pointer in the bfd. */
- if ((abfd -> tdata.elf_core_data =
- (elf_core_tdata *) bfd_zalloc (abfd, sizeof (elf_core_tdata)))
- == NULL)
+ 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);
}
- /* Allocate space for copies of the program header table in external
- and internal form, seek to the program header table in the file,
+ /* 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_ehdr.e_phentsize != sizeof (x_phdr))
+ if (i_ehdrp->e_phentsize != sizeof (x_phdr))
goto wrong;
- if ((i_phdrp = (Elf_Internal_Phdr *)
- bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdr.e_phnum)) == NULL)
+ 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_ehdr.e_phoff, SEEK_SET) == -1)
+ if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) == -1)
{
bfd_error = system_call_error;
return (NULL);
}
- for (phindex = 0; phindex < i_ehdr.e_phnum; phindex++)
+ for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
{
if (bfd_read ((PTR) &x_phdr, sizeof (x_phdr), 1, abfd)
!= sizeof (x_phdr))
/* Once all of the program headers have been read and converted, we
can start processing them. */
- for (phindex = 0; phindex < i_ehdr.e_phnum; phindex++)
+ 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)
/* Remember the entry point specified in the ELF file header. */
- bfd_get_start_address (abfd) = i_ehdr.e_entry;
+ bfd_get_start_address (abfd) = i_ehdrp->e_entry;
return (abfd->xvec);
}
static boolean
DEFUN (elf_mkobject, (abfd), bfd *abfd)
{
- fprintf (stderr, "elf_mkobject unimplemented\n");
- fflush (stderr);
- abort ();
- return (false);
+ /* 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.
+
+*/
+
+/* lacking nested functions and nested types, set up for mapping over
+ BFD sections to produce ELF sections */
+
+typedef struct {
+ Elf_Internal_Ehdr *i_ehdr;
+ Elf_Internal_Shdr *i_shdrp;
+ struct strtab *shstrtab;
+ int symtab_section;
+} elf_sect_thunk;
+
+
+
+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_Internal_Shdr *symstrtab_hdr;
+ Elf_External_Rela *outbound_relocs;
+ Elf_External_Sym *outbound_syms;
+ int rela_section;
+ int symstrtab_section;
+
+ 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_type = SHT_RELA;
+ rela_hdr->sh_link = thunk->symtab_section;
+ rela_hdr->sh_info = this_section;
+ rela_hdr->sh_entsize = sizeof (Elf_External_Rela);
+ /* orelocation has the data, reloc_count has the count... */
+ rela_hdr->sh_size = rela_hdr->sh_entsize * asect->reloc_count;
+ outbound_relocs = (Elf_External_Rela *)
+ bfd_alloc(abfd, asect->reloc_count * sizeof(Elf_External_Rela));
+ for (idx = 0; idx < asect->reloc_count; idx++)
+ {
+ Elf_Internal_Rela dst;
+ arelent *ptr;
+ Elf_External_Rela *src;
+
+ ptr = asect->orelocation[idx];
+ src = outbound_relocs + idx;
+ if (asect->flags & SEC_RELOC)
+ dst.r_offset = ptr->address - asect->vma;
+ else
+ dst.r_offset = ptr->address;
+
+ dst.r_info = ELF_R_INFO(1 /*ptr->sym_ptr_ptr*/, /* needs index into symtab (FIXME) */
+ ptr->howto->type);
+
+ dst.r_addend = ptr->addend;
+ elf_swap_reloca_out(abfd, &dst, src);
+ }
+ rela_hdr->contents = (void*)outbound_relocs;
+ }
+ }
+}
+
+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;
+ 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 = 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;
+ if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD))
+ this_hdr->sh_type = SHT_PROGBITS;
+ else
+ /* what *do* we put here? */
+ this_hdr->sh_type = SHT_PROGBITS;
+
+
+ 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_Internal_Shdr *symstrtab_hdr;
+ Elf_External_Rela *outbound_relocs;
+ Elf_External_Sym *outbound_syms;
+ 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];
+
+ 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, ".rela", asect->name);
+ rela_hdr->sh_type = SHT_RELA;
+ rela_hdr->sh_link = thunk->symtab_section;
+ rela_hdr->sh_info = this_section;
+ rela_hdr->sh_entsize = sizeof (Elf_External_Rela);
+ }
+ }
+}
+
+
+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;
+ int outbase;
+ 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;
+ /* 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 fils it in */
+
+ bfd_map_over_sections(abfd, elf_fake_sections, &est);
+ elf_onesymtab (abfd) = est.symtab_section;
+ return (true);
}
static boolean
DEFUN (elf_write_object_contents, (abfd), bfd *abfd)
{
- fprintf (stderr, "elf_write_object_contents unimplemented\n");
- fflush (stderr);
- abort ();
- return (false);
+ Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
+ Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
+ Elf_External_Phdr *x_phdrp; /* Program header table, external form */
+ Elf_Internal_Phdr *i_phdrp; /* 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;
+ int maxsections;
+ elf_sect_thunk est;
+
+ int outbase = 0;
+ int count;
+ struct strtab *shstrtab;
+
+ if(abfd->output_has_begun == false)
+ elf_compute_section_file_positions(abfd);
+
+ 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 one symtab */
+ {
+ 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;
+
+ /* 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") */
+ for (idx = 0; idx < symcount; idx++)
+ {
+ Elf_Internal_Sym sym;
+ sym.st_name = bfd_add_to_strtab (abfd, stt, syms[idx]->name);
+ sym.st_value = syms[idx]->value;
+ sym.st_size = 0; /* we should recover this (FIXME) */
+ if (syms[idx]->flags & BSF_WEAK)
+ sym.st_info = ELF_ST_INFO(STB_WEAK, STT_OBJECT);
+ else if (syms[idx]->flags & BSF_LOCAL)
+ sym.st_info = ELF_ST_INFO(STB_LOCAL, STT_OBJECT);
+ else if (syms[idx]->flags & BSF_GLOBAL)
+ 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);
+
+ 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+idx+1);
+ }
+ {
+ /* fill in 0th symbol */
+ 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);
+ }
+ symtab_hdr->contents = (void*)outbound_syms;
+ symstrtab_hdr->contents = (void*)stt->tab;
+ symstrtab_hdr->sh_size = stt->length;
+ }
+
+ /* 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_size = shstrtab->length;
+ this_hdr->contents = (void*)shstrtab->tab;
+ }
+
+ outbase = i_ehdrp->e_ehsize;
+
+ /* 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);
+
+ outbase += i_ehdrp->e_shentsize * i_ehdrp->e_shnum;
+
+ /* now we fix up the offsets... */
+ for (count = 0; count < i_ehdrp->e_shnum; count ++)
+ {
+ i_shdrp[count].sh_offset = outbase;
+ outbase += i_shdrp[count].sh_size;
+ }
+
+ /* at this point we've concocted all the ELF sections... */
+ x_shdrp = (Elf_External_Shdr *)
+ bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
+ if (! x_shdrp)
+ {
+ bfd_error = no_memory;
+ return (false);
+ }
+
+ for (count = 0; count < i_ehdrp->e_shnum; count ++)
+ {
+ elf_swap_shdr_out (abfd, i_shdrp+count, x_shdrp+count);
+ }
+ 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);
+ }
+ }
+
+ /* sample use of bfd:
+ * bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
+ * bfd_write ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd);
+ * if (bfd_seek(abfd, scn_base, SEEK_SET) != 0)
+ * return false;
+ * old = bfd_tell(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_bfd_index, (abfd, index),
+DEFUN (section_from_elf_index, (abfd, index),
bfd *abfd AND
int index)
{
- if (index > 0)
+ Elf_Internal_Shdr *i_shdrp = elf_elfsections (abfd);
+ Elf_Internal_Shdr *hdr = i_shdrp + index;
+
+ switch (hdr->sh_type)
{
- struct sec *answer = abfd -> sections;
- while (--index > 0)
- {
- answer = answer -> next;
- }
- return (answer);
+ /* 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;
+ break;
+ default:
+ return (struct sec *)&bfd_abs_section;
}
- return (NULL);
+}
+
+/* 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;
+
+ 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;
}
static boolean
-DEFUN (elf_slurp_symbol_table, (abfd), bfd *abfd)
+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 */
- char *strtab; /* Buffer for raw ELF string table section */
+ int i;
asymbol *sym; /* Pointer to current bfd symbol */
asymbol *symbase; /* Buffer for generated bfd symbols */
- asymbol **vec; /* Pointer to current bfd symbol pointer */
Elf_Internal_Sym i_sym;
- Elf_External_Sym x_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);
}
- /* Slurp in the string table. We will keep it around permanently, as
- long as the bfd is in use, since we will end up setting up pointers
- into it for the names of all the symbols. */
-
- strtab = elf_read (abfd, elf_strtab_filepos(abfd), elf_strtab_filesz(abfd));
- if (strtab == NULL)
- {
- return (false);
- }
-
/* 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 be allocate the initial bfd canonical symbol buffer
+ Note that we allocate the initial bfd canonical symbol buffer
based on a one-to-one mapping of the ELF symbols to canonical
- symbols. However, it is likely that not all the ELF symbols will
- be used, so there will be some space leftover at the end. Once
- we know how many symbols we actual generate, we realloc the buffer
- to the correct size and then build the pointer vector. */
+ 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, elf_symtab_filepos (abfd), SEEK_SET) == -1)
+ if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
{
bfd_error = system_call_error;
return (false);
}
- symcount = elf_symtab_filesz(abfd) / sizeof (Elf_External_Sym);
- sym = symbase = (asymbol *) bfd_zalloc (abfd, symcount * sizeof (asymbol));
+ symcount = hdr->sh_size / sizeof (Elf_External_Sym);
+ symbase = (asymbol *) bfd_zalloc (abfd, symcount * sizeof (asymbol));
+ sym = symbase;
- while (symcount-- > 0)
+ /* Temporarily allocate room for the raw ELF symbols. */
+ x_symp = (Elf_External_Sym *) malloc (symcount * sizeof (Elf_External_Sym));
+
+ if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
+ != symcount * sizeof (Elf_External_Sym))
{
- if (bfd_read ((PTR) &x_sym, sizeof (x_sym), 1, abfd) != sizeof (x_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);
+ sym -> the_bfd = abfd;
+ if (i_sym.st_name > 0)
+ sym -> name = elf_string_from_elf_section(abfd, hdr->sh_link,
+ i_sym.st_name);
+ else
+ sym -> name = "unnamed"; /* perhaps should include the number? */
+ sym -> value = i_sym.st_value;
+/* 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 */
+ sym -> udata = (PTR)i_sym.st_size;
+/* FIXME -- end of bogosity. */
+ if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERV)
{
- bfd_error = system_call_error;
- return (false);
+ sym -> section = section_from_elf_index (abfd, i_sym.st_shndx);
}
- elf_swap_symbol_in (abfd, &x_sym, &i_sym);
- if (i_sym.st_name > 0)
+ else if (i_sym.st_shndx == SHN_ABS)
{
- sym -> the_bfd = abfd;
- sym -> name = strtab + i_sym.st_name;
- sym -> value = i_sym.st_value;
- if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERV)
- {
- /* Note: This code depends upon there being an ordered
- one-for-one mapping of ELF sections to bfd sections. */
- sym -> section = section_from_bfd_index (abfd, i_sym.st_shndx);
- }
- else if (i_sym.st_shndx == SHN_ABS)
- {
- sym -> section = &bfd_abs_section;
- }
- else if (i_sym.st_shndx == SHN_COMMON)
- {
- sym -> section = &bfd_com_section;
- }
- switch (ELF_ST_BIND (i_sym.st_info))
- {
- case STB_LOCAL:
- sym -> flags |= BSF_LOCAL;
- break;
- case STB_GLOBAL:
- sym -> flags |= (BSF_GLOBAL | BSF_EXPORT);
- break;
- case STB_WEAK:
- sym -> flags |= BSF_WEAK;
- break;
- }
- sym++;
+ sym -> section = &bfd_abs_section;
+ }
+ else if (i_sym.st_shndx == SHN_COMMON)
+ {
+ sym -> section = &bfd_com_section;
+ }
+ else if (i_sym.st_shndx == SHN_UNDEF)
+ {
+ sym -> section = &bfd_und_section;
}
+ else
+ sym -> section = &bfd_abs_section;
+
+ switch (ELF_ST_BIND (i_sym.st_info))
+ {
+ case STB_LOCAL:
+ sym -> flags |= BSF_LOCAL;
+ break;
+ case STB_GLOBAL:
+ sym -> flags |= (BSF_GLOBAL | BSF_EXPORT);
+ break;
+ case STB_WEAK:
+ sym -> flags |= BSF_WEAK;
+ break;
+ }
+
+ switch (ELF_ST_TYPE (i_sym.st_info))
+ {
+ case STT_SECTION:
+ sym->flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
+ break;
+ case STT_FILE:
+ sym->flags |= BSF_FILE | BSF_DEBUGGING;
+ break;
+ }
+ sym++;
}
- bfd_get_symcount(abfd) = symcount = sym - symbase;
- sym = symbase = (asymbol *)
- bfd_realloc (abfd, symbase, symcount * sizeof (asymbol));
- bfd_get_outsymbols(abfd) = vec = (asymbol **)
- bfd_alloc (abfd, symcount * sizeof (asymbol *));
+ /* We rely on the zalloc to clear out the final symbol entry. */
- while (symcount-- > 0)
+ /* We're now done with the raw symbols. */
+ free ((PTR)x_symp);
+
+ bfd_get_symcount(abfd) = symcount = sym - symbase;
+
+ /* Fill in the user's symbol pointer vector if needed. */
+ if (symptrs)
{
- *vec++ = sym++;
+ sym = symbase;
+ while (symcount-- > 0)
+ {
+ *symptrs++ = 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. */
+ 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. */
static unsigned int
DEFUN (elf_get_symtab_upper_bound, (abfd), bfd *abfd)
{
- unsigned int symtab_size = 0;
+ unsigned int symcount;
+ unsigned int symtab_size;
+ Elf_Internal_Shdr *i_shdrp = elf_elfsections (abfd);
+ Elf_Internal_Shdr *hdr = i_shdrp + elf_onesymtab (abfd);
- if (elf_slurp_symbol_table (abfd))
- {
- symtab_size = (bfd_get_symcount (abfd) + 1) * (sizeof (asymbol));
- }
+ 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>>
+
+*/
static unsigned int
elf_get_reloc_upper_bound (abfd, asect)
bfd *abfd;
sec_ptr asect;
{
- fprintf (stderr, "elf_get_reloc_upper_bound unimplemented\n");
- fflush (stderr);
+ if (asect->flags & SEC_RELOC)
+ {
+ /* either rel or rela */
+ return asect->_raw_size;
+ }
+ else
+ return (0);
+}
+
+/* FIXME!!! sparc howto should go into elf-32-sparc.c */
+#ifdef sparc
+enum reloc_type
+ {
+ R_SPARC_NONE = 0,
+ R_SPARC_8, R_SPARC_16, R_SPARC_32,
+ R_SPARC_DISP8, R_SPARC_DISP16, R_SPARC_DISP32,
+ R_SPARC_WDISP30, R_SPARC_WDISP22,
+ R_SPARC_HI22, R_SPARC_22,
+ R_SPARC_13, R_SPARC_LO10,
+ R_SPARC_GOT10, R_SPARC_GOT13, R_SPARC_GOT22,
+ R_SPARC_PC10, R_SPARC_PC22,
+ R_SPARC_WPLT30,
+ R_SPARC_COPY,
+ R_SPARC_GLOB_DAT, R_SPARC_JMP_SLOT,
+ R_SPARC_RELATIVE,
+ R_SPARC_UA32,
+ };
+
+#define RELOC_TYPE_NAMES \
+ "R_SPARC_NONE", \
+ "R_SPARC_8", "R_SPARC_16", "R_SPARC_32", \
+ "R_SPARC_DISP8", "R_SPARC_DISP16", "R_SPARC_DISP32", \
+ "R_SPARC_WDISP30", "R_SPARC_WDISP22", \
+ "R_SPARC_HI22", "R_SPARC_22", \
+ "R_SPARC_13", "R_SPARC_LO10", \
+ "R_SPARC_GOT10", "R_SPARC_GOT13", "R_SPARC_GOT22", \
+ "R_SPARC_PC10", "R_SPARC_PC22", \
+ "R_SPARC_WPLT30", \
+ "R_SPARC_COPY", \
+ "R_SPARC_GLOB_DAT", "R_SPARC_JMP_SLOT", \
+ "R_SPARC_RELATIVE", \
+ "R_SPARC_UA32"
+
+static reloc_howto_type elf_howto_table[] =
+{
+ HOWTO(R_SPARC_NONE, 0,0, 0,false,0,false,false, 0,"R_SPARC_NONE", false,0,0x00000000,false),
+ HOWTO(R_SPARC_8, 0,0, 8,false,0,true, true, 0,"R_SPARC_8", false,0,0x000000ff,false),
+ HOWTO(R_SPARC_16, 0,1,16,false,0,true, true, 0,"R_SPARC_16", false,0,0x0000ffff,false),
+ HOWTO(R_SPARC_32, 0,2,32,false,0,true, true, 0,"R_SPARC_32", false,0,0xffffffff,false),
+ HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,false, true, 0,"R_SPARC_DISP8", false,0,0x000000ff,false),
+ HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,false, true, 0,"R_SPARC_DISP16", false,0,0x0000ffff,false),
+ HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,false, true, 0,"R_SPARC_DISP32", false,0,0x00ffffff,false),
+ HOWTO(R_SPARC_WDISP30,2,2,30,true, 0,false, true, 0,"R_SPARC_WDISP30",false,0,0x3fffffff,false),
+ HOWTO(R_SPARC_WDISP22,2,2,22,true, 0,false, true, 0,"R_SPARC_WDISP22",false,0,0x003fffff,false),
+ HOWTO(R_SPARC_HI22, 10,2,22,false,0,true, false, 0,"R_SPARC_HI22", false,0,0x003fffff,false),
+ HOWTO(R_SPARC_22, 0,2,22,false,0,true, true, 0,"R_SPARC_22", false,0,0x003fffff,false),
+ HOWTO(R_SPARC_13, 0,1,13,false,0,true, true, 0,"R_SPARC_13", false,0,0x00001fff,false),
+ HOWTO(R_SPARC_LO10, 0,1,10,false,0,true, false, 0,"R_SPARC_LO10", false,0,0x000003ff,false),
+ HOWTO(R_SPARC_GOT10, 0,1,10,false,0,false, true, 0,"R_SPARC_GOT10", false,0,0x000003ff,false),
+ HOWTO(R_SPARC_GOT13, 0,1,13,false,0,false, true, 0,"R_SPARC_GOT13", false,0,0x00001fff,false),
+ HOWTO(R_SPARC_GOT22, 10,2,22,false,0,false, true, 0,"R_SPARC_GOT22", false,0,0x003fffff,false),
+ HOWTO(R_SPARC_PC10, 0,1,10,false,0,true, true, 0,"R_SPARC_PC10", false,0,0x000003ff,false),
+ HOWTO(R_SPARC_PC22, 0,2,22,false,0,true, true, 0,"R_SPARC_PC22", false,0,0x003fffff,false),
+ HOWTO(R_SPARC_WPLT30, 0,0,00,false,0,false,false, 0,"R_SPARC_WPLT30", false,0,0x00000000,false),
+ HOWTO(R_SPARC_COPY, 0,0,00,false,0,false,false, 0,"R_SPARC_COPY", false,0,0x00000000,false),
+ HOWTO(R_SPARC_GLOB_DAT,0,0,00,false,0,false,false,0,"R_SPARC_GLOB_DAT",false,0,0x00000000,false),
+ HOWTO(R_SPARC_JMP_SLOT,0,0,00,false,0,false,false,0,"R_SPARC_JMP_SLOT",false,0,0x00000000,false),
+ HOWTO(R_SPARC_RELATIVE,0,0,00,false,0,false,false,0,"R_SPARC_RELATIVE",false,0,0x00000000,false),
+ HOWTO(R_SPARC_UA32, 0,0,00,false,0,false,false,0,"R_SPARC_UA32", false,0,0x00000000,false),
+};
+#endif
+
+static void
+DEFUN(elf_info_to_howto, (abfd, cache_ptr, dst),
+ bfd *abfd AND
+ arelent *cache_ptr AND
+ Elf_Internal_Rela *dst)
+{
+ /* FIXME!!! just doing sparc for now... */
+#ifdef sparc
+ BFD_ASSERT (ELF_R_TYPE(dst->r_info) < 24);
+
+ cache_ptr->howto = &elf_howto_table[ELF_R_TYPE(dst->r_info)];
+#else
+ fprintf (stderr, "elf_info_to_howto not implemented\n");
abort ();
- return (0);
+#endif
+}
+
+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
+ /* sparc, 68k, 88k, 860 use rela only. */
+ /* 386 and we32000 use rel only... fix it for them later. */
+ 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... */
+ cache_ptr->sym_ptr_ptr = symbols + ELF_R_SYM(dst.r_info);
+ cache_ptr->addend = dst.r_addend;
+
+ /* Fill in the cache_ptr->howto field from dst.r_type */
+ elf_info_to_howto(abfd, cache_ptr, &dst);
+#endif
+ }
+
+ asect->relocation = reloc_cache;
+ return true;
}
+
static unsigned int
elf_canonicalize_reloc (abfd, section, relptr, symbols)
bfd *abfd;
arelent **relptr;
asymbol **symbols;
{
- fprintf (stderr, "elf_canonicalize_reloc unimplemented\n");
- fflush (stderr);
- abort ();
- return (0);
+ arelent *tblptr = section->relocation;
+ unsigned int count = 0;
+
+ /* snarfed from coffcode.h */
+ /* FIXME: this could be reloc... */
+ elf_slurp_reloca_table(abfd, section, symbols);
+
+ tblptr = section->relocation;
+ if (!tblptr)
+ return 0;
+
+ for (; count++ < section->reloc_count;)
+ *relptr++ = tblptr++;
+
+ *relptr = 0;
+ return section->reloc_count;
}
static unsigned int
bfd *abfd AND
asymbol **alocation)
{
- unsigned int symcount;
- asymbol **vec;
- if (!elf_slurp_symbol_table (abfd))
- {
- return (0);
- }
+ if (!elf_slurp_symbol_table (abfd, alocation))
+ return (0);
else
- {
- symcount = bfd_get_symcount (abfd);
- vec = bfd_get_outsymbols (abfd);
- while (symcount-- > 0)
- {
- *alocation++ = *vec++;
- }
- *alocation++ = NULL;
- return (bfd_get_symcount (abfd));
- }
+ return (bfd_get_symcount (abfd));
}
static asymbol *
DEFUN (elf_make_empty_symbol, (abfd),
bfd *abfd)
{
- elf_symbol_type *new;
+ elf_symbol_type *newsym;
- new = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
- if (new == NULL)
+ newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
+ if (! newsym)
{
bfd_error = no_memory;
return (NULL);
}
else
{
- new -> symbol.the_bfd = abfd;
- return (&new -> symbol);
+ newsym -> symbol.the_bfd = abfd;
+ return (&newsym -> symbol);
}
}
asymbol *symbol AND
bfd_print_symbol_type how)
{
- fprintf (stderr, "elf_print_symbol unimplemented\n");
- fflush (stderr);
- abort ();
+ 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,
+ symbol->flags);
+ break;
+ case bfd_print_symbol_nm:
+ 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;
+ }
+
}
static alent *
enum bfd_architecture arch AND
unsigned long machine)
{
- fprintf (stderr, "elf_set_arch_mach unimplemented\n");
- fflush (stderr);
/* Allow any architecture to be supported by the elf backend */
- return bfd_default_set_arch_mach(abfd, arch, machine);
+ 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) */
+ return bfd_default_set_arch_mach(abfd, arch, machine);
+ default:
+ return false;
+ }
}
static boolean
abort ();
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;
+ void *contents;
+ if (abfd->output_has_begun == false) /* set by bfd.c handler? */
+ {
+ /* do setup calculations (FIXME) */
+ elf_compute_section_file_positions(abfd);
+ }
+#if 0
+ if(bfd_seek (abfd, (file_ptr)section->filepos + offset, SEEK_SET) == -1)
+ return false;
+ if(bfd_write (location, (bfd_size_type)1, count, abfd) != count)
+ return false;
+#endif
+ /* we really just need to save the contents away... */
+ dest_sect = elf_section_from_bfd_section(abfd, section);
+ if(!dest_sect)
+ return false;
+
+ /* FIXME: allocate in set_section_size, then copy in here... */
+ contents = (void*)bfd_alloc(abfd, count);
+ BFD_ASSERT(contents);
+ memcpy(contents, location, count);
+ elf_elfsections (abfd)[dest_sect].contents = contents;
+
+ return true;
+}
+
\f
/* This structure contains everything that BFD knows about a target.
It includes things like its byte order, name, what routines to call
/* Ordinary section reading and writing */
#define elf_new_section_hook _bfd_dummy_new_section_hook
-#define elf_get_section_contents bfd_generic_get_section_contents
-#define elf_set_section_contents bfd_generic_set_section_contents
+#define elf_get_section_contents bfd_generic_get_section_contents
+/* #define elf_set_section_contents bfd_generic_set_section_contents */
#define elf_close_and_cleanup bfd_generic_close_and_cleanup
#define elf_bfd_debug_info_start bfd_void
/* section_flags: mask of all section flags */
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_READONLY |
- SEC_DATA),
+ SEC_CODE | SEC_DATA),
+
+
+ /* leading_symbol_char: is the first char of a user symbol
+ predictable, and if so what is it */
+ 0,
/* ar_pad_char: pad character for filenames within an archive header
FIXME: this really has nothing to do with ELF, this is a characteristic
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_READONLY |
SEC_DATA),
+ /* leading_symbol_char: is the first char of a user symbol
+ predictable, and if so what is it */
+ 0,
+
/* ar_pad_char: pad character for filenames within an archive header
FIXME: this really has nothing to do with ELF, this is a characteristic
of the archiver and/or os and should be independently tunable */