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 abd0140aeaf6f6996cb8dd4bc002389d68be3cf9..17eb565a126ba09662fdcd98d908f59665ed9d35 100644 (file)
--- 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;
@@ -604,7 +712,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 2ce8b04b846e881afb1f878c199c9b802df0da8a..f618e3ad276f87f5109fc70e24568af9b5df6126 100644 (file)
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -660,7 +660,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);
@@ -670,10 +675,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 a04e29207a0a169110b750c2804fa595b1362a90..d785d13ac7054523f326c438c097d700322dc6b4 100644 (file)
--- 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