1 2004-11-04 Jim Blandy <jimb@redhat.com>
3 * gdbtypes.c (make_qualified_type): Doc fix. Add assertion to
4 prevent cross-objfile references.
5 (make_cv_type): Doc fix. Don't create cross-objfile references,
7 (replace_type): Add assertion to prevent cross-objfile references.
8 (check_typedef): Never resolve a stub type by copying over a type
11 Index: src/gdb/gdbtypes.c
12 ===================================================================
13 RCS file: /big/fsf/rsync/src-cvs/src/gdb/gdbtypes.c,v
14 retrieving revision 1.92
15 retrieving revision 1.93
16 diff -u -p -r1.92 -r1.93
17 --- src/gdb/gdbtypes.c 8 Aug 2004 17:18:16 -0000 1.92
18 +++ src/gdb/gdbtypes.c 4 Nov 2004 17:50:16 -0000 1.93
19 @@ -433,7 +433,9 @@ address_space_int_to_name (int space_fla
22 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
23 - If STORAGE is non-NULL, create the new type instance there. */
25 + If STORAGE is non-NULL, create the new type instance there.
26 + STORAGE must be in the same obstack as TYPE. */
29 make_qualified_type (struct type *type, int new_flags,
30 @@ -453,6 +455,12 @@ make_qualified_type (struct type *type,
31 ntype = alloc_type_instance (type);
34 + /* If STORAGE was provided, it had better be in the same objfile as
35 + TYPE. Otherwise, we can't link it into TYPE's cv chain: if one
36 + objfile is freed and the other kept, we'd have dangling
38 + gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
41 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
42 TYPE_CHAIN (ntype) = ntype;
43 @@ -501,11 +509,12 @@ make_type_with_address_space (struct typ
44 CNST is a flag for setting the const attribute
45 VOLTL is a flag for setting the volatile attribute
46 TYPE is the base type whose variant we are creating.
47 - TYPEPTR, if nonzero, points
48 - to a pointer to memory where the reference type should be stored.
49 - If *TYPEPTR is zero, update it to point to the reference type we return.
50 - We allocate new memory if needed. */
52 + If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
53 + storage to hold the new qualified type; *TYPEPTR and TYPE must be
54 + in the same objfile. Otherwise, allocate fresh memory for the new
55 + type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
56 + new type we construct. */
58 make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
60 @@ -524,20 +533,19 @@ make_cv_type (int cnst, int voltl, struc
62 if (typeptr && *typeptr != NULL)
64 - /* Objfile is per-core-type. This const-qualified type had best
65 - belong to the same objfile as the type it is qualifying, unless
66 - we are overwriting a stub type, in which case the safest thing
67 - to do is to copy the core type into the new objfile. */
69 - gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)
70 - || TYPE_STUB (*typeptr));
71 - if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type))
73 - TYPE_MAIN_TYPE (*typeptr)
74 - = TYPE_ALLOC (*typeptr, sizeof (struct main_type));
75 - *TYPE_MAIN_TYPE (*typeptr)
76 - = *TYPE_MAIN_TYPE (type);
78 + /* TYPE and *TYPEPTR must be in the same objfile. We can't have
79 + a C-V variant chain that threads across objfiles: if one
80 + objfile gets freed, then the other has a broken C-V chain.
82 + This code used to try to copy over the main type from TYPE to
83 + *TYPEPTR if they were in different objfiles, but that's
84 + wrong, too: TYPE may have a field list or member function
85 + lists, which refer to types of their own, etc. etc. The
86 + whole shebang would need to be copied over recursively; you
87 + can't have inter-objfile pointers. The only thing to do is
88 + to leave stub types as stub types, and look them up afresh by
89 + name each time you encounter them. */
90 + gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
93 ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL);
94 @@ -562,6 +570,12 @@ replace_type (struct type *ntype, struct
98 + /* These two types had better be in the same objfile. Otherwise,
99 + the assignment of one type's main type structure to the other
100 + will produce a type with references to objects (names; field
101 + lists; etc.) allocated on an objfile other than its own. */
102 + gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
104 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
106 /* The type length is not a part of the main type. Update it for each
107 @@ -1416,8 +1430,24 @@ check_typedef (struct type *type)
110 newtype = lookup_transparent_type (name);
113 - make_cv_type (is_const, is_volatile, newtype, &type);
115 + /* If the resolved type and the stub are in the same objfile,
116 + then replace the stub type with the real deal. But if
117 + they're in separate objfiles, leave the stub alone; we'll
118 + just look up the transparent type every time we call
119 + check_typedef. We can't create pointers between types
120 + allocated to different objfiles, since they may have
121 + different lifetimes. Trying to copy NEWTYPE over to TYPE's
122 + objfile is pointless, too, since you'll have to move over any
123 + other types NEWTYPE refers to, which could be an unbounded
124 + amount of stuff. */
125 + if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
126 + make_cv_type (is_const, is_volatile, newtype, &type);
131 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
132 else if (TYPE_STUB (type) && !currently_reading_symtab)