/* 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 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;
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_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
{
&type_flags))
return type_flags;
else
- error ("Unknown address space specifier: \"%s\"", space_identifier);
+ error (_("Unknown address space specifier: \"%s\""), space_identifier);
}
/* Identify address space identifier by integer flag as defined in
}
/* Create a new type with instance flags NEW_FLAGS, based on TYPE.
- If STORAGE is non-NULL, create the new type instance there. */
+
+ If STORAGE is non-NULL, create the new type instance there.
+ STORAGE must be in the same obstack as TYPE. */
static struct type *
make_qualified_type (struct type *type, int new_flags,
ntype = alloc_type_instance (type);
else
{
+ /* If STORAGE was provided, it had better be in the same objfile as
+ TYPE. Otherwise, we can't link it into TYPE's cv chain: if one
+ objfile is freed and the other kept, we'd have dangling
+ pointers. */
+ gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
+
ntype = storage;
TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
TYPE_CHAIN (ntype) = ntype;
CNST is a flag for setting the const attribute
VOLTL is a flag for setting the volatile attribute
TYPE is the base type whose variant we are creating.
- TYPEPTR, if nonzero, points
- to a pointer to memory where the reference type should be stored.
- If *TYPEPTR is zero, update it to point to the reference type we return.
- We allocate new memory if needed. */
+ If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
+ storage to hold the new qualified type; *TYPEPTR and TYPE must be
+ in the same objfile. Otherwise, allocate fresh memory for the new
+ type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
+ new type we construct. */
struct type *
make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
{
if (typeptr && *typeptr != NULL)
{
- /* Objfile is per-core-type. This const-qualified type had best
- belong to the same objfile as the type it is qualifying, unless
- we are overwriting a stub type, in which case the safest thing
- to do is to copy the core type into the new objfile. */
+ /* TYPE and *TYPEPTR must be in the same objfile. We can't have
+ a C-V variant chain that threads across objfiles: if one
+ objfile gets freed, then the other has a broken C-V chain.
- gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)
- || TYPE_STUB (*typeptr));
- if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type))
- {
- TYPE_MAIN_TYPE (*typeptr)
- = TYPE_ALLOC (*typeptr, sizeof (struct main_type));
- *TYPE_MAIN_TYPE (*typeptr)
- = *TYPE_MAIN_TYPE (type);
- }
+ This code used to try to copy over the main type from TYPE to
+ *TYPEPTR if they were in different objfiles, but that's
+ wrong, too: TYPE may have a field list or member function
+ lists, which refer to types of their own, etc. etc. The
+ whole shebang would need to be copied over recursively; you
+ can't have inter-objfile pointers. The only thing to do is
+ to leave stub types as stub types, and look them up afresh by
+ name each time you encounter them. */
+ gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
}
ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL);
{
struct type *chain;
+ /* These two types had better be in the same objfile. Otherwise,
+ the assignment of one type's main type structure to the other
+ will produce a type with references to objects (names; field
+ lists; etc.) allocated on an objfile other than its own. */
+ gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
+
*TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
/* The type length is not a part of the main type. Update it for each
}
/* 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
struct type *
create_string_type (struct type *result_type, struct type *range_type)
{
+ struct type *string_char_type;
+
+ string_char_type = language_string_char_type (current_language,
+ current_gdbarch);
result_type = create_array_type (result_type,
- *current_language->string_char_type,
+ string_char_type,
range_type);
TYPE_CODE (result_type) = TYPE_CODE_STRING;
return (result_type);
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, 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
return TYPE_NAME (type);
}
-/* Lookup a primitive type named NAME.
- Return zero if NAME is not a primitive type. */
-
-struct type *
-lookup_primitive_typename (char *name)
-{
- struct type **const *p;
-
- for (p = current_language->la_builtin_type_vector; *p != NULL; p++)
- {
- if (strcmp (TYPE_NAME (**p), name) == 0)
- {
- return (**p);
- }
- }
- return (NULL);
-}
-
/* Lookup a typedef or primitive type named NAME,
visible in lexical block BLOCK.
If NOERR is nonzero, return zero if NAME is not suitably defined. */
sym = lookup_symbol (name, block, VAR_DOMAIN, 0, (struct symtab **) NULL);
if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
{
- tmp = lookup_primitive_typename (name);
+ tmp = language_lookup_primitive_type_by_name (current_language,
+ current_gdbarch,
+ name);
if (tmp)
{
return (tmp);
}
else
{
- error ("No type named %s.", name);
+ error (_("No type named %s."), name);
}
}
return (SYMBOL_TYPE (sym));
if (sym == NULL)
{
- error ("No struct type named %s.", name);
+ error (_("No struct type named %s."), name);
}
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
{
- error ("This context has class, union or enum %s, not a struct.", name);
+ error (_("This context has class, union or enum %s, not a struct."), name);
}
return (SYMBOL_TYPE (sym));
}
(struct symtab **) NULL);
if (sym == NULL)
- error ("No union type named %s.", name);
+ error (_("No union type named %s."), name);
t = SYMBOL_TYPE (sym);
return (t);
/* If we get here, it's not a union */
- error ("This context has class, struct or enum %s, not a union.", name);
+ error (_("This context has class, struct or enum %s, not a union."), name);
}
(struct symtab **) NULL);
if (sym == NULL)
{
- error ("No enum type named %s.", name);
+ error (_("No enum type named %s."), name);
}
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
{
- error ("This context has class, struct or union %s, not an enum.", name);
+ error (_("This context has class, struct or union %s, not an enum."), name);
}
return (SYMBOL_TYPE (sym));
}
if (sym == NULL)
{
- error ("No template type named %s.", name);
+ error (_("No template type named %s."), name);
}
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
{
- error ("This context has class, union or enum %s, not a struct.", name);
+ error (_("This context has class, union or enum %s, not a struct."), name);
}
return (SYMBOL_TYPE (sym));
}
gdb_flush (gdb_stdout);
fprintf_unfiltered (gdb_stderr, "Type ");
type_print (type, "", gdb_stderr, -1);
- error (" is not a structure or union type.");
+ error (_(" is not a structure or union type."));
}
#if 0
{
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;
type_print (type, "", gdb_stderr, -1);
fprintf_unfiltered (gdb_stderr, " has no component named ");
fputs_filtered (name, gdb_stderr);
- error (".");
+ error (("."));
return (struct type *) -1; /* For lint */
}
static void
stub_noname_complaint (void)
{
- complaint (&symfile_complaints, "stub type has NULL name");
+ complaint (&symfile_complaints, _("stub type has NULL name"));
}
/* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
return type;
}
newtype = lookup_transparent_type (name);
+
if (newtype)
- make_cv_type (is_const, is_volatile, newtype, &type);
+ {
+ /* If the resolved type and the stub are in the same objfile,
+ then replace the stub type with the real deal. But if
+ they're in separate objfiles, leave the stub alone; we'll
+ just look up the transparent type every time we call
+ check_typedef. We can't create pointers between types
+ allocated to different objfiles, since they may have
+ different lifetimes. Trying to copy NEWTYPE over to TYPE's
+ objfile is pointless, too, since you'll have to move over any
+ other types NEWTYPE refers to, which could be an unbounded
+ amount of stuff. */
+ if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
+ make_cv_type (is_const, is_volatile, newtype, &type);
+ else
+ type = newtype;
+ }
}
/* Otherwise, rely on the stub flag being set for opaque/stubbed types */
else if (TYPE_STUB (type) && !currently_reading_symtab)
p = NULL;
if (demangled_name == NULL || p == NULL)
- error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
+ error (_("Internal: Cannot demangle mangled name `%s'."), mangled_name);
/* Now, read in the parameters that define this type. */
p += 1;
if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
{
- error ("internal error - invalid fundamental type id %d", typeid);
+ error (_("internal error - invalid fundamental type id %d"), typeid);
}
/* If this is the first time we need a fundamental type for this objfile
((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:
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;
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);
+/* 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 void
build_gdbtypes (void)
{
init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"string", (struct objfile *) NULL);
- builtin_type_int0 =
- init_type (TYPE_CODE_INT, 0 / 8,
- 0,
- "int0_t", (struct objfile *) NULL);
- builtin_type_int8 =
- init_type (TYPE_CODE_INT, 8 / 8,
- 0,
- "int8_t", (struct objfile *) NULL);
- builtin_type_uint8 =
- init_type (TYPE_CODE_INT, 8 / 8,
- TYPE_FLAG_UNSIGNED,
- "uint8_t", (struct objfile *) NULL);
- builtin_type_int16 =
- init_type (TYPE_CODE_INT, 16 / 8,
- 0,
- "int16_t", (struct objfile *) NULL);
- builtin_type_uint16 =
- init_type (TYPE_CODE_INT, 16 / 8,
- TYPE_FLAG_UNSIGNED,
- "uint16_t", (struct objfile *) NULL);
- builtin_type_int32 =
- init_type (TYPE_CODE_INT, 32 / 8,
- 0,
- "int32_t", (struct objfile *) NULL);
- builtin_type_uint32 =
- init_type (TYPE_CODE_INT, 32 / 8,
- TYPE_FLAG_UNSIGNED,
- "uint32_t", (struct objfile *) NULL);
- builtin_type_int64 =
- init_type (TYPE_CODE_INT, 64 / 8,
- 0,
- "int64_t", (struct objfile *) NULL);
- builtin_type_uint64 =
- init_type (TYPE_CODE_INT, 64 / 8,
- TYPE_FLAG_UNSIGNED,
- "uint64_t", (struct objfile *) NULL);
- builtin_type_int128 =
- init_type (TYPE_CODE_INT, 128 / 8,
- 0,
- "int128_t", (struct objfile *) NULL);
- builtin_type_uint128 =
- init_type (TYPE_CODE_INT, 128 / 8,
- TYPE_FLAG_UNSIGNED,
- "uint128_t", (struct objfile *) NULL);
builtin_type_bool =
init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"bool", (struct objfile *) NULL);
/* Add user knob for controlling resolution of opaque types */
- 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);
+ 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. */
/* 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. */
"__bfd_vma", (struct objfile *) NULL);
}
+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_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 type *t;
+ if (bit <= 0 || target_type == builtin_type_error)
+ {
+ gdb_assert (builtin_type_error != NULL);
+ return builtin_type_error;
+ }
+ t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT,
+ 0, name, (struct objfile *) NULL);
+ TYPE_TARGET_TYPE (t) = target_type;
+ return t;
+}
+
+static void *
+gdbtypes_post_init (struct gdbarch *gdbarch)
+{
+ struct builtin_type *builtin_type
+ = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
+
+ builtin_type->builtin_void =
+ init_type (TYPE_CODE_VOID, 1,
+ 0,
+ "void", (struct objfile *) NULL);
+ 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)),
+ "char", (struct objfile *) NULL);
+ builtin_type->builtin_true_char =
+ init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+ 0,
+ "true character", (struct objfile *) NULL);
+ builtin_type->builtin_signed_char =
+ init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+ 0,
+ "signed char", (struct objfile *) NULL);
+ builtin_type->builtin_unsigned_char =
+ init_type (TYPE_CODE_INT, 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);
+ builtin_type->builtin_unsigned_short =
+ init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / 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);
+ builtin_type->builtin_unsigned_int =
+ init_type (TYPE_CODE_INT, TARGET_INT_BIT / 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);
+ builtin_type->builtin_unsigned_long =
+ init_type (TYPE_CODE_INT, TARGET_LONG_BIT / 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);
+ 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);
+ builtin_type->builtin_float
+ = build_flt (gdbarch_float_bit (gdbarch), "float",
+ gdbarch_float_format (gdbarch));
+ builtin_type->builtin_double
+ = build_flt (gdbarch_double_bit (gdbarch), "double",
+ gdbarch_double_format (gdbarch));
+ builtin_type->builtin_long_double
+ = build_flt (gdbarch_long_double_bit (gdbarch), "long double",
+ gdbarch_long_double_format (gdbarch));
+ builtin_type->builtin_complex
+ = build_complex (gdbarch_float_bit (gdbarch), "complex",
+ builtin_type->builtin_float);
+ builtin_type->builtin_double_complex
+ = build_complex (gdbarch_double_bit (gdbarch), "double complex",
+ builtin_type->builtin_double);
+ builtin_type->builtin_string =
+ init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+ 0,
+ "string", (struct objfile *) NULL);
+ builtin_type->builtin_bool =
+ init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+ 0,
+ "bool", (struct objfile *) NULL);
+
+ /* 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.
+
+ 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.
+
+ 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->builtin_data_ptr
+ = make_pointer_type (builtin_type->builtin_void, NULL);
+ 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,
+ TYPE_FLAG_UNSIGNED,
+ "__CORE_ADDR", (struct objfile *) NULL);
+
+ return builtin_type;
+}
+
extern void _initialize_gdbtypes (void);
void
_initialize_gdbtypes (void)
{
struct cmd_list_element *c;
+
+ builtin_type_int0 =
+ init_type (TYPE_CODE_INT, 0 / 8,
+ 0,
+ "int0_t", (struct objfile *) NULL);
+ builtin_type_int8 =
+ init_type (TYPE_CODE_INT, 8 / 8,
+ 0,
+ "int8_t", (struct objfile *) NULL);
+ builtin_type_uint8 =
+ init_type (TYPE_CODE_INT, 8 / 8,
+ TYPE_FLAG_UNSIGNED,
+ "uint8_t", (struct objfile *) NULL);
+ builtin_type_int16 =
+ init_type (TYPE_CODE_INT, 16 / 8,
+ 0,
+ "int16_t", (struct objfile *) NULL);
+ builtin_type_uint16 =
+ init_type (TYPE_CODE_INT, 16 / 8,
+ TYPE_FLAG_UNSIGNED,
+ "uint16_t", (struct objfile *) NULL);
+ builtin_type_int32 =
+ init_type (TYPE_CODE_INT, 32 / 8,
+ 0,
+ "int32_t", (struct objfile *) NULL);
+ builtin_type_uint32 =
+ init_type (TYPE_CODE_INT, 32 / 8,
+ TYPE_FLAG_UNSIGNED,
+ "uint32_t", (struct objfile *) NULL);
+ builtin_type_int64 =
+ init_type (TYPE_CODE_INT, 64 / 8,
+ 0,
+ "int64_t", (struct objfile *) NULL);
+ builtin_type_uint64 =
+ init_type (TYPE_CODE_INT, 64 / 8,
+ TYPE_FLAG_UNSIGNED,
+ "uint64_t", (struct objfile *) NULL);
+ builtin_type_int128 =
+ init_type (TYPE_CODE_INT, 128 / 8,
+ 0,
+ "int128_t", (struct objfile *) NULL);
+ builtin_type_uint128 =
+ init_type (TYPE_CODE_INT, 128 / 8,
+ TYPE_FLAG_UNSIGNED,
+ "uint128_t", (struct objfile *) NULL);
+
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_complex);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double_complex);
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_string);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int8);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint8);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int16);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint16);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int32);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint32);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int64);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint64);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int128);
- DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint128);
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_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);
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);
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);
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);
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);
init_type (TYPE_CODE_FLT, floatformat_ia64_quad_little.totalsize / 8,
0, "builtin_type_ia64_quad_little", NULL);
TYPE_FLOATFORMAT (builtin_type_ia64_quad_little) = &floatformat_ia64_quad_little;
-
- add_show_from_set (
- add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,
- "Set debugging of C++ overloading.\n\
- When enabled, ranking of the functions\n\
- is displayed.", &setdebuglist),
- &showdebuglist);
+ 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);
+
+ 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);
}