From: Daniel Jacobowitz Date: Tue, 14 May 2002 18:30:53 +0000 (+0000) Subject: 2002-05-14 Daniel Jacobowitz X-Git-Tag: binutils-2_13-branchpoint~907 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=2fdde8f831d0cf29d3de4baf7e8af19fa6cd638a;p=platform%2Fupstream%2Fbinutils.git 2002-05-14 Daniel Jacobowitz * gdbtypes.h: Update accessor macros to use TYPE_MAIN_TYPE. (TYPE_CONST, TYPE_VOLATILE, TYPE_CODE_SPACE, TYPE_DATA_SPACE): Use TYPE_INSTANCE_FLAGS. (struct main_type): New. (struct type): Move most members to struct main_type. Change cv_type and as_type to new type_chain member. Add instance_flags. (TYPE_MAIN_TYPE, TYPE_CHAIN, TYPE_INSTANCE_FLAGS): New macros. (TYPE_CV_TYPE, TYPE_AS_TYPE): Remove. (finish_cv_type): Remove prototype. * gdbtypes.c (alloc_type): Update comment. Allocate TYPE_MAIN_TYPE. Set TYPE_CHAIN. (alloc_type_instance): New function. (smash_type): New function. (make_pointer_type, make_reference_type, make_function_type) (smash_to_member_type, smash_to_method_type): Call smash_type. (make_qualified_type): New function. (make_type_with_address_space): Call make_qualified_type. (make_cv_type): Likewise. (finish_cv_type): Remove unnecessary function. (replace_type): Update comment. Copy TYPE_MAIN_TYPE. (recursive_dump_type): Dump TYPE_CHAIN and TYPE_INSTANCE_FLAGS; remove TYPE_CV_TYPE and TYPE_AS_TYPE. * c-typeprint.c (c_type_print_modifier): Use TYPE_INSTANCE_FLAGS. * dwarf2read.c (read_structure_scope): Don't call finish_cv_type. * hpread.c (hpread_read_struct_type): Likewise. * stabsread.c (read_struct_type): Likewise. 2002-05-14 Daniel Jacobowitz * gdb.base/maint.exp (maint print type): Update for new type structure. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 32d19fc..82626f3 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,32 @@ +2002-05-14 Daniel Jacobowitz + + * gdbtypes.h: Update accessor macros to use TYPE_MAIN_TYPE. + (TYPE_CONST, TYPE_VOLATILE, TYPE_CODE_SPACE, TYPE_DATA_SPACE): Use + TYPE_INSTANCE_FLAGS. + (struct main_type): New. + (struct type): Move most members to struct main_type. Change + cv_type and as_type to new type_chain member. Add instance_flags. + (TYPE_MAIN_TYPE, TYPE_CHAIN, TYPE_INSTANCE_FLAGS): New macros. + (TYPE_CV_TYPE, TYPE_AS_TYPE): Remove. + (finish_cv_type): Remove prototype. + * gdbtypes.c (alloc_type): Update comment. Allocate TYPE_MAIN_TYPE. + Set TYPE_CHAIN. + (alloc_type_instance): New function. + (smash_type): New function. + (make_pointer_type, make_reference_type, make_function_type) + (smash_to_member_type, smash_to_method_type): Call smash_type. + (make_qualified_type): New function. + (make_type_with_address_space): Call make_qualified_type. + (make_cv_type): Likewise. + (finish_cv_type): Remove unnecessary function. + (replace_type): Update comment. Copy TYPE_MAIN_TYPE. + (recursive_dump_type): Dump TYPE_CHAIN and TYPE_INSTANCE_FLAGS; + remove TYPE_CV_TYPE and TYPE_AS_TYPE. + * c-typeprint.c (c_type_print_modifier): Use TYPE_INSTANCE_FLAGS. + * dwarf2read.c (read_structure_scope): Don't call finish_cv_type. + * hpread.c (hpread_read_struct_type): Likewise. + * stabsread.c (read_struct_type): Likewise. + 2002-05-14 Elena Zannoni * configure.tgt: Add a catch all sh* target, for cases like diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c index 8436bca..430d567 100644 --- a/gdb/c-typeprint.c +++ b/gdb/c-typeprint.c @@ -316,7 +316,7 @@ c_type_print_modifier (struct type *type, struct ui_file *stream, did_print_modifier = 1; } - address_space_id = address_space_int_to_name (TYPE_FLAGS (type)); + address_space_id = address_space_int_to_name (TYPE_INSTANCE_FLAGS (type)); if (address_space_id) { if (did_print_modifier || need_pre_space) diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index b47baef..2793817 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -2486,8 +2486,6 @@ read_structure_scope (struct die_info *die, struct objfile *objfile, /* No children, must be stub. */ TYPE_FLAGS (type) |= TYPE_FLAG_STUB; } - - finish_cv_type (die->type); } /* Given a pointer to a die which begins an enumeration, process all diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index fff720d..e8ba96d 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -135,7 +135,8 @@ static void virtual_base_list_aux (struct type *dclass); /* Alloc a new type structure and fill it with some defaults. If OBJFILE is non-NULL, then allocate the space for the type structure - in that objfile's type_obstack. */ + in that objfile's type_obstack. Otherwise allocate the new type structure + by xmalloc () (for permanent types). */ struct type * alloc_type (struct objfile *objfile) @@ -146,27 +147,73 @@ alloc_type (struct objfile *objfile) if (objfile == NULL) { - type = (struct type *) xmalloc (sizeof (struct type)); + type = xmalloc (sizeof (struct type)); + memset (type, 0, sizeof (struct type)); + TYPE_MAIN_TYPE (type) = xmalloc (sizeof (struct main_type)); } else { - type = (struct type *) obstack_alloc (&objfile->type_obstack, - sizeof (struct type)); + type = obstack_alloc (&objfile->type_obstack, + sizeof (struct type)); + memset (type, 0, sizeof (struct type)); + TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->type_obstack, + sizeof (struct main_type)); OBJSTAT (objfile, n_types++); } - memset ((char *) type, 0, sizeof (struct type)); + memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); /* Initialize the fields that might not be zero. */ TYPE_CODE (type) = TYPE_CODE_UNDEF; TYPE_OBJFILE (type) = objfile; TYPE_VPTR_FIELDNO (type) = -1; - TYPE_CV_TYPE (type) = type; /* chain back to itself */ - TYPE_AS_TYPE (type) = type; /* ditto */ + TYPE_CHAIN (type) = type; /* Chain back to itself. */ return (type); } +/* Alloc a new type instance structure, fill it with some defaults, + and point it at OLDTYPE. Allocate the new type instance from the + same place as OLDTYPE. */ + +static struct type * +alloc_type_instance (struct type *oldtype) +{ + struct type *type; + + /* Allocate the structure. */ + + if (TYPE_OBJFILE (oldtype) == NULL) + { + type = xmalloc (sizeof (struct type)); + memset (type, 0, sizeof (struct type)); + } + else + { + type = obstack_alloc (&TYPE_OBJFILE (oldtype)->type_obstack, + sizeof (struct type)); + memset (type, 0, sizeof (struct type)); + } + TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype); + + TYPE_CHAIN (type) = type; /* Chain back to itself for now. */ + + return (type); +} + +/* Clear all remnants of the previous type at TYPE, in preparation for + replacing it with something else. */ +static void +smash_type (struct type *type) +{ + memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); + + /* For now, delete the rings. */ + TYPE_CHAIN (type) = type; + + /* For now, leave the pointer/reference types alone. */ +} + /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points to a pointer to memory where the pointer type should be stored. If *TYPEPTR is zero, update it to point to the pointer type we return. @@ -202,7 +249,7 @@ make_pointer_type (struct type *type, struct type **typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *) ntype, 0, sizeof (struct type)); + smash_type (ntype); TYPE_OBJFILE (ntype) = objfile; } @@ -269,7 +316,7 @@ make_reference_type (struct type *type, struct type **typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *) ntype, 0, sizeof (struct type)); + smash_type (ntype); TYPE_OBJFILE (ntype) = objfile; } @@ -318,7 +365,7 @@ make_function_type (struct type *type, struct type **typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *) ntype, 0, sizeof (struct type)); + smash_type (ntype); TYPE_OBJFILE (ntype) = objfile; } @@ -368,45 +415,63 @@ address_space_int_to_name (int space_flag) return NULL; } -/* Make an address-space-delimited variant of a type -- a type that - is identical to the one supplied except that it has an address - space attribute attached to it (such as "code" or "data"). - - This is for Harvard architectures. */ +/* Create a new type with instance flags NEW_FLAGS, based on TYPE. + If STORAGE is non-NULL, create the new type instance there. */ struct type * -make_type_with_address_space (struct type *type, int space_flag) +make_qualified_type (struct type *type, int new_flags, + struct type *storage) { struct type *ntype; ntype = type; do { - if ((ntype->flags & space_flag) != 0) + if (TYPE_INSTANCE_FLAGS (ntype) == new_flags) return ntype; - ntype = TYPE_AS_TYPE (ntype); + ntype = TYPE_CHAIN (ntype); } while (ntype != type); - /* Create a new, duplicate type. */ - ntype = alloc_type (TYPE_OBJFILE (type)); - /* Copy original type. */ - memcpy ((char *) ntype, (char *) type, sizeof (struct type)); + /* Create a new type instance. */ + if (storage == NULL) + ntype = alloc_type_instance (type); + else + { + ntype = storage; + TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type); + TYPE_CHAIN (ntype) = ntype; + } /* Pointers or references to the original type are not relevant to - the new type; but if the original type is a pointer, the new type - points to the same thing (so TYPE_TARGET_TYPE remains unchanged). */ + the new type. */ TYPE_POINTER_TYPE (ntype) = (struct type *) 0; TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0; - TYPE_CV_TYPE (ntype) = ntype; - /* Chain the new address-space-specific type to the old type. */ - ntype->as_type = type->as_type; - type->as_type = ntype; + /* Chain the new qualified type to the old type. */ + TYPE_CHAIN (ntype) = TYPE_CHAIN (type); + TYPE_CHAIN (type) = ntype; + + /* Now set the instance flags and return the new type. */ + TYPE_INSTANCE_FLAGS (ntype) = new_flags; - /* Now set the address-space flag, and return the new type. */ - ntype->flags |= space_flag; return ntype; } +/* Make an address-space-delimited variant of a type -- a type that + is identical to the one supplied except that it has an address + space attribute attached to it (such as "code" or "data"). + + This is for Harvard architectures. */ + +struct type * +make_type_with_address_space (struct type *type, int space_flag) +{ + struct type *ntype; + int new_flags = ((TYPE_INSTANCE_FLAGS (type) + & ~(TYPE_FLAG_CODE_SPACE | TYPE_FLAG_DATA_SPACE)) + | space_flag); + + return make_qualified_type (type, new_flags, NULL); +} /* Make a "c-v" variant of a type -- a type that is identical to the one supplied except that it may have const or volatile attributes @@ -425,142 +490,60 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr) register struct type *tmp_type = type; /* tmp type */ struct objfile *objfile; - ntype = TYPE_CV_TYPE (type); - - while (ntype != type) - { - if ((TYPE_CONST (ntype) == cnst) && - (TYPE_VOLATILE (ntype) == voltl)) - { - if (typeptr == 0) - return ntype; - else if (*typeptr == 0) - { - *typeptr = ntype; /* Tracking alloc, and we have new type. */ - return ntype; - } - } - tmp_type = ntype; - ntype = TYPE_CV_TYPE (ntype); - } - - if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ - { - ntype = alloc_type (TYPE_OBJFILE (type)); - if (typeptr) - *typeptr = ntype; - } - else - /* We have storage, but need to reset it. */ - { - ntype = *typeptr; - objfile = TYPE_OBJFILE (ntype); - /* memset ((char *) ntype, 0, sizeof (struct type)); */ - TYPE_OBJFILE (ntype) = objfile; - } - - /* Copy original type */ - memcpy ((char *) ntype, (char *) type, sizeof (struct type)); - /* But zero out fields that shouldn't be copied */ - TYPE_POINTER_TYPE (ntype) = (struct type *) 0; /* Need new pointer kind */ - TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0; /* Need new referene kind */ - TYPE_AS_TYPE (ntype) = ntype; /* Need new address-space kind. */ - /* Note: TYPE_TARGET_TYPE can be left as is */ + int new_flags = (TYPE_INSTANCE_FLAGS (type) + & ~(TYPE_FLAG_CONST | TYPE_FLAG_VOLATILE)); - /* Set flags appropriately */ if (cnst) - TYPE_FLAGS (ntype) |= TYPE_FLAG_CONST; - else - TYPE_FLAGS (ntype) &= ~TYPE_FLAG_CONST; + new_flags |= TYPE_FLAG_CONST; if (voltl) - TYPE_FLAGS (ntype) |= TYPE_FLAG_VOLATILE; - else - TYPE_FLAGS (ntype) &= ~TYPE_FLAG_VOLATILE; - - /* Fix the chain of cv variants */ - TYPE_CV_TYPE (ntype) = type; - TYPE_CV_TYPE (tmp_type) = ntype; - - return ntype; -} - -/* When reading in a class type, we may have created references to - cv-qualified versions of the type (in method arguments, for - instance). Update everything on the cv ring from the primary - type TYPE. - - The only reason we do not need to do the same thing for address - spaces is that type readers do not create address space qualified - types. */ -void -finish_cv_type (struct type *type) -{ - struct type *ntype, *cv_type, *ptr_type, *ref_type; - int cv_flags; + new_flags |= TYPE_FLAG_VOLATILE; - gdb_assert (!TYPE_CONST (type) && !TYPE_VOLATILE (type)); - - ntype = type; - while ((ntype = TYPE_CV_TYPE (ntype)) != type) + if (typeptr && *typeptr != NULL) { - /* Save cv_flags. */ - cv_flags = TYPE_FLAGS (ntype) & (TYPE_FLAG_VOLATILE | TYPE_FLAG_CONST); + /* 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. */ - /* If any reference or pointer types were created, save them too. */ - ptr_type = TYPE_POINTER_TYPE (ntype); - ref_type = TYPE_REFERENCE_TYPE (ntype); - - /* Don't disturb the CV chain. */ - cv_type = TYPE_CV_TYPE (ntype); - - /* Verify that we haven't added any address-space qualified types, - for the future. */ - gdb_assert (ntype == TYPE_AS_TYPE (ntype)); - - /* Copy original type */ - memcpy ((char *) ntype, (char *) type, sizeof (struct type)); + 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); + } + } + + ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL); - /* Restore everything. */ - TYPE_POINTER_TYPE (ntype) = ptr_type; - TYPE_REFERENCE_TYPE (ntype) = ref_type; - TYPE_CV_TYPE (ntype) = cv_type; - TYPE_FLAGS (ntype) = TYPE_FLAGS (ntype) | cv_flags; + if (typeptr != NULL) + *typeptr = ntype; - TYPE_AS_TYPE (ntype) = ntype; - } + return ntype; } -/* Replace the contents of ntype with the type *type. +/* Replace the contents of ntype with the type *type. This changes the + contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus + the changes are propogated to all types in the TYPE_CHAIN. In order to build recursive types, it's inevitable that we'll need to update types in place --- but this sort of indiscriminate smashing is ugly, and needs to be replaced with something more - controlled. For example, Daniel Jacobowitz has suggested moving - the fields common to a set of c/v variants into their own object, - which the variants would share. - - This function does not handle the replacement type being - cv-qualified; it could be easily fixed to, but it would be better - to just change the whole approach. */ + controlled. TYPE_MAIN_TYPE is a step in this direction; it's not + clear if more steps are needed. */ void replace_type (struct type *ntype, struct type *type) { struct type *cv_chain, *as_chain, *ptr, *ref; - cv_chain = TYPE_CV_TYPE (ntype); - as_chain = TYPE_AS_TYPE (ntype); - ptr = TYPE_POINTER_TYPE (ntype); - ref = TYPE_REFERENCE_TYPE (ntype); - - *ntype = *type; - - TYPE_POINTER_TYPE (ntype) = ptr; - TYPE_REFERENCE_TYPE (ntype) = ref; - TYPE_CV_TYPE (ntype) = cv_chain; - TYPE_AS_TYPE (ntype) = as_chain; + *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type); - finish_cv_type (ntype); + /* 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)); } /* Implement direct support for MEMBER_TYPE in GNU C++. @@ -879,7 +862,7 @@ smash_to_member_type (struct type *type, struct type *domain, objfile = TYPE_OBJFILE (type); - memset ((char *) type, 0, sizeof (struct type)); + smash_type (type); TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; @@ -902,7 +885,7 @@ smash_to_method_type (struct type *type, struct type *domain, objfile = TYPE_OBJFILE (type); - memset ((char *) type, 0, sizeof (struct type)); + smash_type (type); TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; @@ -3011,12 +2994,27 @@ recursive_dump_type (struct type *type, int spaces) printfi_filtered (spaces, "reference_type "); gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout); printf_filtered ("\n"); - printfi_filtered (spaces, "cv_type "); - gdb_print_host_address (TYPE_CV_TYPE (type), gdb_stdout); - printf_filtered ("\n"); - printfi_filtered (spaces, "as_type "); - gdb_print_host_address (TYPE_AS_TYPE (type), gdb_stdout); + printfi_filtered (spaces, "type_chain "); + gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout); printf_filtered ("\n"); + printfi_filtered (spaces, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type)); + if (TYPE_CONST (type)) + { + puts_filtered (" TYPE_FLAG_CONST"); + } + if (TYPE_VOLATILE (type)) + { + puts_filtered (" TYPE_FLAG_VOLATILE"); + } + if (TYPE_CODE_SPACE (type)) + { + puts_filtered (" TYPE_FLAG_CODE_SPACE"); + } + if (TYPE_DATA_SPACE (type)) + { + puts_filtered (" TYPE_FLAG_DATA_SPACE"); + } + puts_filtered ("\n"); printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type)); if (TYPE_UNSIGNED (type)) { @@ -3038,14 +3036,6 @@ recursive_dump_type (struct type *type, int spaces) { puts_filtered (" TYPE_FLAG_STATIC"); } - if (TYPE_CONST (type)) - { - puts_filtered (" TYPE_FLAG_CONST"); - } - if (TYPE_VOLATILE (type)) - { - puts_filtered (" TYPE_FLAG_VOLATILE"); - } if (TYPE_PROTOTYPED (type)) { puts_filtered (" TYPE_FLAG_PROTOTYPED"); @@ -3054,14 +3044,6 @@ recursive_dump_type (struct type *type, int spaces) { puts_filtered (" TYPE_FLAG_INCOMPLETE"); } - if (TYPE_CODE_SPACE (type)) - { - puts_filtered (" TYPE_FLAG_CODE_SPACE"); - } - if (TYPE_DATA_SPACE (type)) - { - puts_filtered (" TYPE_FLAG_DATA_SPACE"); - } if (TYPE_VARARGS (type)) { puts_filtered (" TYPE_FLAG_VARARGS"); diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 914d478..87b529e 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -187,14 +187,14 @@ enum type_code */ #define TYPE_FLAG_CONST (1 << 5) -#define TYPE_CONST(t) (TYPE_FLAGS (t) & TYPE_FLAG_CONST) +#define TYPE_CONST(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_CONST) /* Volatile type. If this is set, the corresponding type has a * volatile modifier. */ #define TYPE_FLAG_VOLATILE (1 << 6) -#define TYPE_VOLATILE(t) (TYPE_FLAGS (t) & TYPE_FLAG_VOLATILE) +#define TYPE_VOLATILE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_VOLATILE) /* This is a function type which appears to have a prototype. We need this @@ -235,10 +235,10 @@ enum type_code is instruction space, and for data objects is data memory. */ #define TYPE_FLAG_CODE_SPACE (1 << 9) -#define TYPE_CODE_SPACE(t) (TYPE_FLAGS (t) & TYPE_FLAG_CODE_SPACE) +#define TYPE_CODE_SPACE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_CODE_SPACE) #define TYPE_FLAG_DATA_SPACE (1 << 10) -#define TYPE_DATA_SPACE(t) (TYPE_FLAGS (t) & TYPE_FLAG_DATA_SPACE) +#define TYPE_DATA_SPACE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_DATA_SPACE) /* FIXME: Kludge to mark a varargs function type for C++ member function argument processing. Currently only used in dwarf2read.c, @@ -254,238 +254,240 @@ enum type_code #define TYPE_FLAG_VECTOR (1 << 12) #define TYPE_VECTOR(t) (TYPE_FLAGS (t) & TYPE_FLAG_VECTOR) - -struct type +struct main_type +{ + /* Code for kind of type */ + + enum type_code code; + + /* Name of this type, or NULL if none. + + This is used for printing only, except by poorly designed C++ code. + For looking up a name, look for a symbol in the VAR_NAMESPACE. */ + + char *name; + + /* Tag name for this type, or NULL if none. This means that the + name of the type consists of a keyword followed by the tag name. + Which keyword is determined by the type code ("struct" for + TYPE_CODE_STRUCT, etc.). As far as I know C/C++ are the only languages + with this feature. + + This is used for printing only, except by poorly designed C++ code. + For looking up a name, look for a symbol in the STRUCT_NAMESPACE. + One more legitimate use is that if TYPE_FLAG_STUB is set, this is + the name to use to look for definitions in other files. */ + + 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 +#define BOUND_BY_REF_ON_STACK 4 +#define BOUND_BY_VALUE_ON_STACK 3 +#define BOUND_BY_REF_IN_REG 2 +#define BOUND_BY_VALUE_IN_REG 1 +#define BOUND_SIMPLE 0 + int upper_bound_type; + int lower_bound_type; + + /* Every type is now associated with a particular objfile, and the + type is allocated on the type_obstack for that objfile. One problem + however, is that there are times when gdb allocates new types while + it is not in the process of reading symbols from a particular objfile. + Fortunately, these happen when the type being created is a derived + type of an existing type, such as in lookup_pointer_type(). So + we can just allocate the new type using the same objfile as the + existing type, but to do this we need a backpointer to the objfile + from the existing type. Yes this is somewhat ugly, but without + major overhaul of the internal type system, it can't be avoided + for now. */ + + struct objfile *objfile; + + /* For a pointer type, describes the type of object pointed to. + For an array type, describes the type of the elements. + For a function or method type, describes the type of the return value. + For a range type, describes the type of the full range. + For a complex type, describes the type of each coordinate. + Unused otherwise. */ + + struct type *target_type; + + /* Flags about this type. */ + + int flags; + + /* Number of fields described for this type */ + + short nfields; + + /* For structure and union types, a description of each field. + For set and pascal array types, there is one "field", + whose type is the domain type of the set or array. + For range types, there are two "fields", + the minimum and maximum values (both inclusive). + For enum types, each possible value is described by one "field". + For a function type, a "field" for each parameter type. + For C++ classes, there is one field for each base class (if it is + a derived class) plus one field for each class data member. Member + functions are recorded elsewhere. + + Using a pointer to a separate array of fields + allows all types to have the same size, which is useful + because we can allocate the space for a type before + we know what to put in it. */ + + struct field { + union field_location + { + /* Position of this field, counting in bits from start of + containing structure. + For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB. + For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB. + For a range bound or enum value, this is the value itself. */ - /* Code for kind of type */ + int bitpos; - enum type_code code; + /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr + is the location (in the target) of the static field. + Otherwise, physname is the mangled label of the static field. */ - /* Name of this type, or NULL if none. + CORE_ADDR physaddr; + char *physname; - This is used for printing only, except by poorly designed C++ code. - For looking up a name, look for a symbol in the VAR_NAMESPACE. */ + /* For a function type, this is 1 if the argument is marked + artificial. Artificial arguments should not be shown to the + user. */ + int artificial; + } + loc; - char *name; + /* Size of this field, in bits, or zero if not packed. + For an unpacked field, the field's type's length + says how many bytes the field occupies. + A value of -1 or -2 indicates a static field; -1 means the location + is specified by the label loc.physname; -2 means that loc.physaddr + specifies the actual address. */ - /* Tag name for this type, or NULL if none. This means that the - name of the type consists of a keyword followed by the tag name. - Which keyword is determined by the type code ("struct" for - TYPE_CODE_STRUCT, etc.). As far as I know C/C++ are the only languages - with this feature. - - This is used for printing only, except by poorly designed C++ code. - For looking up a name, look for a symbol in the STRUCT_NAMESPACE. - One more legitimate use is that if TYPE_FLAG_STUB is set, this is - the name to use to look for definitions in other files. */ - - 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 -#define BOUND_BY_REF_ON_STACK 4 -#define BOUND_BY_VALUE_ON_STACK 3 -#define BOUND_BY_REF_IN_REG 2 -#define BOUND_BY_VALUE_IN_REG 1 -#define BOUND_SIMPLE 0 - int upper_bound_type; - int lower_bound_type; - - /* Every type is now associated with a particular objfile, and the - type is allocated on the type_obstack for that objfile. One problem - however, is that there are times when gdb allocates new types while - it is not in the process of reading symbols from a particular objfile. - Fortunately, these happen when the type being created is a derived - type of an existing type, such as in lookup_pointer_type(). So - we can just allocate the new type using the same objfile as the - existing type, but to do this we need a backpointer to the objfile - from the existing type. Yes this is somewhat ugly, but without - major overhaul of the internal type system, it can't be avoided - for now. */ - - struct objfile *objfile; - - /* For a pointer type, describes the type of object pointed to. - For an array type, describes the type of the elements. - For a function or method type, describes the type of the return value. - For a range type, describes the type of the full range. - For a complex type, describes the type of each coordinate. - Unused otherwise. */ - - struct type *target_type; - - /* Type that is a pointer to this type. - NULL if no such pointer-to type is known yet. - The debugger may add the address of such a type - if it has to construct one later. */ - - struct type *pointer_type; - - /* C++: also need a reference type. */ - - struct type *reference_type; - - /* C-v variant chain. This points to a type that - differs from this one only in a const or volatile - attribute (or both). The various c-v variants - are chained together in a ring. */ - struct type *cv_type; - - /* Address-space delimited variant chain. This points to a type - that differs from this one only in an address-space qualifier - attribute. The otherwise-identical address-space delimited - types are chained together in a ring. */ - struct type *as_type; - - /* Flags about this type. */ - - int flags; - - /* Number of fields described for this type */ - - short nfields; - - /* For structure and union types, a description of each field. - For set and pascal array types, there is one "field", - whose type is the domain type of the set or array. - For range types, there are two "fields", - the minimum and maximum values (both inclusive). - For enum types, each possible value is described by one "field". - For a function type, a "field" for each parameter type. - For C++ classes, there is one field for each base class (if it is - a derived class) plus one field for each class data member. Member - functions are recorded elsewhere. - - Using a pointer to a separate array of fields - allows all types to have the same size, which is useful - because we can allocate the space for a type before - we know what to put in it. */ - - struct field - { - union field_location - { - /* Position of this field, counting in bits from start of - containing structure. - For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB. - For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB. - For a range bound or enum value, this is the value itself. */ + int bitsize; - int bitpos; + /* In a struct or union type, type of this field. + In a function type, type of this argument. + In an array type, the domain-type of the array. */ - /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr - is the location (in the target) of the static field. - Otherwise, physname is the mangled label of the static field. */ + struct type *type; - CORE_ADDR physaddr; - char *physname; + /* Name of field, value or argument. + NULL for range bounds and array domains. */ - /* For a function type, this is 1 if the argument is marked - artificial. Artificial arguments should not be shown to the - user. */ - int artificial; - } - loc; + char *name; - /* Size of this field, in bits, or zero if not packed. - For an unpacked field, the field's type's length - says how many bytes the field occupies. - A value of -1 or -2 indicates a static field; -1 means the location - is specified by the label loc.physname; -2 means that loc.physaddr - specifies the actual address. */ + } *fields; - int bitsize; + /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE + is the base class which defined the virtual function table pointer. - /* In a struct or union type, type of this field. - In a function type, type of this argument. - In an array type, the domain-type of the array. */ + For types that are pointer to member types (TYPE_CODE_MEMBER), + VPTR_BASETYPE is the type that this pointer is a member of. - struct type *type; + For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate + type that contains the method. - /* Name of field, value or argument. - NULL for range bounds and array domains. */ + Unused otherwise. */ - char *name; + struct type *vptr_basetype; - } - *fields; + /* Field number of the virtual function table pointer in + VPTR_BASETYPE. If -1, we were unable to find the virtual + function table pointer in initial symbol reading, and + fill_in_vptr_fieldno should be called to find it if possible. - /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE - is the base class which defined the virtual function table pointer. + Unused if this type does not have virtual functions. */ - For types that are pointer to member types (TYPE_CODE_MEMBER), - VPTR_BASETYPE is the type that this pointer is a member of. + int vptr_fieldno; - For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate - type that contains the method. + /* Slot to point to additional language-specific fields of this type. */ - Unused otherwise. */ + union type_specific + { + /* ARG_TYPES is for TYPE_CODE_METHOD. + Contains the type of each argument, ending with a void type + after the last argument for normal member functions or a NULL + pointer after the last argument for functions with variable + arguments. */ - struct type *vptr_basetype; + struct type **arg_types; - /* Field number of the virtual function table pointer in - VPTR_BASETYPE. If -1, we were unable to find the virtual - function table pointer in initial symbol reading, and - fill_in_vptr_fieldno should be called to find it if possible. + /* CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to point to + cplus_struct_default, a default static instance of a struct + cplus_struct_type. */ - Unused if this type does not have virtual functions. */ + struct cplus_struct_type *cplus_stuff; - int vptr_fieldno; + /* FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to the + floatformat object that describes the floating-point value + that resides within the type. */ - /* Slot to point to additional language-specific fields of this type. */ + const struct floatformat *floatformat; + } type_specific; +}; - union type_specific - { +/* A ``struct type'' describes a particular instance of a type, with + some particular qualification. */ +struct type +{ + /* Type that is a pointer to this type. + NULL if no such pointer-to type is known yet. + The debugger may add the address of such a type + if it has to construct one later. */ - /* ARG_TYPES is for TYPE_CODE_METHOD. - Contains the type of each argument, ending with a void type - after the last argument for normal member functions or a NULL - pointer after the last argument for functions with variable - arguments. */ + struct type *pointer_type; - struct type **arg_types; + /* C++: also need a reference type. */ - /* CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to point to - cplus_struct_default, a default static instance of a struct - cplus_struct_type. */ + struct type *reference_type; - struct cplus_struct_type *cplus_stuff; + /* 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. */ + struct type *chain; - /* FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to the - floatformat object that describes the floating-point value - that resides within the type. */ + /* Flags specific to this instance of the type, indicating where + on the ring we are. */ + int instance_flags; - const struct floatformat *floatformat; - } - type_specific; - }; + /* Core type, shared by a group of qualified types. */ + struct main_type *main_type; +}; #define NULL_TYPE ((struct type *) 0) @@ -738,25 +740,26 @@ extern void allocate_cplus_struct_type (struct type *); #define HAVE_CPLUS_STRUCT(type) \ (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default) -#define TYPE_NAME(thistype) (thistype)->name -#define TYPE_TAG_NAME(type) ((type)->tag_name) -#define TYPE_TARGET_TYPE(thistype) (thistype)->target_type +#define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags +#define TYPE_MAIN_TYPE(thistype) (thistype)->main_type +#define TYPE_NAME(thistype) TYPE_MAIN_TYPE(thistype)->name +#define TYPE_TAG_NAME(type) TYPE_MAIN_TYPE(type)->tag_name +#define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type -#define TYPE_CV_TYPE(thistype) (thistype)->cv_type -#define TYPE_AS_TYPE(thistype) (thistype)->as_type +#define TYPE_CHAIN(thistype) (thistype)->chain /* Note that if thistype is a TYPEDEF type, you have to call check_typedef. 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) (thistype)->length -#define TYPE_OBJFILE(thistype) (thistype)->objfile -#define TYPE_FLAGS(thistype) (thistype)->flags +#define TYPE_LENGTH(thistype) TYPE_MAIN_TYPE(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 type, you need to do TYPE_CODE (check_type (this_type)). */ -#define TYPE_CODE(thistype) (thistype)->code -#define TYPE_NFIELDS(thistype) (thistype)->nfields -#define TYPE_FIELDS(thistype) (thistype)->fields +#define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code +#define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields +#define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->fields #define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args #define TYPE_INSTANTIATIONS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->instantiations @@ -766,8 +769,10 @@ extern void allocate_cplus_struct_type (struct type *); /* Moto-specific stuff for FORTRAN arrays */ -#define TYPE_ARRAY_UPPER_BOUND_TYPE(thistype) (thistype)->upper_bound_type -#define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) (thistype)->lower_bound_type +#define TYPE_ARRAY_UPPER_BOUND_TYPE(thistype) \ + TYPE_MAIN_TYPE(thistype)->upper_bound_type +#define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) \ + TYPE_MAIN_TYPE(thistype)->lower_bound_type #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \ (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),1)) @@ -777,22 +782,22 @@ extern void allocate_cplus_struct_type (struct type *); /* C++ */ -#define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype -#define TYPE_DOMAIN_TYPE(thistype) (thistype)->vptr_basetype -#define TYPE_VPTR_FIELDNO(thistype) (thistype)->vptr_fieldno +#define TYPE_VPTR_BASETYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype +#define TYPE_DOMAIN_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype +#define TYPE_VPTR_FIELDNO(thistype) TYPE_MAIN_TYPE(thistype)->vptr_fieldno #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total #define TYPE_NTEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ntemplate_args #define TYPE_NINSTANTIATIONS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ninstantiations #define TYPE_DECLARED_TYPE(thistype) TYPE_CPLUS_SPECIFIC(thistype)->declared_type -#define TYPE_TYPE_SPECIFIC(thistype) (thistype)->type_specific -#define TYPE_ARG_TYPES(thistype) (thistype)->type_specific.arg_types -#define TYPE_CPLUS_SPECIFIC(thistype) (thistype)->type_specific.cplus_stuff -#define TYPE_FLOATFORMAT(thistype) (thistype)->type_specific.floatformat -#define TYPE_BASECLASS(thistype,index) (thistype)->fields[index].type +#define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific +#define TYPE_ARG_TYPES(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.arg_types +#define TYPE_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff +#define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat +#define TYPE_BASECLASS(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].type #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses -#define TYPE_BASECLASS_NAME(thistype,index) (thistype)->fields[index].name +#define TYPE_BASECLASS_NAME(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].name #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index) #define BASETYPE_VIA_PUBLIC(thistype, index) \ ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index))) @@ -812,7 +817,7 @@ extern void allocate_cplus_struct_type (struct type *); ((thisfld).bitsize = -1, FIELD_PHYSNAME(thisfld) = (name)) #define SET_FIELD_PHYSADDR(thisfld, name) \ ((thisfld).bitsize = -2, FIELD_PHYSADDR(thisfld) = (name)) -#define TYPE_FIELD(thistype, n) (thistype)->fields[n] +#define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->fields[n] #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n)) #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n)) #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS(TYPE_FIELD(thistype,n)) @@ -851,8 +856,8 @@ extern void allocate_cplus_struct_type (struct type *); (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \ : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))) -#define TYPE_FIELD_STATIC(thistype, n) ((thistype)->fields[n].bitsize < 0) -#define TYPE_FIELD_STATIC_HAS_ADDR(thistype, n) ((thistype)->fields[n].bitsize == -2) +#define TYPE_FIELD_STATIC(thistype, n) (TYPE_MAIN_TYPE (thistype)->fields[n].bitsize < 0) +#define TYPE_FIELD_STATIC_HAS_ADDR(thistype, n) (TYPE_MAIN_TYPE (thistype)->fields[n].bitsize == -2) #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_PHYSNAME(TYPE_FIELD(thistype, n)) #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_PHYSADDR(TYPE_FIELD(thistype, n)) @@ -1077,8 +1082,6 @@ extern struct type *make_reference_type (struct type *, struct type **); extern struct type *make_cv_type (int, int, struct type *, struct type **); -extern void finish_cv_type (struct type *); - extern void replace_type (struct type *, struct type *); extern int address_space_name_to_int (char *); diff --git a/gdb/hpread.c b/gdb/hpread.c index fe3d343..45a00a6 100644 --- a/gdb/hpread.c +++ b/gdb/hpread.c @@ -4403,9 +4403,6 @@ hpread_read_struct_type (dnttpointer hp_type, union dnttentry *dn_bufp, /* Clear the global saying what template we are in the middle of processing */ current_template = NULL; - /* Fix up any cv-qualified versions of this type. */ - finish_cv_type (type); - return type; } diff --git a/gdb/stabsread.c b/gdb/stabsread.c index 32747f3..56b7849 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -4302,8 +4302,6 @@ read_struct_type (char **pp, struct type *type, enum type_code type_code, type = error_type (pp, objfile); } - /* Fix up any cv-qualified versions of this type. */ - finish_cv_type (type); do_cleanups (back_to); return (type); } diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 63383c6..0887fd5 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2002-05-14 Daniel Jacobowitz + + * gdb.base/maint.exp (maint print type): Update for new type + structure. + 2002-05-14 Elena Zannoni * gdb.arch: New directory. diff --git a/gdb/testsuite/gdb.base/maint.exp b/gdb/testsuite/gdb.base/maint.exp index 44ae25d..ac2e9f8 100644 --- a/gdb/testsuite/gdb.base/maint.exp +++ b/gdb/testsuite/gdb.base/maint.exp @@ -345,7 +345,7 @@ set timeout $old_timeout send_gdb "maint print type argc\n" gdb_expect { - -re "type node $hex\r\nname .int. \\($hex\\)\r\ntagname .. \\($hex\\)\r\ncode $hex \\(TYPE_CODE_INT\\)\r\nlength \[24\]\r\nupper_bound_type $hex \\(BOUND_SIMPLE\\)\r\nlower_bound_type $hex \\(BOUND_SIMPLE\\)\r\nobjfile $hex\r\ntarget_type $hex\r\npointer_type $hex\r\nreference_type $hex\r\ncv_type $hex\r\nas_type $hex\r\nflags $hex\r\nnfields 0 $hex\r\nvptr_basetype $hex\r\nvptr_fieldno -1\r\ntype_specific $hex\r\n$gdb_prompt $"\ + -re "type node $hex\r\nname .int. \\($hex\\)\r\ntagname .. \\($hex\\)\r\ncode $hex \\(TYPE_CODE_INT\\)\r\nlength \[24\]\r\nupper_bound_type $hex \\(BOUND_SIMPLE\\)\r\nlower_bound_type $hex \\(BOUND_SIMPLE\\)\r\nobjfile $hex\r\ntarget_type $hex\r\npointer_type $hex\r\nreference_type $hex\r\ntype_chain $hex\r\ninstance_flags $hex\r\nflags $hex\r\nnfields 0 $hex\r\nvptr_basetype $hex\r\nvptr_fieldno -1\r\ntype_specific $hex\r\n$gdb_prompt $"\ { pass "maint print type" } -re ".*$gdb_prompt $" { fail "maint print type" } timeout { fail "(timeout) maint print type" }