X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=c386a4244b74883bfb6b2ec0c53eaeb7a7353de0;hb=bb140953e4bab8026ff4c51f017755acbb3b253d;hp=2407efac1c31e79175c2db3e4d17b3164bc994d2;hpb=50e0dc4198cd5a873deeae34cf9718e805049693;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 2407efac1c..c386a4244b 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -30,6 +30,29 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "target.h" #include "value.h" #include "demangle.h" +#include "complaints.h" + +/* These variables point to the objects + representing the predefined C data types. */ + +struct type *builtin_type_void; +struct type *builtin_type_char; +struct type *builtin_type_short; +struct type *builtin_type_int; +struct type *builtin_type_long; +struct type *builtin_type_long_long; +struct type *builtin_type_signed_char; +struct type *builtin_type_unsigned_char; +struct type *builtin_type_unsigned_short; +struct type *builtin_type_unsigned_int; +struct type *builtin_type_unsigned_long; +struct type *builtin_type_unsigned_long_long; +struct type *builtin_type_float; +struct type *builtin_type_double; +struct type *builtin_type_long_double; +struct type *builtin_type_complex; +struct type *builtin_type_double_complex; +struct type *builtin_type_string; /* Alloc a new type structure and fill it with some defaults. If OBJFILE is non-NULL, then allocate the space for the type structure @@ -52,7 +75,7 @@ alloc_type (objfile) type = (struct type *) obstack_alloc (&objfile -> type_obstack, sizeof (struct type)); } - (void) memset ((char *)type, 0, sizeof (struct type)); + memset ((char *) type, 0, sizeof (struct type)); /* Initialize the fields that might not be zero. */ @@ -97,7 +120,7 @@ make_pointer_type (type, typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *)ntype, 0, sizeof (struct type)); + memset ((char *) ntype, 0, sizeof (struct type)); TYPE_OBJFILE (ntype) = objfile; } @@ -162,7 +185,7 @@ make_reference_type (type, typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *)ntype, 0, sizeof (struct type)); + memset ((char *) ntype, 0, sizeof (struct type)); TYPE_OBJFILE (ntype) = objfile; } @@ -224,7 +247,7 @@ make_function_type (type, typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *)ntype, 0, sizeof (struct type)); + memset ((char *) ntype, 0, sizeof (struct type)); TYPE_OBJFILE (ntype) = objfile; } @@ -290,57 +313,258 @@ allocate_stub_method (type) return (mtype); } -/* Create an array type. Elements will be of type TYPE, and there will - be NUM of them. +/* Create a range type using either a blank type supplied in RESULT_TYPE, + or creating a new type, inheriting the objfile from INDEX_TYPE. - Eventually this should be extended to take two more arguments which - specify the bounds of the array and the type of the index. - It should also be changed to be a "lookup" function, with the - appropriate data structures added to the type field. - Then read array type should call here. */ + Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to + HIGH_BOUND, inclusive. + + FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make + sure it is TYPE_CODE_UNDEF before we bash it into a range type? */ struct type * -create_array_type (element_type, number) - struct type *element_type; - int number; +create_range_type (result_type, index_type, low_bound, high_bound) + struct type *result_type; + struct type *index_type; + int low_bound; + int high_bound; { - struct type *result_type; - struct type *range_type; + if (result_type == NULL) + { + result_type = alloc_type (TYPE_OBJFILE (index_type)); + } + TYPE_CODE (result_type) = TYPE_CODE_RANGE; + TYPE_TARGET_TYPE (result_type) = index_type; + TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type); + TYPE_NFIELDS (result_type) = 2; + TYPE_FIELDS (result_type) = (struct field *) + TYPE_ALLOC (result_type, 2 * sizeof (struct field)); + memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field)); + TYPE_FIELD_BITPOS (result_type, 0) = low_bound; + TYPE_FIELD_BITPOS (result_type, 1) = high_bound; + TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int; /* FIXME */ + TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int; /* FIXME */ - result_type = alloc_type (TYPE_OBJFILE (element_type)); + 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. */ + +struct type * +force_to_range_type (type) + struct type *type; +{ + switch (TYPE_CODE (type)) + { + case TYPE_CODE_RANGE: + return type; + + 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; + } + 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; + } + 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; + } + 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); + } + } +} +/* Create an array type using either a blank type supplied in RESULT_TYPE, + or creating a new type, inheriting the objfile from RANGE_TYPE. + + Elements will be of type ELEMENT_TYPE, the indices will be of type + RANGE_TYPE. + + FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make + sure it is TYPE_CODE_UNDEF before we bash it into an array type? */ + +struct type * +create_array_type (result_type, element_type, range_type) + struct type *result_type; + struct type *element_type; + struct type *range_type; +{ + int low_bound; + int 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; - TYPE_LENGTH (result_type) = number * TYPE_LENGTH (element_type); + low_bound = TYPE_LOW_BOUND (range_type); + high_bound = TYPE_HIGH_BOUND (range_type); + TYPE_LENGTH (result_type) = + TYPE_LENGTH (element_type) * (high_bound - low_bound + 1); TYPE_NFIELDS (result_type) = 1; - TYPE_FIELDS (result_type) = (struct field *) - obstack_alloc (&TYPE_OBJFILE (result_type) -> type_obstack, - sizeof (struct field)); - - { - /* Create range type. */ - range_type = alloc_type (TYPE_OBJFILE (result_type)); - TYPE_CODE (range_type) = TYPE_CODE_RANGE; - TYPE_TARGET_TYPE (range_type) = builtin_type_int; /* FIXME */ - - /* This should never be needed. */ - TYPE_LENGTH (range_type) = sizeof (int); - - TYPE_NFIELDS (range_type) = 2; - TYPE_FIELDS (range_type) = (struct field *) - obstack_alloc (&TYPE_OBJFILE (range_type) -> type_obstack, - 2 * sizeof (struct field)); - TYPE_FIELD_BITPOS (range_type, 0) = 0; /* FIXME */ - TYPE_FIELD_BITPOS (range_type, 1) = number-1; /* FIXME */ - TYPE_FIELD_TYPE (range_type, 0) = builtin_type_int; /* FIXME */ - TYPE_FIELD_TYPE (range_type, 1) = builtin_type_int; /* FIXME */ - } - TYPE_FIELD_TYPE(result_type,0)=range_type; + TYPE_FIELDS (result_type) = + (struct field *) TYPE_ALLOC (result_type, sizeof (struct field)); + memset (TYPE_FIELDS (result_type), 0, sizeof (struct field)); + TYPE_FIELD_TYPE (result_type, 0) = range_type; TYPE_VPTR_FIELDNO (result_type) = -1; return (result_type); } +/* Create a string type using either a blank type supplied in RESULT_TYPE, + or creating a new type. String types are similar enough to array of + char types that we can use create_array_type to build the basic type + and then bash it into a string type. + + For fixed length strings, the range type contains 0 as the lower + bound and the length of the string minus one as the upper bound. + + FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make + sure it is TYPE_CODE_UNDEF before we bash it into a string type? */ + +struct type * +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); + TYPE_CODE (result_type) = TYPE_CODE_STRING; + return (result_type); +} + +struct type * +create_set_type (result_type, domain_type) + struct type *result_type; + struct type *domain_type; +{ + int low_bound, high_bound, bit_length; + if (result_type == NULL) + { + result_type = alloc_type (TYPE_OBJFILE (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)) + { + domain_type = force_to_range_type (domain_type); + low_bound = TYPE_LOW_BOUND (domain_type); + high_bound = TYPE_HIGH_BOUND (domain_type); + bit_length = high_bound - low_bound + 1; + TYPE_LENGTH (result_type) + = ((bit_length + TARGET_INT_BIT - 1) / TARGET_INT_BIT) + * TARGET_CHAR_BIT; + } + TYPE_FIELD_TYPE (result_type, 0) = domain_type; + return (result_type); +} + +/* Create an F77 literal complex type composed of the two types we are + given as arguments. */ + +struct type * +f77_create_literal_complex_type (type_arg1, type_arg2) + struct type *type_arg1; + struct type *type_arg2; +{ + struct type *result; + + /* First make sure that the 2 components of the complex + number both have the same type */ + + if (TYPE_CODE (type_arg1) != TYPE_CODE (type_arg2)) + error ("Both components of a F77 complex number must have the same type!"); + + result = alloc_type (TYPE_OBJFILE (type_arg1)); + + TYPE_CODE (result) = TYPE_CODE_LITERAL_COMPLEX; + TYPE_LENGTH (result) = TYPE_LENGTH(type_arg1) * 2; + + return result; +} + +/* Create a F77 LITERAL string type supplied by the user from the keyboard. + + Elements will be of type ELEMENT_TYPE, the indices will be of type + RANGE_TYPE. + + FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make + sure it is TYPE_CODE_UNDEF before we bash it into an array type? + + This is a total clone of create_array_type() except that there are + a few simplyfing assumptions (e.g all bound types are simple). */ + +struct type * +f77_create_literal_string_type (result_type, range_type) + struct type *result_type; + struct type *range_type; +{ + int low_bound; + int high_bound; + + if (TYPE_CODE (range_type) != TYPE_CODE_RANGE) + { + /* FIXME: We only handle range types at the moment. Complain and + create a dummy range type to use. */ + warning ("internal error: array index type must be a range type"); + range_type = lookup_fundamental_type (TYPE_OBJFILE (range_type), + FT_INTEGER); + range_type = create_range_type ((struct type *) NULL, range_type, 0, 0); + } + if (result_type == NULL) + result_type = alloc_type (TYPE_OBJFILE (range_type)); + TYPE_CODE (result_type) = TYPE_CODE_LITERAL_STRING; + TYPE_TARGET_TYPE (result_type) = builtin_type_f_character; + low_bound = TYPE_FIELD_BITPOS (range_type, 0); + high_bound = TYPE_FIELD_BITPOS (range_type, 1); + + /* Safely can assume that all bound types are simple */ + + TYPE_LENGTH (result_type) = + TYPE_LENGTH (builtin_type_f_character) * (high_bound - low_bound + 1); + + TYPE_NFIELDS (result_type) = 1; + TYPE_FIELDS (result_type) = + (struct field *) TYPE_ALLOC (result_type, sizeof (struct field)); + memset (TYPE_FIELDS (result_type), 0, sizeof (struct field)); + TYPE_FIELD_TYPE (result_type, 0) = range_type; + TYPE_VPTR_FIELDNO (result_type) = -1; + + /* Remember that all literal strings in F77 are of the + character*N type. */ + + TYPE_ARRAY_LOWER_BOUND_TYPE (result_type) = BOUND_SIMPLE; + TYPE_ARRAY_UPPER_BOUND_TYPE (result_type) = BOUND_SIMPLE; + + return result_type; +} /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. A MEMBER is a wierd thing -- it amounts to a typed offset into @@ -362,7 +586,7 @@ smash_to_member_type (type, domain, to_type) objfile = TYPE_OBJFILE (type); - (void) memset ((char *)type, 0, sizeof (struct type)); + memset ((char *) type, 0, sizeof (struct type)); TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; @@ -388,7 +612,7 @@ smash_to_method_type (type, domain, to_type, args) objfile = TYPE_OBJFILE (type); - (void) memset ((char *)type, 0, sizeof (struct type)); + memset ((char *) type, 0, sizeof (struct type)); TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; @@ -397,43 +621,20 @@ smash_to_method_type (type, domain, to_type, args) TYPE_CODE (type) = TYPE_CODE_METHOD; } -/* Return a typename for a struct/union/enum type - without the tag qualifier. If the type has a NULL name, - NULL is returned. */ +/* Return a typename for a struct/union/enum type without "struct ", + "union ", or "enum ". If the type has a NULL name, return NULL. */ char * type_name_no_tag (type) register const struct type *type; { - register char *name; + if (TYPE_TAG_NAME (type) != NULL) + return TYPE_TAG_NAME (type); - if ((name = TYPE_NAME (type)) != NULL) - { - switch (TYPE_CODE (type)) - { - case TYPE_CODE_STRUCT: - if(!strncmp (name, "struct ", 7)) - { - name += 7; - } - break; - case TYPE_CODE_UNION: - if(!strncmp (name, "union ", 6)) - { - name += 6; - } - break; - case TYPE_CODE_ENUM: - if(!strncmp (name, "enum ", 5)) - { - name += 5; - } - break; - default: /* To avoid -Wall warnings */ - break; - } - } - return (name); + /* Is there code which expects this to return the name if there is no + tag name? My guess is that this is mainly used for C++ in cases where + the two will always be the same. */ + return TYPE_NAME (type); } /* Lookup a primitive type named NAME. @@ -447,7 +648,7 @@ lookup_primitive_typename (name) for (p = current_language -> la_builtin_type_vector; *p != NULL; p++) { - if (!strcmp ((**p) -> name, name)) + if (STREQ ((**p) -> name, name)) { return (**p); } @@ -499,6 +700,22 @@ lookup_unsigned_typename (name) return (lookup_typename (uns, (struct block *) NULL, 0)); } +struct type * +lookup_signed_typename (name) + char *name; +{ + struct type *t; + char *uns = alloca (strlen (name) + 8); + + strcpy (uns, "signed "); + strcpy (uns + 7, name); + t = lookup_typename (uns, (struct block *) NULL, 1); + /* If we don't find "signed FOO" just try again with plain "FOO". */ + if (t != NULL) + return t; + return lookup_typename (name, (struct block *) NULL, 0); +} + /* Lookup a structure type named "struct NAME", visible in lexical block BLOCK. */ @@ -599,9 +816,15 @@ lookup_template_type (name, type, block) return (SYMBOL_TYPE (sym)); } -/* Given a type TYPE, lookup the type of the component of type named - NAME. - If NOERR is nonzero, return zero if NAME is not suitably defined. */ +/* Given a type TYPE, lookup the type of the component of type named NAME. + + TYPE can be either a struct or union, or a pointer or reference to a struct or + union. If it is a pointer or reference, its target type is automatically used. + Thus '.' and '->' are interchangable, as specified for the definitions of the + expression element types STRUCTOP_STRUCT and STRUCTOP_PTR. + + If NOERR is nonzero, return zero if NAME is not suitably defined. + If NAME is the name of a baseclass type, return that type. */ struct type * lookup_struct_elt_type (type, name, noerr) @@ -611,23 +834,41 @@ lookup_struct_elt_type (type, name, noerr) { int i; + while (TYPE_CODE (type) == TYPE_CODE_PTR || + TYPE_CODE (type) == TYPE_CODE_REF) + type = TYPE_TARGET_TYPE (type); + if (TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) { target_terminal_ours (); - fflush (stdout); - fprintf (stderr, "Type "); - type_print (type, "", stderr, -1); + gdb_flush (gdb_stdout); + fprintf_unfiltered (gdb_stderr, "Type "); + type_print (type, "", gdb_stderr, -1); 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 + "ptype bell->bar" for "struct foo { int bar; int foo; } bell;" + Disabled by fnf. */ + { + char *typename; + + typename = type_name_no_tag (type); + if (typename != NULL && STREQ (typename, name)) + return type; + } +#endif + for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) { char *t_field_name = TYPE_FIELD_NAME (type, i); - if (t_field_name && !strcmp (t_field_name, name)) + if (t_field_name && STREQ (t_field_name, name)) { return TYPE_FIELD_TYPE (type, i); } @@ -638,7 +879,7 @@ lookup_struct_elt_type (type, name, noerr) { struct type *t; - t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 0); + t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr); if (t != NULL) { return t; @@ -651,26 +892,35 @@ lookup_struct_elt_type (type, name, noerr) } target_terminal_ours (); - fflush (stdout); - fprintf (stderr, "Type "); - type_print (type, "", stderr, -1); - fprintf (stderr, " has no component named "); - fputs_filtered (name, stderr); + gdb_flush (gdb_stdout); + fprintf_unfiltered (gdb_stderr, "Type "); + type_print (type, "", gdb_stderr, -1); + fprintf_unfiltered (gdb_stderr, " has no component named "); + fputs_filtered (name, gdb_stderr); error ("."); return (struct type *)-1; /* For lint */ } -/* This function is really horrible, but to avoid it, there would need - to be more filling in of forward references. */ +/* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE + valid. Callers should be aware that in some cases (for example, + the type or one of its baseclasses is a stub type and we are + debugging a .o file), this function will not be able to find the virtual + function table pointer, and vptr_fieldno will remain -1 and vptr_basetype + will remain NULL. */ void fill_in_vptr_fieldno (type) struct type *type; { + check_stub_type (type); + if (TYPE_VPTR_FIELDNO (type) < 0) { int i; - for (i = 1; i < TYPE_N_BASECLASSES (type); i++) + + /* We must start at zero in case the first (and only) baseclass is + virtual (and hence we cannot share the table pointer). */ + for (i = 0; i < TYPE_N_BASECLASSES (type); i++) { fill_in_vptr_fieldno (TYPE_BASECLASS (type, i)); if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0) @@ -689,13 +939,14 @@ fill_in_vptr_fieldno (type) If this is a stubbed struct (i.e. declared as struct foo *), see if we can find a full definition in some other file. If so, copy this - definition, so we can use it in future. If not, set a flag so we - don't waste too much time in future. (FIXME, this doesn't seem - to be happening...) + definition, so we can use it in future. There used to be a comment (but + not any code) that if we don't find a full definition, we'd set a flag + so we don't spend time in the future checking the same type. That would + be a mistake, though--we might load in more symbols which contain a + full definition for the type. This used to be coded as a macro, but I don't think it is called - often enough to merit such treatment. -*/ + often enough to merit such treatment. */ struct complaint stub_noname_complaint = {"stub type has NULL name", 0, 0}; @@ -707,17 +958,45 @@ check_stub_type (type) if (TYPE_FLAGS(type) & TYPE_FLAG_STUB) { char* 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). */ struct symbol *sym; if (name == NULL) { - complain (&stub_noname_complaint, 0); + complain (&stub_noname_complaint); return; } sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL); if (sym) { - memcpy ((char *)type, (char *)SYMBOL_TYPE(sym), sizeof (struct type)); + memcpy ((char *)type, + (char *)SYMBOL_TYPE(sym), + sizeof (struct 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)) + { + /* Now recompute the length of the array type, based on its + number of elements and the target type's length. */ + TYPE_LENGTH (type) = + ((TYPE_FIELD_BITPOS (range_type, 1) + - TYPE_FIELD_BITPOS (range_type, 0) + + 1) + * TYPE_LENGTH (TYPE_TARGET_TYPE (type))); + TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB; } } } @@ -740,7 +1019,8 @@ check_stub_method (type, i, j) { struct fn_field *f; char *mangled_name = gdb_mangle_name (type, i, j); - char *demangled_name = cplus_demangle (mangled_name, DMGL_PARAMS); + char *demangled_name = cplus_demangle (mangled_name, + DMGL_PARAMS | DMGL_ANSI); char *argtypetext, *p; int depth = 0, argcount = 1; struct type **argtypes; @@ -776,9 +1056,9 @@ check_stub_method (type, i, j) NULL [...] or void [end of arglist]. */ argtypes = (struct type **) - obstack_alloc (&TYPE_OBJFILE (type) -> type_obstack, - (argcount+2) * sizeof (struct type *)); + TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *)); p = argtypetext; + /* FIXME: This is wrong for static member functions. */ argtypes[0] = lookup_pointer_type (type); argcount = 1; @@ -789,9 +1069,13 @@ check_stub_method (type, i, j) { if (depth <= 0 && (*p == ',' || *p == ')')) { - argtypes[argcount] = - parse_and_eval_type (argtypetext, p - argtypetext); - argcount += 1; + /* Avoid parsing of ellipsis, they will be handled below. */ + if (strncmp (argtypetext, "...", p - argtypetext) != 0) + { + argtypes[argcount] = + parse_and_eval_type (argtypetext, p - argtypetext); + argcount += 1; + } argtypetext = p + 1; } @@ -808,13 +1092,13 @@ check_stub_method (type, i, j) } } - if (p[-2] != '.') /* ... */ + if (p[-2] != '.') /* Not '...' */ { - argtypes[argcount] = builtin_type_void; /* Ellist terminator */ + argtypes[argcount] = builtin_type_void; /* List terminator */ } else { - argtypes[argcount] = NULL; /* List terminator */ + argtypes[argcount] = NULL; /* Ellist terminator */ } free (demangled_name); @@ -839,8 +1123,7 @@ allocate_cplus_struct_type (type) if (!HAVE_CPLUS_STRUCT (type)) { TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *) - obstack_alloc (¤t_objfile -> type_obstack, - sizeof (struct cplus_struct_type)); + TYPE_ALLOC (type, sizeof (struct cplus_struct_type)); *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default; } } @@ -893,28 +1176,24 @@ init_type (code, length, flags, name, objfile) define fundamental types. For the formats which don't provide fundamental types, gdb can create - such types, using defaults reasonable for the current target machine. - - FIXME: Some compilers distinguish explicitly signed integral types - (signed short, signed int, signed long) from "regular" integral types - (short, int, long) in the debugging information. There is some dis- - agreement as to how useful this feature is. In particular, gcc does - not support this. Also, only some debugging formats allow the - distinction to be passed on to a debugger. For now, we always just - use "short", "int", or "long" as the type name, for both the implicit - and explicitly signed types. This also makes life easier for the - gdb test suite since we don't have to account for the differences - in output depending upon what the compiler and debugging format - support. We will probably have to re-examine the issue when gdb - starts taking it's fundamental type information directly from the - debugging information supplied by the compiler. fnf@cygnus.com */ + such types, using defaults reasonable for the current language and + the current target machine. + + NOTE: This routine is obsolescent. Each debugging format reader + should manage it's own fundamental types, either creating them from + suitable defaults or reading them from the debugging information, + whichever is appropriate. The DWARF reader has already been + fixed to do this. Once the other readers are fixed, this routine + will go away. Also note that fundamental types should be managed + on a compilation unit basis in a multi-language environment, not + on a linkage unit basis as is done here. */ + struct type * lookup_fundamental_type (objfile, typeid) struct objfile *objfile; int typeid; { - register struct type *type = NULL; register struct type **typep; register int nbytes; @@ -922,186 +1201,460 @@ lookup_fundamental_type (objfile, typeid) { error ("internal error - invalid fundamental type id %d", typeid); } - else + + /* If this is the first time we need a fundamental type for this objfile + then we need to initialize the vector of type pointers. */ + + if (objfile -> fundamental_types == NULL) + { + nbytes = FT_NUM_MEMBERS * sizeof (struct type *); + objfile -> fundamental_types = (struct type **) + obstack_alloc (&objfile -> type_obstack, nbytes); + memset ((char *) objfile -> fundamental_types, 0, nbytes); + } + + /* Look for this particular type in the fundamental type vector. If one is + not found, create and install one appropriate for the current language. */ + + typep = objfile -> fundamental_types + typeid; + if (*typep == NULL) { - /* If this is the first time we */ - if (objfile -> fundamental_types == NULL) + *typep = create_fundamental_type (objfile, typeid); + } + + return (*typep); +} + +int +can_dereference (t) + struct type *t; +{ + /* FIXME: Should we return true for references as well as pointers? */ + return + (t != NULL + && TYPE_CODE (t) == TYPE_CODE_PTR + && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID); +} + +#if MAINTENANCE_CMDS + +static void +print_bit_vector (bits, nbits) + B_TYPE *bits; + int nbits; +{ + int bitno; + + for (bitno = 0; bitno < nbits; bitno++) + { + if ((bitno % 8) == 0) { - nbytes = FT_NUM_MEMBERS * sizeof (struct type *); - objfile -> fundamental_types = (struct type **) - obstack_alloc (&objfile -> type_obstack, nbytes); - (void) memset ((char *)objfile -> fundamental_types, 0, nbytes); + puts_filtered (" "); } - typep = objfile -> fundamental_types + typeid; - if ((type = *typep) == NULL) + if (B_TST (bits, bitno)) + { + printf_filtered ("1"); + } + else + { + printf_filtered ("0"); + } + } +} + +/* The args list is a strange beast. It is either terminated by a NULL + pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID + type for normal fixed argcount functions. (FIXME someday) + Also note the first arg should be the "this" pointer, we may not want to + include it since we may get into a infinitely recursive situation. */ + +static void +print_arg_types (args, spaces) + struct type **args; + int spaces; +{ + if (args != NULL) + { + while (*args != NULL) { - switch (typeid) + recursive_dump_type (*args, spaces + 2); + if ((*args++) -> code == TYPE_CODE_VOID) { - default: - error ("internal error: unhandled type id %d", typeid); - break; - case FT_VOID: - type = init_type (TYPE_CODE_VOID, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "void", objfile); - break; - case FT_BOOLEAN: - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "boolean", objfile); - break; - case FT_STRING: - type = init_type (TYPE_CODE_PASCAL_ARRAY, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "string", objfile); - break; - case FT_CHAR: - type = init_type (TYPE_CODE_INT, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "char", objfile); - break; - case FT_SIGNED_CHAR: - type = init_type (TYPE_CODE_INT, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_SIGNED, - "signed char", objfile); - break; - case FT_UNSIGNED_CHAR: - type = init_type (TYPE_CODE_INT, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "unsigned char", objfile); - break; - case FT_SHORT: - type = init_type (TYPE_CODE_INT, - TARGET_SHORT_BIT / TARGET_CHAR_BIT, - 0, - "short", objfile); - break; - case FT_SIGNED_SHORT: - type = init_type (TYPE_CODE_INT, - TARGET_SHORT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_SIGNED, - "short", objfile); /* FIXME -fnf */ - break; - case FT_UNSIGNED_SHORT: - type = init_type (TYPE_CODE_INT, - TARGET_SHORT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "unsigned short", objfile); - break; - case FT_INTEGER: - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - 0, - "int", objfile); - break; - case FT_SIGNED_INTEGER: - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_SIGNED, - "int", objfile); /* FIXME -fnf */ - break; - case FT_UNSIGNED_INTEGER: - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "unsigned int", objfile); - break; - case FT_FIXED_DECIMAL: - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - 0, - "fixed decimal", objfile); - break; - case FT_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_BIT / TARGET_CHAR_BIT, - 0, - "long", objfile); - break; - case FT_SIGNED_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_SIGNED, - "long", objfile); /* FIXME -fnf */ - break; - case FT_UNSIGNED_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "unsigned long", objfile); - break; - case FT_LONG_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, - 0, - "long long", objfile); - break; - case FT_SIGNED_LONG_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_SIGNED, - "signed long long", objfile); - break; - case FT_UNSIGNED_LONG_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "unsigned long long", objfile); - break; - case FT_FLOAT: - type = init_type (TYPE_CODE_FLT, - TARGET_FLOAT_BIT / TARGET_CHAR_BIT, - 0, - "float", objfile); - break; - case FT_DBL_PREC_FLOAT: - type = init_type (TYPE_CODE_FLT, - TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, - "double", objfile); - break; - case FT_FLOAT_DECIMAL: - type = init_type (TYPE_CODE_FLT, - TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, - "floating decimal", objfile); - break; - case FT_EXT_PREC_FLOAT: - type = init_type (TYPE_CODE_FLT, - TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, - "long double", objfile); - break; - case FT_COMPLEX: - type = init_type (TYPE_CODE_FLT, - TARGET_COMPLEX_BIT / TARGET_CHAR_BIT, - 0, - "complex", objfile); - break; - case FT_DBL_PREC_COMPLEX: - type = init_type (TYPE_CODE_FLT, - TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT, - 0, - "double complex", objfile); - break; - case FT_EXT_PREC_COMPLEX: - type = init_type (TYPE_CODE_FLT, - TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT, - 0, - "long double complex", objfile); - break; + break; } - /* Install the newly created type in the objfile's fundamental_types - vector. */ - *typep = type; } } - return (type); } +static void +dump_fn_fieldlists (type, spaces) + struct type *type; + int spaces; +{ + int method_idx; + int overload_idx; + struct fn_field *f; + + printfi_filtered (spaces, "fn_fieldlists "); + gdb_print_address (TYPE_FN_FIELDLISTS (type), gdb_stdout); + printf_filtered ("\n"); + for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++) + { + f = TYPE_FN_FIELDLIST1 (type, method_idx); + printfi_filtered (spaces + 2, "[%d] name '%s' (", + method_idx, + TYPE_FN_FIELDLIST_NAME (type, method_idx)); + gdb_print_address (TYPE_FN_FIELDLIST_NAME (type, method_idx), + gdb_stdout); + printf_filtered (") length %d\n", + TYPE_FN_FIELDLIST_LENGTH (type, method_idx)); + for (overload_idx = 0; + overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx); + overload_idx++) + { + printfi_filtered (spaces + 4, "[%d] physname '%s' (", + overload_idx, + TYPE_FN_FIELD_PHYSNAME (f, overload_idx)); + gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx), + gdb_stdout); + printf_filtered (")\n"); + printfi_filtered (spaces + 8, "type "); + gdb_print_address (TYPE_FN_FIELD_TYPE (f, overload_idx), gdb_stdout); + printf_filtered ("\n"); + + recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx), + spaces + 8 + 2); + + printfi_filtered (spaces + 8, "args "); + gdb_print_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout); + printf_filtered ("\n"); + + print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces); + printfi_filtered (spaces + 8, "fcontext "); + gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx), + gdb_stdout); + printf_filtered ("\n"); + + printfi_filtered (spaces + 8, "is_const %d\n", + TYPE_FN_FIELD_CONST (f, overload_idx)); + printfi_filtered (spaces + 8, "is_volatile %d\n", + TYPE_FN_FIELD_VOLATILE (f, overload_idx)); + printfi_filtered (spaces + 8, "is_private %d\n", + TYPE_FN_FIELD_PRIVATE (f, overload_idx)); + printfi_filtered (spaces + 8, "is_protected %d\n", + TYPE_FN_FIELD_PROTECTED (f, overload_idx)); + printfi_filtered (spaces + 8, "is_stub %d\n", + TYPE_FN_FIELD_STUB (f, overload_idx)); + printfi_filtered (spaces + 8, "voffset %u\n", + TYPE_FN_FIELD_VOFFSET (f, overload_idx)); + } + } +} + +static void +print_cplus_stuff (type, spaces) + struct type *type; + int spaces; +{ + printfi_filtered (spaces, "n_baseclasses %d\n", + TYPE_N_BASECLASSES (type)); + printfi_filtered (spaces, "nfn_fields %d\n", + TYPE_NFN_FIELDS (type)); + printfi_filtered (spaces, "nfn_fields_total %d\n", + TYPE_NFN_FIELDS_TOTAL (type)); + if (TYPE_N_BASECLASSES (type) > 0) + { + printfi_filtered (spaces, "virtual_field_bits (%d bits at *", + TYPE_N_BASECLASSES (type)); + gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type), gdb_stdout); + printf_filtered (")"); + + print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type), + TYPE_N_BASECLASSES (type)); + puts_filtered ("\n"); + } + if (TYPE_NFIELDS (type) > 0) + { + if (TYPE_FIELD_PRIVATE_BITS (type) != NULL) + { + printfi_filtered (spaces, "private_field_bits (%d bits at *", + TYPE_NFIELDS (type)); + gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout); + printf_filtered (")"); + print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type), + TYPE_NFIELDS (type)); + puts_filtered ("\n"); + } + if (TYPE_FIELD_PROTECTED_BITS (type) != NULL) + { + printfi_filtered (spaces, "protected_field_bits (%d bits at *", + TYPE_NFIELDS (type)); + gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout); + printf_filtered (")"); + print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type), + TYPE_NFIELDS (type)); + puts_filtered ("\n"); + } + } + if (TYPE_NFN_FIELDS (type) > 0) + { + dump_fn_fieldlists (type, spaces); + } +} + +void +recursive_dump_type (type, spaces) + struct type *type; + int spaces; +{ + int idx; + + printfi_filtered (spaces, "type node "); + gdb_print_address (type, gdb_stdout); + printf_filtered ("\n"); + printfi_filtered (spaces, "name '%s' (", + TYPE_NAME (type) ? TYPE_NAME (type) : ""); + gdb_print_address (TYPE_NAME (type), gdb_stdout); + printf_filtered (")\n"); + if (TYPE_TAG_NAME (type) != NULL) + { + printfi_filtered (spaces, "tagname '%s' (", + TYPE_TAG_NAME (type)); + gdb_print_address (TYPE_TAG_NAME (type), gdb_stdout); + printf_filtered (")\n"); + } + printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type)); + switch (TYPE_CODE (type)) + { + case TYPE_CODE_UNDEF: + printf_filtered ("(TYPE_CODE_UNDEF)"); + break; + case TYPE_CODE_PTR: + printf_filtered ("(TYPE_CODE_PTR)"); + break; + case TYPE_CODE_ARRAY: + printf_filtered ("(TYPE_CODE_ARRAY)"); + break; + case TYPE_CODE_STRUCT: + printf_filtered ("(TYPE_CODE_STRUCT)"); + break; + case TYPE_CODE_UNION: + printf_filtered ("(TYPE_CODE_UNION)"); + break; + case TYPE_CODE_ENUM: + printf_filtered ("(TYPE_CODE_ENUM)"); + break; + case TYPE_CODE_FUNC: + printf_filtered ("(TYPE_CODE_FUNC)"); + break; + case TYPE_CODE_INT: + printf_filtered ("(TYPE_CODE_INT)"); + break; + case TYPE_CODE_FLT: + printf_filtered ("(TYPE_CODE_FLT)"); + break; + case TYPE_CODE_VOID: + printf_filtered ("(TYPE_CODE_VOID)"); + break; + case TYPE_CODE_SET: + printf_filtered ("(TYPE_CODE_SET)"); + break; + case TYPE_CODE_RANGE: + printf_filtered ("(TYPE_CODE_RANGE)"); + break; + case TYPE_CODE_STRING: + printf_filtered ("(TYPE_CODE_STRING)"); + break; + case TYPE_CODE_ERROR: + printf_filtered ("(TYPE_CODE_ERROR)"); + break; + case TYPE_CODE_MEMBER: + printf_filtered ("(TYPE_CODE_MEMBER)"); + break; + case TYPE_CODE_METHOD: + printf_filtered ("(TYPE_CODE_METHOD)"); + break; + case TYPE_CODE_REF: + printf_filtered ("(TYPE_CODE_REF)"); + break; + case TYPE_CODE_CHAR: + printf_filtered ("(TYPE_CODE_CHAR)"); + break; + case TYPE_CODE_BOOL: + printf_filtered ("(TYPE_CODE_BOOL)"); + break; + default: + printf_filtered ("(UNKNOWN TYPE CODE)"); + break; + } + puts_filtered ("\n"); + printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)); + printfi_filtered (spaces, "objfile "); + gdb_print_address (TYPE_OBJFILE (type), gdb_stdout); + printf_filtered ("\n"); + printfi_filtered (spaces, "target_type "); + gdb_print_address (TYPE_TARGET_TYPE (type), gdb_stdout); + printf_filtered ("\n"); + if (TYPE_TARGET_TYPE (type) != NULL) + { + recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2); + } + printfi_filtered (spaces, "pointer_type "); + gdb_print_address (TYPE_POINTER_TYPE (type), gdb_stdout); + printf_filtered ("\n"); + 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) + { + puts_filtered (" TYPE_FLAG_UNSIGNED"); + } + if (TYPE_FLAGS (type) & TYPE_FLAG_STUB) + { + puts_filtered (" TYPE_FLAG_STUB"); + } + puts_filtered ("\n"); + printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type)); + gdb_print_address (TYPE_FIELDS (type), gdb_stdout); + puts_filtered ("\n"); + for (idx = 0; idx < TYPE_NFIELDS (type); idx++) + { + printfi_filtered (spaces + 2, + "[%d] bitpos %d bitsize %d type ", + idx, TYPE_FIELD_BITPOS (type, idx), + TYPE_FIELD_BITSIZE (type, idx)); + gdb_print_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout); + printf_filtered (" name '%s' (", + TYPE_FIELD_NAME (type, idx) != NULL + ? TYPE_FIELD_NAME (type, idx) + : ""); + gdb_print_address (TYPE_FIELD_NAME (type, idx), gdb_stdout); + printf_filtered (")\n"); + if (TYPE_FIELD_TYPE (type, idx) != NULL) + { + recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4); + } + } + printfi_filtered (spaces, "vptr_basetype "); + gdb_print_address (TYPE_VPTR_BASETYPE (type), gdb_stdout); + puts_filtered ("\n"); + if (TYPE_VPTR_BASETYPE (type) != NULL) + { + recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2); + } + printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type)); + switch (TYPE_CODE (type)) + { + case TYPE_CODE_METHOD: + case TYPE_CODE_FUNC: + printfi_filtered (spaces, "arg_types "); + gdb_print_address (TYPE_ARG_TYPES (type), gdb_stdout); + puts_filtered ("\n"); + print_arg_types (TYPE_ARG_TYPES (type), spaces); + break; + + case TYPE_CODE_STRUCT: + printfi_filtered (spaces, "cplus_stuff "); + gdb_print_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout); + puts_filtered ("\n"); + print_cplus_stuff (type, spaces); + break; + + default: + /* We have to pick one of the union types to be able print and test + the value. Pick cplus_struct_type, even though we know it isn't + any particular one. */ + printfi_filtered (spaces, "type_specific "); + gdb_print_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout); + if (TYPE_CPLUS_SPECIFIC (type) != NULL) + { + printf_filtered (" (unknown data form)"); + } + printf_filtered ("\n"); + break; + + } +} + +#endif /* MAINTENANCE_CMDS */ + +void +_initialize_gdbtypes () +{ + builtin_type_void = + init_type (TYPE_CODE_VOID, 1, + 0, + "void", (struct objfile *) NULL); + builtin_type_char = + init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, + "char", (struct objfile *) NULL); + builtin_type_signed_char = + init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, + "signed char", (struct objfile *) NULL); + builtin_type_unsigned_char = + init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned char", (struct objfile *) NULL); + builtin_type_short = + init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT, + 0, + "short", (struct objfile *) NULL); + builtin_type_unsigned_short = + init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned short", (struct objfile *) NULL); + builtin_type_int = + init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, + 0, + "int", (struct objfile *) NULL); + builtin_type_unsigned_int = + init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned int", (struct objfile *) NULL); + builtin_type_long = + init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT, + 0, + "long", (struct objfile *) NULL); + builtin_type_unsigned_long = + init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned long", (struct objfile *) NULL); + builtin_type_long_long = + init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, + 0, + "long long", (struct objfile *) NULL); + builtin_type_unsigned_long_long = + init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned long long", (struct objfile *) NULL); + builtin_type_float = + init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT, + 0, + "float", (struct objfile *) NULL); + builtin_type_double = + init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, + 0, + "double", (struct objfile *) NULL); + builtin_type_long_double = + init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, + 0, + "long double", (struct objfile *) NULL); + builtin_type_complex = + init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT, + 0, + "complex", (struct objfile *) NULL); + builtin_type_double_complex = + init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT, + 0, + "double complex", (struct objfile *) NULL); + builtin_type_string = + init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, + "string", (struct objfile *) NULL); +}