Change allocation of type-copying hash table

When an objfile is destroyed, types that are still in use and
allocated on that objfile are copied.  A temporary hash map is created
during this process, and it is allocated on the destroyed objfile's
obstack -- which normally is fine, as that is going to be destroyed
shortly anyway.

However, this approach requires that the objfile be passed to registry
destruction, and this won't be possible in the rewritten registry.
This patch changes the copied type hash table to simply use the heap
instead.  It also removes the 'objfile' parameter from
copy_type_recursive, to make this all more clear.

This patch also fixes an apparent bug in copy_type_recursive.
Previously it was copying the dynamic property list to the dying
objfile's obstack:

-      = copy_dynamic_prop_list (&objfile->objfile_obstack,

However I think this is incorrect -- that obstack is about to be
destroyed.

diff --git a/gdb/compile/compile-object-run.c b/gdb/compile/compile-object-run.c
index 331ae35c5e92c1ddda6298996aac9341be1e0cd7..6fcd10b29a44ad167772bbb75ff2bd1b43d20860 100644 (file)
--- a/gdb/compile/compile-object-run.c
+++ b/gdb/compile/compile-object-run.c
@@ -109,8 +109,8 @@ do_module_cleanup (void *arg, int registers_valid)
 static type *
 create_copied_type_recursive (objfile *objfile, type *func_type)
 {
-  htab_up copied_types = create_copied_types_hash (objfile);
-  func_type = copy_type_recursive (objfile, func_type, copied_types.get ());
+  htab_up copied_types = create_copied_types_hash ();
+  func_type = copy_type_recursive (func_type, copied_types.get ());
   return func_type;
 }
 

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index c8f985548594e49e5d8baa94f972d46a7cf9495c..34da6d80e924e36d3c5952bc81b69cf7f6c2e5bc 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -5562,7 +5562,7 @@ recursive_dump_type (struct type *type, int spaces)
 /* Trivial helpers for the libiberty hash table, for mapping one
    type to another.  */
 
-struct type_pair : public allocate_on_obstack
+struct type_pair
 {
   type_pair (struct type *old_, struct type *newobj_)
     : old (old_), newobj (newobj_)
@@ -5589,22 +5589,20 @@ type_pair_eq (const void *item_lhs, const void *item_rhs)
 }
 
 /* Allocate the hash table used by copy_type_recursive to walk
-   types without duplicates.  We use OBJFILE's obstack, because
-   OBJFILE is about to be deleted.  */
+   types without duplicates.  */
 
 htab_up
-create_copied_types_hash (struct objfile *objfile)
+create_copied_types_hash ()
 {
-  return htab_up (htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
-                                       NULL, &objfile->objfile_obstack,
-                                       hashtab_obstack_allocate,
-                                       dummy_obstack_deallocate));
+  return htab_up (htab_create_alloc (1, type_pair_hash, type_pair_eq,
+                                    htab_delete_entry<type_pair>,
+                                    xcalloc, xfree));
 }
 
 /* Recursively copy (deep copy) a dynamic attribute list of a type.  */
 
 static struct dynamic_prop_list *
-copy_dynamic_prop_list (struct obstack *objfile_obstack,
+copy_dynamic_prop_list (struct obstack *storage,
                        struct dynamic_prop_list *list)
 {
   struct dynamic_prop_list *copy = list;
@@ -5615,7 +5613,7 @@ copy_dynamic_prop_list (struct obstack *objfile_obstack,
       struct dynamic_prop_list *node_copy;
 
       node_copy = ((struct dynamic_prop_list *)
-                  obstack_copy (objfile_obstack, *node_ptr,
+                  obstack_copy (storage, *node_ptr,
                                 sizeof (struct dynamic_prop_list)));
       node_copy->prop = (*node_ptr)->prop;
       *node_ptr = node_copy;
@@ -5632,9 +5630,7 @@ copy_dynamic_prop_list (struct obstack *objfile_obstack,
    it is not associated with OBJFILE.  */
 
 struct type *
-copy_type_recursive (struct objfile *objfile, 
-                    struct type *type,
-                    htab_t copied_types)
+copy_type_recursive (struct type *type, htab_t copied_types)
 {
   void **slot;
   struct type *new_type;
@@ -5642,10 +5638,6 @@ copy_type_recursive (struct objfile *objfile,
   if (!type->is_objfile_owned ())
     return type;
 
-  /* This type shouldn't be pointing to any types in other objfiles;
-     if it did, the type might disappear unexpectedly.  */
-  gdb_assert (type->objfile_owner () == objfile);
-
   struct type_pair pair (type, nullptr);
 
   slot = htab_find_slot (copied_types, &pair, INSERT);
@@ -5656,8 +5648,7 @@ copy_type_recursive (struct objfile *objfile,
 
   /* We must add the new type to the hash table immediately, in case
      we encounter this type again during a recursive call below.  */
-  struct type_pair *stored
-    = new (&objfile->objfile_obstack) struct type_pair (type, new_type);
+  struct type_pair *stored = new type_pair (type, new_type);
 
   *slot = stored;
 
@@ -5690,8 +5681,7 @@ copy_type_recursive (struct objfile *objfile,
          TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
          if (type->field (i).type ())
            new_type->field (i).set_type
-             (copy_type_recursive (objfile, type->field (i).type (),
-                                   copied_types));
+             (copy_type_recursive (type->field (i).type (), copied_types));
          if (type->field (i).name ())
            new_type->field (i).set_name (xstrdup (type->field (i).name ()));
 
@@ -5736,16 +5726,14 @@ copy_type_recursive (struct objfile *objfile,
 
   if (type->main_type->dyn_prop_list != NULL)
     new_type->main_type->dyn_prop_list
-      = copy_dynamic_prop_list (&objfile->objfile_obstack,
+      = copy_dynamic_prop_list (gdbarch_obstack (new_type->arch_owner ()),
                                type->main_type->dyn_prop_list);
 
 
   /* Copy pointers to other types.  */
   if (TYPE_TARGET_TYPE (type))
     TYPE_TARGET_TYPE (new_type) = 
-      copy_type_recursive (objfile, 
-                          TYPE_TARGET_TYPE (type),
-                          copied_types);
+      copy_type_recursive (TYPE_TARGET_TYPE (type), copied_types);
 
   /* Maybe copy the type_specific bits.
 
@@ -5774,7 +5762,7 @@ copy_type_recursive (struct objfile *objfile,
       break;
     case TYPE_SPECIFIC_SELF_TYPE:
       set_type_self_type (new_type,
-                         copy_type_recursive (objfile, TYPE_SELF_TYPE (type),
+                         copy_type_recursive (TYPE_SELF_TYPE (type),
                                               copied_types));
       break;
     case TYPE_SPECIFIC_FIXED_POINT:

diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 7437e1db8ab08d897be9e7d62e249a957f1e491b..cb98922822287ae5e12462b555503f8d5041806f 100644 (file)
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -2875,10 +2875,9 @@ extern int class_or_union_p (const struct type *);
 
 extern void maintenance_print_type (const char *, int);
 
-extern htab_up create_copied_types_hash (struct objfile *objfile);
+extern htab_up create_copied_types_hash ();
 
-extern struct type *copy_type_recursive (struct objfile *objfile,
-                                        struct type *type,
+extern struct type *copy_type_recursive (struct type *type,
                                         htab_t copied_types);
 
 extern struct type *copy_type (const struct type *type);

diff --git a/gdb/guile/scm-type.c b/gdb/guile/scm-type.c
index 27d00f12a95e01696107d2f692993419798e283a..dd7eace8d40f69df275c1cd0337ae09a54cb9fd0 100644 (file)
--- a/gdb/guile/scm-type.c
+++ b/gdb/guile/scm-type.c
@@ -360,7 +360,7 @@ tyscm_copy_type_recursive (void **slot, void *info)
   gdb_assert (objfile != NULL);
 
   htab_empty (copied_types);
-  t_smob->type = copy_type_recursive (objfile, t_smob->type, copied_types);
+  t_smob->type = copy_type_recursive (t_smob->type, copied_types);
 
   /* The eq?-hashtab that the type lived in is going away.
      Add the type to its new eq?-hashtab: Otherwise if/when the type is later
@@ -391,7 +391,7 @@ save_objfile_types (struct objfile *objfile, void *datum)
   if (!gdb_scheme_initialized)
     return;
 
-  htab_up copied_types = create_copied_types_hash (objfile);
+  htab_up copied_types = create_copied_types_hash ();
 
   if (htab != NULL)
     {

diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c
index 0e772ad44b4a9d397ae8465bb4cafe613885ede9..7cfc8d16233a3420235ca77516a1ed23b36e2ce5 100644 (file)
--- a/gdb/python/py-type.c
+++ b/gdb/python/py-type.c
@@ -1123,7 +1123,7 @@ save_objfile_types (struct objfile *objfile, void *datum)
      operating on.  */
   gdbpy_enter enter_py (objfile->arch ());
 
-  htab_up copied_types = create_copied_types_hash (objfile);
+  htab_up copied_types = create_copied_types_hash ();
 
   while (obj)
     {
@@ -1131,8 +1131,7 @@ save_objfile_types (struct objfile *objfile, void *datum)
 
       htab_empty (copied_types.get ());
 
-      obj->type = copy_type_recursive (objfile, obj->type,
-                                      copied_types.get ());
+      obj->type = copy_type_recursive (obj->type, copied_types.get ());
 
       obj->next = NULL;
       obj->prev = NULL;

diff --git a/gdb/value.c b/gdb/value.c
index d027eef07e577e675224dc9c11799631de231e02..557e22154ebf378120f4a53c0b2b7b33fe61fad5 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -2571,11 +2571,10 @@ preserve_one_value (struct value *value, struct objfile *objfile,
                    htab_t copied_types)
 {
   if (value->type->objfile_owner () == objfile)
-    value->type = copy_type_recursive (objfile, value->type, copied_types);
+    value->type = copy_type_recursive (value->type, copied_types);
 
   if (value->enclosing_type->objfile_owner () == objfile)
-    value->enclosing_type = copy_type_recursive (objfile,
-                                                value->enclosing_type,
+    value->enclosing_type = copy_type_recursive (value->enclosing_type,
                                                 copied_types);
 }
 
@@ -2591,7 +2590,7 @@ preserve_one_internalvar (struct internalvar *var, struct objfile *objfile,
       if (var->u.integer.type
          && var->u.integer.type->objfile_owner () == objfile)
        var->u.integer.type
-         = copy_type_recursive (objfile, var->u.integer.type, copied_types);
+         = copy_type_recursive (var->u.integer.type, copied_types);
       break;
 
     case INTERNALVAR_VALUE:
@@ -2612,7 +2611,7 @@ preserve_one_varobj (struct varobj *varobj, struct objfile *objfile,
       && varobj->type->objfile_owner () == objfile)
     {
       varobj->type
-       = copy_type_recursive (objfile, varobj->type, copied_types);
+       = copy_type_recursive (varobj->type, copied_types);
     }
 
   if (varobj->value != nullptr)
@@ -2632,7 +2631,7 @@ preserve_values (struct objfile *objfile)
 
   /* Create the hash table.  We allocate on the objfile's obstack, since
      it is soon to be deleted.  */
-  htab_up copied_types = create_copied_types_hash (objfile);
+  htab_up copied_types = create_copied_types_hash ();
 
   for (const value_ref_ptr &item : value_history)
     preserve_one_value (item.get (), objfile, copied_types.get ());