diff options
Diffstat (limited to 'gdb')
| -rw-r--r-- | gdb/ChangeLog | 9 | ||||
| -rw-r--r-- | gdb/gdbtypes.c | 21 | ||||
| -rw-r--r-- | gdb/gdbtypes.h | 61 |
3 files changed, 60 insertions, 31 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d5ec952..f169218 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,12 @@ +2003-02-07 Kevin Buettner <kevinb@redhat.com> + + * gdbtypes.h (struct main_type): Move ``length'' field from here... + (struct type): ...to here. + (TYPE_LENGTH): Adjust to reflect different location of ``length'' + field. + * gdbtypes.c (make_qualified_type): Set length on newly created type. + (replace_type): Set length on all type variants for a given type. + 2003-02-07 Andrew Cagney <ac131313@redhat.com> * sol-thread.c, hpux-thread.c: Include "gdb_stat.h" instead of diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index f93b36b..67567d9 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -469,6 +469,9 @@ make_qualified_type (struct type *type, int new_flags, /* Now set the instance flags and return the new type. */ TYPE_INSTANCE_FLAGS (ntype) = new_flags; + /* Set length of new type to that of the original type. */ + TYPE_LENGTH (ntype) = TYPE_LENGTH (type); + return ntype; } @@ -556,10 +559,26 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr) void replace_type (struct type *ntype, struct type *type) { - struct type *cv_chain, *as_chain, *ptr, *ref; + struct type *chain; *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type); + /* The type length is not a part of the main type. Update it for each + type on the variant chain. */ + chain = ntype; + do { + /* Assert that this element of the chain has no address-class bits + set in its flags. Such type variants might have type lengths + which are supposed to be different from the non-address-class + variants. This assertion shouldn't ever be triggered because + symbol readers which do construct address-class variants don't + call replace_type(). */ + gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0); + + TYPE_LENGTH (ntype) = TYPE_LENGTH (type); + chain = TYPE_CHAIN (chain); + } while (ntype != chain); + /* Assert that the two types have equivalent instance qualifiers. This should be true for at least all of our debug readers. */ gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type)); diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index e3ba6fa..5a079bf 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -297,32 +297,6 @@ struct main_type char *tag_name; - /* Length of storage for a value of this type. This is what - sizeof(type) would return; use it for address arithmetic, - memory reads and writes, etc. This size includes padding. For - example, an i386 extended-precision floating point value really - only occupies ten bytes, but most ABI's declare its size to be - 12 bytes, to preserve alignment. A `struct type' representing - such a floating-point type would have a `length' value of 12, - even though the last two bytes are unused. - - There's a bit of a host/target mess here, if you're concerned - about machines whose bytes aren't eight bits long, or who don't - have byte-addressed memory. Various places pass this to memcpy - and such, meaning it must be in units of host bytes. Various - other places expect they can calculate addresses by adding it - and such, meaning it must be in units of target bytes. For - some DSP targets, in which HOST_CHAR_BIT will (presumably) be 8 - and TARGET_CHAR_BIT will be (say) 32, this is a problem. - - One fix would be to make this field in bits (requiring that it - always be a multiple of HOST_CHAR_BIT and TARGET_CHAR_BIT) --- - the other choice would be to make it consistently in units of - HOST_CHAR_BIT. However, this would still fail to address - machines based on a ternary or decimal representation. */ - - unsigned length; - /* FIXME, these should probably be restricted to a Fortran-specific field in some fashion. */ #define BOUND_CANNOT_BE_DETERMINED 5 @@ -489,15 +463,42 @@ struct type struct type *reference_type; /* Variant chain. This points to a type that differs from this one only - in qualifiers. Currently, the possible qualifiers are const, volatile, - code-space, and data-space. The variants are linked in a circular - ring and share MAIN_TYPE. */ + in qualifiers and length. Currently, the possible qualifiers are + const, volatile, code-space, data-space, and address class. The + length may differ only when one of the address class flags are set. + The variants are linked in a circular ring and share MAIN_TYPE. */ struct type *chain; /* Flags specific to this instance of the type, indicating where on the ring we are. */ int instance_flags; + /* Length of storage for a value of this type. This is what + sizeof(type) would return; use it for address arithmetic, + memory reads and writes, etc. This size includes padding. For + example, an i386 extended-precision floating point value really + only occupies ten bytes, but most ABI's declare its size to be + 12 bytes, to preserve alignment. A `struct type' representing + such a floating-point type would have a `length' value of 12, + even though the last two bytes are unused. + + There's a bit of a host/target mess here, if you're concerned + about machines whose bytes aren't eight bits long, or who don't + have byte-addressed memory. Various places pass this to memcpy + and such, meaning it must be in units of host bytes. Various + other places expect they can calculate addresses by adding it + and such, meaning it must be in units of target bytes. For + some DSP targets, in which HOST_CHAR_BIT will (presumably) be 8 + and TARGET_CHAR_BIT will be (say) 32, this is a problem. + + One fix would be to make this field in bits (requiring that it + always be a multiple of HOST_CHAR_BIT and TARGET_CHAR_BIT) --- + the other choice would be to make it consistently in units of + HOST_CHAR_BIT. However, this would still fail to address + machines based on a ternary or decimal representation. */ + + unsigned length; + /* Core type, shared by a group of qualified types. */ struct main_type *main_type; }; @@ -758,7 +759,7 @@ extern void allocate_cplus_struct_type (struct type *); But check_typedef does set the TYPE_LENGTH of the TYPEDEF type, so you only have to call check_typedef once. Since allocate_value calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */ -#define TYPE_LENGTH(thistype) TYPE_MAIN_TYPE(thistype)->length +#define TYPE_LENGTH(thistype) (thistype)->length #define TYPE_OBJFILE(thistype) TYPE_MAIN_TYPE(thistype)->objfile #define TYPE_FLAGS(thistype) TYPE_MAIN_TYPE(thistype)->flags /* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real |