OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* 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.
This commit is contained in:
Jim Blandy 2004-11-04 17:50:16 +00:00
parent 02b1af09c7
commit ad766c0a80
2 changed files with 59 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gdb/ChangeLog
View File

@ -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.

68
gdb/gdbtypes.c
View File

@ -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)