From: Nick Alcock Date: Mon, 13 Jan 2025 11:34:56 +0000 (+0000) Subject: libctf, hash: add support for freeing functions taking an arg X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=6a6a3cc9c209d55494f8688c3cfe8ccf8aa209b5;p=thirdparty%2Fbinutils-gdb.git libctf, hash: add support for freeing functions taking an arg There are a bunch of places in libctf where the code is complicated by the fact that freeing a hash key or value requires access to the dict: more generally, they want an arg pointer to *something*. But for the sake of being able to use free() as a freeing function, we can't do this at all times. We also don't want to bloat up the hash itself with an arg value unless necessary (in the same way we already avoid storing the key or value freeing functions unless at least one of them is specified). So from the outside this change is simple: add a new ctf_dynhash_create_arg which takes a new sort of freeing function which takes an argument. Internally, we store the arg only when the key or owner is set, and cast from the one freeing function to the other iff the arg is non-NULL. This means it's impossible to pass a value that may or may not be NULL to the freeing function, but that's harmless for all current uses, and allows significant simplifications elsewhere. --- diff --git a/libctf/ctf-hash.c b/libctf/ctf-hash.c index a11d11e189c..8b5c379bcb3 100644 --- a/libctf/ctf-hash.c +++ b/libctf/ctf-hash.c @@ -46,13 +46,54 @@ typedef struct ctf_helem ctf_dynhash_t *owner; /* The hash that owns us. */ } ctf_helem_t; -/* Equally, the key_free and value_free may not exist. */ +/* Equally, the key_free_ and value_free_ may not exist: if neither do, the + arg will not exist either. */ struct ctf_dynhash { struct htab *htab; - ctf_hash_free_fun key_free; - ctf_hash_free_fun value_free; + + /* The freeing functions may be of type ctf_hash_free_fun, if arg is NULL, + or ctf_hash_free_arg_fun, if it is not. + + Everything from this point on is allocated only if we have at least one + freeing function defined. */ + +#ifdef __GNUC__ + __extension__ + union + { + ctf_hash_free_fun key_free_; + ctf_hash_free_arg_fun key_arg_free_; + }; + + __extension__ + union + { + ctf_hash_free_fun value_free_; + ctf_hash_free_arg_fun value_arg_free_; + }; +#else + union + { + ctf_hash_free_fun key_free_; + ctf_hash_free_arg_fun key_arg_free_; + } _k; + + union + { + ctf_hash_free_fun value_free_; + ctf_hash_free_arg_fun value_arg_free_; + } _v; + +#define key_free_ _k.key_free_ +#define key_arg_free_ _k.key_arg_free_ +#define value_free_ _v.value_free_ +#define value_arg_free_ _v.value_arg_free_ + +#endif + + void *arg; /* arg to freeing functions. */ }; /* Hash and eq functions for the dynhash and hash. */ @@ -146,17 +187,30 @@ ctf_dynhash_item_free (void *item) { ctf_helem_t *helem = item; - if (helem->owner->key_free && helem->key) - helem->owner->key_free (helem->key); - if (helem->owner->value_free && helem->value) - helem->owner->value_free (helem->value); + if (helem->owner->key_free_ && helem->key) + { + if (!helem->owner->arg) + helem->owner->key_free_ (helem->key); + else + helem->owner->key_arg_free_ (helem->key, helem->owner->arg); + } + if (helem->owner->value_free_ && helem->value) + { + if (!helem->owner->arg) + helem->owner->value_free_ (helem->value); + else + { + helem->owner->value_arg_free_ (helem->value, helem->owner->arg); + } + } free (helem); } ctf_dynhash_t * ctf_dynhash_create_sized (unsigned long nelems, ctf_hash_fun hash_fun, - ctf_hash_eq_fun eq_fun, ctf_hash_free_fun key_free, - ctf_hash_free_fun value_free) + ctf_hash_eq_fun eq_fun, + ctf_hash_free_arg_fun key_free, + ctf_hash_free_arg_fun value_free, void *arg) { ctf_dynhash_t *dynhash; htab_del del = ctf_dynhash_item_free; @@ -165,7 +219,7 @@ ctf_dynhash_create_sized (unsigned long nelems, ctf_hash_fun hash_fun, dynhash = malloc (sizeof (ctf_dynhash_t)); else { - void *p = malloc (offsetof (ctf_dynhash_t, key_free)); + void *p = malloc (offsetof (ctf_dynhash_t, key_free_)); dynhash = p; } if (!dynhash) @@ -183,20 +237,44 @@ ctf_dynhash_create_sized (unsigned long nelems, ctf_hash_fun hash_fun, if (key_free || value_free) { - dynhash->key_free = key_free; - dynhash->value_free = value_free; + dynhash->key_arg_free_ = key_free; + dynhash->value_arg_free_ = value_free; + dynhash->arg = arg; } return dynhash; } +ctf_dynhash_t * +ctf_dynhash_create_arg (ctf_hash_fun hash_fun, ctf_hash_eq_fun eq_fun, + ctf_hash_free_arg_fun key_free, + ctf_hash_free_arg_fun value_free, + void *arg) +{ + /* 7 is arbitrary and not benchmarked yet. */ + + return ctf_dynhash_create_sized (7, hash_fun, eq_fun, key_free, value_free, arg); +} + ctf_dynhash_t * ctf_dynhash_create (ctf_hash_fun hash_fun, ctf_hash_eq_fun eq_fun, ctf_hash_free_fun key_free, ctf_hash_free_fun value_free) { + union cast + { + ctf_hash_free_fun in; + ctf_hash_free_arg_fun out; + }; + union cast key_arg_free; + union cast value_arg_free; + + key_arg_free.in = key_free; + value_arg_free.in = value_free; + /* 7 is arbitrary and not benchmarked yet. */ - return ctf_dynhash_create_sized (7, hash_fun, eq_fun, key_free, value_free); + return ctf_dynhash_create_sized (7, hash_fun, eq_fun, key_arg_free.out, + value_arg_free.out, NULL); } static ctf_helem_t ** @@ -209,7 +287,8 @@ ctf_hashtab_lookup (struct htab *htab, const void *key, enum insert_option inser static ctf_helem_t * ctf_hashtab_insert (struct htab *htab, void *key, void *value, ctf_hash_free_fun key_free, - ctf_hash_free_fun value_free) + ctf_hash_free_fun value_free, + void *arg) { ctf_helem_t **slot; @@ -238,10 +317,37 @@ ctf_hashtab_insert (struct htab *htab, void *key, void *value, } else { + union cast + { + ctf_hash_free_fun in; + ctf_hash_free_arg_fun out; + }; + if (key_free) - key_free (key); + { + {if (!arg) + key_free (key); + else + { + union cast key_arg_free; + + key_arg_free.in = key_free; + key_arg_free.out (key, arg); + } + } + } if (value_free) - value_free ((*slot)->value); + { + if (!arg) + value_free ((*slot)->value); + else + { + union cast value_arg_free; + + value_arg_free.in = value_free; + value_arg_free.out ((*slot)->value, arg); + } + } } (*slot)->value = value; return *slot; @@ -252,14 +358,16 @@ ctf_dynhash_insert (ctf_dynhash_t *hp, void *key, void *value) { ctf_helem_t *slot; ctf_hash_free_fun key_free = NULL, value_free = NULL; + void *arg = NULL; if (hp->htab->del_f == ctf_dynhash_item_free) { - key_free = hp->key_free; - value_free = hp->value_free; + key_free = hp->key_free_; + value_free = hp->value_free_; + arg = hp->arg; } slot = ctf_hashtab_insert (hp->htab, key, value, - key_free, value_free); + key_free, value_free, arg); if (!slot) return -errno; @@ -579,7 +687,8 @@ ctf_dynhash_destroy (ctf_dynhash_t *hp) /* The dynset, used for sets of keys with no value. The implementation of this can be much simpler, because without a value the slot can simply be the stored key, which means we don't need to store the freeing functions and the - dynset itself is just a htab. */ + dynset itself is just a htab. There is no support for freeing + functions with args. */ ctf_dynset_t * ctf_dynset_create (htab_hash hash_fun, htab_eq eq_fun, diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h index c50f06e3d6f..90b0b95d08c 100644 --- a/libctf/ctf-impl.h +++ b/libctf/ctf-impl.h @@ -651,7 +651,12 @@ extern int ctf_hash_eq_string (const void *, const void *); extern int ctf_hash_eq_type_key (const void *, const void *); extern int ctf_hash_eq_type_id_key (const void *, const void *); +/* Freeing functions. ctf_hash_free_fun is used unless the arg + parameter to ctf_dynhash_create_{arg,sized} is non-NULL. + There is no way to pass a NULL arg to ctf_hash_free_arg_fun. */ + typedef void (*ctf_hash_free_fun) (void *); +typedef void (*ctf_hash_free_arg_fun) (void *, void *); typedef void (*ctf_hash_iter_f) (void *key, void *value, void *arg); typedef int (*ctf_hash_iter_remove_f) (void *key, void *value, void *arg); @@ -661,10 +666,14 @@ typedef int (*ctf_hash_sort_f) (const ctf_next_hkv_t *, const ctf_next_hkv_t *, extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun, ctf_hash_free_fun, ctf_hash_free_fun); +extern ctf_dynhash_t *ctf_dynhash_create_arg (ctf_hash_fun, ctf_hash_eq_fun, + ctf_hash_free_arg_fun, + ctf_hash_free_arg_fun, void *); extern ctf_dynhash_t *ctf_dynhash_create_sized (unsigned long, ctf_hash_fun, ctf_hash_eq_fun, - ctf_hash_free_fun, - ctf_hash_free_fun); + ctf_hash_free_arg_fun, + ctf_hash_free_arg_fun, + void *); extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *); extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *); diff --git a/libctf/ctf-open.c b/libctf/ctf-open.c index 219831be46d..4cf18f0bced 100644 --- a/libctf/ctf-open.c +++ b/libctf/ctf-open.c @@ -791,17 +791,20 @@ init_static_types (ctf_dict_t *fp, ctf_header_t *cth) if ((fp->ctf_structs = ctf_dynhash_create_sized (pop[CTF_K_STRUCT], ctf_hash_string, - ctf_hash_eq_string, NULL, NULL)) == NULL) + ctf_hash_eq_string, + NULL, NULL, NULL)) == NULL) return ENOMEM; if ((fp->ctf_unions = ctf_dynhash_create_sized (pop[CTF_K_UNION], ctf_hash_string, - ctf_hash_eq_string, NULL, NULL)) == NULL) + ctf_hash_eq_string, + NULL, NULL, NULL)) == NULL) return ENOMEM; if ((fp->ctf_enums = ctf_dynhash_create_sized (pop[CTF_K_ENUM], ctf_hash_string, - ctf_hash_eq_string, NULL, NULL)) == NULL) + ctf_hash_eq_string, + NULL, NULL, NULL)) == NULL) return ENOMEM; if ((fp->ctf_names @@ -816,7 +819,8 @@ init_static_types (ctf_dict_t *fp, ctf_header_t *cth) pop[CTF_K_RESTRICT] + pop_enumerators, ctf_hash_string, - ctf_hash_eq_string, NULL, NULL)) == NULL) + ctf_hash_eq_string, + NULL, NULL, NULL)) == NULL) return ENOMEM; if ((fp->ctf_conflicting_enums