/* elf.c
* This file is part of decomp - a disassembler. Here are the routines
* for manipulating ELF32/64 files.
*
* Copyright (C) 2002 Jonathan duSaint <dusaint@earthlink.net>
*
* Started on 30 January 2002.
*/
#include <stdio.h>
#include <string.h>
#include <elf.h>
#include "decomp.h"
/* give these forward references */
int elf_unneeded_section (const char *name);
char *elf_get_flags (unsigned long flags);
enum symbol_type elf_get_symbol_type (struct file_info *fi,unsigned char info);
/* I finally found a problem with C - the lack of dynamic types forces
me to separate elf32/elf64 handling into two virtually identical
largish functions. Of course, that sort of thing would cause a lot
of bloat in the language itself, so I guess I'll live. */
/* ELF32 section */
/* elf32_read_file_header
* Reads the ELF32 file header in the file pointed to by FP and
* populates FILE_HEADER with the information.
*/
void
elf32_read_file_header (Elf32_Ehdr *file_header, FILE *fp)
{
d_read (file_header->e_ident, sizeof (char), EI_NIDENT, fp, 1);
d_read (&file_header->e_type, sizeof (Elf32_Half), 1, fp, 0);
d_read (&file_header->e_machine, sizeof (Elf32_Half), 1, fp, 0);
d_read (&file_header->e_version, sizeof (Elf32_Word), 1, fp, 0);
d_read (&file_header->e_entry, sizeof (Elf32_Addr), 1, fp, 0);
d_read (&file_header->e_phoff, sizeof (Elf32_Off), 1, fp, 0);
d_read (&file_header->e_shoff, sizeof (Elf32_Off), 1, fp, 0);
d_read (&file_header->e_flags, sizeof (Elf32_Word), 1, fp, 0);
d_read (&file_header->e_ehsize, sizeof (Elf32_Half), 1, fp, 0);
d_read (&file_header->e_phentsize, sizeof (Elf32_Half), 1, fp, 0);
d_read (&file_header->e_phnum, sizeof (Elf32_Half), 1, fp, 0);
d_read (&file_header->e_shentsize, sizeof (Elf32_Half), 1, fp, 0);
d_read (&file_header->e_shnum, sizeof (Elf32_Half), 1, fp, 0);
d_read (&file_header->e_shstrndx, sizeof (Elf32_Half), 1, fp, 0);
}
/* elf32_read_section_header
* Reads and ELF32 section header which is pointed to by FP and
* uses the information to populate SH.
*/
void
elf32_read_section_header (Elf32_Shdr *sh, FILE *fp)
{
d_read (&sh->sh_name, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sh->sh_type, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sh->sh_flags, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sh->sh_addr, sizeof (Elf32_Addr), 1, fp, 0);
d_read (&sh->sh_offset, sizeof (Elf32_Off), 1, fp, 0);
d_read (&sh->sh_size, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sh->sh_link, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sh->sh_info, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sh->sh_addralign, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sh->sh_entsize, sizeof (Elf32_Word), 1, fp, 0);
}
/* elf32_get_file_info
* Get the information from an ELF32 file and populate FI with the
* information.
*/
void
elf32_get_file_info (struct file_info *fi)
{
int k, n_data = 0, n_code = 0;
char *shstrtab;
Elf32_Ehdr fh;
Elf32_Shdr sh;
elf32_read_file_header (&fh, fi->fp);
fi->bit_size = BS_32;
fi->load_address = fh.e_entry;
fi->endian = ((fh.e_ident[EI_DATA] == ELFDATA2LSB)
? BO_LITTLE_ENDIAN
: BO_BIG_ENDIAN);
/* do some sanity checks on the header */
if (strncmp (fh.e_ident, ELFMAG, SELFMAG) /* magic - \x7fELF */
|| (fh.e_ident[EI_VERSION] != EV_CURRENT) /* current version */
|| (fh.e_type != ET_REL /* object file */
&& fh.e_type != ET_EXEC /* or executable */
&& fh.e_type != ET_DYN) /* or library */
|| (fh.e_version != EV_CURRENT)) /* current version */
error_out (ERR_INVALID_FILE);
/* only handle IA-32 for now... */
if (fh.e_machine == EM_386)
fi->arch = MT_IA32;
else
fi->arch = MT_UNK;
/* read the section header string table index */
fseek (fi->fp, fh.e_shoff + fh.e_shstrndx * fh.e_shentsize, SEEK_SET);
elf32_read_section_header (&sh, fi->fp);
shstrtab = xmalloc (sh.sh_size);
fseek (fi->fp, sh.sh_offset, SEEK_SET);
/* and then read the section header string table */
fread (shstrtab, sizeof (char), sh.sh_size, fi->fp);
/* read the sections and put them in their proper places */
fi->data_sections = xmalloc ((fh.e_shnum + 1)
* sizeof (struct section_info *));
fi->code_sections = xmalloc ((fh.e_shnum + 1)
* sizeof (struct section_info *));
/* position at start of section headers */
fseek (fi->fp, fh.e_shoff, SEEK_SET);
for (k = 0; k < fh.e_shnum; k++)
{
char *section_name = NULL;
/* read the header */
elf32_read_section_header (&sh, fi->fp);
/* find the name */
section_name = xmalloc (strlen (shstrtab + sh.sh_name) + 1);
strcpy (section_name, shstrtab + sh.sh_name);
if (debug)
printf ("read %s, idx %#x, offset %#x\n", section_name, k,
sh.sh_offset);
/* parse the header into the proper place */
switch (sh.sh_type)
{
case SHT_PROGBITS:
if (sh.sh_flags & SHF_EXECINSTR) /* code section */
{
if (elf_unneeded_section (section_name))
{
xfree (section_name);
continue;
}
fi->code_sections[n_code] = alloc_section_info (section_name,
CODE_SECTION,
sh.sh_offset,
sh.sh_size, 0, k,
sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
put_data_limits (sh.sh_addr, sh.sh_addr + sh.sh_size);
n_code++;
}
else /* data section */
{
if (elf_unneeded_section (section_name))
{
xfree (section_name);
continue;
}
fi->data_sections[n_data] = alloc_section_info (section_name,
DATA_SECTION,
sh.sh_offset,
sh.sh_size, 0, k,
sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
put_data_limits (sh.sh_addr, sh.sh_addr + sh.sh_size);
n_data++;
}
break;
case SHT_SYMTAB: /* symbol table */
fi->symtab = alloc_section_info (section_name, OTHER_SECTION,
sh.sh_offset, sh.sh_size,
sh.sh_entsize, k, sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
break;
case SHT_STRTAB: /* string table */
if (elf_unneeded_section (section_name))
{
xfree (section_name);
continue;
}
if (!strcmp (section_name, ".strtab")) /* the string table */
{
fi->strtab = alloc_section_info (section_name, STRING_SECTION,
sh.sh_offset, sh.sh_size, 0, k,
sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
}
else /* another table with strings (??) */
{
fi->data_sections[n_data] = alloc_section_info (section_name,
STRING_SECTION,
sh.sh_offset,
sh.sh_size, 0, k,
sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
put_data_limits (sh.sh_addr, sh.sh_addr + sh.sh_size);
n_data++;
}
break;
/*
I don't think that these two are needed, but they're here
as a reminder, just in case.
case SHT_RELA:
case SHT_HASH:
*/
default:
xfree (section_name);
continue;
}
}
xfree (shstrtab);
}
/* elf32_read_symbol
* Read an Elf32_Sym and store it into SYM.
*/
void
elf32_read_symbol (Elf32_Sym *sym, FILE *fp)
{
d_read (&sym->st_name, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sym->st_value, sizeof (Elf32_Addr), 1, fp, 0);
d_read (&sym->st_size, sizeof (Elf32_Word), 1, fp, 0);
d_read (&sym->st_info, sizeof (unsigned char), 1, fp, 0);
d_read (&sym->st_other, sizeof (unsigned char), 1, fp, 0);
d_read (&sym->st_shndx, sizeof (Elf32_Section), 1, fp, 0);
}
/* elf_32_get_next_symbol
* Read the next symbol from the object file and return it as a struct symtab.
*/
struct symtab *
elf32_get_next_symbol (struct file_info *fi, char *strtab)
{
unsigned long unnamed_index = 0;
char *tmp;
struct symtab *sym;
Elf32_Sym symbol;
elf32_read_symbol (&symbol, fi->fp);
/* ignore symbols with no section */
/* if (symbol.st_shndx == 0xfff1) continue; */
/* ignore unknown symbol types */
/*if (get_symbol_type (symbol.st_info) == UNKNOWN_SYMBOL) continue;*/
/* ignore null-named symbols */
/*if (!strlen (strtab + symbol.st_name)) continue;*/
/* if this symbol references a section or a file, ignore */
if (ELF32_ST_TYPE (symbol.st_info) == STT_SECTION
|| ELF32_ST_TYPE (symbol.st_info) == STT_FILE) return NULL;
if (symbol.st_value == 0) return NULL;
sym = xmalloc (sizeof (struct symtab));
/* if a symbol has no name, make up a (sorta) random name */
if (!strlen (strtab + symbol.st_name))
{
char *tmp_name;
tmp_name = xmalloc (16);
snprintf (tmp_name, 16, "sym_%ld", unnamed_index++);
sym->name = xmalloc (strlen (tmp_name) + 1);
strcpy (sym->name, tmp_name);
xfree (tmp_name);
}
else /* symbol has a name */
{
sym->name = xmalloc (strlen (strtab + symbol.st_name) + 1);
strcpy (sym->name, strtab + symbol.st_name);
}
sym->address = symbol.st_value;
sym->size = symbol.st_size;
sym->idx = symbol.st_shndx;
sym->type = elf_get_symbol_type (fi, symbol.st_info);
if (debug)
printf ("%#lx:%s: size %#lx, info %#02x, other %#02x, idx %#x\n",
(unsigned long)symbol.st_value, sym->name,
(unsigned long)symbol.st_size, symbol.st_info,
symbol.st_other, symbol.st_shndx);
/* if (debug) */
/* printf ("%s: %#lx, %#lx, %#lx, %d\n", sym->name, sym->address, */
/* sym->size, sym->section_index, sym->type); */
/* check for @@foo at the end of a symbol - if it is there, strip it */
if ((tmp = strchr (sym->name, '@')) != NULL) *tmp = '\0';
return sym;
}
/* ELF64 section */
/* elf64_read_file_header
* Reads the ELF64 file header in the file pointed to by FP and
* populates FILE_HEADER with the information.
*/
void
elf64_read_file_header (Elf64_Ehdr *file_header, FILE *fp)
{
d_read (file_header->e_ident, sizeof (char), EI_NIDENT, fp, 1);
d_read (&file_header->e_type, sizeof (Elf64_Half), 1, fp, 0);
d_read (&file_header->e_machine, sizeof (Elf64_Half), 1, fp, 0);
d_read (&file_header->e_version, sizeof (Elf64_Word), 1, fp, 0);
d_read (&file_header->e_entry, sizeof (Elf64_Addr), 1, fp, 0);
d_read (&file_header->e_phoff, sizeof (Elf64_Off), 1, fp, 0);
d_read (&file_header->e_shoff, sizeof (Elf64_Off), 1, fp, 0);
d_read (&file_header->e_flags, sizeof (Elf64_Word), 1, fp, 0);
d_read (&file_header->e_ehsize, sizeof (Elf64_Half), 1, fp, 0);
d_read (&file_header->e_phentsize, sizeof (Elf64_Half), 1, fp, 0);
d_read (&file_header->e_phnum, sizeof (Elf64_Half), 1, fp, 0);
d_read (&file_header->e_shentsize, sizeof (Elf64_Half), 1, fp, 0);
d_read (&file_header->e_shnum, sizeof (Elf64_Half), 1, fp, 0);
d_read (&file_header->e_shstrndx, sizeof (Elf64_Half), 1, fp, 0);
}
/* elf64_read_section_header
* Reads and ELF64 section header which is pointed to by FP and
* uses the information to populate SH.
*/
void
elf64_read_section_header (Elf64_Shdr *sh, FILE *fp)
{
d_read (&sh->sh_name, sizeof (Elf64_Word), 1, fp, 0);
d_read (&sh->sh_type, sizeof (Elf64_Word), 1, fp, 0);
d_read (&sh->sh_flags, sizeof (Elf64_Xword), 1, fp, 0);
d_read (&sh->sh_addr, sizeof (Elf64_Addr), 1, fp, 0);
d_read (&sh->sh_offset, sizeof (Elf64_Off), 1, fp, 0);
d_read (&sh->sh_size, sizeof (Elf64_Xword), 1, fp, 0);
d_read (&sh->sh_link, sizeof (Elf64_Word), 1, fp, 0);
d_read (&sh->sh_info, sizeof (Elf64_Word), 1, fp, 0);
d_read (&sh->sh_addralign, sizeof (Elf64_Xword), 1, fp, 0);
d_read (&sh->sh_entsize, sizeof (Elf64_Xword), 1, fp, 0);
}
/* elf64_get_file_info
* Get the information from an ELF64 file and populate FI with the
* information.
*/
void
elf64_get_file_info (struct file_info *fi)
{
int k, n_data = 0, n_code = 0;
char *shstrtab;
Elf64_Ehdr fh;
Elf64_Shdr sh;
elf64_read_file_header (&fh, fi->fp);
fi->bit_size = BS_64;
fi->load_address = fh.e_entry;
fi->endian = ((fh.e_ident[EI_DATA] == ELFDATA2LSB)
? BO_LITTLE_ENDIAN
: BO_BIG_ENDIAN);
/* do some sanity checks on the header */
if (strncmp (fh.e_ident, ELFMAG, SELFMAG) /* magic - \x7fELF */
|| (fh.e_ident[EI_VERSION] != EV_CURRENT) /* current version */
|| (fh.e_type != ET_REL /* object file */
&& fh.e_type != ET_EXEC /* or executable */
&& fh.e_type != ET_DYN) /* or library */
|| (fh.e_version != EV_CURRENT)) /* current version */
error_out (ERR_INVALID_FILE);
/* only handle IA-32 for now... */
switch (fh.e_machine)
{
case EM_386:
fi->arch = MT_IA32;
break;
default:
fi->arch = MT_UNK;
}
/* read the section header string table index */
fseek (fi->fp, fh.e_shoff + fh.e_shstrndx * fh.e_shentsize, SEEK_SET);
elf64_read_section_header (&sh, fi->fp);
shstrtab = xmalloc (sh.sh_size);
fseek (fi->fp, sh.sh_offset, SEEK_SET);
/* and then read the section header string table */
fread (shstrtab, sizeof (char), sh.sh_size, fi->fp);
/* read the sections and put them in their proper places */
fi->data_sections = xmalloc ((fh.e_shnum + 1)
* sizeof (struct section_info *));
fi->code_sections = xmalloc ((fh.e_shnum + 1)
* sizeof (struct section_info *));
/* position at start of section headers */
fseek (fi->fp, fh.e_shoff, SEEK_SET);
for (k = 0; k < fh.e_shnum; k++)
{
char *section_name = NULL;
/* read the header */
elf64_read_section_header (&sh, fi->fp);
/* find the name */
section_name = xmalloc (strlen (shstrtab + sh.sh_name) + 1);
strcpy (section_name, shstrtab + sh.sh_name);
if (debug)
printf ("read %s, idx %#x, offset %#llx\n", section_name, k,
sh.sh_offset);
/* parse the header into the proper place */
switch (sh.sh_type)
{
case SHT_PROGBITS:
if (sh.sh_flags & SHF_EXECINSTR) /* code section */
{
if (elf_unneeded_section (section_name))
{
xfree (section_name);
continue;
}
fi->code_sections[n_code] = alloc_section_info (section_name,
CODE_SECTION,
sh.sh_offset,
sh.sh_size, 0, k,
sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
put_data_limits (sh.sh_addr, sh.sh_addr + sh.sh_size);
n_code++;
}
else /* data section */
{
if (elf_unneeded_section (section_name))
{
xfree (section_name);
continue;
}
fi->data_sections[n_data] = alloc_section_info (section_name,
DATA_SECTION,
sh.sh_offset,
sh.sh_size, 0, k,
sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
put_data_limits (sh.sh_addr, sh.sh_addr + sh.sh_size);
n_data++;
}
break;
case SHT_SYMTAB: /* symbol table */
fi->symtab = alloc_section_info (section_name, OTHER_SECTION,
sh.sh_offset, sh.sh_size,
sh.sh_entsize, k, sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
break;
case SHT_STRTAB: /* string table */
if (elf_unneeded_section (section_name))
{
xfree (section_name);
continue;
}
if (!strcmp (section_name, ".strtab")) /* the string table */
{
fi->strtab = alloc_section_info (section_name, STRING_SECTION,
sh.sh_offset, sh.sh_size, 0, k,
sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
}
else /* another table with strings (??) */
{
fi->data_sections[n_data] = alloc_section_info (section_name,
STRING_SECTION,
sh.sh_offset,
sh.sh_size, 0, k,
sh.sh_addr, NULL,
elf_get_flags (sh.sh_flags),
sh.sh_addralign);
put_data_limits (sh.sh_addr, sh.sh_addr + sh.sh_size);
n_data++;
}
break;
/*
I don't think that these two are needed, but they're here
as a reminder, just in case.
case SHT_RELA:
case SHT_HASH:
*/
default:
xfree (section_name);
continue;
}
}
xfree (shstrtab);
}
/* elf64_read_symbol
* Read an Elf64_Sym and store it into SYM.
*/
void
elf64_read_symbol (Elf64_Sym *sym, FILE *fp)
{
d_read (&sym->st_name, sizeof (Elf64_Word), 1, fp, 0);
d_read (&sym->st_info, sizeof (unsigned char), 1, fp, 0);
d_read (&sym->st_other, sizeof (unsigned char), 1, fp, 0);
d_read (&sym->st_shndx, sizeof (Elf64_Section), 1, fp, 0);
d_read (&sym->st_value, sizeof (Elf64_Addr), 1, fp, 0);
d_read (&sym->st_size, sizeof (Elf64_Xword), 1, fp, 0);
}
/* elf64_get_next_symbol
* Read the next symbol from the object file and return it as a struct symtab.
*/
struct symtab *
elf64_get_next_symbol (struct file_info *fi, char *strtab)
{
unsigned long unnamed_index = 0;
char *tmp;
struct symtab *sym;
Elf64_Sym symbol;
elf64_read_symbol (&symbol, fi->fp);
/* ignore symbols with no section */
/* if (symbol.st_shndx == 0xfff1) continue; */
/* ignore unknown symbol types */
/*if (get_symbol_type (symbol.st_info) == UNKNOWN_SYMBOL) continue;*/
/* ignore null-named symbols */
/*if (!strlen (strtab + symbol.st_name)) continue;*/
/* if this symbol references a section or a file, ignore */
if (ELF64_ST_TYPE (symbol.st_info) == STT_SECTION
|| ELF64_ST_TYPE (symbol.st_info) == STT_FILE) return NULL;
if (symbol.st_value == 0) return NULL;
sym = xmalloc (sizeof (struct symtab));
/* if a symbol has no name, make up a (sorta) random name */
if (!strlen (strtab + symbol.st_name))
{
char *tmp_name;
tmp_name = xmalloc (16);
snprintf (tmp_name, 16, "sym_%ld", unnamed_index++);
sym->name = xmalloc (strlen (tmp_name) + 1);
strcpy (sym->name, tmp_name);
xfree (tmp_name);
}
else /* symbol has a name */
{
sym->name = xmalloc (strlen (strtab + symbol.st_name) + 1);
strcpy (sym->name, strtab + symbol.st_name);
}
sym->address = symbol.st_value;
sym->size = symbol.st_size;
sym->idx = symbol.st_shndx;
sym->type = elf_get_symbol_type (fi, symbol.st_info);
if (debug)
printf ("%#lx:%s: size %#lx, info %#02x, other %#02x, idx %#x\n",
(unsigned long)symbol.st_value, sym->name,
(unsigned long)symbol.st_size, symbol.st_info,
symbol.st_other, symbol.st_shndx);
/* if (debug) */
/* printf ("%s: %#lx, %#lx, %#lx, %d\n", sym->name, sym->address, */
/* sym->size, sym->section_index, sym->type); */
/* check for @@foo at the end of a symbol - if it is there, strip it */
if ((tmp = strchr (sym->name, '@')) != NULL) *tmp = '\0';
return sym;
}
/* Generic ELF section */
/* elf_unneeded_section
* If NAME matches one of the names of the unneeded data sections,
* then 1 is returned, otherwise 0 is returned.
*/
int
elf_unneeded_section (const char *name)
{
int k = -1;
char *unneeded[] = { ".interp", ".plt", ".stab", ".comment", ".sbss",
".shstrtab", ".stabstr", ".got", ".dtors", ".dynstr",
".ctors", ".eh_frame", NULL };
while (unneeded[++k] != NULL) if (!strcmp (name, unneeded[k])) return 1;
if (!strncmp (name, ".debug", 6)) return 1;
return 0;
}
char *flag_str_array[] = {
"", /* no flags */
", \"w\"", /* writeable */
", \"a\"", /* occupies memory during execution */
", \"aw\"", /* writeable and occupies memory during execution */
", \"x\"", /* executable */
", \"xw\"", /* executable and writeable */
", \"xa\"", /* executable and occupies memory during execution */
", \"xaw\"", /* executable, occupies memory during execution and writeable */
};
/* elf_get_flags
* Translate the flags from the section header into textual flags that the
* assembler will understand.
*/
char *
elf_get_flags (unsigned long flags)
{
int index;
index = (flags & SHF_WRITE) + (flags & SHF_ALLOC) + (flags & SHF_EXECINSTR);
if (index > 7) index = 0;
return flag_str_array[index];
}
/* elf_get_file_info
* Get the information from the object file and populate FI.
*/
void
elf_get_file_info (struct file_info *fi)
{
int k;
char ident_buffer[EI_NIDENT];
fi->symtab = NULL;
fi->strtab = NULL;
/* read in the first EI_NIDENT chars in to find out if this is ELF32
or ELF64 */
fseek (fi->fp, 0, SEEK_SET);
fread (ident_buffer, sizeof (char), EI_NIDENT, fi->fp);
/* reset the file pointer */
fseek (fi->fp, 0, SEEK_SET);
/* find the target byte order */
if (ident_buffer[EI_DATA] == ELFDATA2LSB) /* little endian */
target_endian = BO_LITTLE_ENDIAN;
else /* big endian */
target_endian = BO_BIG_ENDIAN;
if (ident_buffer[EI_CLASS] == ELFCLASS32)
elf32_get_file_info (fi);
else
elf64_get_file_info (fi);
/* print debug info */
if (debug)
{
k = -1;
printf ("data:\n");
while (fi->data_sections[++k])
{
printf (" %s (%#lx), %d, %#lx, %#lx, %#lx\n",
fi->data_sections[k]->section_name,
fi->data_sections[k]->section_index,
fi->data_sections[k]->section_type,
fi->data_sections[k]->section_offset,
fi->data_sections[k]->section_size,
fi->data_sections[k]->load_address);
}
k = -1;
printf ("code:\n");
while (fi->code_sections[++k])
{
printf (" %s (%#lx), %d, %#lx, %#lx, %#lx\n",
fi->code_sections[k]->section_name,
fi->code_sections[k]->section_index,
fi->code_sections[k]->section_type,
fi->code_sections[k]->section_offset,
fi->code_sections[k]->section_size,
fi->code_sections[k]->load_address);
}
if (fi->symtab != NULL)
printf ("symtab:\n %s (%#lx), %d, %#lx, %#lx, %#lx\n",
fi->symtab->section_name,
fi->symtab->section_index,
fi->symtab->section_type,
fi->symtab->section_offset,
fi->symtab->section_size,
fi->symtab->load_address);
if (fi->strtab != NULL)
printf ("strtab:\n %s (%#lx), %d, %#lx, %#lx, %#lx\n",
fi->strtab->section_name,
fi->strtab->section_index,
fi->strtab->section_type,
fi->strtab->section_offset,
fi->strtab->section_size,
fi->strtab->load_address);
}
}
/* elf_read_strtab
* Read the string table from the object file.
*/
char *
elf_read_strtab (struct file_info *fi)
{
char *strtab;
if (fi->strtab == NULL) return (NULL);
fseek (fi->fp, fi->strtab->section_offset, SEEK_SET);
strtab = xmalloc (fi->strtab->section_size);
d_read (strtab, sizeof (char), fi->strtab->section_size, fi->fp, 1);
return strtab;
}
/* elf_get_symbol_type
* Translate a symbol's type into the internal format.
*/
enum symbol_type
elf_get_symbol_type (struct file_info *fi, unsigned char info)
{
unsigned char bind, type;
enum symbol_type stype = UNKNOWN_SYMBOL;
if (fi->bit_size == BS_32)
{
bind = ELF32_ST_BIND (info);
type = ELF32_ST_TYPE (info);
}
else
{
bind = ELF64_ST_BIND (info);
type = ELF64_ST_TYPE (info);
}
if (bind == STB_LOCAL && type == STT_OBJECT)
stype = LOCAL_DATA;
else if (bind == STB_LOCAL && type == STT_FUNC)
stype = LOCAL_FUNCTION;
else if (bind == STB_GLOBAL && type == STT_OBJECT)
stype = GLOBAL_DATA;
else if (bind == STB_GLOBAL && type == STT_FUNC)
stype = GLOBAL_FUNCTION;
else if (bind == STB_GLOBAL)
stype = GLOBAL_UNKNOWN;
else if (bind == STB_LOCAL)
stype = LOCAL_UNKNOWN;
else if (type == STT_OBJECT)
stype = UNKNOWN_DATA;
else if (type == STT_FUNC)
stype = UNKNOWN_FUNCTION;
else
stype = UNKNOWN_SYMBOL;
return (stype);
}
/* elf_get_next_symbol
* Read the next symbol from the object file and return it as a struct symtab.
*/
struct symtab *
elf_get_next_symbol (struct file_info *fi, char *strtab)
{
if (fi->bit_size == BS_32)
return elf32_get_next_symbol (fi, strtab);
else
return elf64_get_next_symbol (fi, strtab);
}
