/* Unifies the basic duplicate/empty testing and section
data setting to one place. */
static int
get_basic_section_data(Dwarf_Debug dbg,
struct Dwarf_Section_s *secdata,
struct Dwarf_Obj_Access_Section_s *doas,
Dwarf_Half section_index,
Dwarf_Error* error,
int duperr, int emptyerr )
{
/* There is an elf convention that section index 0 is reserved,
and that section is always empty.
Non-elf object formats must honor that by ensuring that
(when they assign numbers to 'sections' or 'section-like-things')
they never assign a real section section-number 0 to dss_index. */
if (secdata->dss_index != 0) {
DWARF_DBG_ERROR(dbg, duperr, DW_DLV_ERROR);
}
if (doas->size == 0) {
if (emptyerr == 0 ) {
/* Allow empty section. */
return DW_DLV_OK;
}
/* Know no reason to allow section */
DWARF_DBG_ERROR(dbg, emptyerr, DW_DLV_ERROR);
}
secdata->dss_index = section_index;
secdata->dss_size = doas->size;
secdata->dss_addr = doas->addr;
secdata->dss_link = doas->link;
secdata->dss_entrysize = doas->entrysize;
return DW_DLV_OK;
}
/*
The alternate dwarf setup call for consumers
*/
int
dwarf_elf_init(dwarf_elf_handle elf_file_pointer,
Dwarf_Unsigned access,
Dwarf_Handler errhand,
Dwarf_Ptr errarg,
Dwarf_Debug * ret_dbg, Dwarf_Error * error)
{
Dwarf_Debug dbg;
int res;
dbg = _dwarf_get_debug();
if (dbg == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
}
dbg->de_errhand = errhand;
dbg->de_errarg = errarg;
if (access != DW_DLC_READ) {
DWARF_DBG_ERROR(dbg, DW_DLE_INIT_ACCESS_WRONG, DW_DLV_ERROR);
}
dbg->de_access = access;
dbg->de_elf_must_close = 0;
if ((res = _dwarf_setup(dbg, elf_file_pointer, error)) != DW_DLV_OK) {
free(dbg);
return (res);
}
/* this call cannot fail: allocates nothing, releases nothing */
_dwarf_setup_debug(dbg);
*ret_dbg = dbg;
return (DW_DLV_OK);
}
/*
Use a Dwarf_Obj_Access_Interface to kick things off. All other
init routines eventually use this one.
The returned Dwarf_Debug contains a copy of *obj
the callers copy of *obj may be freed whenever the caller
wishes.
*/
int
dwarf_object_init(Dwarf_Obj_Access_Interface* obj, Dwarf_Handler errhand,
Dwarf_Ptr errarg, Dwarf_Debug* ret_dbg,
Dwarf_Error* error)
{
Dwarf_Debug dbg = 0;
int setup_result = DW_DLV_OK;
dbg = _dwarf_get_debug();
if (dbg == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
}
dbg->de_errhand = errhand;
dbg->de_errarg = errarg;
dbg->de_frame_rule_initial_value = DW_FRAME_REG_INITIAL_VALUE;
dbg->de_frame_reg_rules_entry_count = DW_FRAME_LAST_REG_NUM;
#ifdef HAVE_OLD_FRAME_CFA_COL
/* DW_FRAME_CFA_COL is really only suitable for old libdwarf frame
interfaces and its value of 0 there is only usable where
(as in MIPS) register 0 has no value other than 0 so
we can use the frame table column 0 for the CFA value
(and rely on client software to know when 'register 0'
is the cfa and when to just use a value 0 for register 0).
*/
dbg->de_frame_cfa_col_number = DW_FRAME_CFA_COL;
#else
dbg->de_frame_cfa_col_number = DW_FRAME_CFA_COL3;
#endif
dbg->de_frame_same_value_number = DW_FRAME_SAME_VAL;
dbg->de_frame_undefined_value_number = DW_FRAME_UNDEFINED_VAL;
dbg->de_obj_file = obj;
setup_result = _dwarf_setup(dbg, error);
if (setup_result != DW_DLV_OK) {
/* The status we want to return here is of _dwarf_setup,
not of the _dwarf_free_all_of_one_debug(dbg) call.
So use a local status variable for the free. */
int freeresult = _dwarf_free_all_of_one_debug(dbg);
if (freeresult == DW_DLV_ERROR) {
DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
}
dwarf_malloc_check_complete("After Final free");
return setup_result;
}
dwarf_harmless_init(&dbg->de_harmless_errors,
DW_HARMLESS_ERROR_CIRCULAR_LIST_DEFAULT_SIZE);
/* This call cannot fail: allocates nothing, releases nothing */
_dwarf_setup_debug(dbg);
*ret_dbg = dbg;
return DW_DLV_OK;
}
/* Given a section index, get its size and address */
int
dwarf_get_section_info_by_index(Dwarf_Debug dbg,
int section_index,
const char **section_name,
Dwarf_Addr *section_addr,
Dwarf_Unsigned *section_size,
Dwarf_Error * error)
{
*section_addr = 0;
*section_size = 0;
*section_name = NULL;
/* Check if we have a valid section index */
if (section_index >= 0 && section_index < dwarf_get_section_count(dbg)) {
int res = 0;
int err = 0;
struct Dwarf_Obj_Access_Section_s doas;
struct Dwarf_Obj_Access_Interface_s * obj = dbg->de_obj_file;
if (NULL == obj) {
return DW_DLV_NO_ENTRY;
}
res = obj->methods->get_section_info(obj->object,
section_index, &doas, &err);
if (res == DW_DLV_ERROR){
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
*section_addr = doas.addr;
*section_size = doas.size;
*section_name = doas.name;
return DW_DLV_OK;
}
return DW_DLV_NO_ENTRY;
}
/*
Frees all memory that was not previously freed
by dwarf_dealloc.
Aside from certain categories.
*/
int
dwarf_finish(Dwarf_Debug dbg, Dwarf_Error * error)
{
int res = DW_DLV_OK;
if (dbg->de_elf_must_close) {
/* Must do this *before* _dwarf_free_all_of_one_debug() as that
zeroes out dbg contents */
#ifdef __SGI_FAST_LIBELF
elf_sgi_free(dbg->de_elf);
#else
elf_end(dbg->de_elf);
#endif
}
res = _dwarf_free_all_of_one_debug(dbg);
if (res == DW_DLV_ERROR) {
DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
}
dwarf_malloc_check_complete("After Final free");
return res;
}
/* A finish routine that is completely unaware of ELF.
Frees all memory that was not previously freed by
dwarf_dealloc.
Aside frmo certain categories. */
int
dwarf_object_finish(Dwarf_Debug dbg, Dwarf_Error * error)
{
int res = _dwarf_free_all_of_one_debug(dbg);
if (res == DW_DLV_ERROR) {
DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
}
return res;
}
/*
Load the ELF section with the specified index and set the
pointer pointed to by section_data to the memory where it
was loaded.
*/
int
_dwarf_load_section(Dwarf_Debug dbg,
Dwarf_Half section_index,
Dwarf_Small ** section_data,
Dwarf_Error * error)
{
if (section_index == 0) {
return DW_DLV_NO_ENTRY;
}
/* check to see if the section is already loaded */
if (*section_data != NULL) {
return DW_DLV_OK;
}
{
#ifdef __SGI_FAST_LIBELF
enum elf_sgi_error_type sres;
sres = elf_sgi_section(dbg->de_elf,
section_index,
(void**) section_data);
if (sres != ELF_SGI_ERROR_OK) {
DWARF_DBG_ERROR(dbg, _dwarf_error_code_from_elf_sgi_error_code(sres),
DW_DLV_ERROR);
}
#else
Elf_Scn* scn;
Elf_Data* data;
scn = elf_getscn(dbg->de_elf, section_index);
if (scn == NULL) {
_dwarf_error(dbg, error, DW_DLE_MDE);
return DW_DLV_ERROR;
}
/*
When using libelf as a producer, section data may be stored
in multiple buffers. In libdwarf however, we only use libelf
as a consumer (there is a dwarf producer API, but it doesn't
use libelf). Because of this, this single call to elf_getdata
will retrieve the entire section in a single contiguous buffer.
*/
data = elf_getdata(scn, NULL);
if (data == NULL) {
_dwarf_error(dbg, error, DW_DLE_MDE);
return DW_DLV_ERROR;
}
*section_data = data->d_buf;
#endif /* !defined(__SGI_FAST_LIBELF) */
}
return DW_DLV_OK;
}
/* Load the ELF section with the specified index and set its
dss_data pointer to the memory where it was loaded. */
int
_dwarf_load_section(Dwarf_Debug dbg,
struct Dwarf_Section_s *section,
Dwarf_Error * error)
{
int res = DW_DLV_ERROR;
int err = 0;
struct Dwarf_Obj_Access_Interface_s *o = 0;
/* check to see if the section is already loaded */
if (section->dss_data != NULL) {
return DW_DLV_OK;
}
o = dbg->de_obj_file;
/* There is an elf convention that section index 0 is reserved,
and that section is always empty.
Non-elf object formats must honor that by ensuring that
(when they assign numbers to 'sections' or 'section-like-things')
they never assign a real section section-number 0 to dss_index. */
res = o->methods->load_section(
o->object, section->dss_index,
§ion->dss_data, &err);
if (res == DW_DLV_ERROR){
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
if (_dwarf_apply_relocs == 0) {
return res;
}
if (section->dss_reloc_size == 0) {
return res;
}
if (!o->methods->relocate_a_section) {
return res;
}
/*apply relocations */
res = o->methods->relocate_a_section( o->object, section->dss_index,
dbg, &err);
if (res == DW_DLV_ERROR) {
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
return res;
}
/* The basic dwarf initializer function for consumers using
libelf.
Return a libdwarf error code on error, return DW_DLV_OK
if this succeeds. */
int
dwarf_init(int fd,
Dwarf_Unsigned access,
Dwarf_Handler errhand,
Dwarf_Ptr errarg, Dwarf_Debug * ret_dbg, Dwarf_Error * error)
{
struct stat fstat_buf;
dwarf_elf_handle elf_file_pointer = 0;
/* ELF_C_READ is a portable value */
Elf_Cmd what_kind_of_elf_read = ELF_C_READ;
#if !defined(S_ISREG)
#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
#endif
if (fstat(fd, &fstat_buf) != 0) {
DWARF_DBG_ERROR(NULL, DW_DLE_FSTAT_ERROR, DW_DLV_ERROR);
}
if (!S_ISREG(fstat_buf.st_mode)) {
DWARF_DBG_ERROR(NULL, DW_DLE_FSTAT_MODE_ERROR, DW_DLV_ERROR);
}
if (access != DW_DLC_READ) {
DWARF_DBG_ERROR(NULL, DW_DLE_INIT_ACCESS_WRONG, DW_DLV_ERROR);
}
elf_version(EV_CURRENT);
/* Changed to mmap request per bug 281217. 6/95 */
#ifdef HAVE_ELF_C_READ_MMAP
/* ELF_C_READ_MMAP is an SGI IRIX specific enum value from IRIX
libelf.h meaning read but use mmap */
what_kind_of_elf_read = ELF_C_READ_MMAP;
#endif /* !HAVE_ELF_C_READ_MMAP */
elf_file_pointer = elf_begin(fd, what_kind_of_elf_read, 0);
if (elf_file_pointer == NULL) {
DWARF_DBG_ERROR(NULL, DW_DLE_ELF_BEGIN_ERROR, DW_DLV_ERROR);
}
return dwarf_elf_init_file_ownership(elf_file_pointer,
TRUE, access, errhand, errarg, ret_dbg, error);
}
/* A finish routine that is completely unaware of ELF.
Frees all memory that was not previously freed by
dwarf_dealloc.
Aside frmo certain categories. */
int
dwarf_object_finish(Dwarf_Debug dbg, Dwarf_Error * error)
{
int res = DW_DLV_OK;
res = _dwarf_free_all_of_one_debug(dbg);
if (res == DW_DLV_ERROR) {
DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
}
dwarf_malloc_check_complete("After Final free");
return res;
}
/* Initialize the ELF object access for libdwarf. */
static int
dwarf_elf_init_file_ownership(dwarf_elf_handle elf_file_pointer,
int libdwarf_owns_elf,
Dwarf_Unsigned access,
Dwarf_Handler errhand,
Dwarf_Ptr errarg,
Dwarf_Debug * ret_dbg,
Dwarf_Error * error)
{
/* ELF is no longer tied to libdwarf. */
Dwarf_Obj_Access_Interface *binary_interface = 0;
int res = DW_DLV_OK;
int err = 0;
if (access != DW_DLC_READ) {
DWARF_DBG_ERROR(NULL, DW_DLE_INIT_ACCESS_WRONG, DW_DLV_ERROR);
}
/* This allocates and fills in *binary_interface. */
res = dwarf_elf_object_access_init(
elf_file_pointer,
libdwarf_owns_elf,
&binary_interface,
&err);
if(res != DW_DLV_OK){
DWARF_DBG_ERROR(NULL, err, DW_DLV_ERROR);
}
/* This mallocs space and returns pointer thru ret_dbg,
saving the binary interface in 'ret-dbg' */
res = dwarf_object_init(binary_interface, errhand, errarg,
ret_dbg, error);
if(res != DW_DLV_OK){
dwarf_elf_object_access_finish(binary_interface);
}
return res;
}
/* Given a section name, get its size and address */
int
dwarf_get_section_info_by_name(Dwarf_Debug dbg,
const char *section_name,
Dwarf_Addr *section_addr,
Dwarf_Unsigned *section_size,
Dwarf_Error * error)
{
struct Dwarf_Obj_Access_Section_s doas;
struct Dwarf_Obj_Access_Interface_s * obj = 0;
Dwarf_Unsigned section_count = 0;
Dwarf_Half section_index = 0;
*section_addr = 0;
*section_size = 0;
obj = dbg->de_obj_file;
if (NULL == obj) {
return DW_DLV_NO_ENTRY;
}
section_count = obj->methods->get_section_count(obj->object);
/* We can skip index 0 when considering ELF files, but not other
object types. */
for (section_index = 0; section_index < section_count;
++section_index) {
int err = 0;
int res = obj->methods->get_section_info(obj->object,
section_index, &doas, &err);
if (res == DW_DLV_ERROR) {
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
if (!strcmp(section_name,doas.name)) {
*section_addr = doas.addr;
*section_size = doas.size;
return DW_DLV_OK;
}
}
return DW_DLV_NO_ENTRY;
}
/*
The basic dwarf initializer function for consumers.
Return NULL on error.
*/
int
dwarf_init(int fd,
Dwarf_Unsigned access,
Dwarf_Handler errhand,
Dwarf_Ptr errarg, Dwarf_Debug * ret_dbg, Dwarf_Error * error)
{
Dwarf_Debug dbg;
struct stat fstat_buf;
dwarf_elf_handle elf;
int res;
#ifdef __SGI_FAST_LIBELF
enum elf_sgi_error_type sres;
#else
Elf_Cmd what_kind_of_elf_read;
#endif
dbg = _dwarf_get_debug();
if (dbg == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
}
dbg->de_errhand = errhand;
dbg->de_errarg = errarg;
if (fstat(fd, &fstat_buf) != 0) {
DWARF_DBG_ERROR(dbg, DW_DLE_FSTAT_ERROR, DW_DLV_ERROR);
}
if (!S_ISREG(fstat_buf.st_mode)) {
DWARF_DBG_ERROR(dbg, DW_DLE_FSTAT_MODE_ERROR, DW_DLV_ERROR);
}
if (access != DW_DLC_READ) {
DWARF_DBG_ERROR(dbg, DW_DLE_INIT_ACCESS_WRONG, DW_DLV_ERROR);
}
dbg->de_access = access;
#ifdef __SGI_FAST_LIBELF
elf = elf_sgi_new();
if (elf == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_MAF, DW_DLV_ERROR);
}
sres = elf_sgi_begin_fd(elf, fd, 0);
if (sres != ELF_SGI_ERROR_OK) {
DWARF_DBG_ERROR(dbg, _dwarf_error_code_from_elf_sgi_error_code(sres),
DW_DLV_ERROR);
}
#else
elf_version(EV_CURRENT);
/* changed to mmap request per bug 281217. 6/95 */
#ifdef HAVE_ELF_C_READ_MMAP
/* ELF_C_READ_MMAP is an SGI IRIX specific enum value from IRIX
libelf.h meaning read but use mmap */
what_kind_of_elf_read = ELF_C_READ_MMAP;
#else
/* ELF_C_READ is a portable value */
what_kind_of_elf_read = ELF_C_READ;
#endif
if ((elf = elf_begin(fd, what_kind_of_elf_read, 0)) == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_ELF_BEGIN_ERROR, DW_DLV_ERROR);
}
#endif /* !defined(__SGI_FAST_LIBELF) */
dbg->de_elf_must_close = 1;
if ((res = _dwarf_setup(dbg, elf, error)) != DW_DLV_OK) {
free(dbg);
return (res);
}
/* call cannot fail: no malloc or free involved */
_dwarf_setup_debug(dbg);
*ret_dbg = dbg;
return (DW_DLV_OK);
}
/*
Given an Elf ptr, set up dbg with pointers
to all the Dwarf data sections.
Return NULL on error.
This function is also responsible for determining
whether the given object contains Dwarf information
or not. The test currently used is that it contains
either a .debug_info or a .debug_frame section. If
not, it returns DW_DLV_NO_ENTRY causing dwarf_init() also to
return DW_DLV_NO_ENTRY. Earlier, we had thought of using only
the presence/absence of .debug_info to test, but we
added .debug_frame since there could be stripped objects
that have only a .debug_frame section for exception
processing.
DW_DLV_NO_ENTRY or DW_DLV_OK or DW_DLV_ERROR
*/
static int
_dwarf_setup(Dwarf_Debug dbg, dwarf_elf_handle elf, Dwarf_Error * error)
{
#ifdef __SGI_FAST_LIBELF
Elf64_Ehdr ehdr;
Elf64_Shdr shdr;
enum elf_sgi_error_type sres;
unsigned char const* ehdr_ident;
#else
Elf32_Ehdr *ehdr32;
#ifdef HAVE_ELF64_GETEHDR
Elf64_Ehdr *ehdr64;
#endif
Elf32_Shdr *shdr32;
#ifdef HAVE_ELF64_GETSHDR
Elf64_Shdr *shdr64;
#endif
Elf_Scn *scn;
char *ehdr_ident;
#endif /* !defined(__SGI_FAST_LIBELF) */
Dwarf_Half machine;
char *scn_name;
int is_64bit;
int foundDwarf;
Dwarf_Unsigned section_size;
Dwarf_Unsigned section_count;
Dwarf_Half section_index;
foundDwarf = FALSE;
dbg->de_elf = elf;
dbg->de_assume_string_in_bounds = _dwarf_assume_string_bad;
#ifdef __SGI_FAST_LIBELF
sres = elf_sgi_ehdr(elf, &ehdr);
if (sres != ELF_SGI_ERROR_OK) {
DWARF_DBG_ERROR(dbg, _dwarf_error_code_from_elf_sgi_error_code(sres),
DW_DLV_ERROR);
}
ehdr_ident = ehdr.e_ident;
section_count = ehdr.e_shnum;
machine = ehdr.e_machine;
#else
if ((ehdr_ident = elf_getident(elf, NULL)) == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETIDENT_ERROR, DW_DLV_ERROR);
}
#endif
is_64bit = (ehdr_ident[EI_CLASS] == ELFCLASS64);
dbg->de_same_endian = 1;
dbg->de_copy_word = memcpy;
#ifdef WORDS_BIGENDIAN
dbg->de_big_endian_object = 1;
if (ehdr_ident[EI_DATA] == ELFDATA2LSB) {
dbg->de_same_endian = 0;
dbg->de_big_endian_object = 0;
dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
}
#else /* little endian */
dbg->de_big_endian_object = 0;
if (ehdr_ident[EI_DATA] == ELFDATA2MSB) {
dbg->de_same_endian = 0;
dbg->de_big_endian_object = 1;
dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
}
#endif /* !WORDS_BIGENDIAN */
/* The following de_length_size is Not Too Significant.
Only used one calculation, and an appoximate one at that. */
dbg->de_length_size = is_64bit ? 8 : 4;
dbg->de_pointer_size = is_64bit ? 8 : 4;
#ifdef __SGI_FAST_LIBELF
/* We've already loaded the ELF header, so there's nothing to do here */
#else
#ifdef HAVE_ELF64_GETEHDR
if (is_64bit) {
ehdr64 = elf64_getehdr(elf);
if (ehdr64 == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETEHDR_ERROR,
DW_DLV_ERROR);
}
section_count = ehdr64->e_shnum;
machine = ehdr64->e_machine;
} else
#endif
{
ehdr32 = elf32_getehdr(elf);
if (ehdr32 == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETEHDR_ERROR,
DW_DLV_ERROR);
}
section_count = ehdr32->e_shnum;
machine = ehdr32->e_machine;
}
#endif /* !defined(__SGI_FAST_LIBELF) */
if (is_64bit && machine != EM_MIPS) {
/* MIPS/IRIX makes pointer size and length size 8 for -64.
Other platforms make length 4 always. */
/* 4 here supports 32bit-offset dwarf2, as emitted by
cygnus tools, and the dwarfv2.1 64bit extension setting. */
dbg->de_length_size = 4;
}
/* We start at index 1 to skip the initial empty section. */
for (section_index = 1; section_index < section_count; ++section_index) {
#ifdef __SGI_FAST_LIBELF
sres = elf_sgi_shdr(elf, section_index, &shdr);
if (sres != ELF_SGI_ERROR_OK) {
DWARF_DBG_ERROR(dbg, _dwarf_error_code_from_elf_sgi_error_code(sres),
DW_DLV_ERROR);
}
section_size = shdr.sh_size;
sres = elf_sgi_string(elf, ehdr.e_shstrndx, shdr.sh_name, (char const** )&scn_name);
if (sres != ELF_SGI_ERROR_OK) {
DWARF_DBG_ERROR(dbg, _dwarf_error_code_from_elf_sgi_error_code(sres),
DW_DLV_ERROR);
}
#else /* !defined(__SGI_FAST_LIBELF) */
scn = elf_getscn(elf, section_index);
if (scn == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_MDE,
DW_DLV_ERROR);
}
#ifdef HAVE_ELF64_GETSHDR
if (is_64bit) {
shdr64 = elf64_getshdr(scn);
if (shdr64 == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETSHDR_ERROR,
DW_DLV_ERROR);
}
section_size = shdr64->sh_size;
if ((scn_name = elf_strptr(elf, ehdr64->e_shstrndx,
shdr64->sh_name))
== NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_ELF_STRPTR_ERROR,
DW_DLV_ERROR);
}
} else
#endif /* HAVE_ELF64_GETSHDR */
{
if ((shdr32 = elf32_getshdr(scn)) == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETSHDR_ERROR, 0);
}
section_size = shdr32->sh_size;
if ((scn_name = elf_strptr(elf, ehdr32->e_shstrndx,
shdr32->sh_name)) == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_ELF_STRPTR_ERROR,
DW_DLV_ERROR);
}
}
#endif /* !defined(__SGI_FAST_LIBELF) */
if (strncmp(scn_name, ".debug_", 7)
&& strcmp(scn_name, ".eh_frame")
)
continue;
else if (strcmp(scn_name, ".debug_info") == 0) {
if (dbg->de_debug_info != NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_INFO_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* Know no reason to allow empty debug_info section */
DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_INFO_NULL,
DW_DLV_ERROR);
}
foundDwarf = TRUE;
dbg->de_debug_info_index = section_index;
dbg->de_debug_info_size = section_size;
}
else if (strcmp(scn_name, ".debug_abbrev") == 0) {
if (dbg->de_debug_abbrev != NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_ABBREV_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* Know no reason to allow empty debug_abbrev section */
DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_ABBREV_NULL,
DW_DLV_ERROR);
}
dbg->de_debug_abbrev_index = section_index;
dbg->de_debug_abbrev_size = section_size;
}
else if (strcmp(scn_name, ".debug_aranges") == 0) {
if (dbg->de_debug_aranges_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_ARANGES_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_aranges_index = section_index;
dbg->de_debug_aranges_size = section_size;
}
else if (strcmp(scn_name, ".debug_line") == 0) {
if (dbg->de_debug_line_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_LINE_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_line_index = section_index;
dbg->de_debug_line_size = section_size;
}
else if (strcmp(scn_name, ".debug_frame") == 0) {
if (dbg->de_debug_frame_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_FRAME_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_frame_index = section_index;
dbg->de_debug_frame_size = section_size;
foundDwarf = TRUE;
} else if (strcmp(scn_name, ".eh_frame") == 0) {
/* gnu egcs-1.1.2 data */
if (dbg->de_debug_frame_eh_gnu_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_FRAME_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_frame_eh_gnu_index = section_index;
dbg->de_debug_frame_size_eh_gnu = section_size;
foundDwarf = TRUE;
}
else if (strcmp(scn_name, ".debug_loc") == 0) {
if (dbg->de_debug_loc_index != 0) {
DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_LOC_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_loc_index = section_index;
dbg->de_debug_loc_size = section_size;
}
else if (strcmp(scn_name, ".debug_pubnames") == 0) {
if (dbg->de_debug_pubnames_index != 0) {
DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_PUBNAMES_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_pubnames_index = section_index;
dbg->de_debug_pubnames_size = section_size;
}
else if (strcmp(scn_name, ".debug_str") == 0) {
if (dbg->de_debug_str_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_STR_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_str_index = section_index;
dbg->de_debug_str_size = section_size;
}
else if (strcmp(scn_name, ".debug_funcnames") == 0) {
if (dbg->de_debug_funcnames_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_FUNCNAMES_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_funcnames_index = section_index;
dbg->de_debug_funcnames_size = section_size;
}
else if (strcmp(scn_name, ".debug_typenames") == 0) {
if (dbg->de_debug_typenames_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_TYPENAMES_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_typenames_index = section_index;
dbg->de_debug_typenames_size = section_size;
}
else if (strcmp(scn_name, ".debug_varnames") == 0) {
if (dbg->de_debug_varnames_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_VARNAMES_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_varnames_index = section_index;
dbg->de_debug_varnames_size = section_size;
}
else if (strcmp(scn_name, ".debug_weaknames") == 0) {
if (dbg->de_debug_weaknames_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_WEAKNAMES_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_weaknames_index = section_index;
dbg->de_debug_weaknames_size = section_size;
} else if (strcmp(scn_name, ".debug_macinfo") == 0) {
if (dbg->de_debug_macinfo_index != 0) {
DWARF_DBG_ERROR(dbg,
DW_DLE_DEBUG_MACINFO_DUPLICATE,
DW_DLV_ERROR);
}
if (section_size == 0) {
/* a zero size section is just empty. Ok, no error */
continue;
}
dbg->de_debug_macinfo_index = section_index;
dbg->de_debug_macinfo_size = section_size;
}
}
if (foundDwarf) {
return DW_DLV_OK;
}
return (DW_DLV_NO_ENTRY);
}
/*
Use a Dwarf_Obj_Access_Interface to kick things off. All other
init routines eventually use this one.
The returned Dwarf_Debug contains a copy of *obj
the callers copy of *obj may be freed whenever the caller
wishes.
*/
int
dwarf_object_init(Dwarf_Obj_Access_Interface* obj, Dwarf_Handler errhand,
Dwarf_Ptr errarg, Dwarf_Debug* ret_dbg,
Dwarf_Error* error)
{
Dwarf_Debug dbg = 0;
int setup_result = DW_DLV_OK;
dbg = _dwarf_get_debug();
if (dbg == NULL) {
DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
}
dbg->de_errhand = errhand;
dbg->de_errarg = errarg;
dbg->de_frame_rule_initial_value = DW_FRAME_REG_INITIAL_VALUE;
dbg->de_frame_reg_rules_entry_count = DW_FRAME_LAST_REG_NUM;
#ifdef HAVE_OLD_FRAME_CFA_COL
/* DW_FRAME_CFA_COL is really only suitable for old libdwarf frame
interfaces and its value of 0 there is only usable where
(as in MIPS) register 0 has no value other than 0 so
we can use the frame table column 0 for the CFA value
(and rely on client software to know when 'register 0'
is the cfa and when to just use a value 0 for register 0).
*/
dbg->de_frame_cfa_col_number = DW_FRAME_CFA_COL;
#else
dbg->de_frame_cfa_col_number = DW_FRAME_CFA_COL3;
#endif
dbg->de_frame_same_value_number = DW_FRAME_SAME_VAL;
dbg->de_frame_undefined_value_number = DW_FRAME_UNDEFINED_VAL;
dbg->de_obj_file = obj;
setup_result = _dwarf_setup(dbg, error);
if (setup_result == DW_DLV_OK) {
int fission_result = load_debugfission_tables(dbg,error);
/* In most cases we get
setup_result == DW_DLV_NO_ENTRY here
as having debugfission (.dwp objects)
is fairly rare. */
if (fission_result == DW_DLV_ERROR) {
/* Something is very wrong. */
setup_result = fission_result;
}
}
if (setup_result != DW_DLV_OK) {
int freeresult = 0;
/* We cannot use any _dwarf_setup()
error here as
we are freeing dbg, making that error (setup
as part of dbg) stale.
Hence we have to make a new error without a dbg.
But error might be NULL and the init call
error-handler function might be set.
*/
int myerr = 0;
if ( (setup_result == DW_DLV_ERROR) && error ) {
/* Preserve our _dwarf_setup error number, but
this does not apply if error NULL. */
myerr = dwarf_errno(*error);
/* deallocate the soon-stale error pointer. */
dwarf_dealloc(dbg,*error,DW_DLA_ERROR);
*error = 0;
}
/* The status we want to return here is of _dwarf_setup,
not of the _dwarf_free_all_of_one_debug(dbg) call.
So use a local status variable for the free. */
freeresult = _dwarf_free_all_of_one_debug(dbg);
dbg = 0;
/* DW_DLV_NO_ENTRY not possible in freeresult */
if (freeresult == DW_DLV_ERROR) {
/* Use the _dwarf_setup error number.
If error is NULL the following will issue
a message on stderr and abort(), as without
dbg there is no error-handler function.
*/
_dwarf_error(NULL,error,DW_DLE_DBG_ALLOC);
return DW_DLV_ERROR;
}
if (setup_result == DW_DLV_ERROR) {
/* Use the _dwarf_setup error number.
If error is NULL the following will issue
a message on stderr and abort(), as without
dbg there is no error-handler function.
*/
_dwarf_error(NULL,error,myerr);
}
return setup_result;
}
dwarf_harmless_init(&dbg->de_harmless_errors,
DW_HARMLESS_ERROR_CIRCULAR_LIST_DEFAULT_SIZE);
*ret_dbg = dbg;
return DW_DLV_OK;
}
static int
_dwarf_setup(Dwarf_Debug dbg, Dwarf_Error * error)
{
const char *scn_name = 0;
int foundDwarf = 0;
struct Dwarf_Obj_Access_Interface_s * obj = 0;
Dwarf_Endianness endianness;
/* Table with pointers to debug sections */
struct Dwarf_Section_s **sections = 0;
Dwarf_Unsigned section_count = 0;
Dwarf_Half obj_section_index = 0;
foundDwarf = FALSE;
dbg->de_assume_string_in_bounds = _dwarf_assume_string_in_bounds;
dbg->de_same_endian = 1;
dbg->de_copy_word = memcpy;
obj = dbg->de_obj_file;
endianness = obj->methods->get_byte_order(obj->object);
#ifdef WORDS_BIGENDIAN
dbg->de_big_endian_object = 1;
if (endianness == DW_OBJECT_LSB ) {
dbg->de_same_endian = 0;
dbg->de_big_endian_object = 0;
dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
}
#else /* little endian */
dbg->de_big_endian_object = 0;
if (endianness == DW_OBJECT_MSB ) {
dbg->de_same_endian = 0;
dbg->de_big_endian_object = 1;
dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
}
#endif /* !WORDS_BIGENDIAN */
/* The following de_length_size is Not Too Significant. Only used
one calculation, and an approximate one at that. */
dbg->de_length_size = obj->methods->get_length_size(obj->object);
dbg->de_pointer_size = obj->methods->get_pointer_size(obj->object);
/* For windows always is 4 ? */
#ifdef WIN32
dbg->de_pointer_size = 4;
#endif /* WIN32 */
section_count = obj->methods->get_section_count(obj->object);
/* Allocate space to record references to debug sections, that can
be referenced by RELA sections in the 'sh_info' field. */
sections = (struct Dwarf_Section_s **)calloc(section_count + 1,
sizeof(struct Dwarf_Section_s *));
if (!sections) {
/* Impossible case, we hope. Give up. */
return DW_DLV_ERROR;
}
/* We can skip index 0 when considering ELF files, but not other
object types. Indeed regardless of the object type we should
skip section 0 here.
This is a convention. We depend on it.
Non-elf object access code should
(in itself) understand we will index beginning at 1 and adjust
itself to deal with this Elf convention. Without this
convention various parts of the code in this file won't work correctly.
A dss_index of 0 must not be used, even though we start at 0
here. So the get_section_info() must adapt to the situation
(the elf version does automatically as a result of Elf having
a section zero with zero length and an empty name). */
for (obj_section_index = 0; obj_section_index < section_count;
++obj_section_index) {
struct Dwarf_Obj_Access_Section_s doas;
int res = DW_DLV_ERROR;
int err = 0;
memset(&doas,0,sizeof(doas));
res = obj->methods->get_section_info(obj->object,
obj_section_index,
&doas, &err);
if (res == DW_DLV_ERROR){
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
scn_name = doas.name;
if (!this_section_dwarf_relevant(scn_name,doas.type) ) {
continue;
} else {
/* Build up the sections table and the
de_debug* etc pointers in Dwarf_Debug. */
struct Dwarf_dbg_sect_s *section;
int found_match = FALSE;
unsigned initial_start_number = 0;
unsigned dbg_section_number = 0;
res = is_section_known_already(dbg,scn_name,
&dbg_section_number,
initial_start_number,
&err);
if (res == DW_DLV_OK) {
/* DUPLICATE */
DWARF_DBG_ERROR(dbg, DW_DLE_SECTION_DUPLICATION,
DW_DLV_ERROR);
} else if (res == DW_DLV_ERROR) {
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
/* No entry: new-to-us section, the normal case. */
res = enter_section_in_de_debug_sections_array(dbg,scn_name,&err);
if (res == DW_DLV_OK) {
/* We just added a new entry in the dbg
de_debug_sections array. So we know its number. */
unsigned real_start_number =
dbg->de_debug_sections_total_entries-1;
res = is_section_known_already(dbg,scn_name,
&dbg_section_number,
real_start_number,
&err);
if (res == DW_DLV_OK) {
section = &dbg->de_debug_sections[dbg_section_number];
res = get_basic_section_data(dbg,
section->ds_secdata, &doas,
obj_section_index, error,
section->ds_duperr,
section->ds_emptyerr);
if (res != DW_DLV_OK) {
return res;
}
sections[obj_section_index] = section->ds_secdata;
foundDwarf += section->ds_have_dwarf;
found_match = TRUE;
/* Normal section set up.
Fall through. */
}else if (res == DW_DLV_NO_ENTRY) {
/* Some sort of bug in the code here.
Should be impossible to get here. */
DWARF_DBG_ERROR(dbg, DW_DLE_SECTION_ERROR, DW_DLV_ERROR);
} else {
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
} else if (res == DW_DLV_NO_ENTRY) {
/* We get here for relocation sections.
Fall through. */
} else {
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
if (!found_match) {
/* For an object file with incorrect rela section name,
the 'readelf' tool, prints correct debug information,
as the tool takes the section type instead
of the section name. If the current section
is a RELA one and the 'sh_info'
refers to a debug section, add the relocation data. */
if (doas.type == SHT_RELA && sections[doas.info]) {
add_rela_data(sections[doas.info],&doas,
obj_section_index);
}
}
/* Fetch next section */
}
}
/* Free table with section information. */
if (sections){
free(sections);
}
if (foundDwarf) {
return DW_DLV_OK;
}
return DW_DLV_NO_ENTRY;
}
static int
_dwarf_setup(Dwarf_Debug dbg, Dwarf_Error * error)
{
const char *scn_name = 0;
int foundDwarf = 0;
struct Dwarf_Obj_Access_Interface_s * obj = 0;
Dwarf_Endianness endianness;
/* Table with pointers to debug sections */
struct Dwarf_Section_s **sections = 0;
Dwarf_Unsigned section_count = 0;
Dwarf_Half section_index = 0;
foundDwarf = FALSE;
dbg->de_assume_string_in_bounds = _dwarf_assume_string_in_bounds;
dbg->de_same_endian = 1;
dbg->de_copy_word = memcpy;
obj = dbg->de_obj_file;
endianness = obj->methods->get_byte_order(obj->object);
#ifdef WORDS_BIGENDIAN
dbg->de_big_endian_object = 1;
if (endianness == DW_OBJECT_LSB ) {
dbg->de_same_endian = 0;
dbg->de_big_endian_object = 0;
dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
}
#else /* little endian */
dbg->de_big_endian_object = 0;
if (endianness == DW_OBJECT_MSB ) {
dbg->de_same_endian = 0;
dbg->de_big_endian_object = 1;
dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
}
#endif /* !WORDS_BIGENDIAN */
/* The following de_length_size is Not Too Significant. Only used
one calculation, and an approximate one at that. */
dbg->de_length_size = obj->methods->get_length_size(obj->object);
dbg->de_pointer_size = obj->methods->get_pointer_size(obj->object);
/* For windows always is 4 ? */
#ifdef WIN32
dbg->de_pointer_size = 4;
#endif /* WIN32 */
section_count = obj->methods->get_section_count(obj->object);
/* Allocate space to record references to debug sections, that can
be referenced by RELA sections in the 'sh_info' field. */
sections = (struct Dwarf_Section_s **)calloc(section_count + 1,
sizeof(struct Dwarf_Section_s *));
if (!sections) {
/* Impossible case, we hope. Give up. */
return DW_DLV_ERROR;
}
/* Setup the table that contains the basic information about the
sections that are DWARF related. The entries are very unlikely
to change very often. */
add_debug_section_info(dbg,".debug_info",&dbg->de_debug_info, /*01*/
DW_DLE_DEBUG_INFO_DUPLICATE,DW_DLE_DEBUG_INFO_NULL,
TRUE);
add_debug_section_info(dbg,".debug_types",&dbg->de_debug_types, /*02*/
DW_DLE_DEBUG_TYPES_DUPLICATE,DW_DLE_DEBUG_TYPES_NULL,
TRUE);
add_debug_section_info(dbg,".debug_abbrev",&dbg->de_debug_abbrev, /*03*/
DW_DLE_DEBUG_ABBREV_DUPLICATE,DW_DLE_DEBUG_ABBREV_NULL,
FALSE);
add_debug_section_info(dbg,".debug_aranges",&dbg->de_debug_aranges, /*04*/
DW_DLE_DEBUG_ARANGES_DUPLICATE,0,
FALSE);
add_debug_section_info(dbg,".debug_line",&dbg->de_debug_line, /*05*/
DW_DLE_DEBUG_LINE_DUPLICATE,0,
FALSE);
add_debug_section_info(dbg,".debug_frame",&dbg->de_debug_frame, /*06*/
DW_DLE_DEBUG_FRAME_DUPLICATE,0,
TRUE);
/* gnu egcs-1.1.2 data */
add_debug_section_info(dbg,".eh_frame",&dbg->de_debug_frame_eh_gnu, /*07*/
DW_DLE_DEBUG_FRAME_DUPLICATE,0,
TRUE);
add_debug_section_info(dbg,".debug_loc",&dbg->de_debug_loc, /*08*/
DW_DLE_DEBUG_LOC_DUPLICATE,0,
FALSE);
add_debug_section_info(dbg,".debug_pubnames",&dbg->de_debug_pubnames,/*09*/
DW_DLE_DEBUG_PUBNAMES_DUPLICATE,0,
FALSE);
add_debug_section_info(dbg,".debug_str",&dbg->de_debug_str, /*10*/
DW_DLE_DEBUG_STR_DUPLICATE,0,
FALSE);
/* SGI IRIX-only. */
add_debug_section_info(dbg,".debug_funcnames",&dbg->de_debug_funcnames,
/*11*/
DW_DLE_DEBUG_FUNCNAMES_DUPLICATE,0,
FALSE);
/* SGI IRIX-only, created years before DWARF3. Content
essentially identical to .debug_pubtypes. */
add_debug_section_info(dbg,".debug_typenames",&dbg->de_debug_typenames,
/*12*/
DW_DLE_DEBUG_TYPENAMES_DUPLICATE,0,
FALSE);
/* Section new in DWARF3. */
add_debug_section_info(dbg,".debug_pubtypes",&dbg->de_debug_pubtypes,
/*13*/
DW_DLE_DEBUG_PUBTYPES_DUPLICATE,0,
FALSE);
/* SGI IRIX-only. */
add_debug_section_info(dbg,".debug_varnames",&dbg->de_debug_varnames,
/*14*/
DW_DLE_DEBUG_VARNAMES_DUPLICATE,0,
FALSE);
/* SGI IRIX-only. */
add_debug_section_info(dbg,".debug_weaknames",&dbg->de_debug_weaknames,
/*15*/
DW_DLE_DEBUG_WEAKNAMES_DUPLICATE,0,
FALSE);
add_debug_section_info(dbg,".debug_macinfo",&dbg->de_debug_macinfo,
/*16*/
DW_DLE_DEBUG_MACINFO_DUPLICATE,0,
FALSE);
add_debug_section_info(dbg,".debug_ranges",&dbg->de_debug_ranges,
/*17*/
DW_DLE_DEBUG_RANGES_DUPLICATE,0,
TRUE);
add_debug_section_info(dbg,".symtab",&dbg->de_elf_symtab,
/*18*/
DW_DLE_DEBUG_SYMTAB_ERR,0,
FALSE);
add_debug_section_info(dbg,".strtab",&dbg->de_elf_strtab,
/*19*/
DW_DLE_DEBUG_STRTAB_ERR,0,
FALSE);
/* Newtype macros. */
add_debug_section_info(dbg,".debug_macro",&dbg->de_debug_macro,
/*20*/
DW_DLE_DEBUG_MACRO_DUPLICATE,0,
FALSE);
/* We can skip index 0 when considering ELF files, but not other
object types. Indeed regardless of the object type we should
skip section 0 here.
This is a convention. We depend on it.
Non-elf object access code should
(in itself) understand we will index beginning at 1 and adjust
itself to deal with this Elf convention. Without this
convention various parts of the code in this file won't work correctly.
A dss_index of 0 must not be used, even though we start at 0
here. So the get_section_info() must adapt to the situation
(the elf version does automatically as a result of Elf having
a section zero with zero length and an empty name). */
for (section_index = 0; section_index < section_count;
++section_index) {
struct Dwarf_Obj_Access_Section_s doas;
int res = DW_DLV_ERROR;
int err = 0;
memset(&doas,0,sizeof(doas));
res = obj->methods->get_section_info(obj->object,
section_index,
&doas, &err);
if (res == DW_DLV_ERROR){
DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
}
scn_name = doas.name;
if (strncmp(scn_name, ".debug_", 7)
&& strcmp(scn_name, ".eh_frame")
&& strcmp(scn_name, ".symtab")
&& strcmp(scn_name, ".strtab")
&& strncmp(scn_name, ".rela.",6)
/* For an object file with incorrect rela section name,
readelf prints correct debug information,
as the tool takes the section type instead
of the section name. Include the incorrect
section name, until this test uses the section type. */
&& doas.type != SHT_RELA) {
continue;
} else {
/* Search the debug sections table for a match */
struct Dwarf_dbg_sect_s *section;
unsigned i = 0;
int found_match = FALSE;
for (i = 0; i <
dbg->de_debug_sections_total_entries; ++i) {
section = &dbg->de_debug_sections[i];
if (strcmp(scn_name, section->ds_name) == 0) {
res = get_basic_section_data(dbg,
section->ds_secdata, &doas,
section_index, error,
section->ds_duperr, section->ds_emptyerr);
if (res != DW_DLV_OK) {
return res;
}
/* Mark the entry as debug section related */
sections[section_index] = section->ds_secdata;
foundDwarf += section->ds_have_dwarf;
found_match = TRUE;
break;
}
}
if (!found_match) {
/* For an object file with incorrect rela section name,
the 'readelf' tool, prints correct debug information,
as the tool takes the section type instead
of the section name. If the current section
is a RELA one and the 'sh_info'
refers to a debug section, add the relocation data. */
if (doas.type == SHT_RELA && sections[doas.info]) {
add_rela_data(sections[doas.info],&doas,section_index);
}
}
/* Fetch next section */
}
}
/* Free table with section information. */
if (sections){
free(sections);
}
if (foundDwarf) {
return DW_DLV_OK;
}
return DW_DLV_NO_ENTRY;
}
