X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=e8ba96d10385fee485f76e07c6a451adb880c00b;hb=de4112fa387b662c7c7a1dd3e334a1274ca54d28;hp=f15d10eed7adccf4d27a74c3113f2a2e60667425;hpb=598f52dfcc03c4b00a85d0420444acec5d201ec2;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index f15d10eed7..e8ba96d103 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,5 +1,5 @@ /* Support routines for manipulating internal types for GDB. - Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000 + Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -36,6 +36,7 @@ #include "gdbcmd.h" #include "wrapper.h" #include "cp-abi.h" +#include "gdb_assert.h" /* These variables point to the objects representing the predefined C data types. */ @@ -67,12 +68,29 @@ struct type *builtin_type_int32; struct type *builtin_type_uint32; struct type *builtin_type_int64; struct type *builtin_type_uint64; +struct type *builtin_type_int128; +struct type *builtin_type_uint128; struct type *builtin_type_bool; + +/* 128 bit long vector types */ +struct type *builtin_type_v4_float; +struct type *builtin_type_v4_int32; +struct type *builtin_type_v8_int16; +struct type *builtin_type_v16_int8; +/* 64 bit long vector types */ +struct type *builtin_type_v2_float; +struct type *builtin_type_v2_int32; +struct type *builtin_type_v4_int16; +struct type *builtin_type_v8_int8; + struct type *builtin_type_v4sf; struct type *builtin_type_v4si; +struct type *builtin_type_v16qi; struct type *builtin_type_v8qi; +struct type *builtin_type_v8hi; struct type *builtin_type_v4hi; struct type *builtin_type_v2si; +struct type *builtin_type_vec128; struct type *builtin_type_ieee_single_big; struct type *builtin_type_ieee_single_little; struct type *builtin_type_ieee_double_big; @@ -117,7 +135,8 @@ static void virtual_base_list_aux (struct type *dclass); /* Alloc a new type structure and fill it with some defaults. If OBJFILE is non-NULL, then allocate the space for the type structure - in that objfile's type_obstack. */ + in that objfile's type_obstack. Otherwise allocate the new type structure + by xmalloc () (for permanent types). */ struct type * alloc_type (struct objfile *objfile) @@ -128,26 +147,73 @@ alloc_type (struct objfile *objfile) if (objfile == NULL) { - type = (struct type *) xmalloc (sizeof (struct type)); + type = xmalloc (sizeof (struct type)); + memset (type, 0, sizeof (struct type)); + TYPE_MAIN_TYPE (type) = xmalloc (sizeof (struct main_type)); } else { - type = (struct type *) obstack_alloc (&objfile->type_obstack, - sizeof (struct type)); + type = obstack_alloc (&objfile->type_obstack, + sizeof (struct type)); + memset (type, 0, sizeof (struct type)); + TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->type_obstack, + sizeof (struct main_type)); OBJSTAT (objfile, n_types++); } - memset ((char *) type, 0, sizeof (struct type)); + memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); /* Initialize the fields that might not be zero. */ TYPE_CODE (type) = TYPE_CODE_UNDEF; TYPE_OBJFILE (type) = objfile; TYPE_VPTR_FIELDNO (type) = -1; - TYPE_CV_TYPE (type) = type; /* chain back to itself */ + TYPE_CHAIN (type) = type; /* Chain back to itself. */ return (type); } +/* Alloc a new type instance structure, fill it with some defaults, + and point it at OLDTYPE. Allocate the new type instance from the + same place as OLDTYPE. */ + +static struct type * +alloc_type_instance (struct type *oldtype) +{ + struct type *type; + + /* Allocate the structure. */ + + if (TYPE_OBJFILE (oldtype) == NULL) + { + type = xmalloc (sizeof (struct type)); + memset (type, 0, sizeof (struct type)); + } + else + { + type = obstack_alloc (&TYPE_OBJFILE (oldtype)->type_obstack, + sizeof (struct type)); + memset (type, 0, sizeof (struct type)); + } + TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype); + + TYPE_CHAIN (type) = type; /* Chain back to itself for now. */ + + return (type); +} + +/* Clear all remnants of the previous type at TYPE, in preparation for + replacing it with something else. */ +static void +smash_type (struct type *type) +{ + memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); + + /* For now, delete the rings. */ + TYPE_CHAIN (type) = type; + + /* For now, leave the pointer/reference types alone. */ +} + /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points to a pointer to memory where the pointer type should be stored. If *TYPEPTR is zero, update it to point to the pointer type we return. @@ -183,7 +249,7 @@ make_pointer_type (struct type *type, struct type **typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *) ntype, 0, sizeof (struct type)); + smash_type (ntype); TYPE_OBJFILE (ntype) = objfile; } @@ -250,7 +316,7 @@ make_reference_type (struct type *type, struct type **typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *) ntype, 0, sizeof (struct type)); + smash_type (ntype); TYPE_OBJFILE (ntype) = objfile; } @@ -299,7 +365,7 @@ make_function_type (struct type *type, struct type **typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); - memset ((char *) ntype, 0, sizeof (struct type)); + smash_type (ntype); TYPE_OBJFILE (ntype) = objfile; } @@ -321,6 +387,91 @@ lookup_function_type (struct type *type) return make_function_type (type, (struct type **) 0); } +/* Identify address space identifier by name -- + return the integer flag defined in gdbtypes.h. */ +extern int +address_space_name_to_int (char *space_identifier) +{ + /* Check for known address space delimiters. */ + if (!strcmp (space_identifier, "code")) + return TYPE_FLAG_CODE_SPACE; + else if (!strcmp (space_identifier, "data")) + return TYPE_FLAG_DATA_SPACE; + else + error ("Unknown address space specifier: \"%s\"", space_identifier); +} + +/* Identify address space identifier by integer flag as defined in + gdbtypes.h -- return the string version of the adress space name. */ + +extern char * +address_space_int_to_name (int space_flag) +{ + if (space_flag & TYPE_FLAG_CODE_SPACE) + return "code"; + else if (space_flag & TYPE_FLAG_DATA_SPACE) + return "data"; + else + return NULL; +} + +/* 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_qualified_type (struct type *type, int new_flags, + struct type *storage) +{ + struct type *ntype; + + ntype = type; + do { + if (TYPE_INSTANCE_FLAGS (ntype) == new_flags) + return ntype; + ntype = TYPE_CHAIN (ntype); + } while (ntype != type); + + /* Create a new type instance. */ + if (storage == NULL) + ntype = alloc_type_instance (type); + else + { + ntype = storage; + TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type); + TYPE_CHAIN (ntype) = ntype; + } + + /* Pointers or references to the original type are not relevant to + the new type. */ + TYPE_POINTER_TYPE (ntype) = (struct type *) 0; + TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0; + + /* 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; + + 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 @@ -339,67 +490,61 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr) register struct type *tmp_type = type; /* tmp type */ struct objfile *objfile; - ntype = TYPE_CV_TYPE (type); + int new_flags = (TYPE_INSTANCE_FLAGS (type) + & ~(TYPE_FLAG_CONST | TYPE_FLAG_VOLATILE)); + + if (cnst) + new_flags |= TYPE_FLAG_CONST; + + if (voltl) + new_flags |= TYPE_FLAG_VOLATILE; - while (ntype != type) + if (typeptr && *typeptr != NULL) { - if ((TYPE_CONST (ntype) == cnst) && - (TYPE_VOLATILE (ntype) == voltl)) + /* 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)) { - if (typeptr == 0) - return ntype; - else if (*typeptr == 0) - { - *typeptr = ntype; /* Tracking alloc, and we have new type. */ - return ntype; - } + TYPE_MAIN_TYPE (*typeptr) + = TYPE_ALLOC (*typeptr, sizeof (struct main_type)); + *TYPE_MAIN_TYPE (*typeptr) + = *TYPE_MAIN_TYPE (type); } - tmp_type = ntype; - ntype = TYPE_CV_TYPE (ntype); } + + ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL); - 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 */ - /* Note: TYPE_TARGET_TYPE can be left as is */ - - /* Set flags appropriately */ - if (cnst) - TYPE_FLAGS (ntype) |= TYPE_FLAG_CONST; - else - TYPE_FLAGS (ntype) &= ~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; + if (typeptr != NULL) + *typeptr = ntype; return ntype; } +/* Replace the contents of ntype with the type *type. This changes the + contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus + the changes are propogated to all types in the TYPE_CHAIN. + In order to build recursive types, it's inevitable that we'll need + to update types in place --- but this sort of indiscriminate + smashing is ugly, and needs to be replaced with something more + controlled. TYPE_MAIN_TYPE is a step in this direction; it's not + clear if more steps are needed. */ +void +replace_type (struct type *ntype, struct type *type) +{ + struct type *cv_chain, *as_chain, *ptr, *ref; + + *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type); + /* 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++. May need to construct such a type if this is the first use. @@ -427,13 +572,11 @@ allocate_stub_method (struct type *type) { struct type *mtype; - mtype = alloc_type (TYPE_OBJFILE (type)); + mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL, + TYPE_OBJFILE (type)); TYPE_TARGET_TYPE (mtype) = type; /* _DOMAIN_TYPE (mtype) = unknown yet */ /* _ARG_TYPES (mtype) = unknown yet */ - TYPE_FLAGS (mtype) = TYPE_FLAG_STUB; - TYPE_CODE (mtype) = TYPE_CODE_METHOD; - TYPE_LENGTH (mtype) = 1; return (mtype); } @@ -456,7 +599,7 @@ create_range_type (struct type *result_type, struct type *index_type, } TYPE_CODE (result_type) = TYPE_CODE_RANGE; TYPE_TARGET_TYPE (result_type) = index_type; - if (TYPE_FLAGS (index_type) & TYPE_FLAG_STUB) + if (TYPE_STUB (index_type)) TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB; else TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type)); @@ -619,7 +762,7 @@ create_set_type (struct type *result_type, struct type *domain_type) 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 (!TYPE_STUB (domain_type)) { if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0) low_bound = high_bound = 0; @@ -635,7 +778,6 @@ create_set_type (struct type *result_type, struct type *domain_type) return (result_type); } - /* Construct and return a type of the form: struct NAME { ELT_TYPE ELT_NAME[N]; } We use these types for SIMD registers. For example, the type of @@ -651,28 +793,57 @@ init_simd_type (char *name, char *elt_name, int n) { + struct type *simd_type; + struct type *array_type; + + simd_type = init_composite_type (name, TYPE_CODE_STRUCT); + array_type = create_array_type (0, elt_type, + create_range_type (0, builtin_type_int, + 0, n-1)); + append_composite_type_field (simd_type, elt_name, array_type); + return simd_type; +} + +static struct type * +init_vector_type (struct type *elt_type, int n) +{ + struct type *array_type; + + array_type = create_array_type (0, elt_type, + create_range_type (0, builtin_type_int, + 0, n-1)); + TYPE_FLAGS (array_type) |= TYPE_FLAG_VECTOR; + return array_type; +} + +static struct type * +build_builtin_type_vec128 (void) +{ + /* Construct a type for the 128 bit registers. The type we're + building is this: */ +#if 0 + union __gdb_builtin_type_vec128 + { + int128_t uint128; + float v4_float[4]; + int32_t v4_int32[4]; + int16_t v8_int16[8]; + int8_t v16_int8[16]; + }; +#endif + struct type *t; - struct field *f; - /* Build the field structure. */ - f = xmalloc (sizeof (*f)); - memset (f, 0, sizeof (*f)); - f->loc.bitpos = 0; - f->type = create_array_type (0, elt_type, - create_range_type (0, builtin_type_int, - 0, n-1)); - f->name = elt_name; - - /* Build a struct type with that field. */ - t = init_type (TYPE_CODE_STRUCT, n * TYPE_LENGTH (elt_type), 0, 0, 0); - t->nfields = 1; - t->fields = f; - t->tag_name = name; + t = init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION); + append_composite_type_field (t, "uint128", builtin_type_int128); + append_composite_type_field (t, "v4_float", builtin_type_v4_float); + append_composite_type_field (t, "v4_int32", builtin_type_v4_int32); + append_composite_type_field (t, "v8_int16", builtin_type_v8_int16); + append_composite_type_field (t, "v16_int8", builtin_type_v16_int8); return t; } - /* 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 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't @@ -691,7 +862,7 @@ smash_to_member_type (struct type *type, struct type *domain, objfile = TYPE_OBJFILE (type); - memset ((char *) type, 0, sizeof (struct type)); + smash_type (type); TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; @@ -714,7 +885,7 @@ smash_to_method_type (struct type *type, struct type *domain, objfile = TYPE_OBJFILE (type); - memset ((char *) type, 0, sizeof (struct type)); + smash_type (type); TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; @@ -748,7 +919,7 @@ lookup_primitive_typename (char *name) for (p = current_language->la_builtin_type_vector; *p != NULL; p++) { - if (STREQ ((**p)->name, name)) + if (STREQ (TYPE_NAME (**p), name)) { return (**p); } @@ -893,10 +1064,10 @@ struct type * lookup_template_type (char *name, struct type *type, struct block *block) { struct symbol *sym; - char *nam = (char *) alloca (strlen (name) + strlen (type->name) + 4); + char *nam = (char *) alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4); strcpy (nam, name); strcat (nam, "<"); - strcat (nam, type->name); + strcat (nam, TYPE_NAME (type)); strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */ sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **) NULL); @@ -1073,9 +1244,11 @@ struct complaint stub_noname_complaint = {"stub type has NULL name", 0, 0}; struct type * -check_typedef (register struct type *type) +check_typedef (struct type *type) { struct type *orig_type = type; + int is_const, is_volatile; + while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) { if (!TYPE_TARGET_TYPE (type)) @@ -1108,6 +1281,9 @@ check_typedef (register struct type *type) type = TYPE_TARGET_TYPE (type); } + is_const = TYPE_CONST (type); + is_volatile = TYPE_VOLATILE (type); + /* If this is a struct/class/union with no fields, then check whether a full definition exists somewhere else. This is for systems where a type definition with no fields is issued for such types, instead of @@ -1124,12 +1300,10 @@ check_typedef (register struct type *type) } newtype = lookup_transparent_type (name); if (newtype) - { - memcpy ((char *) type, (char *) newtype, sizeof (struct type)); - } + make_cv_type (is_const, is_volatile, newtype, &type); } /* Otherwise, rely on the stub flag being set for opaque/stubbed types */ - else if ((TYPE_FLAGS (type) & TYPE_FLAG_STUB) && !currently_reading_symtab) + else if (TYPE_STUB (type) && !currently_reading_symtab) { char *name = type_name_no_tag (type); /* FIXME: shouldn't we separately check the TYPE_NAME and the @@ -1144,17 +1318,15 @@ check_typedef (register struct type *type) } sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL); if (sym) - { - memcpy ((char *) type, (char *) SYMBOL_TYPE (sym), sizeof (struct type)); - } + make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type); } - if (TYPE_FLAGS (type) & TYPE_FLAG_TARGET_STUB) + if (TYPE_TARGET_STUB (type)) { struct type *range_type; struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type)); - if (TYPE_FLAGS (target_type) & (TYPE_FLAG_STUB | TYPE_FLAG_TARGET_STUB)) + if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type)) { } else if (TYPE_CODE (type) == TYPE_CODE_ARRAY @@ -1322,8 +1494,8 @@ add_mangled_type (struct extra *pextras, struct type *t) complain (&msg, tcode); } } - if (t->target_type) - add_mangled_type (pextras, t->target_type); + if (TYPE_TARGET_TYPE (t)) + add_mangled_type (pextras, TYPE_TARGET_TYPE (t)); } #if 0 @@ -1460,9 +1632,16 @@ check_stub_method (struct type *type, int method_id, int signature_id) argtypes = (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; + + /* Add THIS pointer for non-static methods. */ + f = TYPE_FN_FIELDLIST1 (type, method_id); + if (TYPE_FN_FIELD_STATIC_P (f, signature_id)) + argcount = 0; + else + { + argtypes[0] = lookup_pointer_type (type); + argcount = 1; + } if (*p != ')') /* () means no args, skip while */ { @@ -1505,8 +1684,6 @@ check_stub_method (struct type *type, int method_id, int signature_id) xfree (demangled_name); - f = TYPE_FN_FIELDLIST1 (type, method_id); - TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name; /* Now update the old "stub" type into a real type. */ @@ -1566,6 +1743,48 @@ init_type (enum type_code code, int length, int flags, char *name, return (type); } +/* Helper function. Create an empty composite type. */ + +struct type * +init_composite_type (char *name, enum type_code code) +{ + struct type *t; + gdb_assert (code == TYPE_CODE_STRUCT + || code == TYPE_CODE_UNION); + t = init_type (code, 0, 0, NULL, NULL); + TYPE_TAG_NAME (t) = name; + return t; +} + +/* Helper function. Append a field to a composite type. */ + +void +append_composite_type_field (struct type *t, char *name, struct type *field) +{ + struct field *f; + TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1; + TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t), + sizeof (struct field) * TYPE_NFIELDS (t)); + f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]); + memset (f, 0, sizeof f[0]); + FIELD_TYPE (f[0]) = field; + FIELD_NAME (f[0]) = name; + if (TYPE_CODE (t) == TYPE_CODE_UNION) + { + if (TYPE_LENGTH (t) < TYPE_LENGTH (field)) + TYPE_LENGTH (t) = TYPE_LENGTH (field); + } + else if (TYPE_CODE (t) == TYPE_CODE_STRUCT) + { + TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field); + if (TYPE_NFIELDS (t) > 1) + { + FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1]) + + TYPE_LENGTH (field) * TARGET_CHAR_BIT); + } + } +} + /* Look up a fundamental type for the specified objfile. May need to construct such a type if this is the first use. @@ -2477,7 +2696,7 @@ print_arg_types (struct type **args, int spaces) while (*args != NULL) { recursive_dump_type (*args, spaces + 2); - if ((*args++)->code == TYPE_CODE_VOID) + if (TYPE_CODE (*args++) == TYPE_CODE_VOID) { break; } @@ -2597,6 +2816,35 @@ print_cplus_stuff (struct type *type, int spaces) } } +static void +print_bound_type (int bt) +{ + switch (bt) + { + case BOUND_CANNOT_BE_DETERMINED: + printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)"); + break; + case BOUND_BY_REF_ON_STACK: + printf_filtered ("(BOUND_BY_REF_ON_STACK)"); + break; + case BOUND_BY_VALUE_ON_STACK: + printf_filtered ("(BOUND_BY_VALUE_ON_STACK)"); + break; + case BOUND_BY_REF_IN_REG: + printf_filtered ("(BOUND_BY_REF_IN_REG)"); + break; + case BOUND_BY_VALUE_IN_REG: + printf_filtered ("(BOUND_BY_VALUE_IN_REG)"); + break; + case BOUND_SIMPLE: + printf_filtered ("(BOUND_SIMPLE)"); + break; + default: + printf_filtered ("(unknown bound type)"); + break; + } +} + static struct obstack dont_print_type_obstack; void @@ -2637,13 +2885,10 @@ recursive_dump_type (struct type *type, int spaces) TYPE_NAME (type) ? TYPE_NAME (type) : ""); gdb_print_host_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_host_address (TYPE_TAG_NAME (type), gdb_stdout); - printf_filtered (")\n"); - } + printfi_filtered (spaces, "tagname '%s' (", + TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : ""); + gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout); + printf_filtered (")\n"); printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type)); switch (TYPE_CODE (type)) { @@ -2686,6 +2931,9 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_STRING: printf_filtered ("(TYPE_CODE_STRING)"); break; + case TYPE_CODE_BITSTRING: + printf_filtered ("(TYPE_CODE_BITSTRING)"); + break; case TYPE_CODE_ERROR: printf_filtered ("(TYPE_CODE_ERROR)"); break; @@ -2704,15 +2952,32 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_BOOL: printf_filtered ("(TYPE_CODE_BOOL)"); break; + case TYPE_CODE_COMPLEX: + printf_filtered ("(TYPE_CODE_COMPLEX)"); + break; case TYPE_CODE_TYPEDEF: printf_filtered ("(TYPE_CODE_TYPEDEF)"); break; + case TYPE_CODE_TEMPLATE: + printf_filtered ("(TYPE_CODE_TEMPLATE)"); + break; + case TYPE_CODE_TEMPLATE_ARG: + printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)"); + break; default: printf_filtered ("(UNKNOWN TYPE CODE)"); break; } puts_filtered ("\n"); printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)); + printfi_filtered (spaces, "upper_bound_type 0x%x ", + TYPE_ARRAY_UPPER_BOUND_TYPE (type)); + print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type)); + puts_filtered ("\n"); + printfi_filtered (spaces, "lower_bound_type 0x%x ", + TYPE_ARRAY_LOWER_BOUND_TYPE (type)); + print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type)); + puts_filtered ("\n"); printfi_filtered (spaces, "objfile "); gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout); printf_filtered ("\n"); @@ -2729,15 +2994,67 @@ recursive_dump_type (struct type *type, int spaces) printfi_filtered (spaces, "reference_type "); gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout); printf_filtered ("\n"); + printfi_filtered (spaces, "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_FLAGS (type) & TYPE_FLAG_UNSIGNED) + if (TYPE_UNSIGNED (type)) { puts_filtered (" TYPE_FLAG_UNSIGNED"); } - if (TYPE_FLAGS (type) & TYPE_FLAG_STUB) + if (TYPE_NOSIGN (type)) + { + puts_filtered (" TYPE_FLAG_NOSIGN"); + } + if (TYPE_STUB (type)) { puts_filtered (" TYPE_FLAG_STUB"); } + if (TYPE_TARGET_STUB (type)) + { + puts_filtered (" TYPE_FLAG_TARGET_STUB"); + } + if (TYPE_STATIC (type)) + { + puts_filtered (" TYPE_FLAG_STATIC"); + } + if (TYPE_PROTOTYPED (type)) + { + puts_filtered (" TYPE_FLAG_PROTOTYPED"); + } + if (TYPE_INCOMPLETE (type)) + { + puts_filtered (" TYPE_FLAG_INCOMPLETE"); + } + if (TYPE_VARARGS (type)) + { + puts_filtered (" TYPE_FLAG_VARARGS"); + } + /* This is used for things like AltiVec registers on ppc. Gcc emits + an attribute for the array type, which tells whether or not we + have a vector, instead of a regular array. */ + if (TYPE_VECTOR (type)) + { + puts_filtered (" TYPE_FLAG_VECTOR"); + } puts_filtered ("\n"); printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type)); gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout); @@ -2823,9 +3140,9 @@ build_gdbtypes (void) "void", (struct objfile *) NULL); builtin_type_char = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, + (TYPE_FLAG_NOSIGN + | (TARGET_CHAR_SIGNED ? 0 : TYPE_FLAG_UNSIGNED)), "char", (struct objfile *) NULL); - TYPE_FLAGS (builtin_type_char) |= TYPE_FLAG_NOSIGN; builtin_type_true_char = init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0, @@ -2874,17 +3191,31 @@ build_gdbtypes (void) init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT, 0, "float", (struct objfile *) NULL); +/* vinschen@redhat.com 2002-02-08: + The below lines are disabled since they are doing the wrong + thing for non-multiarch targets. They are setting the correct + type of floats for the target but while on multiarch targets + this is done everytime the architecture changes, it's done on + non-multiarch targets only on startup, leaving the wrong values + in even if the architecture changes (eg. from big-endian to + little-endian). */ +#if 0 TYPE_FLOATFORMAT (builtin_type_float) = TARGET_FLOAT_FORMAT; +#endif builtin_type_double = init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, 0, "double", (struct objfile *) NULL); +#if 0 TYPE_FLOATFORMAT (builtin_type_double) = TARGET_DOUBLE_FORMAT; +#endif builtin_type_long_double = init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, 0, "long double", (struct objfile *) NULL); +#if 0 TYPE_FLOATFORMAT (builtin_type_long_double) = TARGET_LONG_DOUBLE_FORMAT; +#endif builtin_type_complex = init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT, 0, @@ -2931,6 +3262,14 @@ build_gdbtypes (void) init_type (TYPE_CODE_INT, 64 / 8, TYPE_FLAG_UNSIGNED, "uint64_t", (struct objfile *) NULL); + builtin_type_int128 = + init_type (TYPE_CODE_INT, 128 / 8, + 0, + "int128_t", (struct objfile *) NULL); + builtin_type_uint128 = + init_type (TYPE_CODE_INT, 128 / 8, + TYPE_FLAG_UNSIGNED, + "uint128_t", (struct objfile *) NULL); builtin_type_bool = init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0, @@ -2944,19 +3283,36 @@ build_gdbtypes (void) &showlist); opaque_type_resolution = 1; - /* Build SIMD types. */ builtin_type_v4sf = init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4); builtin_type_v4si = init_simd_type ("__builtin_v4si", builtin_type_int32, "f", 4); + builtin_type_v16qi + = init_simd_type ("__builtin_v16qi", builtin_type_int8, "f", 16); builtin_type_v8qi = init_simd_type ("__builtin_v8qi", builtin_type_int8, "f", 8); + builtin_type_v8hi + = init_simd_type ("__builtin_v8hi", builtin_type_int16, "f", 8); builtin_type_v4hi = init_simd_type ("__builtin_v4hi", builtin_type_int16, "f", 4); builtin_type_v2si = init_simd_type ("__builtin_v2si", builtin_type_int32, "f", 2); + /* 128 bit vectors. */ + builtin_type_v4_float = init_vector_type (builtin_type_float, 4); + builtin_type_v4_int32 = init_vector_type (builtin_type_int32, 4); + builtin_type_v8_int16 = init_vector_type (builtin_type_int16, 8); + builtin_type_v16_int8 = init_vector_type (builtin_type_int8, 16); + /* 64 bit vectors. */ + builtin_type_v2_float = init_vector_type (builtin_type_float, 2); + builtin_type_v2_int32 = init_vector_type (builtin_type_int32, 2); + builtin_type_v4_int16 = init_vector_type (builtin_type_int16, 4); + builtin_type_v8_int8 = init_vector_type (builtin_type_int8, 8); + + /* Vector types. */ + builtin_type_vec128 = build_builtin_type_vec128 (); + /* Pointer/Address types. */ /* NOTE: on some targets, addresses and pointers are not necessarily @@ -3035,11 +3391,24 @@ _initialize_gdbtypes (void) register_gdbarch_swap (&builtin_type_uint32, sizeof (struct type *), NULL); register_gdbarch_swap (&builtin_type_int64, sizeof (struct type *), NULL); register_gdbarch_swap (&builtin_type_uint64, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_int128, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_uint128, sizeof (struct type *), NULL); register_gdbarch_swap (&builtin_type_v4sf, sizeof (struct type *), NULL); register_gdbarch_swap (&builtin_type_v4si, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v16qi, sizeof (struct type *), NULL); register_gdbarch_swap (&builtin_type_v8qi, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v8hi, sizeof (struct type *), NULL); register_gdbarch_swap (&builtin_type_v4hi, sizeof (struct type *), NULL); register_gdbarch_swap (&builtin_type_v2si, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v4_float, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v4_int32, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v8_int16, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v16_int8, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v2_float, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v2_int32, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v8_int8, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_v4_int16, sizeof (struct type *), NULL); + register_gdbarch_swap (&builtin_type_vec128, sizeof (struct type *), NULL); REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr); REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr); REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR); @@ -3055,48 +3424,63 @@ _initialize_gdbtypes (void) builtin_type_ieee_single_little = init_type (TYPE_CODE_FLT, floatformat_ieee_single_little.totalsize / 8, 0, "builtin_type_ieee_single_little", NULL); + TYPE_FLOATFORMAT (builtin_type_ieee_single_little) = &floatformat_ieee_single_little; builtin_type_ieee_double_big = init_type (TYPE_CODE_FLT, floatformat_ieee_double_big.totalsize / 8, 0, "builtin_type_ieee_double_big", NULL); + TYPE_FLOATFORMAT (builtin_type_ieee_double_big) = &floatformat_ieee_double_big; builtin_type_ieee_double_little = init_type (TYPE_CODE_FLT, floatformat_ieee_double_little.totalsize / 8, 0, "builtin_type_ieee_double_little", NULL); + TYPE_FLOATFORMAT (builtin_type_ieee_double_little) = &floatformat_ieee_double_little; builtin_type_ieee_double_littlebyte_bigword = init_type (TYPE_CODE_FLT, floatformat_ieee_double_littlebyte_bigword.totalsize / 8, 0, "builtin_type_ieee_double_littlebyte_bigword", NULL); + TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword) = &floatformat_ieee_double_littlebyte_bigword; builtin_type_i387_ext = init_type (TYPE_CODE_FLT, floatformat_i387_ext.totalsize / 8, 0, "builtin_type_i387_ext", NULL); + TYPE_FLOATFORMAT (builtin_type_i387_ext) = &floatformat_i387_ext; builtin_type_m68881_ext = init_type (TYPE_CODE_FLT, floatformat_m68881_ext.totalsize / 8, 0, "builtin_type_m68881_ext", NULL); + TYPE_FLOATFORMAT (builtin_type_m68881_ext) = &floatformat_m68881_ext; builtin_type_i960_ext = init_type (TYPE_CODE_FLT, floatformat_i960_ext.totalsize / 8, 0, "builtin_type_i960_ext", NULL); + TYPE_FLOATFORMAT (builtin_type_i960_ext) = &floatformat_i960_ext; builtin_type_m88110_ext = init_type (TYPE_CODE_FLT, floatformat_m88110_ext.totalsize / 8, 0, "builtin_type_m88110_ext", NULL); + TYPE_FLOATFORMAT (builtin_type_m88110_ext) = &floatformat_m88110_ext; builtin_type_m88110_harris_ext = init_type (TYPE_CODE_FLT, floatformat_m88110_harris_ext.totalsize / 8, 0, "builtin_type_m88110_harris_ext", NULL); + TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext) = &floatformat_m88110_harris_ext; builtin_type_arm_ext_big = init_type (TYPE_CODE_FLT, floatformat_arm_ext_big.totalsize / 8, 0, "builtin_type_arm_ext_big", NULL); + TYPE_FLOATFORMAT (builtin_type_arm_ext_big) = &floatformat_arm_ext_big; builtin_type_arm_ext_littlebyte_bigword = init_type (TYPE_CODE_FLT, floatformat_arm_ext_littlebyte_bigword.totalsize / 8, 0, "builtin_type_arm_ext_littlebyte_bigword", NULL); + TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword) = &floatformat_arm_ext_littlebyte_bigword; builtin_type_ia64_spill_big = init_type (TYPE_CODE_FLT, floatformat_ia64_spill_big.totalsize / 8, 0, "builtin_type_ia64_spill_big", NULL); + TYPE_FLOATFORMAT (builtin_type_ia64_spill_big) = &floatformat_ia64_spill_big; builtin_type_ia64_spill_little = init_type (TYPE_CODE_FLT, floatformat_ia64_spill_little.totalsize / 8, 0, "builtin_type_ia64_spill_little", NULL); + TYPE_FLOATFORMAT (builtin_type_ia64_spill_little) = &floatformat_ia64_spill_little; builtin_type_ia64_quad_big = init_type (TYPE_CODE_FLT, floatformat_ia64_quad_big.totalsize / 8, 0, "builtin_type_ia64_quad_big", NULL); + TYPE_FLOATFORMAT (builtin_type_ia64_quad_big) = &floatformat_ia64_quad_big; builtin_type_ia64_quad_little = init_type (TYPE_CODE_FLT, floatformat_ia64_quad_little.totalsize / 8, 0, "builtin_type_ia64_quad_little", NULL); + TYPE_FLOATFORMAT (builtin_type_ia64_quad_little) = &floatformat_ia64_quad_little; add_show_from_set ( add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,