const char *
dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr addr,
GElf_Sym *closest_sym, GElf_Word *shndxp)
{
int syments = INTUSE(dwfl_module_getsymtab) (mod);
if (syments < 0)
return NULL;
/* Return true iff we consider ADDR to lie in the same section as SYM. */
GElf_Word addr_shndx = SHN_UNDEF;
inline bool same_section (const GElf_Sym *sym, GElf_Word shndx)
{
/* For absolute symbols and the like, only match exactly. */
if (shndx >= SHN_LORESERVE)
return sym->st_value == addr;
/* Figure out what section ADDR lies in. */
if (addr_shndx == SHN_UNDEF)
{
GElf_Addr mod_addr = dwfl_deadjust_st_value (mod, addr);
Elf_Scn *scn = NULL;
addr_shndx = SHN_ABS;
while ((scn = elf_nextscn (mod->symfile->elf, scn)) != NULL)
{
GElf_Shdr shdr_mem;
GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
if (likely (shdr != NULL)
&& mod_addr >= shdr->sh_addr
&& mod_addr < shdr->sh_addr + shdr->sh_size)
{
addr_shndx = elf_ndxscn (scn);
break;
}
}
}
return shndx == addr_shndx;
}
/* Keep track of the closest symbol we have seen so far.
Here we store only symbols with nonzero st_size. */
const char *closest_name = NULL;
GElf_Word closest_shndx = SHN_UNDEF;
/* Keep track of an eligible symbol with st_size == 0 as a fallback. */
const char *sizeless_name = NULL;
GElf_Sym sizeless_sym = { 0, 0, 0, 0, 0, SHN_UNDEF };
GElf_Word sizeless_shndx = SHN_UNDEF;
/* Keep track of the lowest address a relevant sizeless symbol could have. */
GElf_Addr min_label = 0;
/* Look through the symbol table for a matching symbol. */
inline void search_table (int start, int end)
{
for (int i = start; i < end; ++i)
{
GElf_Sym sym;
GElf_Word shndx;
const char *name = INTUSE(dwfl_module_getsym) (mod, i, &sym, &shndx);
if (name != NULL && name[0] != '\0'
&& sym.st_shndx != SHN_UNDEF
&& sym.st_value <= addr
&& GELF_ST_TYPE (sym.st_info) != STT_SECTION
&& GELF_ST_TYPE (sym.st_info) != STT_FILE
&& GELF_ST_TYPE (sym.st_info) != STT_TLS)
{
/* Even if we don't choose this symbol, its existence excludes
any sizeless symbol (assembly label) that is below its upper
bound. */
if (sym.st_value + sym.st_size > min_label)
min_label = sym.st_value + sym.st_size;
if (sym.st_size == 0 || addr - sym.st_value < sym.st_size)
{
/* This symbol is a better candidate than the current one
if it's closer to ADDR or is global when it was local. */
if (closest_name == NULL
|| closest_sym->st_value < sym.st_value
|| (GELF_ST_BIND (closest_sym->st_info)
< GELF_ST_BIND (sym.st_info)))
{
if (sym.st_size != 0)
{
*closest_sym = sym;
closest_shndx = shndx;
closest_name = name;
}
else if (closest_name == NULL
&& sym.st_value >= min_label
&& same_section (&sym, shndx))
{
/* Handwritten assembly symbols sometimes have no
st_size. If no symbol with proper size includes
the address, we'll use the closest one that is in
the same section as ADDR. */
sizeless_sym = sym;
sizeless_shndx = shndx;
sizeless_name = name;
}
}
/* When the beginning of its range is no closer,
the end of its range might be. But do not
replace a global symbol with a local! */
else if (sym.st_size != 0
&& closest_sym->st_value == sym.st_value
&& closest_sym->st_size > sym.st_size
&& (GELF_ST_BIND (closest_sym->st_info)
<= GELF_ST_BIND (sym.st_info)))
{
*closest_sym = sym;
closest_shndx = shndx;
closest_name = name;
}
}
}
}
}
/* First go through global symbols. mod->first_global is setup by
dwfl_module_getsymtab to the index of the first global symbol in
the module's symbol table, or -1 when unknown. All symbols with
local binding come first in the symbol table, then all globals. */
search_table (mod->first_global < 0 ? 1 : mod->first_global, syments);
/* If we found nothing searching the global symbols, then try the locals.
Unless we have a global sizeless symbol that matches exactly. */
if (closest_name == NULL && mod->first_global > 1
&& (sizeless_name == NULL || sizeless_sym.st_value != addr))
search_table (1, mod->first_global);
/* If we found no proper sized symbol to use, fall back to the best
candidate sizeless symbol we found, if any. */
if (closest_name == NULL
&& sizeless_name != NULL && sizeless_sym.st_value >= min_label)
{
*closest_sym = sizeless_sym;
closest_shndx = sizeless_shndx;
closest_name = sizeless_name;
}
if (shndxp != NULL)
*shndxp = closest_shndx;
return closest_name;
}
internal_function
__libdwfl_getsym (Dwfl_Module *mod, int ndx, GElf_Sym *sym, GElf_Addr *addr,
GElf_Word *shndxp, Elf **elfp, Dwarf_Addr *biasp,
bool *resolved, bool adjust_st_value)
{
if (unlikely (mod == NULL))
return NULL;
if (unlikely (mod->symdata == NULL))
{
int result = INTUSE(dwfl_module_getsymtab) (mod);
if (result < 0)
return NULL;
}
/* All local symbols should come before all global symbols. If we
have an auxiliary table make sure all the main locals come first,
then all aux locals, then all main globals and finally all aux globals.
And skip the auxiliary table zero undefined entry. */
GElf_Word shndx;
int tndx = ndx;
int skip_aux_zero = (mod->syments > 0 && mod->aux_syments > 0) ? 1 : 0;
Elf *elf;
Elf_Data *symdata;
Elf_Data *symxndxdata;
Elf_Data *symstrdata;
if (mod->aux_symdata == NULL
|| ndx < mod->first_global)
{
/* main symbol table (locals). */
tndx = ndx;
elf = mod->symfile->elf;
symdata = mod->symdata;
symxndxdata = mod->symxndxdata;
symstrdata = mod->symstrdata;
}
else if (ndx < mod->first_global + mod->aux_first_global - skip_aux_zero)
{
/* aux symbol table (locals). */
tndx = ndx - mod->first_global + skip_aux_zero;
elf = mod->aux_sym.elf;
symdata = mod->aux_symdata;
symxndxdata = mod->aux_symxndxdata;
symstrdata = mod->aux_symstrdata;
}
else if ((size_t) ndx < mod->syments + mod->aux_first_global - skip_aux_zero)
{
/* main symbol table (globals). */
tndx = ndx - mod->aux_first_global + skip_aux_zero;
elf = mod->symfile->elf;
symdata = mod->symdata;
symxndxdata = mod->symxndxdata;
symstrdata = mod->symstrdata;
}
else
{
/* aux symbol table (globals). */
tndx = ndx - mod->syments + skip_aux_zero;
elf = mod->aux_sym.elf;
symdata = mod->aux_symdata;
symxndxdata = mod->aux_symxndxdata;
symstrdata = mod->aux_symstrdata;
}
sym = gelf_getsymshndx (symdata, symxndxdata, tndx, sym, &shndx);
if (unlikely (sym == NULL))
{
__libdwfl_seterrno (DWFL_E_LIBELF);
return NULL;
}
if (sym->st_shndx != SHN_XINDEX)
shndx = sym->st_shndx;
/* Figure out whether this symbol points into an SHF_ALLOC section. */
bool alloc = true;
if ((shndxp != NULL || mod->e_type != ET_REL)
&& (sym->st_shndx == SHN_XINDEX
|| (sym->st_shndx < SHN_LORESERVE && sym->st_shndx != SHN_UNDEF)))
{
GElf_Shdr shdr_mem;
GElf_Shdr *shdr = gelf_getshdr (elf_getscn (elf, shndx), &shdr_mem);
alloc = unlikely (shdr == NULL) || (shdr->sh_flags & SHF_ALLOC);
}
/* In case of an value in an allocated section the main Elf Ebl
might know where the real value is (e.g. for function
descriptors). */
char *ident;
GElf_Addr st_value = sym->st_value & ebl_func_addr_mask (mod->ebl);
*resolved = false;
if (! adjust_st_value && mod->e_type != ET_REL && alloc
&& (GELF_ST_TYPE (sym->st_info) == STT_FUNC
|| (GELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
&& (ident = elf_getident (elf, NULL)) != NULL
&& ident[EI_OSABI] == ELFOSABI_LINUX)))
{
if (likely (__libdwfl_module_getebl (mod) == DWFL_E_NOERROR))
{
if (elf != mod->main.elf)
{
st_value = dwfl_adjusted_st_value (mod, elf, st_value);
st_value = dwfl_deadjust_st_value (mod, mod->main.elf, st_value);
}
*resolved = ebl_resolve_sym_value (mod->ebl, &st_value);
if (! *resolved)
st_value = sym->st_value;
}
}
if (shndxp != NULL)
/* Yield -1 in case of a non-SHF_ALLOC section. */
*shndxp = alloc ? shndx : (GElf_Word) -1;
switch (sym->st_shndx)
{
case SHN_ABS: /* XXX sometimes should use bias?? */
case SHN_UNDEF:
case SHN_COMMON:
break;
default:
if (mod->e_type == ET_REL)
{
/* In an ET_REL file, the symbol table values are relative
to the section, not to the module's load base. */
size_t symshstrndx = SHN_UNDEF;
Dwfl_Error result = __libdwfl_relocate_value (mod, elf,
&symshstrndx,
shndx, &st_value);
if (unlikely (result != DWFL_E_NOERROR))
{
__libdwfl_seterrno (result);
return NULL;
}
}
else if (alloc)
/* Apply the bias to the symbol value. */
st_value = dwfl_adjusted_st_value (mod,
*resolved ? mod->main.elf : elf,
st_value);
break;
}
if (adjust_st_value)
sym->st_value = st_value;
if (addr != NULL)
*addr = st_value;
if (unlikely (sym->st_name >= symstrdata->d_size))
{
__libdwfl_seterrno (DWFL_E_BADSTROFF);
return NULL;
}
if (elfp)
*elfp = elf;
if (biasp)
*biasp = dwfl_adjusted_st_value (mod, elf, 0);
return (const char *) symstrdata->d_buf + sym->st_name;
}
