* gdbtypes.c (make_qualified_type): Doc fix. Add assertion to

prevent cross-objfile references.
(make_cv_type): Doc fix.  Don't create cross-objfile references,
even for stub types.
(replace_type): Add assertion to prevent cross-objfile references.
(check_typedef): Never resolve a stub type by copying over a type
from another file.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index e2fa7d378a0ad6ed54358e886f11999148c1fa34..b0c52eaf5509b8c3f71315646085e6400b9f122b 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,13 @@
+2004-11-04  Jim Blandy  <jimb@redhat.com>
+
+       * gdbtypes.c (make_qualified_type): Doc fix.  Add assertion to
+       prevent cross-objfile references.
+       (make_cv_type): Doc fix.  Don't create cross-objfile references,
+       even for stub types.
+       (replace_type): Add assertion to prevent cross-objfile references.
+       (check_typedef): Never resolve a stub type by copying over a type
+       from another file.
+
 2004-11-04  Kei Sakamoto  <sakamoto.kei@denesas.com>
 
        * Makefile.in (m32r-tdep.o): Update dependencies.

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index f8604bc151a6bb5897d52d9484e8f61e6c76ab71..3b0c48a45e4ec4ddad4b0bc86070a6a62b9dde09 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -433,7 +433,9 @@ address_space_int_to_name (int space_flag)
 }
 
 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
-   If STORAGE is non-NULL, create the new type instance there.  */
+
+   If STORAGE is non-NULL, create the new type instance there.
+   STORAGE must be in the same obstack as TYPE.  */
 
 static struct type *
 make_qualified_type (struct type *type, int new_flags,
@@ -453,6 +455,12 @@ make_qualified_type (struct type *type, int new_flags,
     ntype = alloc_type_instance (type);
   else
     {
+      /* If STORAGE was provided, it had better be in the same objfile as
+        TYPE.  Otherwise, we can't link it into TYPE's cv chain: if one
+        objfile is freed and the other kept, we'd have dangling
+        pointers.  */
+      gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
+
       ntype = storage;
       TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
       TYPE_CHAIN (ntype) = ntype;
@@ -501,11 +509,12 @@ make_type_with_address_space (struct type *type, int space_flag)
    CNST is a flag for setting the const attribute
    VOLTL is a flag for setting the volatile attribute
    TYPE is the base type whose variant we are creating.
-   TYPEPTR, if nonzero, points
-   to a pointer to memory where the reference type should be stored.
-   If *TYPEPTR is zero, update it to point to the reference type we return.
-   We allocate new memory if needed.  */
 
+   If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
+   storage to hold the new qualified type; *TYPEPTR and TYPE must be
+   in the same objfile.  Otherwise, allocate fresh memory for the new
+   type whereever TYPE lives.  If TYPEPTR is non-zero, set it to the
+   new type we construct.  */
 struct type *
 make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
 {
@@ -524,20 +533,19 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
 
   if (typeptr && *typeptr != NULL)
     {
-      /* Objfile is per-core-type.  This const-qualified type had best
-        belong to the same objfile as the type it is qualifying, unless
-        we are overwriting a stub type, in which case the safest thing
-        to do is to copy the core type into the new objfile.  */
+      /* TYPE and *TYPEPTR must be in the same objfile.  We can't have
+        a C-V variant chain that threads across objfiles: if one
+        objfile gets freed, then the other has a broken C-V chain.
 
-      gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)
-                 || TYPE_STUB (*typeptr));
-      if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type))
-       {
-         TYPE_MAIN_TYPE (*typeptr)
-           = TYPE_ALLOC (*typeptr, sizeof (struct main_type));
-         *TYPE_MAIN_TYPE (*typeptr)
-           = *TYPE_MAIN_TYPE (type);
-       }
+        This code used to try to copy over the main type from TYPE to
+        *TYPEPTR if they were in different objfiles, but that's
+        wrong, too: TYPE may have a field list or member function
+        lists, which refer to types of their own, etc. etc.  The
+        whole shebang would need to be copied over recursively; you
+        can't have inter-objfile pointers.  The only thing to do is
+        to leave stub types as stub types, and look them up afresh by
+        name each time you encounter them.  */
+      gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
     }
   
   ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL);
@@ -562,6 +570,12 @@ replace_type (struct type *ntype, struct type *type)
 {
   struct type *chain;
 
+  /* These two types had better be in the same objfile.  Otherwise,
+     the assignment of one type's main type structure to the other
+     will produce a type with references to objects (names; field
+     lists; etc.) allocated on an objfile other than its own.  */
+  gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
+
   *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
 
   /* The type length is not a part of the main type.  Update it for each
@@ -1416,8 +1430,24 @@ check_typedef (struct type *type)
          return type;
        }
       newtype = lookup_transparent_type (name);
+
       if (newtype)
-       make_cv_type (is_const, is_volatile, newtype, &type);
+       {
+         /* If the resolved type and the stub are in the same objfile,
+            then replace the stub type with the real deal.  But if
+            they're in separate objfiles, leave the stub alone; we'll
+            just look up the transparent type every time we call
+            check_typedef.  We can't create pointers between types
+            allocated to different objfiles, since they may have
+            different lifetimes.  Trying to copy NEWTYPE over to TYPE's
+            objfile is pointless, too, since you'll have to move over any
+            other types NEWTYPE refers to, which could be an unbounded
+            amount of stuff.  */
+         if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
+           make_cv_type (is_const, is_volatile, newtype, &type);
+         else
+           type = newtype;
+       }
     }
   /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
   else if (TYPE_STUB (type) && !currently_reading_symtab)