/* Support routines for manipulating internal types for GDB.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
- 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
/* 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_true_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;
struct type *builtin_type_int0;
struct type *builtin_type_int8;
struct type *builtin_type_uint8;
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_v2_double;
-struct type *builtin_type_v4_float;
-struct type *builtin_type_v2_int64;
-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_vec64;
-struct type *builtin_type_vec128;
-struct type *builtin_type_ieee_single[BFD_ENDIAN_UNKNOWN];
-struct type *builtin_type_ieee_single_big;
-struct type *builtin_type_ieee_single_little;
-struct type *builtin_type_ieee_double[BFD_ENDIAN_UNKNOWN];
-struct type *builtin_type_ieee_double_big;
-struct type *builtin_type_ieee_double_little;
-struct type *builtin_type_ieee_double_littlebyte_bigword;
+
+/* Floatformat pairs. */
+const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_ieee_single_big,
+ &floatformat_ieee_single_little
+};
+const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_ieee_double_big,
+ &floatformat_ieee_double_little
+};
+const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_ieee_double_big,
+ &floatformat_ieee_double_littlebyte_bigword
+};
+const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_i387_ext,
+ &floatformat_i387_ext
+};
+const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_m68881_ext,
+ &floatformat_m68881_ext
+};
+const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_arm_ext_big,
+ &floatformat_arm_ext_littlebyte_bigword
+};
+const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_ia64_spill_big,
+ &floatformat_ia64_spill_little
+};
+const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_ia64_quad_big,
+ &floatformat_ia64_quad_little
+};
+const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_vax_f,
+ &floatformat_vax_f
+};
+const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_vax_d,
+ &floatformat_vax_d
+};
+
+struct type *builtin_type_ieee_single;
+struct type *builtin_type_ieee_double;
struct type *builtin_type_i387_ext;
struct type *builtin_type_m68881_ext;
-struct type *builtin_type_i960_ext;
-struct type *builtin_type_m88110_ext;
-struct type *builtin_type_m88110_harris_ext;
-struct type *builtin_type_arm_ext[BFD_ENDIAN_UNKNOWN];
-struct type *builtin_type_arm_ext_big;
-struct type *builtin_type_arm_ext_littlebyte_bigword;
-struct type *builtin_type_ia64_spill[BFD_ENDIAN_UNKNOWN];
-struct type *builtin_type_ia64_spill_big;
-struct type *builtin_type_ia64_spill_little;
-struct type *builtin_type_ia64_quad[BFD_ENDIAN_UNKNOWN];
-struct type *builtin_type_ia64_quad_big;
-struct type *builtin_type_ia64_quad_little;
-struct type *builtin_type_void_data_ptr;
-struct type *builtin_type_void_func_ptr;
-struct type *builtin_type_CORE_ADDR;
-struct type *builtin_type_bfd_vma;
+struct type *builtin_type_arm_ext;
+struct type *builtin_type_ia64_spill;
+struct type *builtin_type_ia64_quad;
+
int opaque_type_resolution = 1;
static void
{
struct type *ntype; /* New type */
struct objfile *objfile;
+ struct type *chain;
ntype = TYPE_POINTER_TYPE (type);
{
ntype = *typeptr;
objfile = TYPE_OBJFILE (ntype);
+ chain = TYPE_CHAIN (ntype);
smash_type (ntype);
+ TYPE_CHAIN (ntype) = chain;
TYPE_OBJFILE (ntype) = objfile;
}
/* FIXME! Assume the machine has only one representation for pointers! */
- TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
+ TYPE_LENGTH (ntype) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
TYPE_CODE (ntype) = TYPE_CODE_PTR;
/* Mark pointers as unsigned. The target converts between pointers
- and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
- ADDRESS_TO_POINTER(). */
+ and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
+ gdbarch_address_to_pointer. */
TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
TYPE_POINTER_TYPE (type) = ntype;
+ /* Update the length of all the other variants of this type. */
+ chain = TYPE_CHAIN (ntype);
+ while (chain != ntype)
+ {
+ TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
+ chain = TYPE_CHAIN (chain);
+ }
+
return ntype;
}
{
struct type *ntype; /* New type */
struct objfile *objfile;
+ struct type *chain;
ntype = TYPE_REFERENCE_TYPE (type);
{
ntype = *typeptr;
objfile = TYPE_OBJFILE (ntype);
+ chain = TYPE_CHAIN (ntype);
smash_type (ntype);
+ TYPE_CHAIN (ntype) = chain;
TYPE_OBJFILE (ntype) = objfile;
}
/* FIXME! Assume the machine has only one representation for references,
and that it matches the (only) representation for pointers! */
- TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
+ TYPE_LENGTH (ntype) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
TYPE_CODE (ntype) = TYPE_CODE_REF;
if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
TYPE_REFERENCE_TYPE (type) = ntype;
+ /* Update the length of all the other variants of this type. */
+ chain = TYPE_CHAIN (ntype);
+ while (chain != ntype)
+ {
+ TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
+ chain = TYPE_CHAIN (chain);
+ }
+
return ntype;
}
call replace_type(). */
gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
- TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
+ TYPE_LENGTH (chain) = TYPE_LENGTH (type);
chain = TYPE_CHAIN (chain);
} while (ntype != chain);
of the aggregate that the member belongs to. */
struct type *
-lookup_member_type (struct type *type, struct type *domain)
+lookup_memberptr_type (struct type *type, struct type *domain)
{
struct type *mtype;
mtype = alloc_type (TYPE_OBJFILE (type));
- smash_to_member_type (mtype, domain, type);
+ smash_to_memberptr_type (mtype, domain, type);
return (mtype);
}
+/* Return a pointer-to-method type, for a method of type TO_TYPE. */
+
+struct type *
+lookup_methodptr_type (struct type *to_type)
+{
+ struct type *mtype;
+
+ mtype = alloc_type (TYPE_OBJFILE (to_type));
+ TYPE_TARGET_TYPE (mtype) = to_type;
+ TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type);
+ TYPE_LENGTH (mtype) = cplus_method_ptr_size ();
+ TYPE_CODE (mtype) = TYPE_CODE_METHODPTR;
+ return mtype;
+}
+
/* Allocate a stub method whose return type is TYPE.
This apparently happens for speed of symbol reading, since parsing
out the arguments to the method is cpu-intensive, the way we are doing
type = init_type (TYPE_CODE_FLAGS, length, TYPE_FLAG_UNSIGNED, name, NULL);
TYPE_NFIELDS (type) = nfields;
TYPE_FIELDS (type) = TYPE_ALLOC (type, nfields * sizeof (struct field));
- memset (TYPE_FIELDS (type), 0, sizeof (struct field));
+ memset (TYPE_FIELDS (type), 0, nfields * sizeof (struct field));
return 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
- the SSE registers on the late x86-family processors is:
- struct __builtin_v4sf { float f[4]; }
- built by the function call:
- init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
- The type returned is a permanent type, allocated using malloc; it
- doesn't live in any objfile's obstack. */
-static struct type *
-init_simd_type (char *name,
- struct type *elt_type,
- 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 *
+struct type *
init_vector_type (struct type *elt_type, int n)
{
struct type *array_type;
return array_type;
}
-static struct type *
-build_builtin_type_vec64 (void)
-{
- /* Construct a type for the 64 bit registers. The type we're
- building is this: */
-#if 0
- union __gdb_builtin_type_vec64
- {
- int64_t uint64;
- float v2_float[2];
- int32_t v2_int32[2];
- int16_t v4_int16[4];
- int8_t v8_int8[8];
- };
-#endif
-
- struct type *t;
-
- t = init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION);
- append_composite_type_field (t, "uint64", builtin_type_int64);
- append_composite_type_field (t, "v2_float", builtin_type_v2_float);
- append_composite_type_field (t, "v2_int32", builtin_type_v2_int32);
- append_composite_type_field (t, "v4_int16", builtin_type_v4_int16);
- append_composite_type_field (t, "v8_int8", builtin_type_v8_int8);
-
- TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
- TYPE_NAME (t) = "builtin_type_vec64";
- return t;
-}
-
-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;
-
- 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);
-
- TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
- TYPE_NAME (t) = "builtin_type_vec128";
- 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
- include the offset (that's the value of the MEMBER itself), but does
- include the structure type into which it points (for some reason).
+/* Smash TYPE to be a type of pointers to members of DOMAIN with type
+ TO_TYPE. A member pointer 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 include the offset (that's the value of the MEMBER
+ itself), but does include the structure type into which it points
+ (for some reason).
When "smashing" the type, we preserve the objfile that the
old type pointed to, since we aren't changing where the type is actually
allocated. */
void
-smash_to_member_type (struct type *type, struct type *domain,
- struct type *to_type)
+smash_to_memberptr_type (struct type *type, struct type *domain,
+ struct type *to_type)
{
struct objfile *objfile;
TYPE_OBJFILE (type) = objfile;
TYPE_TARGET_TYPE (type) = to_type;
TYPE_DOMAIN_TYPE (type) = domain;
- TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
- TYPE_CODE (type) = TYPE_CODE_MEMBER;
+ /* Assume that a data member pointer is the same size as a normal
+ pointer. */
+ TYPE_LENGTH (type) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
+ TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
}
/* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
{
struct type *t;
- t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);
+ t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
if (t != NULL)
{
return t;
}
sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0, (struct symtab **) NULL);
if (sym)
- make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type);
+ {
+ /* Same as above for opaque types, we can replace the stub
+ with the complete type only if they are int the same
+ objfile. */
+ if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
+ make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type);
+ else
+ type = SYMBOL_TYPE (sym);
+ }
}
if (TYPE_TARGET_STUB (type))
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
- case TYPE_CODE_MEMBER:
+ case TYPE_CODE_MEMBERPTR:
switch (TYPE_CODE (arg))
{
default:
case TYPE_CODE_ERROR:
printf_filtered ("(TYPE_CODE_ERROR)");
break;
- case TYPE_CODE_MEMBER:
- printf_filtered ("(TYPE_CODE_MEMBER)");
+ case TYPE_CODE_MEMBERPTR:
+ printf_filtered ("(TYPE_CODE_MEMBERPTR)");
+ break;
+ case TYPE_CODE_METHODPTR:
+ printf_filtered ("(TYPE_CODE_METHODPTR)");
break;
case TYPE_CODE_METHOD:
printf_filtered ("(TYPE_CODE_METHOD)");
case TYPE_CODE_FLT:
printfi_filtered (spaces, "floatformat ");
- if (TYPE_FLOATFORMAT (type) == NULL
- || TYPE_FLOATFORMAT (type)->name == NULL)
+ if (TYPE_FLOATFORMAT (type) == NULL)
puts_filtered ("(null)");
else
- puts_filtered (TYPE_FLOATFORMAT (type)->name);
+ {
+ puts_filtered ("{ ");
+ if (TYPE_FLOATFORMAT (type)[0] == NULL
+ || TYPE_FLOATFORMAT (type)[0]->name == NULL)
+ puts_filtered ("(null)");
+ else
+ puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
+
+ puts_filtered (", ");
+ if (TYPE_FLOATFORMAT (type)[1] == NULL
+ || TYPE_FLOATFORMAT (type)[1]->name == NULL)
+ puts_filtered ("(null)");
+ else
+ puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
+
+ puts_filtered (" }");
+ }
puts_filtered ("\n");
break;
can't, but at the moment it is not needed. */
if (TYPE_CODE (type) == TYPE_CODE_FLT)
- TYPE_FLOATFORMAT (new_type) == TYPE_FLOATFORMAT (type);
+ TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
|| TYPE_CODE (type) == TYPE_CODE_UNION
|| TYPE_CODE (type) == TYPE_CODE_TEMPLATE
return new_type;
}
-static void
-build_gdbtypes (void)
+static struct type *
+build_flt (int bit, char *name, const struct floatformat **floatformats)
{
- 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,
- (TYPE_FLAG_NOSIGN
- | (TARGET_CHAR_SIGNED ? 0 : TYPE_FLAG_UNSIGNED)),
- "char", (struct objfile *) NULL);
- builtin_type_true_char =
- init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
- 0,
- "true character", (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);
-/* 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,
- "complex", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (builtin_type_complex) = builtin_type_float;
- builtin_type_double_complex =
- 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,
- "string", (struct objfile *) NULL);
- builtin_type_bool =
- init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
- 0,
- "bool", (struct objfile *) NULL);
-
- /* Add user knob for controlling resolution of opaque types */
- add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
- &opaque_type_resolution, _("\
-Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
-Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL,
- NULL,
- show_opaque_type_resolution,
- &setlist, &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_v2_double = init_vector_type (builtin_type_double, 2);
- builtin_type_v4_float = init_vector_type (builtin_type_float, 4);
- builtin_type_v2_int64 = init_vector_type (builtin_type_int64, 2);
- 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_vec64 = build_builtin_type_vec64 ();
- builtin_type_vec128 = build_builtin_type_vec128 ();
-
- /* Pointer/Address types. */
-
- /* NOTE: on some targets, addresses and pointers are not necessarily
- the same --- for example, on the D10V, pointers are 16 bits long,
- but addresses are 32 bits long. See doc/gdbint.texinfo,
- ``Pointers Are Not Always Addresses''.
-
- The upshot is:
- - gdb's `struct type' always describes the target's
- representation.
- - gdb's `struct value' objects should always hold values in
- target form.
- - gdb's CORE_ADDR values are addresses in the unified virtual
- address space that the assembler and linker work with. Thus,
- since target_read_memory takes a CORE_ADDR as an argument, it
- can access any memory on the target, even if the processor has
- separate code and data address spaces.
+ struct type *t;
- So, for example:
- - If v is a value holding a D10V code pointer, its contents are
- in target form: a big-endian address left-shifted two bits.
- - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
- sizeof (void *) == 2 on the target.
+ if (bit == -1)
+ {
+ gdb_assert (floatformats != NULL);
+ gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
+ bit = floatformats[0]->totalsize;
+ }
+ gdb_assert (bit >= 0);
- In this context, builtin_type_CORE_ADDR is a bit odd: it's a
- target type for a value the target will never see. It's only
- used to hold the values of (typeless) linker symbols, which are
- indeed in the unified virtual address space. */
- builtin_type_void_data_ptr = make_pointer_type (builtin_type_void, NULL);
- builtin_type_void_func_ptr
- = lookup_pointer_type (lookup_function_type (builtin_type_void));
- builtin_type_CORE_ADDR =
- init_type (TYPE_CODE_INT, TARGET_ADDR_BIT / 8,
- TYPE_FLAG_UNSIGNED,
- "__CORE_ADDR", (struct objfile *) NULL);
- builtin_type_bfd_vma =
- init_type (TYPE_CODE_INT, TARGET_BFD_VMA_BIT / 8,
- TYPE_FLAG_UNSIGNED,
- "__bfd_vma", (struct objfile *) NULL);
+ t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, 0, name, NULL);
+ TYPE_FLOATFORMAT (t) = floatformats;
+ return t;
}
static struct gdbarch_data *gdbtypes_data;
}
-static struct type *
-build_flt (int bit, char *name, const struct floatformat *floatformat)
-{
- struct type *t;
- if (bit <= 0 || floatformat == NULL)
- {
- gdb_assert (builtin_type_error != NULL);
- return builtin_type_error;
- }
- t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT,
- 0, name, (struct objfile *) NULL);
- TYPE_FLOATFORMAT (t) = floatformat;
- return t;
-}
-
static struct type *
build_complex (int bit, char *name, struct type *target_type)
{
builtin_type->builtin_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
(TYPE_FLAG_NOSIGN
- | (TARGET_CHAR_SIGNED ? 0 : TYPE_FLAG_UNSIGNED)),
+ | (gdbarch_char_signed (current_gdbarch) ?
+ 0 : TYPE_FLAG_UNSIGNED)),
"char", (struct objfile *) NULL);
builtin_type->builtin_true_char =
init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_UNSIGNED,
"unsigned char", (struct objfile *) NULL);
builtin_type->builtin_short =
- init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
- 0,
- "short", (struct objfile *) NULL);
+ init_type
+ (TYPE_CODE_INT, gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
+ 0, "short", (struct objfile *) NULL);
builtin_type->builtin_unsigned_short =
- init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED,
- "unsigned short", (struct objfile *) NULL);
+ init_type
+ (TYPE_CODE_INT, gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED, "unsigned short", (struct objfile *) NULL);
builtin_type->builtin_int =
- init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
- 0,
- "int", (struct objfile *) NULL);
+ init_type
+ (TYPE_CODE_INT, gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
+ 0, "int", (struct objfile *) NULL);
builtin_type->builtin_unsigned_int =
- init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED,
- "unsigned int", (struct objfile *) NULL);
+ init_type
+ (TYPE_CODE_INT, gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED, "unsigned int", (struct objfile *) NULL);
builtin_type->builtin_long =
- init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
- 0,
- "long", (struct objfile *) NULL);
+ init_type
+ (TYPE_CODE_INT, gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
+ 0, "long", (struct objfile *) NULL);
builtin_type->builtin_unsigned_long =
- init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED,
- "unsigned long", (struct objfile *) NULL);
+ init_type
+ (TYPE_CODE_INT, gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED, "unsigned long", (struct objfile *) NULL);
builtin_type->builtin_long_long =
- init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
- 0,
- "long long", (struct objfile *) NULL);
+ init_type (TYPE_CODE_INT,
+ gdbarch_long_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
+ 0, "long long", (struct objfile *) NULL);
builtin_type->builtin_unsigned_long_long =
- init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED,
- "unsigned long long", (struct objfile *) NULL);
+ init_type (TYPE_CODE_INT,
+ gdbarch_long_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED, "unsigned long long",
+ (struct objfile *) NULL);
builtin_type->builtin_float
= build_flt (gdbarch_float_bit (gdbarch), "float",
gdbarch_float_format (gdbarch));
builtin_type->builtin_func_ptr
= lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
builtin_type->builtin_core_addr =
- init_type (TYPE_CODE_INT, TARGET_ADDR_BIT / 8,
+ init_type (TYPE_CODE_INT, gdbarch_addr_bit (current_gdbarch) / 8,
TYPE_FLAG_UNSIGNED,
"__CORE_ADDR", (struct objfile *) NULL);
+
+ /* The following set of types is used for symbols with no
+ debug information. */
+ builtin_type->nodebug_text_symbol
+ = init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
+ TYPE_TARGET_TYPE (builtin_type->nodebug_text_symbol)
+ = builtin_type->builtin_int;
+ builtin_type->nodebug_data_symbol
+ = init_type (TYPE_CODE_INT, gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
+ "<data variable, no debug info>", NULL);
+ builtin_type->nodebug_unknown_symbol
+ = init_type (TYPE_CODE_INT, 1, 0,
+ "<variable (not text or data), no debug info>", NULL);
+ builtin_type->nodebug_tls_symbol
+ = init_type (TYPE_CODE_INT, gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
+ "<thread local variable, no debug info>", NULL);
+
return builtin_type;
}
void
_initialize_gdbtypes (void)
{
- struct cmd_list_element *c;
+ gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
+
+ /* FIXME: The following types are architecture-neutral. However, they
+ contain pointer_type and reference_type fields potentially caching
+ pointer or reference types that *are* architecture dependent. */
builtin_type_int0 =
init_type (TYPE_CODE_INT, 0 / 8,
TYPE_FLAG_UNSIGNED,
"uint128_t", (struct objfile *) NULL);
- build_gdbtypes ();
-
- gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
-
- /* FIXME - For the moment, handle types by swapping them in and out.
- Should be using the per-architecture data-pointer and a large
- struct. */
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_char);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_short);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_long);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_signed_char);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_char);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_short);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_int);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long_long);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_float);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_double);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_complex);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double_complex);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_string);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4sf);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4si);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16qi);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8qi);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8hi);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4hi);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2si);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_double);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_float);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int64);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int32);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int16);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16_int8);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_float);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int32);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int8);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int16);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma);
- deprecated_register_gdbarch_swap (NULL, 0, build_gdbtypes);
-
- /* Note: These types do not need to be swapped - they are target
- neutral. */
- builtin_type_ieee_single_big =
- init_type (TYPE_CODE_FLT, floatformat_ieee_single_big.totalsize / 8,
- 0, "builtin_type_ieee_single_big", NULL);
- TYPE_FLOATFORMAT (builtin_type_ieee_single_big) = &floatformat_ieee_single_big;
- 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_single[BFD_ENDIAN_BIG]
- = build_flt (floatformat_ieee_single_big.totalsize,
- "builtin_type_ieee_single_big",
- &floatformat_ieee_single_big);
- builtin_type_ieee_single[BFD_ENDIAN_LITTLE]
- = build_flt (floatformat_ieee_single_little.totalsize,
- "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[BFD_ENDIAN_BIG]
- = build_flt (floatformat_ieee_double_big.totalsize,
- "builtin_type_ieee_double_big",
- &floatformat_ieee_double_big);
- builtin_type_ieee_double[BFD_ENDIAN_LITTLE]
- = build_flt (floatformat_ieee_double_little.totalsize,
- "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_arm_ext[BFD_ENDIAN_BIG]
- = build_flt (floatformat_arm_ext_big.totalsize,
- "builtin_type_arm_ext_big",
- &floatformat_arm_ext_big);
- builtin_type_arm_ext[BFD_ENDIAN_LITTLE]
- = build_flt (floatformat_arm_ext_littlebyte_bigword.totalsize,
- "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_spill[BFD_ENDIAN_BIG]
- = build_flt (floatformat_ia64_spill_big.totalsize,
- "builtin_type_ia64_spill_big",
- &floatformat_ia64_spill_big);
- builtin_type_ia64_spill[BFD_ENDIAN_LITTLE]
- = build_flt (floatformat_ia64_spill_little.totalsize,
- "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;
- builtin_type_ia64_quad[BFD_ENDIAN_BIG]
- = build_flt (floatformat_ia64_quad_big.totalsize,
- "builtin_type_ia64_quad_big",
- &floatformat_ia64_quad_big);
- builtin_type_ia64_quad[BFD_ENDIAN_LITTLE]
- = build_flt (floatformat_ia64_quad_little.totalsize,
- "builtin_type_ia64_quad_little",
- &floatformat_ia64_quad_little);
+ builtin_type_ieee_single
+ = build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single);
+ builtin_type_ieee_double
+ = build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double);
+ builtin_type_i387_ext
+ = build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext);
+ builtin_type_m68881_ext
+ = build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext);
+ builtin_type_arm_ext
+ = build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext);
+ builtin_type_ia64_spill
+ = build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill);
+ builtin_type_ia64_quad
+ = build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad);
add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, _("\
Set debugging of C++ overloading."), _("\
NULL,
show_overload_debug,
&setdebuglist, &showdebuglist);
+
+ /* Add user knob for controlling resolution of opaque types */
+ add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
+ &opaque_type_resolution, _("\
+Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
+Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL,
+ NULL,
+ show_opaque_type_resolution,
+ &setlist, &showlist);
}