/* 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_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_arm_ext;
+struct type *builtin_type_ia64_spill;
+struct type *builtin_type_ia64_quad;
+
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;
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
{
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);
}
+void
+append_flags_type_flag (struct type *type, int bitpos, char *name)
+{
+ 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;
+ }
+}
+
+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;
+}
+
/* 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
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)
{
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) = TARGET_PTR_BIT / 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:
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;
obstack_free (&dont_print_type_obstack, NULL);
}
-static void build_gdbtypes (void);
+/* Trivial helpers for the libiberty hash table, for mapping one
+ type to another. */
+
+struct type_pair
+{
+ struct type *old, *new;
+};
+
+static hashval_t
+type_pair_hash (const void *item)
+{
+ const struct type_pair *pair = item;
+ return htab_hash_pointer (pair->old);
+}
+
+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;
+}
+
+/* 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. */
+
+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);
+}
+
+/* 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. */
+
+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;
+ }
+ }
+ }
+
+ /* 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.
+
+ 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 **floatformats)
+{
+ struct type *t;
+
+ if (bit == -1)
+ {
+ gdb_assert (floatformats != NULL);
+ gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
+ bit = floatformats[0]->totalsize;
+ }
+ gdb_assert (bit >= 0);
+
+ t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, 0, name, NULL);
+ TYPE_FLOATFORMAT (t) = floatformats;
+ return t;
+}
+
static void
build_gdbtypes (void)
{
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_float = build_flt (TARGET_FLOAT_BIT, "float",
+ TARGET_FLOAT_FORMAT);
+ builtin_type_double = build_flt (TARGET_DOUBLE_BIT, "double",
+ TARGET_DOUBLE_FORMAT);
+ builtin_type_long_double = build_flt (TARGET_LONG_DOUBLE_BIT, "long double",
+ TARGET_LONG_DOUBLE_FORMAT);
+
builtin_type_complex =
init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
0,
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,
- NULL, /* FIXME: i18n: */
+ show_opaque_type_resolution,
&setlist, &showlist);
opaque_type_resolution = 1;
/* 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 ();
/* Pointer/Address types. */
}
-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)
{
{
struct cmd_list_element *c;
+ /* FIXME: Why don't the following types need to be arch-swapped?
+ See the comment at the top of the calls to
+ DEPRECATED_REGISTER_GDBARCH_SWAP below. */
builtin_type_int0 =
init_type (TYPE_CODE_INT, 0 / 8,
0,
/* FIXME - For the moment, handle types by swapping them in and out.
Should be using the per-architecture data-pointer and a large
- struct. */
+ struct.
+
+ Note that any type T that we might create a 'T *' type for must
+ be arch-swapped: we cache a type's 'T *' type in the pointer_type
+ field, so if we change architectures but don't swap T, then
+ lookup_pointer_type will start handing out pointer types made for
+ a different architecture. */
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_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 (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);
+ neutral. FIXME: Are you sure? See the comment above the calls
+ to DEPRECATED_REGISTER_GDBARCH_SWAP above. */
+ 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);
}