libctf, include: find types of symbols by name
The existing ctf_lookup_by_symbol and ctf_arc_lookup_symbol functions suffice to look up the types of symbols if the caller already has a symbol number. But the caller often doesn't have one of those and only knows the name of the symbol: also, in object files, the caller might not have a useful symbol number in any sense (and neither does libctf: the 'symbol number' we use in that case literally starts at 0 for the lexicographically first-sorted symbol in the symtypetab and counts those symbols, so it corresponds to nothing useful). This means that even though object files have a symtypetab (generated by the compiler or by ld -r), the only way we can look up anything in it is to iterate over all symbols in turn with ctf_symbol_next until we find the one we want. This is unhelpful and pointlessly inefficient. So add a pair of functions to look up symbols by name in a dict and in a whole archive: ctf_lookup_by_symbol_name and ctf_arc_lookup_symbol_name. These are identical to the existing functions except that they take symbol names rather than symbol numbers. To avoid insane repetition, we do some refactoring in the process, so that both ctf_lookup_by_symbol and ctf_arc_lookup_symbol turn into thin wrappers around internal functions that do both lookup by symbol index and lookup by name. This massively reduces code duplication because even the existing lookup-by-index stuff wants to use a name sometimes (when looking up in indexed sections), and the new lookup-by-name stuff has to turn it into an index sometimes (when looking up in non-indexed sections): doing it this way lets us share most of that. The actual name->index lookup is done by ctf_lookup_symbol_idx. We do not anticipate this lookup to be as heavily used as ld.so symbol lookup by many orders of magnitude, so using the ELF symbol hashes would probably take more time to read them than is saved by using the hashes, and it adds a lot of complexity. Instead, do a linear search for the symbol name, caching all the name -> index mappings as we go, so that future searches are likely to hit in the cache. To avoid having to repeat this search over and over in a CTF archive when ctf_arc_lookup_symbol_name is used, have cached archive lookups (the sort done by ctf_arc_lookup_symbol* and the ctf_archive_next iterator) pick out the first dict they cache in a given archive and store it in a new ctf_archive field, ctfi_crossdict_cache. This can be used to store cross-dictionary cached state that depends on things like the ELF symbol table rather than the contents of any one dict. ctf_lookup_symbol_idx then caches its name->index mappings in the dictionary named in the crossdict cache, if any, so that ctf_lookup_symbol_idx in other dicts in the same archive benefit from the previous linear search, and the symtab only needs to be scanned at most once. (Note that if you call ctf_lookup_by_symbol_name in one specific dict, and then follow it with a ctf_arc_lookup_symbol_name, the former will not use the crossdict cache because it's only populated by the dict opens in ctf_arc_lookup_symbol_name. This is harmless except for a small one-off waste of memory and time: it's only a cache, after all. We can fix this later by using the archive caching machinery more aggressively.) In ctf-archive, we do similar things, turning ctf_arc_lookup_symbol into a wrapper around a new function that does both index -> ID and name -> ID lookups across all dicts in an archive. We add a new ctfi_symnamedicts cache that maps symbol names to the ctf_dict_t * that it was found in (so that linear searches for symbols don't need to be repeated): but we also *remove* a cache, the ctfi_syms cache that was memoizing the actual ctf_id_t returned from every call to ctf_arc_lookup_symbol. This is pointless: all it saves is one call to ctf_lookup_by_symbol, and that's basically an array lookup and nothing more so isn't worth caching. (Equally, given that symbol -> index mappings are cached by ctf_lookup_by_symbol_name, those calls are nearly free after the first call, so there's no point caching the ctf_id_t in that case either.) We fix up one test that was doing manual symbol lookup to use ctf_arc_lookup_symbol instead, and enhance it to check that the caching layer is not totally broken: we also add a new test to do lookups in a .o file, and another to do lookups in an archive with conflicted types and make sure that sort of multi-dict lookup is actually working. include/ChangeLog 2021-02-17 Nick Alcock <nick.alcock@oracle.com> * ctf-api.h (ctf_arc_lookup_symbol_name): New. (ctf_lookup_by_symbol_name): Likewise. libctf/ChangeLog 2021-02-17 Nick Alcock <nick.alcock@oracle.com> * ctf-impl.h (ctf_dict_t) <ctf_symhash>: New. <ctf_symhash_latest>: Likewise. (struct ctf_archive_internal) <ctfi_crossdict_cache>: New. <ctfi_symnamedicts>: New. <ctfi_syms>: Remove. (ctf_lookup_symbol_name): Remove. * ctf-lookup.c (ctf_lookup_symbol_name): Propagate errors from parent properly. Make static. (ctf_lookup_symbol_idx): New, linear search for the symbol name, cached in the crossdict cache's ctf_symhash (if available), or this dict's (otherwise). (ctf_try_lookup_indexed): Allow the symname to be passed in. (ctf_lookup_by_symbol): Turn into a wrapper around... (ctf_lookup_by_sym_or_name): ... this, supporting name lookup too, using ctf_lookup_symbol_idx in non-writable dicts. Special-case name lookup in dynamic dicts without reported symbols, which have no symtab or dynsymidx but where name lookup should still work. (ctf_lookup_by_symbol_name): New, another wrapper. * ctf-archive.c (enosym): Note that this is present in ctfi_symnamedicts too. (ctf_arc_close): Adjust for removal of ctfi_syms. Free the ctfi_symnamedicts. (ctf_arc_flush_caches): Likewise. (ctf_dict_open_cached): Memoize the first cached dict in the crossdict cache. (ctf_arc_lookup_symbol): Turn into a wrapper around... (ctf_arc_lookup_sym_or_name): ... this. No longer cache ctf_id_t lookups: just call ctf_lookup_by_symbol as needed (but still cache the dicts those lookups succeed in). Add lookup-by-name support, with dicts of successful lookups cached in ctfi_symnamedicts. Refactor the caching code a bit. (ctf_arc_lookup_symbol_name): New, another wrapper. * ctf-open.c (ctf_dict_close): Free the ctf_symhash. * libctf.ver (LIBCTF_1.2): New version. Add ctf_lookup_by_symbol_name, ctf_arc_lookup_symbol_name. * testsuite/libctf-lookup/enum-symbol.c (main): Use ctf_arc_lookup_symbol rather than looking up the name ourselves. Fish it out repeatedly, to make sure that symbol caching isn't broken. (symidx_64): Remove. (symidx_32): Remove. * testsuite/libctf-lookup/enum-symbol-obj.lk: Test symbol lookup in an unlinked object file (indexed symtypetab sections only). * testsuite/libctf-writable/symtypetab-nonlinker-writeout.c (try_maybe_reporting): Check symbol types via ctf_lookup_by_symbol_name as well as ctf_symbol_next. * testsuite/libctf-lookup/conflicting-type-syms.*: New test of lookups in a multi-dict archive.
This commit is contained in:
Nick Alcock
parent
3e8bb3e934
commit
f4f60336da
15 changed files with 578 additions and 181 deletions
|
|
@ -459,7 +459,7 @@ ctf_symidx_sort (ctf_dict_t *fp, uint32_t *idx, size_t *nidx,
|
|||
/* Given a symbol index, return the name of that symbol from the table provided
|
||||
by ctf_link_shuffle_syms, or failing that from the secondary string table, or
|
||||
the null string. */
|
||||
const char *
|
||||
static const char *
|
||||
ctf_lookup_symbol_name (ctf_dict_t *fp, unsigned long symidx)
|
||||
{
|
||||
const ctf_sect_t *sp = &fp->ctf_symtab;
|
||||
|
|
@ -512,7 +512,13 @@ ctf_lookup_symbol_name (ctf_dict_t *fp, unsigned long symidx)
|
|||
|
||||
try_parent:
|
||||
if (fp->ctf_parent)
|
||||
return ctf_lookup_symbol_name (fp->ctf_parent, symidx);
|
||||
{
|
||||
const char *ret;
|
||||
ret = ctf_lookup_symbol_name (fp->ctf_parent, symidx);
|
||||
if (ret == NULL)
|
||||
ctf_set_errno (fp, ctf_errno (fp->ctf_parent));
|
||||
return ret;
|
||||
}
|
||||
else
|
||||
{
|
||||
ctf_set_errno (fp, err);
|
||||
|
|
@ -520,6 +526,116 @@ ctf_lookup_symbol_name (ctf_dict_t *fp, unsigned long symidx)
|
|||
}
|
||||
}
|
||||
|
||||
/* Given a symbol name, return the index of that symbol, or -1 on error or if
|
||||
not found. */
|
||||
static unsigned long
|
||||
ctf_lookup_symbol_idx (ctf_dict_t *fp, const char *symname)
|
||||
{
|
||||
const ctf_sect_t *sp = &fp->ctf_symtab;
|
||||
ctf_link_sym_t sym;
|
||||
void *known_idx;
|
||||
int err;
|
||||
ctf_dict_t *cache = fp;
|
||||
|
||||
if (fp->ctf_dynsyms)
|
||||
{
|
||||
err = EINVAL;
|
||||
|
||||
ctf_link_sym_t *symp;
|
||||
|
||||
if ((symp = ctf_dynhash_lookup (fp->ctf_dynsyms, symname)) == NULL)
|
||||
goto try_parent;
|
||||
|
||||
return symp->st_symidx;
|
||||
}
|
||||
|
||||
err = ECTF_NOSYMTAB;
|
||||
if (sp->cts_data == NULL)
|
||||
goto try_parent;
|
||||
|
||||
/* First, try a hash lookup to see if we have already spotted this symbol
|
||||
during a past iteration: create the hash first if need be. The lifespan
|
||||
of the strings is equal to the lifespan of the cts_data, so we don't
|
||||
need to strdup them. If this dict was opened as part of an archive,
|
||||
and this archive has designed a crossdict_cache to cache results that
|
||||
are the same across all dicts in an archive, use it. */
|
||||
|
||||
if (fp->ctf_archive && fp->ctf_archive->ctfi_crossdict_cache)
|
||||
cache = fp->ctf_archive->ctfi_crossdict_cache;
|
||||
|
||||
if (!cache->ctf_symhash)
|
||||
if ((cache->ctf_symhash = ctf_dynhash_create (ctf_hash_string,
|
||||
ctf_hash_eq_string,
|
||||
NULL, NULL)) == NULL)
|
||||
goto oom;
|
||||
|
||||
if (ctf_dynhash_lookup_kv (cache->ctf_symhash, symname, NULL, &known_idx))
|
||||
return (unsigned long) (uintptr_t) known_idx;
|
||||
|
||||
/* Hash lookup unsuccessful: linear search, populating the hashtab for later
|
||||
lookups as we go. */
|
||||
|
||||
for (; cache->ctf_symhash_latest < sp->cts_size / sp->cts_entsize;
|
||||
cache->ctf_symhash_latest++)
|
||||
{
|
||||
switch (sp->cts_entsize)
|
||||
{
|
||||
case sizeof (Elf64_Sym):
|
||||
{
|
||||
Elf64_Sym *symp = (Elf64_Sym *) sp->cts_data;
|
||||
ctf_elf64_to_link_sym (fp, &sym, &symp[cache->ctf_symhash_latest],
|
||||
cache->ctf_symhash_latest);
|
||||
if (!ctf_dynhash_lookup_kv (cache->ctf_symhash, sym.st_name,
|
||||
NULL, NULL))
|
||||
if (ctf_dynhash_cinsert (cache->ctf_symhash, sym.st_name,
|
||||
(const void *) (uintptr_t)
|
||||
cache->ctf_symhash_latest) < 0)
|
||||
goto oom;
|
||||
if (strcmp (sym.st_name, symname) == 0)
|
||||
return cache->ctf_symhash_latest++;
|
||||
}
|
||||
break;
|
||||
case sizeof (Elf32_Sym):
|
||||
{
|
||||
Elf32_Sym *symp = (Elf32_Sym *) sp->cts_data;
|
||||
ctf_elf32_to_link_sym (fp, &sym, &symp[cache->ctf_symhash_latest],
|
||||
cache->ctf_symhash_latest);
|
||||
if (!ctf_dynhash_lookup_kv (cache->ctf_symhash, sym.st_name,
|
||||
NULL, NULL))
|
||||
if (ctf_dynhash_cinsert (cache->ctf_symhash, sym.st_name,
|
||||
(const void *) (uintptr_t)
|
||||
cache->ctf_symhash_latest) < 0)
|
||||
goto oom;
|
||||
if (strcmp (sym.st_name, symname) == 0)
|
||||
return cache->ctf_symhash_latest++;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ctf_set_errno (fp, ECTF_SYMTAB);
|
||||
return (unsigned long) -1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Searched everything, still not found. */
|
||||
|
||||
return (unsigned long) -1;
|
||||
|
||||
try_parent:
|
||||
if (fp->ctf_parent)
|
||||
return ctf_lookup_symbol_idx (fp->ctf_parent, symname);
|
||||
else
|
||||
{
|
||||
ctf_set_errno (fp, err);
|
||||
return (unsigned long) -1;
|
||||
}
|
||||
oom:
|
||||
ctf_set_errno (fp, ENOMEM);
|
||||
ctf_err_warn (fp, 0, ENOMEM, _("cannot allocate memory for symbol "
|
||||
"lookup hashtab"));
|
||||
return (unsigned long) -1;
|
||||
|
||||
}
|
||||
|
||||
/* Iterate over all symbols with types: if FUNC, function symbols, otherwise,
|
||||
data symbols. The name argument is not optional. The return order is
|
||||
arbitrary, though is likely to be in symbol index or name order. You can
|
||||
|
|
@ -664,20 +780,24 @@ ctf_lookup_idx_name (const void *key_, const void *idx_)
|
|||
return (strcmp (key->clik_name, ctf_strptr (key->clik_fp, key->clik_names[*idx])));
|
||||
}
|
||||
|
||||
/* Given a symbol number, look up that symbol in the function or object
|
||||
index table (which must exist). Return 0 if not found there (or pad). */
|
||||
/* Given a symbol name or (failing that) number, look up that symbol in the
|
||||
function or object index table (which must exist). Return 0 if not found
|
||||
there (or pad). */
|
||||
|
||||
static ctf_id_t
|
||||
ctf_try_lookup_indexed (ctf_dict_t *fp, unsigned long symidx, int is_function)
|
||||
ctf_try_lookup_indexed (ctf_dict_t *fp, unsigned long symidx,
|
||||
const char *symname, int is_function)
|
||||
{
|
||||
const char *symname = ctf_lookup_symbol_name (fp, symidx);
|
||||
struct ctf_header *hp = fp->ctf_header;
|
||||
uint32_t *symtypetab;
|
||||
uint32_t *names;
|
||||
uint32_t *sxlate;
|
||||
size_t nidx;
|
||||
|
||||
ctf_dprintf ("Looking up type of object with symtab idx %lx (%s) in "
|
||||
if (symname == NULL)
|
||||
symname = ctf_lookup_symbol_name (fp, symidx);
|
||||
|
||||
ctf_dprintf ("Looking up type of object with symtab idx %lx or name %s in "
|
||||
"indexed symtypetab\n", symidx, symname);
|
||||
|
||||
if (symname[0] == '\0')
|
||||
|
|
@ -745,13 +865,15 @@ ctf_try_lookup_indexed (ctf_dict_t *fp, unsigned long symidx, int is_function)
|
|||
return symtypetab[*idx];
|
||||
}
|
||||
|
||||
/* Given a symbol table index, return the type of the function or data object
|
||||
described by the corresponding entry in the symbol table. We can only return
|
||||
symbols in read-only dicts and in dicts for which ctf_link_shuffle_syms has
|
||||
been called to assign symbol indexes to symbol names. */
|
||||
/* Given a symbol name or (if NULL) symbol index, return the type of the
|
||||
function or data object described by the corresponding entry in the symbol
|
||||
table. We can only return symbols in read-only dicts and in dicts for which
|
||||
ctf_link_shuffle_syms has been called to assign symbol indexes to symbol
|
||||
names. */
|
||||
|
||||
ctf_id_t
|
||||
ctf_lookup_by_symbol (ctf_dict_t *fp, unsigned long symidx)
|
||||
static ctf_id_t
|
||||
ctf_lookup_by_sym_or_name (ctf_dict_t *fp, unsigned long symidx,
|
||||
const char *symname)
|
||||
{
|
||||
const ctf_sect_t *sp = &fp->ctf_symtab;
|
||||
ctf_id_t type = 0;
|
||||
|
|
@ -762,38 +884,62 @@ ctf_lookup_by_symbol (ctf_dict_t *fp, unsigned long symidx)
|
|||
{
|
||||
const ctf_link_sym_t *sym;
|
||||
|
||||
ctf_dprintf ("Looking up type of object with symtab idx %lx in "
|
||||
"writable dict symtypetab\n", symidx);
|
||||
if (symname)
|
||||
ctf_dprintf ("Looking up type of object with symname %s in "
|
||||
"writable dict symtypetab\n", symname);
|
||||
else
|
||||
ctf_dprintf ("Looking up type of object with symtab idx %lx in "
|
||||
"writable dict symtypetab\n", symidx);
|
||||
|
||||
/* The dict must be dynamic. */
|
||||
if (!ctf_assert (fp, fp->ctf_flags & LCTF_RDWR))
|
||||
return CTF_ERR;
|
||||
|
||||
err = EINVAL;
|
||||
if (symidx > fp->ctf_dynsymmax)
|
||||
goto try_parent;
|
||||
/* No name? Need to look it up. */
|
||||
if (!symname)
|
||||
{
|
||||
err = EINVAL;
|
||||
if (symidx > fp->ctf_dynsymmax)
|
||||
goto try_parent;
|
||||
|
||||
sym = fp->ctf_dynsymidx[symidx];
|
||||
err = ECTF_NOTYPEDAT;
|
||||
if (!sym || (sym->st_shndx != STT_OBJECT && sym->st_shndx != STT_FUNC))
|
||||
goto try_parent;
|
||||
sym = fp->ctf_dynsymidx[symidx];
|
||||
err = ECTF_NOTYPEDAT;
|
||||
if (!sym || (sym->st_shndx != STT_OBJECT && sym->st_shndx != STT_FUNC))
|
||||
goto try_parent;
|
||||
|
||||
if (!ctf_assert (fp, !sym->st_nameidx_set))
|
||||
return CTF_ERR;
|
||||
if (!ctf_assert (fp, !sym->st_nameidx_set))
|
||||
return CTF_ERR;
|
||||
symname = sym->st_name;
|
||||
}
|
||||
|
||||
if (fp->ctf_objthash == NULL
|
||||
|| ((type = (ctf_id_t) (uintptr_t)
|
||||
ctf_dynhash_lookup (fp->ctf_objthash, sym->st_name)) == 0))
|
||||
ctf_dynhash_lookup (fp->ctf_objthash, symname)) == 0))
|
||||
{
|
||||
if (fp->ctf_funchash == NULL
|
||||
|| ((type = (ctf_id_t) (uintptr_t)
|
||||
ctf_dynhash_lookup (fp->ctf_funchash, sym->st_name)) == 0))
|
||||
ctf_dynhash_lookup (fp->ctf_funchash, symname)) == 0))
|
||||
goto try_parent;
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
/* Lookup by name in a dynamic dict: just do it directly. */
|
||||
if (symname && fp->ctf_flags & LCTF_RDWR)
|
||||
{
|
||||
if (fp->ctf_objthash == NULL
|
||||
|| ((type = (ctf_id_t) (uintptr_t)
|
||||
ctf_dynhash_lookup (fp->ctf_objthash, symname)) == 0))
|
||||
{
|
||||
if (fp->ctf_funchash == NULL
|
||||
|| ((type = (ctf_id_t) (uintptr_t)
|
||||
ctf_dynhash_lookup (fp->ctf_funchash, symname)) == 0))
|
||||
goto try_parent;
|
||||
}
|
||||
return type;
|
||||
}
|
||||
|
||||
err = ECTF_NOSYMTAB;
|
||||
if (sp->cts_data == NULL)
|
||||
goto try_parent;
|
||||
|
|
@ -801,17 +947,17 @@ ctf_lookup_by_symbol (ctf_dict_t *fp, unsigned long symidx)
|
|||
/* This covers both out-of-range lookups and a dynamic dict which hasn't been
|
||||
shuffled yet. */
|
||||
err = EINVAL;
|
||||
if (symidx >= fp->ctf_nsyms)
|
||||
if (symname == NULL && symidx >= fp->ctf_nsyms)
|
||||
goto try_parent;
|
||||
|
||||
if (fp->ctf_objtidx_names)
|
||||
{
|
||||
if ((type = ctf_try_lookup_indexed (fp, symidx, 0)) == CTF_ERR)
|
||||
if ((type = ctf_try_lookup_indexed (fp, symidx, symname, 0)) == CTF_ERR)
|
||||
return CTF_ERR; /* errno is set for us. */
|
||||
}
|
||||
if (type == 0 && fp->ctf_funcidx_names)
|
||||
{
|
||||
if ((type = ctf_try_lookup_indexed (fp, symidx, 1)) == CTF_ERR)
|
||||
if ((type = ctf_try_lookup_indexed (fp, symidx, symname, 1)) == CTF_ERR)
|
||||
return CTF_ERR; /* errno is set for us. */
|
||||
}
|
||||
if (type != 0)
|
||||
|
|
@ -825,6 +971,10 @@ ctf_lookup_by_symbol (ctf_dict_t *fp, unsigned long symidx)
|
|||
|
||||
ctf_dprintf ("Looking up object type %lx in 1:1 dict symtypetab\n", symidx);
|
||||
|
||||
if (symname != NULL)
|
||||
if ((symidx = ctf_lookup_symbol_idx (fp, symname)) == (unsigned long) -1)
|
||||
goto try_parent;
|
||||
|
||||
if (fp->ctf_sxlate[symidx] == -1u)
|
||||
goto try_parent;
|
||||
|
||||
|
|
@ -836,11 +986,33 @@ ctf_lookup_by_symbol (ctf_dict_t *fp, unsigned long symidx)
|
|||
return type;
|
||||
try_parent:
|
||||
if (fp->ctf_parent)
|
||||
return ctf_lookup_by_symbol (fp->ctf_parent, symidx);
|
||||
{
|
||||
ctf_id_t ret = ctf_lookup_by_sym_or_name (fp->ctf_parent, symidx,
|
||||
symname);
|
||||
if (ret == CTF_ERR)
|
||||
ctf_set_errno (fp, ctf_errno (fp->ctf_parent));
|
||||
return ret;
|
||||
}
|
||||
else
|
||||
return (ctf_set_errno (fp, err));
|
||||
}
|
||||
|
||||
/* Given a symbol table index, return the type of the function or data object
|
||||
described by the corresponding entry in the symbol table. */
|
||||
ctf_id_t
|
||||
ctf_lookup_by_symbol (ctf_dict_t *fp, unsigned long symidx)
|
||||
{
|
||||
return ctf_lookup_by_sym_or_name (fp, symidx, NULL);
|
||||
}
|
||||
|
||||
/* Given a symbol name, return the type of the function or data object described
|
||||
by the corresponding entry in the symbol table. */
|
||||
ctf_id_t
|
||||
ctf_lookup_by_symbol_name (ctf_dict_t *fp, const char *symname)
|
||||
{
|
||||
return ctf_lookup_by_sym_or_name (fp, 0, symname);
|
||||
}
|
||||
|
||||
/* Given a symbol table index, return the info for the function described
|
||||
by the corresponding entry in the symbol table, which may be a function
|
||||
symbol or may be a data symbol that happens to be a function pointer. */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue