diff options
author | Nick Alcock <nick.alcock@oracle.com> | 2024-06-11 20:58:00 +0100 |
---|---|---|
committer | Nick Alcock <nick.alcock@oracle.com> | 2024-06-18 13:20:32 +0100 |
commit | 2fa4b6e6df05990365066a0b286322502778d530 (patch) | |
tree | d4179f254df17ed689443abc326fc110f540293a /libctf/ctf-archive.c | |
parent | 1f62f2a9b561cd828feb719489be5dd5b9721777 (diff) | |
download | binutils-2fa4b6e6df05990365066a0b286322502778d530.zip binutils-2fa4b6e6df05990365066a0b286322502778d530.tar.gz binutils-2fa4b6e6df05990365066a0b286322502778d530.tar.bz2 |
libctf, include: new functions for looking up enumerators
Three new functions for looking up the enum type containing a given
enumeration constant, and optionally that constant's value.
The simplest, ctf_lookup_enumerator, looks up a root-visible enumerator by
name in one dict: if the dict contains multiple such constants (which is
possible for dicts created by older versions of the libctf deduplicator),
ECTF_DUPLICATE is returned.
The next simplest, ctf_lookup_enumerator_next, is an iterator which returns
all enumerators with a given name in a given dict, whether root-visible or
not.
The most elaborate, ctf_arc_lookup_enumerator_next, finds all
enumerators with a given name across all dicts in an entire CTF archive,
whether root-visible or not, starting looking in the shared parent dict;
opened dicts are cached (as with all other ctf_arc_*lookup functions) so
that repeated use does not incur repeated opening costs.
All three of these return enumerator values as int64_t: unfortunately, API
compatibility concerns prevent us from doing the same with the other older
enum-related functions, which all return enumerator constant values as ints.
We may be forced to add symbol-versioning compatibility aliases that fix the
other functions in due course, bumping the soname for platforms that do not
support such things.
ctf_arc_lookup_enumerator_next is implemented as a nested ctf_archive_next
iterator, and inside that, a nested ctf_lookup_enumerator_next iterator
within each dict. To aid in this, add support to ctf_next_t iterators for
iterators that are implemented in terms of two simultaneous nested iterators
at once. (It has always been possible for callers to use as many nested or
semi-overlapping ctf_next_t iterators as they need, which is one of the
advantages of this style over the _iter style that calls a function for each
thing iterated over: the iterator change here permits *ctf_next_t iterators
themselves* to be implemented by iterating using multiple other iterators as
part of their internal operation, transparently to the caller.)
Also add a testcase that tests all these functions (which is fairly easy
because ctf_arc_lookup_enumerator_next is implemented in terms of
ctf_lookup_enumerator_next) in addition to enumeration addition in
ctf_open()ed dicts, ctf_add_enumerator duplicate enumerator addition, and
conflicting enumerator constant deduplication.
include/
* ctf-api.h (ctf_lookup_enumerator): New.
(ctf_lookup_enumerator_next): Likewise.
(ctf_arc_lookup_enumerator_next): Likewise.
libctf/
* libctf.ver: Add them.
* ctf-impl.h (ctf_next_t) <ctn_next_inner>: New.
* ctf-util.c (ctf_next_copy): Copy it.
(ctf_next_destroy): Destroy it.
* ctf-lookup.c (ctf_lookup_enumerator): New.
(ctf_lookup_enumerator_next): New.
* ctf-archive.c (ctf_arc_lookup_enumerator_next): New.
* testsuite/libctf-lookup/enumerator-iteration.*: New test.
* testsuite/libctf-lookup/enum-ctf-2.c: New test CTF, used by the
above.
Diffstat (limited to 'libctf/ctf-archive.c')
-rw-r--r-- | libctf/ctf-archive.c | 107 |
1 files changed, 107 insertions, 0 deletions
diff --git a/libctf/ctf-archive.c b/libctf/ctf-archive.c index 4744cb7..c602705 100644 --- a/libctf/ctf-archive.c +++ b/libctf/ctf-archive.c @@ -1011,6 +1011,113 @@ ctf_arc_lookup_symbol_name (ctf_archive_t *wrapper, const char *symname, return ctf_arc_lookup_sym_or_name (wrapper, 0, symname, typep, errp); } +/* Return all enumeration constants with a given NAME across all dicts in an + archive, similar to ctf_lookup_enumerator_next. The DICT is cached, so + opening costs are paid only once, but (unlike ctf_arc_lookup_symbol* + above) the results of the iterations are not cached. dict and errp are + not optional. */ + +ctf_id_t +ctf_arc_lookup_enumerator_next (ctf_archive_t *arc, const char *name, + ctf_next_t **it, int64_t *enum_value, + ctf_dict_t **dict, int *errp) +{ + ctf_next_t *i = *it; + ctf_id_t type; + int opened_this_time = 0; + int err; + + /* We have two nested iterators in here: ctn_next tracks archives, while + within it ctn_next_inner tracks enumerators within an archive. We + keep track of the dict by simply reusing the passed-in arg: if it's + changed by the caller, the caller will get an ECTF_WRONGFP error, + so this is quite safe and means we don't have to track the arc and fp + simultaneously in the ctf_next_t. */ + + if (!i) + { + if ((i = ctf_next_create ()) == NULL) + { + err = ENOMEM; + goto err; + } + i->ctn_iter_fun = (void (*) (void)) ctf_arc_lookup_enumerator_next; + i->cu.ctn_arc = arc; + *it = i; + } + + if ((void (*) (void)) ctf_arc_lookup_enumerator_next != i->ctn_iter_fun) + { + err = ECTF_NEXT_WRONGFUN; + goto err; + } + + if (arc != i->cu.ctn_arc) + { + err = ECTF_NEXT_WRONGFP; + goto err; + } + + /* Prevent any earlier end-of-iteration on this dict from confusing the + test below. */ + if (i->ctn_next != NULL) + ctf_set_errno (*dict, 0); + + do + { + /* At end of one dict, or not started any iterations yet? + Traverse to next dict. If we never returned this dict to the + caller, close it ourselves: the caller will never see it and cannot + do so. */ + + if (i->ctn_next == NULL || ctf_errno (*dict) == ECTF_NEXT_END) + { + if (opened_this_time) + { + ctf_dict_close (*dict); + *dict = NULL; + opened_this_time = 0; + } + + *dict = ctf_archive_next (arc, &i->ctn_next, NULL, 0, &err); + if (!*dict) + goto err; + opened_this_time = 1; + } + + type = ctf_lookup_enumerator_next (*dict, name, &i->ctn_next_inner, + enum_value); + } + while (type == CTF_ERR && ctf_errno (*dict) == ECTF_NEXT_END); + + if (type == CTF_ERR) + { + err = ctf_errno (*dict); + goto err; + } + + /* If this dict is being reused from the previous iteration, bump its + refcnt: the caller is going to close it and has no idea that we didn't + open it this time round. */ + if (!opened_this_time) + ctf_ref (*dict); + + return type; + + err: /* Also ECTF_NEXT_END. */ + if (opened_this_time) + { + ctf_dict_close (*dict); + *dict = NULL; + } + + ctf_next_destroy (i); + *it = NULL; + if (errp) + *errp = err; + return CTF_ERR; +} + /* Raw iteration over all CTF files in an archive. We pass the raw data for all CTF files in turn to the specified callback function. */ static int |