From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2208 invoked by alias); 14 May 2002 04:08:26 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 2163 invoked from network); 14 May 2002 04:07:53 -0000 Received: from unknown (HELO nevyn.them.org) (128.2.145.6) by sources.redhat.com with SMTP; 14 May 2002 04:07:53 -0000 Received: from drow by nevyn.them.org with local (Exim 3.35 #1 (Debian)) id 177TbI-0002UY-00; Tue, 14 May 2002 00:07:48 -0400 Date: Mon, 13 May 2002 21:08:00 -0000 From: Daniel Jacobowitz To: Elena Zannoni Cc: gdb-patches@sources.redhat.com Subject: Re: [RFA] Fix gdb/277 by separating types, take 3 Message-ID: <20020514040748.GA9559@nevyn.them.org> Mail-Followup-To: Elena Zannoni , gdb-patches@sources.redhat.com References: <20020513160257.GC19484@nevyn.them.org> <15584.30942.983188.4941@localhost.redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <15584.30942.983188.4941@localhost.redhat.com> User-Agent: Mutt/1.5.1i X-SW-Source: 2002-05/txt/msg00528.txt.bz2 On Mon, May 13, 2002 at 10:39:26PM -0400, Elena Zannoni wrote: > > Ok with me, except (now he shoots her....) I don't like the 'core' > name. It gets a bit confusing between TYPE_CODE and TYPE_CORE, not to > mention the use of core as in corefiles. How about base, basis, > nucleus, main, nub (just going through my dictionary).... > Probably any of you, native English speakers, has a better suggestion. How about TYPE_MAIN_TYPE, then? Amusingly, I found a couple dozen more cases where this patch helps today in fooling around with C++ method printing... > > Elena > > > Daniel Jacobowitz writes: > > Same as last time, with three new changes: > > > > - testsuite fix included for maint.exp > > - formatting bug in the code that maint.exp was testing fixed > > - Excess casts removed. > > > > Michael, I don't really see a need to retest this one; I verified > > carefully that the only changes were to casts (no new warnings) and to > > the one failing test. If you prefer to, of course, I won't complain :) > > > > Retested i386-linux, verified that all cross targets still build. > > > > -- > > Daniel Jacobowitz Carnegie Mellon University > > MontaVista Software Debian GNU/Linux Developer > > > > 2002-05-13 Daniel Jacobowitz > > > > * gdbtypes.h: Update accessor macros to use TYPE_CORE_TYPE. > > (TYPE_CONST, TYPE_VOLATILE, TYPE_CODE_SPACE, TYPE_DATA_SPACE): Use > > TYPE_INSTANCE_FLAGS. > > (struct type_core): New. > > (struct type): Move most members to struct type_core. Change > > cv_type and as_type to new type_chain member. Add instance_flags. > > (TYPE_CORE_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_CORE_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_CORE_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-13 Daniel Jacobowitz > > > > * gdb.base/maint.exp (maint print type): Update for new type > > structure. > > > > diff -x CVS -x *.orig -pur gdb.real/c-typeprint.c gdb/c-typeprint.c > > --- gdb.real/c-typeprint.c Mon May 13 10:02:10 2002 > > +++ gdb/c-typeprint.c Mon May 13 10:09:50 2002 > > @@ -316,7 +316,7 @@ c_type_print_modifier (struct type *type > > 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 -x CVS -x *.orig -pur gdb.real/dwarf2read.c gdb/dwarf2read.c > > --- gdb.real/dwarf2read.c Sun May 12 21:00:28 2002 > > +++ gdb/dwarf2read.c Sun May 12 22:26:22 2002 > > @@ -2486,8 +2486,6 @@ read_structure_scope (struct die_info *d > > /* 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 -x CVS -x *.orig -pur gdb.real/gdbtypes.c gdb/gdbtypes.c > > --- gdb.real/gdbtypes.c Mon May 13 10:02:11 2002 > > +++ gdb/gdbtypes.c Mon May 13 10:09:53 2002 > > @@ -135,7 +135,8 @@ static void virtual_base_list_aux (struc > > > > /* 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_CORE_TYPE (type) = xmalloc (sizeof (struct type_core)); > > } > > 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_CORE_TYPE (type) = obstack_alloc (&objfile->type_obstack, > > + sizeof (struct type_core)); > > OBJSTAT (objfile, n_types++); > > } > > - memset ((char *) type, 0, sizeof (struct type)); > > + memset (TYPE_CORE_TYPE (type), 0, sizeof (struct type_core)); > > > > /* 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_CORE_TYPE (type) = TYPE_CORE_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_CORE_TYPE (type), 0, sizeof (struct type_core)); > > + > > + /* 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, st > > { > > 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, > > { > > 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, s > > { > > 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_fla > > 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_CORE_TYPE (ntype) = TYPE_CORE_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, struc > > 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); > > - > > - /* 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)); > > + /* 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. */ > > + > > + gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type) > > + || TYPE_STUB (*typeptr)); > > + if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type)) > > + { > > + TYPE_CORE_TYPE (*typeptr) > > + = TYPE_ALLOC (*typeptr, sizeof (struct type_core)); > > + *TYPE_CORE_TYPE (*typeptr) > > + = *TYPE_CORE_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_CORE_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_CORE_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_CORE_TYPE (ntype) = *TYPE_CORE_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, > > > > 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, > > > > 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, > > 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, > > { > > 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"); > > @@ -3053,14 +3043,6 @@ recursive_dump_type (struct type *type, > > if (TYPE_INCOMPLETE (type)) > > { > > 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)) > > { > > diff -x CVS -x *.orig -pur gdb.real/gdbtypes.h gdb/gdbtypes.h > > --- gdb.real/gdbtypes.h Mon May 13 10:20:46 2002 > > +++ gdb/gdbtypes.h Sun May 12 22:26:22 2002 > > @@ -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_core > > +{ > > + /* 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; > > > > -struct 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. */ > > + /* 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 bitpos; > > - > > - /* 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. */ > > - > > - CORE_ADDR physaddr; > > - char *physname; > > + int upper_bound_type; > > + int lower_bound_type; > > > > - /* 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; > > + /* 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. */ > > > > - /* 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. */ > > - > > - int bitsize; > > - > > - /* 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. */ > > - > > - struct type *type; > > - > > - /* Name of field, value or argument. > > - NULL for range bounds and array domains. */ > > - > > - char *name; > > - > > - } > > - *fields; > > - > > - /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE > > - is the base class which defined the virtual function table pointer. > > + 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 bitpos; > > + > > + /* 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. */ > > + > > + CORE_ADDR physaddr; > > + char *physname; > > + > > + /* 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; > > + > > + /* 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. */ > > + > > + int bitsize; > > + > > + /* 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 > > - { > > + struct type *vptr_basetype; > > > > - /* 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. */ > > + /* 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. > > > > - struct type **arg_types; > > + Unused if this type does not have virtual functions. */ > > > > - /* 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. */ > > + int vptr_fieldno; > > > > - struct cplus_struct_type *cplus_stuff; > > + /* Slot to point to additional language-specific fields of this type. */ > > > > - /* 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. */ > > + 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 **arg_types; > > + > > + /* 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 cplus_struct_type *cplus_stuff; > > + > > + /* 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. */ > > + > > + const struct floatformat *floatformat; > > + } type_specific; > > +}; > > > > - const struct floatformat *floatformat; > > - } > > - 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. */ > > + > > + struct type *pointer_type; > > + > > + /* C++: also need a reference 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 CORE_TYPE. */ > > + struct type *chain; > > + > > + /* Flags specific to this instance of the type, indicating where > > + on the ring we are. */ > > + int instance_flags; > > + > > + /* Core type, shared by a group of qualified types. */ > > + struct type_core *core_type; > > +}; > > > > #define NULL_TYPE ((struct type *) 0) > > > > @@ -738,25 +740,26 @@ extern void allocate_cplus_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_CORE_TYPE(thistype) (thistype)->core_type > > +#define TYPE_NAME(thistype) TYPE_CORE_TYPE(thistype)->name > > +#define TYPE_TAG_NAME(type) TYPE_CORE_TYPE(type)->tag_name > > +#define TYPE_TARGET_TYPE(thistype) TYPE_CORE_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_CORE_TYPE(thistype)->length > > +#define TYPE_OBJFILE(thistype) TYPE_CORE_TYPE(thistype)->objfile > > +#define TYPE_FLAGS(thistype) TYPE_CORE_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_CORE_TYPE(thistype)->code > > +#define TYPE_NFIELDS(thistype) TYPE_CORE_TYPE(thistype)->nfields > > +#define TYPE_FIELDS(thistype) TYPE_CORE_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 ( > > > > /* 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_CORE_TYPE(thistype)->upper_bound_type > > +#define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) \ > > + TYPE_CORE_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 ( > > > > /* 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_CORE_TYPE(thistype)->vptr_basetype > > +#define TYPE_DOMAIN_TYPE(thistype) TYPE_CORE_TYPE(thistype)->vptr_basetype > > +#define TYPE_VPTR_FIELDNO(thistype) TYPE_CORE_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_CORE_TYPE(thistype)->type_specific > > +#define TYPE_ARG_TYPES(thistype) TYPE_CORE_TYPE(thistype)->type_specific.arg_types > > +#define TYPE_CPLUS_SPECIFIC(thistype) TYPE_CORE_TYPE(thistype)->type_specific.cplus_stuff > > +#define TYPE_FLOATFORMAT(thistype) TYPE_CORE_TYPE(thistype)->type_specific.floatformat > > +#define TYPE_BASECLASS(thistype,index) TYPE_CORE_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_CORE_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 ( > > ((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_CORE_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 ( > > (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_CORE_TYPE (thistype)->fields[n].bitsize < 0) > > +#define TYPE_FIELD_STATIC_HAS_ADDR(thistype, n) (TYPE_CORE_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)) > > > > @@ -1076,8 +1081,6 @@ extern struct type *lookup_reference_typ > > 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 *); > > > > diff -x CVS -x *.orig -pur gdb.real/hpread.c gdb/hpread.c > > --- gdb.real/hpread.c Mon May 13 10:02:11 2002 > > +++ gdb/hpread.c Mon May 13 10:09:54 2002 > > @@ -4403,9 +4403,6 @@ hpread_read_struct_type (dnttpointer hp_ > > /* 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 -x CVS -x *.orig -pur gdb.real/stabsread.c gdb/stabsread.c > > --- gdb.real/stabsread.c Sun May 12 21:00:28 2002 > > +++ gdb/stabsread.c Sun May 12 22:26:22 2002 > > @@ -4302,8 +4302,6 @@ read_struct_type (char **pp, struct type > > 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 -x CVS -x *.orig -pur gdb.real/testsuite/gdb.base/maint.exp gdb/testsuite/gdb.base/maint.exp > > --- gdb.real/testsuite/gdb.base/maint.exp Mon May 13 10:10:08 2002 > > +++ gdb/testsuite/gdb.base/maint.exp Mon May 13 09:37:18 2002 > > @@ -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" } > -- Daniel Jacobowitz Carnegie Mellon University MontaVista Software Debian GNU/Linux Developer