/* Support routines for manipulating internal types for GDB.
- Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
- 2004 Free Software Foundation, Inc.
+
+ Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
+ 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+
Contributed by Cygnus Support, using pieces from other GDB modules.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "gdb_string.h"
#include "wrapper.h"
#include "cp-abi.h"
#include "gdb_assert.h"
+#include "hashtab.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_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_vec64i;
-struct type *builtin_type_vec128;
-struct type *builtin_type_vec128i;
-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
+show_opaque_type_resolution (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
+ value);
+}
+
int overload_debug = 0;
+static void
+show_overload_debug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"), value);
+}
struct extra
{
{
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
}
/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
- Return 1 of type is a range type, 0 if it is discrete (and bounds
+ Return 1 if type is a range type, 0 if it is discrete (and bounds
will fit in LONGEST), or -1 otherwise. */
int
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
- 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)
+void
+append_flags_type_flag (struct type *type, int bitpos, char *name)
{
- 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;
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
+ gdb_assert (bitpos < TYPE_NFIELDS (type));
+ gdb_assert (bitpos >= 0);
+
+ if (name)
+ {
+ TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
+ TYPE_FIELD_BITPOS (type, bitpos) = bitpos;
+ }
+ else
+ {
+ /* Don't show this field to the user. */
+ TYPE_FIELD_BITPOS (type, bitpos) = -1;
+ }
}
-static struct type *
+struct type *
+init_flags_type (char *name, int length)
+{
+ int nfields = length * TARGET_CHAR_BIT;
+ struct type *type;
+
+ 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, nfields * sizeof (struct field));
+
+ return 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_vec64i (void)
-{
- /* Construct a type for the 64 bit registers. The type we're
- building is this: */
-#if 0
- union __gdb_builtin_type_vec64i
- {
- int64_t uint64;
- 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_vec64i", TYPE_CODE_UNION);
- append_composite_type_field (t, "uint64", builtin_type_int64);
- 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_vec64i";
- 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;
-}
-
-static struct type *
-build_builtin_type_vec128i (void)
-{
- /* 128-bit Intel SIMD registers */
- struct type *t;
-
- t = init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION);
- append_composite_type_field (t, "v4_float", builtin_type_v4_float);
- append_composite_type_field (t, "v2_double", builtin_type_v2_double);
- append_composite_type_field (t, "v16_int8", builtin_type_v16_int8);
- append_composite_type_field (t, "v8_int16", builtin_type_v8_int16);
- append_composite_type_field (t, "v4_int32", builtin_type_v4_int32);
- append_composite_type_field (t, "v2_int64", builtin_type_v2_int64);
- append_composite_type_field (t, "uint128", builtin_type_int128);
-
- TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
- TYPE_NAME (t) = "builtin_type_vec128i";
- 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))
((t != NULL)
&& ((TYPE_CODE (t) == TYPE_CODE_INT)
|| (TYPE_CODE (t) == TYPE_CODE_ENUM)
+ || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
|| (TYPE_CODE (t) == TYPE_CODE_CHAR)
|| (TYPE_CODE (t) == TYPE_CODE_RANGE)
|| (TYPE_CODE (t) == TYPE_CODE_BOOL)));
return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
case TYPE_CODE_INT:
case TYPE_CODE_ENUM:
+ case TYPE_CODE_FLAGS:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
else
return INTEGER_CONVERSION_BADNESS;
case TYPE_CODE_ENUM:
+ case TYPE_CODE_FLAGS:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
return INCOMPATIBLE_TYPE_BADNESS;
}
break;
- case TYPE_CODE_MEMBER:
+ case TYPE_CODE_MEMBERPTR:
switch (TYPE_CODE (arg))
{
default:
puts_filtered (" ");
}
if (B_TST (bits, bitno))
- {
- printf_filtered ("1");
- }
+ printf_filtered (("1"));
else
- {
- printf_filtered ("0");
- }
+ printf_filtered (("0"));
}
}
TYPE_FN_FIELDLIST_NAME (type, method_idx));
gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
gdb_stdout);
- printf_filtered (") length %d\n",
+ 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);
printf_filtered ("(BOUND_SIMPLE)");
break;
default:
- printf_filtered ("(unknown bound type)");
+ printf_filtered (_("(unknown bound type)"));
break;
}
}
{
printfi_filtered (spaces, "type node ");
gdb_print_host_address (type, gdb_stdout);
- printf_filtered (" <same as already seen type>\n");
+ printf_filtered (_(" <same as already seen type>\n"));
return;
}
}
case TYPE_CODE_ENUM:
printf_filtered ("(TYPE_CODE_ENUM)");
break;
+ case TYPE_CODE_FLAGS:
+ printf_filtered ("(TYPE_CODE_FLAGS)");
+ break;
case TYPE_CODE_FUNC:
printf_filtered ("(TYPE_CODE_FUNC)");
break;
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;
gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
if (TYPE_CPLUS_SPECIFIC (type) != NULL)
{
- printf_filtered (" (unknown data form)");
+ printf_filtered (_(" (unknown data form)"));
}
printf_filtered ("\n");
break;
obstack_free (&dont_print_type_obstack, NULL);
}
-static void build_gdbtypes (void);
-static void
-build_gdbtypes (void)
+/* Trivial helpers for the libiberty hash table, for mapping one
+ type to another. */
+
+struct type_pair
{
- 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);
+ struct type *old, *new;
+};
- /* Add user knob for controlling resolution of opaque types */
- deprecated_add_show_from_set
- (add_set_cmd ("opaque-type-resolution", class_support, var_boolean, (char *) &opaque_type_resolution,
- "Set resolution of opaque struct/class/union types (if set before loading symbols).",
- &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_vec64i = build_builtin_type_vec64i ();
- builtin_type_vec128 = build_builtin_type_vec128 ();
- builtin_type_vec128i = build_builtin_type_vec128i ();
+static hashval_t
+type_pair_hash (const void *item)
+{
+ const struct type_pair *pair = item;
+ return htab_hash_pointer (pair->old);
+}
- /* Pointer/Address types. */
+static int
+type_pair_eq (const void *item_lhs, const void *item_rhs)
+{
+ const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
+ return lhs->old == rhs->old;
+}
- /* 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''.
+/* Allocate the hash table used by copy_type_recursive to walk
+ types without duplicates. We use OBJFILE's obstack, because
+ OBJFILE is about to be deleted. */
- 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.
+htab_t
+create_copied_types_hash (struct objfile *objfile)
+{
+ return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
+ NULL, &objfile->objfile_obstack,
+ hashtab_obstack_allocate,
+ dummy_obstack_deallocate);
+}
- 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.
+/* Recursively copy (deep copy) TYPE, if it is associated with OBJFILE.
+ Return a new type allocated using malloc, a saved type if we have already
+ visited TYPE (using COPIED_TYPES), or TYPE if it is not associated with
+ OBJFILE. */
- 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);
-}
+struct type *
+copy_type_recursive (struct objfile *objfile, struct type *type,
+ htab_t copied_types)
+{
+ struct type_pair *stored, pair;
+ void **slot;
+ struct type *new_type;
+
+ if (TYPE_OBJFILE (type) == NULL)
+ return type;
+
+ /* This type shouldn't be pointing to any types in other objfiles; if
+ it did, the type might disappear unexpectedly. */
+ gdb_assert (TYPE_OBJFILE (type) == objfile);
+
+ pair.old = type;
+ slot = htab_find_slot (copied_types, &pair, INSERT);
+ if (*slot != NULL)
+ return ((struct type_pair *) *slot)->new;
+
+ new_type = alloc_type (NULL);
+
+ /* We must add the new type to the hash table immediately, in case
+ we encounter this type again during a recursive call below. */
+ stored = xmalloc (sizeof (struct type_pair));
+ stored->old = type;
+ stored->new = new_type;
+ *slot = stored;
+
+ /* Copy the common fields of types. */
+ TYPE_CODE (new_type) = TYPE_CODE (type);
+ TYPE_ARRAY_UPPER_BOUND_TYPE (new_type) = TYPE_ARRAY_UPPER_BOUND_TYPE (type);
+ TYPE_ARRAY_LOWER_BOUND_TYPE (new_type) = TYPE_ARRAY_LOWER_BOUND_TYPE (type);
+ if (TYPE_NAME (type))
+ TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
+ if (TYPE_TAG_NAME (type))
+ TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
+ TYPE_FLAGS (new_type) = TYPE_FLAGS (type);
+ TYPE_VPTR_FIELDNO (new_type) = TYPE_VPTR_FIELDNO (type);
+
+ TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
+ TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
+
+ /* Copy the fields. */
+ TYPE_NFIELDS (new_type) = TYPE_NFIELDS (type);
+ if (TYPE_NFIELDS (type))
+ {
+ int i, nfields;
+
+ nfields = TYPE_NFIELDS (type);
+ TYPE_FIELDS (new_type) = xmalloc (sizeof (struct field) * nfields);
+ for (i = 0; i < nfields; i++)
+ {
+ TYPE_FIELD_ARTIFICIAL (new_type, i) = TYPE_FIELD_ARTIFICIAL (type, i);
+ TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
+ if (TYPE_FIELD_TYPE (type, i))
+ TYPE_FIELD_TYPE (new_type, i)
+ = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
+ copied_types);
+ if (TYPE_FIELD_NAME (type, i))
+ TYPE_FIELD_NAME (new_type, i) = xstrdup (TYPE_FIELD_NAME (type, i));
+ if (TYPE_FIELD_STATIC_HAS_ADDR (type, i))
+ SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
+ TYPE_FIELD_STATIC_PHYSADDR (type, i));
+ else if (TYPE_FIELD_STATIC (type, i))
+ SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
+ xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, i)));
+ else
+ {
+ TYPE_FIELD_BITPOS (new_type, i) = TYPE_FIELD_BITPOS (type, i);
+ TYPE_FIELD_STATIC_KIND (new_type, i) = 0;
+ }
+ }
+ }
-static struct gdbarch_data *gdbtypes_data;
+ /* Copy pointers to other types. */
+ if (TYPE_TARGET_TYPE (type))
+ TYPE_TARGET_TYPE (new_type) = copy_type_recursive (objfile,
+ TYPE_TARGET_TYPE (type),
+ copied_types);
+ if (TYPE_VPTR_BASETYPE (type))
+ TYPE_VPTR_BASETYPE (new_type) = copy_type_recursive (objfile,
+ TYPE_VPTR_BASETYPE (type),
+ copied_types);
+ /* Maybe copy the type_specific bits.
-const struct builtin_type *
-builtin_type (struct gdbarch *gdbarch)
-{
- return gdbarch_data (gdbarch, gdbtypes_data);
-}
+ NOTE drow/2005-12-09: We do not copy the C++-specific bits like
+ base classes and methods. There's no fundamental reason why we
+ can't, but at the moment it is not needed. */
+ if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ 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
+ || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
+ INIT_CPLUS_SPECIFIC (new_type);
+
+ return new_type;
+}
static struct type *
-build_flt (int bit, char *name, const struct floatformat *floatformat)
+build_flt (int bit, char *name, const struct floatformat **floatformats)
{
struct type *t;
- if (bit <= 0 || floatformat == NULL)
+
+ if (bit == -1)
{
- gdb_assert (builtin_type_error != NULL);
- return builtin_type_error;
+ gdb_assert (floatformats != NULL);
+ gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
+ bit = floatformats[0]->totalsize;
}
- t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT,
- 0, name, (struct objfile *) NULL);
- TYPE_FLOATFORMAT (t) = floatformat;
+ gdb_assert (bit >= 0);
+
+ 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;
+
+const struct builtin_type *
+builtin_type (struct gdbarch *gdbarch)
+{
+ return gdbarch_data (gdbarch, gdbtypes_data);
+}
+
+
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 ();
+ 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."), _("\
+Show debugging of C++ overloading."), _("\
+When enabled, ranking of the functions is displayed."),
+ NULL,
+ show_overload_debug,
+ &setdebuglist, &showdebuglist);
- 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_vec128i);
- 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);
-
- deprecated_add_show_from_set
- (add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,
- "Set debugging of C++ overloading.\n\
-When enabled, ranking of the functions is displayed.", &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);
}