X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=2f4e411fb3022e70ebb068c8ab118071aa533b7f;hb=f109cc3d9ef5ddcbd26afa98207b3eebaea9463f;hp=12caa7a124c6a211414724de48d8e1c58384f852;hpb=5e678752031189556550c3faa3e27be9c628659a;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 12caa7a124..2f4e411fb3 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,5 +1,5 @@ /* Support routines for manipulating internal types for GDB. - Copyright (C) 1992 Free Software Foundation, Inc. + Copyright (C) 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. This file is part of GDB. @@ -16,10 +16,10 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "defs.h" -#include +#include "gdb_string.h" #include "bfd.h" #include "symtab.h" #include "symfile.h" @@ -54,6 +54,18 @@ struct type *builtin_type_complex; struct type *builtin_type_double_complex; struct type *builtin_type_string; +struct extra { char str[128]; int len; }; /* maximum extention is 128! FIXME */ + +static void add_name PARAMS ((struct extra *, char *)); +static void add_mangled_type PARAMS ((struct extra *, struct type *)); +#if 0 +static void cfront_mangle_name PARAMS ((struct type *, int, int)); +#endif +static void print_bit_vector PARAMS ((B_TYPE *, int)); +static void print_arg_types PARAMS ((struct type **, int)); +static void dump_fn_fieldlists PARAMS ((struct type *, int)); +static void print_cplus_stuff PARAMS ((struct type *, int)); + /* 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. */ @@ -74,6 +86,7 @@ alloc_type (objfile) { type = (struct type *) obstack_alloc (&objfile -> type_obstack, sizeof (struct type)); + OBJSTAT (objfile, n_types++); } memset ((char *) type, 0, sizeof (struct type)); @@ -226,17 +239,6 @@ make_function_type (type, typeptr) register struct type *ntype; /* New type */ struct objfile *objfile; - ntype = TYPE_FUNCTION_TYPE (type); - - if (ntype) - if (typeptr == 0) - return ntype; /* Don't care about alloc, and have new type. */ - else if (*typeptr == 0) - { - *typeptr = ntype; /* Tracking alloc, and we have new type. */ - return ntype; - } - if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ { ntype = alloc_type (TYPE_OBJFILE (type)); @@ -252,14 +254,10 @@ make_function_type (type, typeptr) } TYPE_TARGET_TYPE (ntype) = type; - TYPE_FUNCTION_TYPE (type) = ntype; TYPE_LENGTH (ntype) = 1; TYPE_CODE (ntype) = TYPE_CODE_FUNC; - if (!TYPE_FUNCTION_TYPE (type)) /* Remember it, if don't have one. */ - TYPE_FUNCTION_TYPE (type) = ntype; - return ntype; } @@ -335,7 +333,10 @@ create_range_type (result_type, index_type, low_bound, high_bound) } TYPE_CODE (result_type) = TYPE_CODE_RANGE; TYPE_TARGET_TYPE (result_type) = index_type; - TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type); + if (TYPE_FLAGS (index_type) & TYPE_FLAG_STUB) + TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB; + else + TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type)); TYPE_NFIELDS (result_type) = 2; TYPE_FIELDS (result_type) = (struct field *) TYPE_ALLOC (result_type, 2 * sizeof (struct field)); @@ -348,51 +349,68 @@ create_range_type (result_type, index_type, low_bound, high_bound) return (result_type); } -/* A lot of code assumes that the "index type" of an array/string/ - set/bitstring is specifically a range type, though in some languages - it can be any discrete type. */ +/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE. + Return 1 of type is a range type, 0 if it is discrete (and bounds + will fit in LONGEST), or -1 otherwise. */ -struct type * -force_to_range_type (type) +int +get_discrete_bounds (type, lowp, highp) struct type *type; + LONGEST *lowp, *highp; { + CHECK_TYPEDEF (type); switch (TYPE_CODE (type)) { case TYPE_CODE_RANGE: - return type; - + *lowp = TYPE_LOW_BOUND (type); + *highp = TYPE_HIGH_BOUND (type); + return 1; case TYPE_CODE_ENUM: - { - int low_bound = TYPE_FIELD_BITPOS (type, 0); - int high_bound = TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1); - struct type *range_type = - create_range_type (NULL, type, low_bound, high_bound); - TYPE_NAME (range_type) = TYPE_NAME (range_type); - TYPE_DUMMY_RANGE (range_type) = 1; - return range_type; - } + if (TYPE_NFIELDS (type) > 0) + { + /* The enums may not be sorted by value, so search all + entries */ + int i; + + *lowp = *highp = TYPE_FIELD_BITPOS (type, 0); + for (i = 0; i < TYPE_NFIELDS (type); i++) + { + if (TYPE_FIELD_BITPOS (type, i) < *lowp) + *lowp = TYPE_FIELD_BITPOS (type, i); + if (TYPE_FIELD_BITPOS (type, i) > *highp) + *highp = TYPE_FIELD_BITPOS (type, i); + } + } + else + { + *lowp = 0; + *highp = -1; + } + return 0; case TYPE_CODE_BOOL: - { - struct type *range_type = create_range_type (NULL, type, 0, 1); - TYPE_NAME (range_type) = TYPE_NAME (range_type); - TYPE_DUMMY_RANGE (range_type) = 1; - return range_type; - } + *lowp = 0; + *highp = 1; + return 0; + case TYPE_CODE_INT: + if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */ + return -1; + if (!TYPE_UNSIGNED (type)) + { + *lowp = - (1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1)); + *highp = -*lowp - 1; + return 0; + } + /* ... fall through for unsigned ints ... */ case TYPE_CODE_CHAR: - { - struct type *range_type = create_range_type (NULL, type, 0, 255); - TYPE_NAME (range_type) = TYPE_NAME (range_type); - TYPE_DUMMY_RANGE (range_type) = 1; - return range_type; - } + *lowp = 0; + /* This round-about calculation is to avoid shifting by + TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work + if TYPE_LENGTH (type) == sizeof (LONGEST). */ + *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1); + *highp = (*highp - 1) | *highp; + return 0; default: - { - static struct complaint msg = - { "array index type must be a discrete type", 0, 0}; - complain (&msg); - - return create_range_type (NULL, builtin_type_int, 0, 0); - } + return -1; } } @@ -411,18 +429,17 @@ create_array_type (result_type, element_type, range_type) struct type *element_type; struct type *range_type; { - int low_bound; - int high_bound; + LONGEST low_bound, high_bound; - range_type = force_to_range_type (range_type); if (result_type == NULL) { result_type = alloc_type (TYPE_OBJFILE (range_type)); } TYPE_CODE (result_type) = TYPE_CODE_ARRAY; TYPE_TARGET_TYPE (result_type) = element_type; - low_bound = TYPE_LOW_BOUND (range_type); - high_bound = TYPE_HIGH_BOUND (range_type); + if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) + low_bound = high_bound = 0; + CHECK_TYPEDEF (element_type); TYPE_LENGTH (result_type) = TYPE_LENGTH (element_type) * (high_bound - low_bound + 1); TYPE_NFIELDS (result_type) = 1; @@ -432,6 +449,10 @@ create_array_type (result_type, element_type, range_type) TYPE_FIELD_TYPE (result_type, 0) = range_type; TYPE_VPTR_FIELDNO (result_type) = -1; + /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */ + if (TYPE_LENGTH (result_type) == 0) + TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB; + return (result_type); } @@ -451,7 +472,9 @@ create_string_type (result_type, range_type) struct type *result_type; struct type *range_type; { - result_type = create_array_type (result_type, builtin_type_char, range_type); + result_type = create_array_type (result_type, + *current_language->string_char_type, + range_type); TYPE_CODE (result_type) = TYPE_CODE_STRING; return (result_type); } @@ -461,29 +484,26 @@ create_set_type (result_type, domain_type) struct type *result_type; struct type *domain_type; { - int low_bound, high_bound, bit_length; + LONGEST low_bound, high_bound, bit_length; if (result_type == NULL) { result_type = alloc_type (TYPE_OBJFILE (domain_type)); } - domain_type = force_to_range_type (domain_type); TYPE_CODE (result_type) = TYPE_CODE_SET; TYPE_NFIELDS (result_type) = 1; TYPE_FIELDS (result_type) = (struct field *) TYPE_ALLOC (result_type, 1 * sizeof (struct field)); memset (TYPE_FIELDS (result_type), 0, sizeof (struct field)); + + if (! (TYPE_FLAGS (domain_type) & TYPE_FLAG_STUB)) + { + if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0) + low_bound = high_bound = 0; + bit_length = high_bound - low_bound + 1; + TYPE_LENGTH (result_type) + = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT; + } TYPE_FIELD_TYPE (result_type, 0) = domain_type; - low_bound = TYPE_LOW_BOUND (domain_type); - high_bound = TYPE_HIGH_BOUND (domain_type); - bit_length = high_bound - low_bound + 1; - if (bit_length <= TARGET_CHAR_BIT) - TYPE_LENGTH (result_type) = 1; - else if (bit_length <= TARGET_SHORT_BIT) - TYPE_LENGTH (result_type) = TARGET_SHORT_BIT / TARGET_CHAR_BIT; - else - TYPE_LENGTH (result_type) - = ((bit_length + TARGET_INT_BIT - 1) / TARGET_INT_BIT) - * TARGET_CHAR_BIT; return (result_type); } @@ -755,9 +775,14 @@ lookup_struct_elt_type (type, name, noerr) { int i; - while (TYPE_CODE (type) == TYPE_CODE_PTR || - TYPE_CODE (type) == TYPE_CODE_REF) + for (;;) + { + CHECK_TYPEDEF (type); + if (TYPE_CODE (type) != TYPE_CODE_PTR + && TYPE_CODE (type) != TYPE_CODE_REF) + break; type = TYPE_TARGET_TYPE (type); + } if (TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) @@ -769,8 +794,6 @@ lookup_struct_elt_type (type, name, noerr) error (" is not a structure or union type."); } - check_stub_type (type); - #if 0 /* FIXME: This change put in by Michael seems incorrect for the case where the structure tag name is the same as the member name. I.E. when doing @@ -833,7 +856,7 @@ void fill_in_vptr_fieldno (type) struct type *type; { - check_stub_type (type); + CHECK_TYPEDEF (type); if (TYPE_VPTR_FIELDNO (type) < 0) { @@ -856,6 +879,35 @@ fill_in_vptr_fieldno (type) } } +/* Find the method and field indices for the destructor in class type T. + Return 1 if the destructor was found, otherwise, return 0. */ + +int +get_destructor_fn_field (t, method_indexp, field_indexp) + struct type *t; + int *method_indexp; + int *field_indexp; +{ + int i; + + for (i = 0; i < TYPE_NFN_FIELDS (t); i++) + { + int j; + struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i); + + for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++) + { + if (DESTRUCTOR_PREFIX_P (TYPE_FN_FIELD_PHYSNAME (f, j))) + { + *method_indexp = i; + *field_indexp = j; + return 1; + } + } + } + return 0; +} + /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989. If this is a stubbed struct (i.e. declared as struct foo *), see if @@ -872,11 +924,44 @@ fill_in_vptr_fieldno (type) struct complaint stub_noname_complaint = {"stub type has NULL name", 0, 0}; -void -check_stub_type (type) - struct type *type; +struct type * +check_typedef (type) + register struct type *type; { - if (TYPE_FLAGS(type) & TYPE_FLAG_STUB) + struct type *orig_type = type; + while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) + { + if (!TYPE_TARGET_TYPE (type)) + { + char* name; + struct symbol *sym; + + /* It is dangerous to call lookup_symbol if we are currently + reading a symtab. Infinite recursion is one danger. */ + if (currently_reading_symtab) + return type; + + name = type_name_no_tag (type); + /* FIXME: shouldn't we separately check the TYPE_NAME and the + TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE + as appropriate? (this code was written before TYPE_NAME and + TYPE_TAG_NAME were separate). */ + if (name == NULL) + { + complain (&stub_noname_complaint); + return type; + } + sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, + (struct symtab **) NULL); + if (sym) + TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym); + else + TYPE_TARGET_TYPE (type) = alloc_type (NULL); /* TYPE_CODE_UNDEF */ + } + type = TYPE_TARGET_TYPE (type); + } + + if ((TYPE_FLAGS(type) & TYPE_FLAG_STUB) && ! currently_reading_symtab) { char* name = type_name_no_tag (type); /* FIXME: shouldn't we separately check the TYPE_NAME and the @@ -887,7 +972,7 @@ check_stub_type (type) if (name == NULL) { complain (&stub_noname_complaint); - return; + return type; } sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL); @@ -902,13 +987,14 @@ check_stub_type (type) if (TYPE_FLAGS (type) & TYPE_FLAG_TARGET_STUB) { struct type *range_type; - - check_stub_type (TYPE_TARGET_TYPE (type)); - if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_STUB) - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_NFIELDS (type) == 1 - && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0)) - == TYPE_CODE_RANGE)) + struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type)); + + if (TYPE_FLAGS (target_type) & TYPE_FLAG_STUB) + { } + else if (TYPE_CODE (type) == TYPE_CODE_ARRAY + && TYPE_NFIELDS (type) == 1 + && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0)) + == TYPE_CODE_RANGE)) { /* Now recompute the length of the array type, based on its number of elements and the target type's length. */ @@ -916,11 +1002,215 @@ check_stub_type (type) ((TYPE_FIELD_BITPOS (range_type, 1) - TYPE_FIELD_BITPOS (range_type, 0) + 1) - * TYPE_LENGTH (TYPE_TARGET_TYPE (type))); + * TYPE_LENGTH (target_type)); TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB; } + else if (TYPE_CODE (type) == TYPE_CODE_RANGE) + { + TYPE_LENGTH (type) = TYPE_LENGTH (target_type); + TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB; + } + } + /* Cache TYPE_LENGTH for future use. */ + TYPE_LENGTH (orig_type) = TYPE_LENGTH (type); + return type; +} + +/* New code added to support parsing of Cfront stabs strings */ +#include +#define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; } +#define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; } + +static void +add_name(pextras,n) + struct extra * pextras; + char * n; +{ + int nlen; + + if ((nlen = (n ? strlen(n) : 0))==0) + return; + sprintf(pextras->str+pextras->len,"%d%s",nlen,n); + pextras->len=strlen(pextras->str); +} + +static void +add_mangled_type(pextras,t) + struct extra * pextras; + struct type * t; +{ + enum type_code tcode; + int tlen, tflags; + char * tname; + + tcode = TYPE_CODE(t); + tlen = TYPE_LENGTH(t); + tflags = TYPE_FLAGS(t); + tname = TYPE_NAME(t); + /* args of "..." seem to get mangled as "e" */ + + switch (tcode) + { + case TYPE_CODE_INT: + if (tflags==1) + ADD_EXTRA('U'); + switch (tlen) + { + case 1: + ADD_EXTRA('c'); + break; + case 2: + ADD_EXTRA('s'); + break; + case 4: + { + char* pname; + if ((pname=strrchr(tname,'l'),pname) && !strcmp(pname,"long")) + ADD_EXTRA('l') + else + ADD_EXTRA('i') + } + break; + default: + { + + static struct complaint msg = {"Bad int type code length x%x\n",0,0}; + + complain (&msg, tlen); + + } + } + break; + case TYPE_CODE_FLT: + switch (tlen) + { + case 4: + ADD_EXTRA('f'); + break; + case 8: + ADD_EXTRA('d'); + break; + case 16: + ADD_EXTRA('r'); + break; + default: + { + static struct complaint msg = {"Bad float type code length x%x\n",0,0}; + complain (&msg, tlen); + } + } + break; + case TYPE_CODE_REF: + ADD_EXTRA('R'); + /* followed by what it's a ref to */ + break; + case TYPE_CODE_PTR: + ADD_EXTRA('P'); + /* followed by what it's a ptr to */ + break; + case TYPE_CODE_TYPEDEF: + { + static struct complaint msg = {"Typedefs in overloaded functions not yet supported\n",0,0}; + complain (&msg); + } + /* followed by type bytes & name */ + break; + case TYPE_CODE_FUNC: + ADD_EXTRA('F'); + /* followed by func's arg '_' & ret types */ + break; + case TYPE_CODE_VOID: + ADD_EXTRA('v'); + break; + case TYPE_CODE_METHOD: + ADD_EXTRA('M'); + /* followed by name of class and func's arg '_' & ret types */ + add_name(pextras,tname); + ADD_EXTRA('F'); /* then mangle function */ + break; + case TYPE_CODE_STRUCT: /* C struct */ + case TYPE_CODE_UNION: /* C union */ + case TYPE_CODE_ENUM: /* Enumeration type */ + /* followed by name of type */ + add_name(pextras,tname); + break; + + /* errors possible types/not supported */ + case TYPE_CODE_CHAR: + case TYPE_CODE_ARRAY: /* Array type */ + case TYPE_CODE_MEMBER: /* Member type */ + case TYPE_CODE_BOOL: + case TYPE_CODE_COMPLEX: /* Complex float */ + case TYPE_CODE_UNDEF: + case TYPE_CODE_SET: /* Pascal sets */ + case TYPE_CODE_RANGE: + case TYPE_CODE_STRING: + case TYPE_CODE_BITSTRING: + case TYPE_CODE_ERROR: + default: + { + static struct complaint msg = {"Unknown type code x%x\n",0,0}; + complain (&msg, tcode); + } } + if (t->target_type) + add_mangled_type(pextras,t->target_type); +} + +#if 0 +void +cfront_mangle_name(type, i, j) + struct type *type; + int i; + int j; +{ + struct fn_field *f; + char *mangled_name = gdb_mangle_name (type, i, j); + + f = TYPE_FN_FIELDLIST1 (type, i); /* moved from below */ + + /* kludge to support cfront methods - gdb expects to find "F" for + ARM_mangled names, so when we mangle, we have to add it here */ + if (ARM_DEMANGLING) + { + int k; + char * arm_mangled_name; + struct fn_field *method = &f[j]; + char *field_name = TYPE_FN_FIELDLIST_NAME (type, i); + char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); + char *newname = type_name_no_tag (type); + + struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); + int nargs = TYPE_NFIELDS(ftype); /* number of args */ + struct extra extras, * pextras = &extras; + INIT_EXTRA + + if (TYPE_FN_FIELD_STATIC_P (f, j)) /* j for sublist within this list */ + ADD_EXTRA('S') + ADD_EXTRA('F') + /* add args here! */ + if (nargs <= 1) /* no args besides this */ + ADD_EXTRA('v') + else { + for (k=1; k fundamental_types = (struct type **) obstack_alloc (&objfile -> type_obstack, nbytes); memset ((char *) objfile -> fundamental_types, 0, nbytes); + OBJSTAT (objfile, n_types += FT_NUM_MEMBERS); } /* Look for this particular type in the fundamental type vector. If one is @@ -1145,6 +1440,35 @@ lookup_fundamental_type (objfile, typeid) return (*typep); } +int +can_dereference (t) + struct type *t; +{ + /* FIXME: Should we return true for references as well as pointers? */ + CHECK_TYPEDEF (t); + return + (t != NULL + && TYPE_CODE (t) == TYPE_CODE_PTR + && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID); +} + +/* Chill varying string and arrays are represented as follows: + + struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data}; + + Return true if TYPE is such a Chill varying type. */ + +int +chill_varying_type (type) + struct type *type; +{ + if (TYPE_CODE (type) != TYPE_CODE_STRUCT + || TYPE_NFIELDS (type) != 2 + || strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0) + return 0; + return 1; +} + #if MAINTENANCE_CMDS static void @@ -1311,6 +1635,8 @@ print_cplus_stuff (type, spaces) } } +static struct obstack dont_print_type_obstack; + void recursive_dump_type (type, spaces) struct type *type; @@ -1318,6 +1644,32 @@ recursive_dump_type (type, spaces) { int idx; + if (spaces == 0) + obstack_begin (&dont_print_type_obstack, 0); + + if (TYPE_NFIELDS (type) > 0 + || (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0)) + { + struct type **first_dont_print + = (struct type **)obstack_base (&dont_print_type_obstack); + + int i = (struct type **)obstack_next_free (&dont_print_type_obstack) + - first_dont_print; + + while (--i >= 0) + { + if (type == first_dont_print[i]) + { + printfi_filtered (spaces, "type node "); + gdb_print_address (type, gdb_stdout); + printf_filtered (" \n"); + return; + } + } + + obstack_ptr_grow (&dont_print_type_obstack, type); + } + printfi_filtered (spaces, "type node "); gdb_print_address (type, gdb_stdout); printf_filtered ("\n"); @@ -1392,6 +1744,9 @@ recursive_dump_type (type, spaces) case TYPE_CODE_BOOL: printf_filtered ("(TYPE_CODE_BOOL)"); break; + case TYPE_CODE_TYPEDEF: + printf_filtered ("(TYPE_CODE_TYPEDEF)"); + break; default: printf_filtered ("(UNKNOWN TYPE CODE)"); break; @@ -1414,9 +1769,6 @@ recursive_dump_type (type, spaces) printfi_filtered (spaces, "reference_type "); gdb_print_address (TYPE_REFERENCE_TYPE (type), gdb_stdout); printf_filtered ("\n"); - printfi_filtered (spaces, "function_type "); - gdb_print_address (TYPE_FUNCTION_TYPE (type), gdb_stdout); - printf_filtered ("\n"); printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type)); if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED) { @@ -1487,6 +1839,8 @@ recursive_dump_type (type, spaces) break; } + if (spaces == 0) + obstack_free (&dont_print_type_obstack, NULL); } #endif /* MAINTENANCE_CMDS */ @@ -1555,13 +1909,15 @@ _initialize_gdbtypes () 0, "long double", (struct objfile *) NULL); builtin_type_complex = - init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT, + init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT, 0, "complex", (struct objfile *) NULL); + TYPE_TARGET_TYPE (builtin_type_complex) = builtin_type_float; builtin_type_double_complex = - init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT, + init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, 0, "double complex", (struct objfile *) NULL); + TYPE_TARGET_TYPE (builtin_type_double_complex) = builtin_type_double; builtin_type_string = init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0,