/* Support routines for manipulating internal types for GDB.
- Copyright (C) 1992-2013 Free Software Foundation, Inc.
+ Copyright (C) 1992-2015 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include <string.h>
#include "bfd.h"
#include "symtab.h"
#include "symfile.h"
#include "complaints.h"
#include "gdbcmd.h"
#include "cp-abi.h"
-#include "gdb_assert.h"
#include "hashtab.h"
-#include "exceptions.h"
#include "cp-support.h"
+#include "bcache.h"
+#include "dwarf2loc.h"
+#include "gdbcore.h"
/* Initialize BADNESS constants. */
/* Initialize the fields that might not be zero. */
TYPE_CODE (type) = TYPE_CODE_UNDEF;
- TYPE_VPTR_FIELDNO (type) = -1;
TYPE_CHAIN (type) = type; /* Chain back to itself. */
return type;
/* Allocate a new GDBARCH-associated type structure and fill it
with some defaults. Space for the type structure is allocated
- on the heap. */
+ on the obstack associated with GDBARCH. */
struct type *
alloc_type_arch (struct gdbarch *gdbarch)
/* Alloc the structure and start off with all fields zeroed. */
- type = XZALLOC (struct type);
- TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
+ type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct type);
+ TYPE_MAIN_TYPE (type) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct main_type);
TYPE_OBJFILE_OWNED (type) = 0;
TYPE_OWNER (type).gdbarch = gdbarch;
/* Initialize the fields that might not be zero. */
TYPE_CODE (type) = TYPE_CODE_UNDEF;
- TYPE_VPTR_FIELDNO (type) = -1;
TYPE_CHAIN (type) = type; /* Chain back to itself. */
return type;
return type;
}
+/* See gdbtypes.h. */
+
+unsigned int
+type_length_units (struct type *type)
+{
+ struct gdbarch *arch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (arch);
+
+ return TYPE_LENGTH (type) / unit_size;
+}
+
/* Alloc a new type instance structure, fill it with some defaults,
and point it at OLDTYPE. Allocate the new type instance from the
same place as OLDTYPE. */
/* Allocate the structure. */
if (! TYPE_OBJFILE_OWNED (oldtype))
- type = XZALLOC (struct type);
+ type = XCNEW (struct type);
else
type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
struct type);
}
TYPE_NFIELDS (fn) = nparams;
- TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field));
+ TYPE_FIELDS (fn)
+ = (struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field));
for (i = 0; i < nparams; ++i)
TYPE_FIELD_TYPE (fn, i) = param_types[i];
NULL);
}
+/* Make a type without const, volatile, or restrict. */
+
+struct type *
+make_unqualified_type (struct type *type)
+{
+ return make_qualified_type (type,
+ (TYPE_INSTANCE_FLAGS (type)
+ & ~(TYPE_INSTANCE_FLAG_CONST
+ | TYPE_INSTANCE_FLAG_VOLATILE
+ | TYPE_INSTANCE_FLAG_RESTRICT)),
+ NULL);
+}
+
+/* Make a '_Atomic'-qualified version of TYPE. */
+
+struct type *
+make_atomic_type (struct type *type)
+{
+ return make_qualified_type (type,
+ (TYPE_INSTANCE_FLAGS (type)
+ | TYPE_INSTANCE_FLAG_ATOMIC),
+ NULL);
+}
+
/* Replace the contents of ntype with the type *type. This changes the
contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
the changes are propogated to all types in the TYPE_CHAIN.
TYPE_LENGTH (mtype) = 1;
TYPE_STUB (mtype) = 1;
TYPE_TARGET_TYPE (mtype) = type;
- /* _DOMAIN_TYPE (mtype) = unknown yet */
+ /* TYPE_SELF_TYPE (mtype) = unknown yet */
return mtype;
}
-/* Create a range type using either a blank type supplied in
- RESULT_TYPE, or creating a new type, inheriting the objfile from
- INDEX_TYPE.
-
- Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
- to HIGH_BOUND, inclusive.
-
- FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
- sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
+/* Create a range type with a dynamic range from LOW_BOUND to
+ HIGH_BOUND, inclusive. See create_range_type for further details. */
struct type *
create_range_type (struct type *result_type, struct type *index_type,
- LONGEST low_bound, LONGEST high_bound)
+ const struct dynamic_prop *low_bound,
+ const struct dynamic_prop *high_bound)
{
if (result_type == NULL)
result_type = alloc_type_copy (index_type);
TYPE_TARGET_STUB (result_type) = 1;
else
TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
+
TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
- TYPE_LOW_BOUND (result_type) = low_bound;
- TYPE_HIGH_BOUND (result_type) = high_bound;
+ TYPE_RANGE_DATA (result_type)->low = *low_bound;
+ TYPE_RANGE_DATA (result_type)->high = *high_bound;
- if (low_bound >= 0)
+ if (low_bound->kind == PROP_CONST && low_bound->data.const_val >= 0)
TYPE_UNSIGNED (result_type) = 1;
+ /* Ada allows the declaration of range types whose upper bound is
+ less than the lower bound, so checking the lower bound is not
+ enough. Make sure we do not mark a range type whose upper bound
+ is negative as unsigned. */
+ if (high_bound->kind == PROP_CONST && high_bound->data.const_val < 0)
+ TYPE_UNSIGNED (result_type) = 0;
+
return result_type;
}
+/* Create a range type using either a blank type supplied in
+ RESULT_TYPE, or creating a new type, inheriting the objfile from
+ INDEX_TYPE.
+
+ Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
+ to HIGH_BOUND, inclusive.
+
+ FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
+ sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
+
+struct type *
+create_static_range_type (struct type *result_type, struct type *index_type,
+ LONGEST low_bound, LONGEST high_bound)
+{
+ struct dynamic_prop low, high;
+
+ low.kind = PROP_CONST;
+ low.data.const_val = low_bound;
+
+ high.kind = PROP_CONST;
+ high.data.const_val = high_bound;
+
+ result_type = create_range_type (result_type, index_type, &low, &high);
+
+ return result_type;
+}
+
+/* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values
+ are static, otherwise returns 0. */
+
+static int
+has_static_range (const struct range_bounds *bounds)
+{
+ return (bounds->low.kind == PROP_CONST
+ && bounds->high.kind == PROP_CONST);
+}
+
+
/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
TYPE. Return 1 if type is a range type, 0 if it is discrete (and
bounds will fit in LONGEST), or -1 otherwise. */
int
get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_RANGE:
return 1;
}
+/* Assuming that TYPE is a discrete type and VAL is a valid integer
+ representation of a value of this type, save the corresponding
+ position number in POS.
+
+ Its differs from VAL only in the case of enumeration types. In
+ this case, the position number of the value of the first listed
+ enumeration literal is zero; the position number of the value of
+ each subsequent enumeration literal is one more than that of its
+ predecessor in the list.
+
+ Return 1 if the operation was successful. Return zero otherwise,
+ in which case the value of POS is unmodified.
+*/
+
+int
+discrete_position (struct type *type, LONGEST val, LONGEST *pos)
+{
+ if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+ {
+ int i;
+
+ for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ {
+ if (val == TYPE_FIELD_ENUMVAL (type, i))
+ {
+ *pos = i;
+ return 1;
+ }
+ }
+ /* Invalid enumeration value. */
+ return 0;
+ }
+ else
+ {
+ *pos = val;
+ return 1;
+ }
+}
+
/* Create an array type using either a blank type supplied in
RESULT_TYPE, or creating a new type, inheriting the objfile from
RANGE_TYPE.
Elements will be of type ELEMENT_TYPE, the indices will be of type
RANGE_TYPE.
+ If BIT_STRIDE is not zero, build a packed array type whose element
+ size is BIT_STRIDE. Otherwise, ignore this parameter.
+
FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
sure it is TYPE_CODE_UNDEF before we bash it into an array
type? */
struct type *
-create_array_type (struct type *result_type,
- struct type *element_type,
- struct type *range_type)
+create_array_type_with_stride (struct type *result_type,
+ struct type *element_type,
+ struct type *range_type,
+ unsigned int bit_stride)
{
- LONGEST low_bound, high_bound;
-
if (result_type == NULL)
result_type = alloc_type_copy (range_type);
TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
TYPE_TARGET_TYPE (result_type) = element_type;
- if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
- low_bound = high_bound = 0;
- CHECK_TYPEDEF (element_type);
- /* Be careful when setting the array length. Ada arrays can be
- empty arrays with the high_bound being smaller than the low_bound.
- In such cases, the array length should be zero. */
- if (high_bound < low_bound)
- TYPE_LENGTH (result_type) = 0;
+ if (has_static_range (TYPE_RANGE_DATA (range_type))
+ && (!type_not_associated (result_type)
+ && !type_not_allocated (result_type)))
+ {
+ LONGEST low_bound, high_bound;
+
+ if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
+ low_bound = high_bound = 0;
+ element_type = check_typedef (element_type);
+ /* Be careful when setting the array length. Ada arrays can be
+ empty arrays with the high_bound being smaller than the low_bound.
+ In such cases, the array length should be zero. */
+ if (high_bound < low_bound)
+ TYPE_LENGTH (result_type) = 0;
+ else if (bit_stride > 0)
+ TYPE_LENGTH (result_type) =
+ (bit_stride * (high_bound - low_bound + 1) + 7) / 8;
+ else
+ TYPE_LENGTH (result_type) =
+ TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
+ }
else
- TYPE_LENGTH (result_type) =
- TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
+ {
+ /* This type is dynamic and its length needs to be computed
+ on demand. In the meantime, avoid leaving the TYPE_LENGTH
+ undefined by setting it to zero. Although we are not expected
+ to trust TYPE_LENGTH in this case, setting the size to zero
+ allows us to avoid allocating objects of random sizes in case
+ we accidently do. */
+ TYPE_LENGTH (result_type) = 0;
+ }
+
TYPE_NFIELDS (result_type) = 1;
TYPE_FIELDS (result_type) =
(struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
TYPE_INDEX_TYPE (result_type) = range_type;
- TYPE_VPTR_FIELDNO (result_type) = -1;
+ if (bit_stride > 0)
+ TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
/* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
if (TYPE_LENGTH (result_type) == 0)
return result_type;
}
+/* Same as create_array_type_with_stride but with no bit_stride
+ (BIT_STRIDE = 0), thus building an unpacked array. */
+
+struct type *
+create_array_type (struct type *result_type,
+ struct type *element_type,
+ struct type *range_type)
+{
+ return create_array_type_with_stride (result_type, element_type,
+ range_type, 0);
+}
+
struct type *
lookup_array_range_type (struct type *element_type,
LONGEST low_bound, LONGEST high_bound)
struct gdbarch *gdbarch = get_type_arch (element_type);
struct type *index_type = builtin_type (gdbarch)->builtin_int;
struct type *range_type
- = create_range_type (NULL, index_type, low_bound, high_bound);
+ = create_static_range_type (NULL, index_type, low_bound, high_bound);
return create_array_type (NULL, element_type, range_type);
}
TYPE_CODE (result_type) = TYPE_CODE_SET;
TYPE_NFIELDS (result_type) = 1;
- TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
+ TYPE_FIELDS (result_type)
+ = (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
if (!TYPE_STUB (domain_type))
{
return array_type;
}
-/* Smash TYPE to be a type of pointers to members of DOMAIN with type
+/* Internal routine called by TYPE_SELF_TYPE to return the type that TYPE
+ belongs to. In c++ this is the class of "this", but TYPE_THIS_TYPE is too
+ confusing. "self" is a common enough replacement for "this".
+ TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
+ TYPE_CODE_METHOD. */
+
+struct type *
+internal_type_self_type (struct type *type)
+{
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_METHODPTR:
+ case TYPE_CODE_MEMBERPTR:
+ if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
+ return NULL;
+ gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_SELF_TYPE);
+ return TYPE_MAIN_TYPE (type)->type_specific.self_type;
+ case TYPE_CODE_METHOD:
+ if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
+ return NULL;
+ gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
+ return TYPE_MAIN_TYPE (type)->type_specific.func_stuff->self_type;
+ default:
+ gdb_assert_not_reached ("bad type");
+ }
+}
+
+/* Set the type of the class that TYPE belongs to.
+ In c++ this is the class of "this".
+ TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
+ TYPE_CODE_METHOD. */
+
+void
+set_type_self_type (struct type *type, struct type *self_type)
+{
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_METHODPTR:
+ case TYPE_CODE_MEMBERPTR:
+ if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
+ TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_SELF_TYPE;
+ gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_SELF_TYPE);
+ TYPE_MAIN_TYPE (type)->type_specific.self_type = self_type;
+ break;
+ case TYPE_CODE_METHOD:
+ if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
+ INIT_FUNC_SPECIFIC (type);
+ gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
+ TYPE_MAIN_TYPE (type)->type_specific.func_stuff->self_type = self_type;
+ break;
+ default:
+ gdb_assert_not_reached ("bad type");
+ }
+}
+
+/* Smash TYPE to be a type of pointers to members of SELF_TYPE 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
allocated. */
void
-smash_to_memberptr_type (struct type *type, struct type *domain,
+smash_to_memberptr_type (struct type *type, struct type *self_type,
struct type *to_type)
{
smash_type (type);
+ TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
TYPE_TARGET_TYPE (type) = to_type;
- TYPE_DOMAIN_TYPE (type) = domain;
+ set_type_self_type (type, self_type);
/* Assume that a data member pointer is the same size as a normal
pointer. */
TYPE_LENGTH (type)
= gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
- TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
}
/* Smash TYPE to be a type of pointer to methods type TO_TYPE.
smash_to_methodptr_type (struct type *type, struct type *to_type)
{
smash_type (type);
+ TYPE_CODE (type) = TYPE_CODE_METHODPTR;
TYPE_TARGET_TYPE (type) = to_type;
- TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type);
+ set_type_self_type (type, TYPE_SELF_TYPE (to_type));
TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
- TYPE_CODE (type) = TYPE_CODE_METHODPTR;
}
-/* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
+/* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
METHOD just means `function that gets an extra "this" argument'.
When "smashing" the type, we preserve the objfile that the old type
allocated. */
void
-smash_to_method_type (struct type *type, struct type *domain,
+smash_to_method_type (struct type *type, struct type *self_type,
struct type *to_type, struct field *args,
int nargs, int varargs)
{
smash_type (type);
+ TYPE_CODE (type) = TYPE_CODE_METHOD;
TYPE_TARGET_TYPE (type) = to_type;
- TYPE_DOMAIN_TYPE (type) = domain;
+ set_type_self_type (type, self_type);
TYPE_FIELDS (type) = args;
TYPE_NFIELDS (type) = nargs;
if (varargs)
TYPE_VARARGS (type) = 1;
TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
- TYPE_CODE (type) = TYPE_CODE_METHOD;
}
/* Return a typename for a struct/union/enum type without "struct ",
const char *name;
struct objfile *objfile;
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
name = type_name_no_tag (type);
if (name != NULL)
struct symbol *sym;
struct type *type;
- sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
+ sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
+ language->la_language, NULL).symbol;
if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
return SYMBOL_TYPE (sym);
- type = language_lookup_primitive_type_by_name (language, gdbarch, name);
- if (type)
- return type;
-
if (noerr)
return NULL;
error (_("No type named %s."), name);
lookup_unsigned_typename (const struct language_defn *language,
struct gdbarch *gdbarch, const char *name)
{
- char *uns = alloca (strlen (name) + 10);
+ char *uns = (char *) alloca (strlen (name) + 10);
strcpy (uns, "unsigned ");
strcpy (uns + 9, name);
struct gdbarch *gdbarch, const char *name)
{
struct type *t;
- char *uns = alloca (strlen (name) + 8);
+ char *uns = (char *) alloca (strlen (name) + 8);
strcpy (uns, "signed ");
strcpy (uns + 7, name);
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
struct symbol *sym;
struct type *t;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
error (_("No union type named %s."), name);
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
error (_("No enum type named %s."), name);
strcat (nam, TYPE_NAME (type));
strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
- sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
+ sym = lookup_symbol (nam, block, VAR_DOMAIN, 0).symbol;
if (sym == NULL)
{
lookup_struct_elt_type (struct type *type, const char *name, int noerr)
{
int i;
- char *typename;
+ char *type_name;
for (;;)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
break;
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
{
- typename = type_to_string (type);
- make_cleanup (xfree, typename);
- error (_("Type %s is not a structure or union type."), typename);
+ type_name = type_to_string (type);
+ make_cleanup (xfree, type_name);
+ error (_("Type %s is not a structure or union type."), type_name);
}
#if 0
I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
foo; } bell;" Disabled by fnf. */
{
- char *typename;
+ char *type_name;
- typename = type_name_no_tag (type);
- if (typename != NULL && strcmp (typename, name) == 0)
+ type_name = type_name_no_tag (type);
+ if (type_name != NULL && strcmp (type_name, name) == 0)
return type;
}
#endif
return NULL;
}
- typename = type_to_string (type);
- make_cleanup (xfree, typename);
- error (_("Type %s has no component named %s."), typename, name);
+ type_name = type_to_string (type);
+ make_cleanup (xfree, type_name);
+ error (_("Type %s has no component named %s."), type_name, name);
+}
+
+/* Store in *MAX the largest number representable by unsigned integer type
+ TYPE. */
+
+void
+get_unsigned_type_max (struct type *type, ULONGEST *max)
+{
+ unsigned int n;
+
+ type = check_typedef (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_UNSIGNED (type));
+ gdb_assert (TYPE_LENGTH (type) <= sizeof (ULONGEST));
+
+ /* Written this way to avoid overflow. */
+ n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
+ *max = ((((ULONGEST) 1 << (n - 1)) - 1) << 1) | 1;
+}
+
+/* Store in *MIN, *MAX the smallest and largest numbers representable by
+ signed integer type TYPE. */
+
+void
+get_signed_type_minmax (struct type *type, LONGEST *min, LONGEST *max)
+{
+ unsigned int n;
+
+ type = check_typedef (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && !TYPE_UNSIGNED (type));
+ gdb_assert (TYPE_LENGTH (type) <= sizeof (LONGEST));
+
+ n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
+ *min = -((ULONGEST) 1 << (n - 1));
+ *max = ((ULONGEST) 1 << (n - 1)) - 1;
+}
+
+/* Internal routine called by TYPE_VPTR_FIELDNO to return the value of
+ cplus_stuff.vptr_fieldno.
+
+ cplus_stuff is initialized to cplus_struct_default which does not
+ set vptr_fieldno to -1 for portability reasons (IWBN to use C99
+ designated initializers). We cope with that here. */
+
+int
+internal_type_vptr_fieldno (struct type *type)
+{
+ type = check_typedef (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION);
+ if (!HAVE_CPLUS_STRUCT (type))
+ return -1;
+ return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno;
+}
+
+/* Set the value of cplus_stuff.vptr_fieldno. */
+
+void
+set_type_vptr_fieldno (struct type *type, int fieldno)
+{
+ type = check_typedef (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION);
+ if (!HAVE_CPLUS_STRUCT (type))
+ ALLOCATE_CPLUS_STRUCT_TYPE (type);
+ TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno = fieldno;
+}
+
+/* Internal routine called by TYPE_VPTR_BASETYPE to return the value of
+ cplus_stuff.vptr_basetype. */
+
+struct type *
+internal_type_vptr_basetype (struct type *type)
+{
+ type = check_typedef (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION);
+ gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF);
+ return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype;
+}
+
+/* Set the value of cplus_stuff.vptr_basetype. */
+
+void
+set_type_vptr_basetype (struct type *type, struct type *basetype)
+{
+ type = check_typedef (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION);
+ if (!HAVE_CPLUS_STRUCT (type))
+ ALLOCATE_CPLUS_STRUCT_TYPE (type);
+ TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype = basetype;
}
/* Lookup the vptr basetype/fieldno values for TYPE.
int
get_vptr_fieldno (struct type *type, struct type **basetypep)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
if (TYPE_VPTR_FIELDNO (type) < 0)
{
it, it may have a different lifetime. PR 2384 */
if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
{
- TYPE_VPTR_FIELDNO (type) = fieldno;
- TYPE_VPTR_BASETYPE (type) = basetype;
+ set_type_vptr_fieldno (type, fieldno);
+ set_type_vptr_basetype (type, basetype);
}
if (basetypep)
*basetypep = basetype;
complaint (&symfile_complaints, _("stub type has NULL name"));
}
+/* Worker for is_dynamic_type. */
+
+static int
+is_dynamic_type_internal (struct type *type, int top_level)
+{
+ type = check_typedef (type);
+
+ /* We only want to recognize references at the outermost level. */
+ if (top_level && TYPE_CODE (type) == TYPE_CODE_REF)
+ type = check_typedef (TYPE_TARGET_TYPE (type));
+
+ /* Types that have a dynamic TYPE_DATA_LOCATION are considered
+ dynamic, even if the type itself is statically defined.
+ From a user's point of view, this may appear counter-intuitive;
+ but it makes sense in this context, because the point is to determine
+ whether any part of the type needs to be resolved before it can
+ be exploited. */
+ if (TYPE_DATA_LOCATION (type) != NULL
+ && (TYPE_DATA_LOCATION_KIND (type) == PROP_LOCEXPR
+ || TYPE_DATA_LOCATION_KIND (type) == PROP_LOCLIST))
+ return 1;
+
+ if (TYPE_ASSOCIATED_PROP (type))
+ return 1;
+
+ if (TYPE_ALLOCATED_PROP (type))
+ return 1;
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_RANGE:
+ {
+ /* A range type is obviously dynamic if it has at least one
+ dynamic bound. But also consider the range type to be
+ dynamic when its subtype is dynamic, even if the bounds
+ of the range type are static. It allows us to assume that
+ the subtype of a static range type is also static. */
+ return (!has_static_range (TYPE_RANGE_DATA (type))
+ || is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0));
+ }
+
+ case TYPE_CODE_ARRAY:
+ {
+ gdb_assert (TYPE_NFIELDS (type) == 1);
+
+ /* The array is dynamic if either the bounds are dynamic,
+ or the elements it contains have a dynamic contents. */
+ if (is_dynamic_type_internal (TYPE_INDEX_TYPE (type), 0))
+ return 1;
+ return is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0);
+ }
+
+ case TYPE_CODE_STRUCT:
+ case TYPE_CODE_UNION:
+ {
+ int i;
+
+ for (i = 0; i < TYPE_NFIELDS (type); ++i)
+ if (!field_is_static (&TYPE_FIELD (type, i))
+ && is_dynamic_type_internal (TYPE_FIELD_TYPE (type, i), 0))
+ return 1;
+ }
+ break;
+ }
+
+ return 0;
+}
+
+/* See gdbtypes.h. */
+
+int
+is_dynamic_type (struct type *type)
+{
+ return is_dynamic_type_internal (type, 1);
+}
+
+static struct type *resolve_dynamic_type_internal
+ (struct type *type, struct property_addr_info *addr_stack, int top_level);
+
+/* Given a dynamic range type (dyn_range_type) and a stack of
+ struct property_addr_info elements, return a static version
+ of that type. */
+
+static struct type *
+resolve_dynamic_range (struct type *dyn_range_type,
+ struct property_addr_info *addr_stack)
+{
+ CORE_ADDR value;
+ struct type *static_range_type, *static_target_type;
+ const struct dynamic_prop *prop;
+ const struct dwarf2_locexpr_baton *baton;
+ struct dynamic_prop low_bound, high_bound;
+
+ gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE);
+
+ prop = &TYPE_RANGE_DATA (dyn_range_type)->low;
+ if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ {
+ low_bound.kind = PROP_CONST;
+ low_bound.data.const_val = value;
+ }
+ else
+ {
+ low_bound.kind = PROP_UNDEFINED;
+ low_bound.data.const_val = 0;
+ }
+
+ prop = &TYPE_RANGE_DATA (dyn_range_type)->high;
+ if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ {
+ high_bound.kind = PROP_CONST;
+ high_bound.data.const_val = value;
+
+ if (TYPE_RANGE_DATA (dyn_range_type)->flag_upper_bound_is_count)
+ high_bound.data.const_val
+ = low_bound.data.const_val + high_bound.data.const_val - 1;
+ }
+ else
+ {
+ high_bound.kind = PROP_UNDEFINED;
+ high_bound.data.const_val = 0;
+ }
+
+ static_target_type
+ = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type),
+ addr_stack, 0);
+ static_range_type = create_range_type (copy_type (dyn_range_type),
+ static_target_type,
+ &low_bound, &high_bound);
+ TYPE_RANGE_DATA (static_range_type)->flag_bound_evaluated = 1;
+ return static_range_type;
+}
+
+/* Resolves dynamic bound values of an array type TYPE to static ones.
+ ADDR_STACK is a stack of struct property_addr_info to be used
+ if needed during the dynamic resolution. */
+
+static struct type *
+resolve_dynamic_array (struct type *type,
+ struct property_addr_info *addr_stack)
+{
+ CORE_ADDR value;
+ struct type *elt_type;
+ struct type *range_type;
+ struct type *ary_dim;
+ struct dynamic_prop *prop;
+
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY);
+
+ type = copy_type (type);
+
+ elt_type = type;
+ range_type = check_typedef (TYPE_INDEX_TYPE (elt_type));
+ range_type = resolve_dynamic_range (range_type, addr_stack);
+
+ /* Resolve allocated/associated here before creating a new array type, which
+ will update the length of the array accordingly. */
+ prop = TYPE_ALLOCATED_PROP (type);
+ if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ {
+ TYPE_DYN_PROP_ADDR (prop) = value;
+ TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
+ }
+ prop = TYPE_ASSOCIATED_PROP (type);
+ if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ {
+ TYPE_DYN_PROP_ADDR (prop) = value;
+ TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
+ }
+
+ ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type));
+
+ if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY)
+ elt_type = resolve_dynamic_array (ary_dim, addr_stack);
+ else
+ elt_type = TYPE_TARGET_TYPE (type);
+
+ return create_array_type_with_stride (type, elt_type, range_type,
+ TYPE_FIELD_BITSIZE (type, 0));
+}
+
+/* Resolve dynamic bounds of members of the union TYPE to static
+ bounds. ADDR_STACK is a stack of struct property_addr_info
+ to be used if needed during the dynamic resolution. */
+
+static struct type *
+resolve_dynamic_union (struct type *type,
+ struct property_addr_info *addr_stack)
+{
+ struct type *resolved_type;
+ int i;
+ unsigned int max_len = 0;
+
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
+
+ resolved_type = copy_type (type);
+ TYPE_FIELDS (resolved_type)
+ = (struct field *) TYPE_ALLOC (resolved_type,
+ TYPE_NFIELDS (resolved_type)
+ * sizeof (struct field));
+ memcpy (TYPE_FIELDS (resolved_type),
+ TYPE_FIELDS (type),
+ TYPE_NFIELDS (resolved_type) * sizeof (struct field));
+ for (i = 0; i < TYPE_NFIELDS (resolved_type); ++i)
+ {
+ struct type *t;
+
+ if (field_is_static (&TYPE_FIELD (type, i)))
+ continue;
+
+ t = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i),
+ addr_stack, 0);
+ TYPE_FIELD_TYPE (resolved_type, i) = t;
+ if (TYPE_LENGTH (t) > max_len)
+ max_len = TYPE_LENGTH (t);
+ }
+
+ TYPE_LENGTH (resolved_type) = max_len;
+ return resolved_type;
+}
+
+/* Resolve dynamic bounds of members of the struct TYPE to static
+ bounds. ADDR_STACK is a stack of struct property_addr_info to
+ be used if needed during the dynamic resolution. */
+
+static struct type *
+resolve_dynamic_struct (struct type *type,
+ struct property_addr_info *addr_stack)
+{
+ struct type *resolved_type;
+ int i;
+ unsigned resolved_type_bit_length = 0;
+
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
+ gdb_assert (TYPE_NFIELDS (type) > 0);
+
+ resolved_type = copy_type (type);
+ TYPE_FIELDS (resolved_type)
+ = (struct field *) TYPE_ALLOC (resolved_type,
+ TYPE_NFIELDS (resolved_type)
+ * sizeof (struct field));
+ memcpy (TYPE_FIELDS (resolved_type),
+ TYPE_FIELDS (type),
+ TYPE_NFIELDS (resolved_type) * sizeof (struct field));
+ for (i = 0; i < TYPE_NFIELDS (resolved_type); ++i)
+ {
+ unsigned new_bit_length;
+ struct property_addr_info pinfo;
+
+ if (field_is_static (&TYPE_FIELD (type, i)))
+ continue;
+
+ /* As we know this field is not a static field, the field's
+ field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
+ this is the case, but only trigger a simple error rather
+ than an internal error if that fails. While failing
+ that verification indicates a bug in our code, the error
+ is not severe enough to suggest to the user he stops
+ his debugging session because of it. */
+ if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_BITPOS)
+ error (_("Cannot determine struct field location"
+ " (invalid location kind)"));
+
+ pinfo.type = check_typedef (TYPE_FIELD_TYPE (type, i));
+ pinfo.valaddr = addr_stack->valaddr;
+ pinfo.addr = addr_stack->addr;
+ pinfo.next = addr_stack;
+
+ TYPE_FIELD_TYPE (resolved_type, i)
+ = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i),
+ &pinfo, 0);
+ gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type, i)
+ == FIELD_LOC_KIND_BITPOS);
+
+ new_bit_length = TYPE_FIELD_BITPOS (resolved_type, i);
+ if (TYPE_FIELD_BITSIZE (resolved_type, i) != 0)
+ new_bit_length += TYPE_FIELD_BITSIZE (resolved_type, i);
+ else
+ new_bit_length += (TYPE_LENGTH (TYPE_FIELD_TYPE (resolved_type, i))
+ * TARGET_CHAR_BIT);
+
+ /* Normally, we would use the position and size of the last field
+ to determine the size of the enclosing structure. But GCC seems
+ to be encoding the position of some fields incorrectly when
+ the struct contains a dynamic field that is not placed last.
+ So we compute the struct size based on the field that has
+ the highest position + size - probably the best we can do. */
+ if (new_bit_length > resolved_type_bit_length)
+ resolved_type_bit_length = new_bit_length;
+ }
+
+ TYPE_LENGTH (resolved_type)
+ = (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+
+ /* The Ada language uses this field as a cache for static fixed types: reset
+ it as RESOLVED_TYPE must have its own static fixed type. */
+ TYPE_TARGET_TYPE (resolved_type) = NULL;
+
+ return resolved_type;
+}
+
+/* Worker for resolved_dynamic_type. */
+
+static struct type *
+resolve_dynamic_type_internal (struct type *type,
+ struct property_addr_info *addr_stack,
+ int top_level)
+{
+ struct type *real_type = check_typedef (type);
+ struct type *resolved_type = type;
+ struct dynamic_prop *prop;
+ CORE_ADDR value;
+
+ if (!is_dynamic_type_internal (real_type, top_level))
+ return type;
+
+ if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ {
+ resolved_type = copy_type (type);
+ TYPE_TARGET_TYPE (resolved_type)
+ = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type), addr_stack,
+ top_level);
+ }
+ else
+ {
+ /* Before trying to resolve TYPE, make sure it is not a stub. */
+ type = real_type;
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_REF:
+ {
+ struct property_addr_info pinfo;
+
+ pinfo.type = check_typedef (TYPE_TARGET_TYPE (type));
+ pinfo.valaddr = NULL;
+ if (addr_stack->valaddr != NULL)
+ pinfo.addr = extract_typed_address (addr_stack->valaddr, type);
+ else
+ pinfo.addr = read_memory_typed_address (addr_stack->addr, type);
+ pinfo.next = addr_stack;
+
+ resolved_type = copy_type (type);
+ TYPE_TARGET_TYPE (resolved_type)
+ = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type),
+ &pinfo, top_level);
+ break;
+ }
+
+ case TYPE_CODE_ARRAY:
+ resolved_type = resolve_dynamic_array (type, addr_stack);
+ break;
+
+ case TYPE_CODE_RANGE:
+ resolved_type = resolve_dynamic_range (type, addr_stack);
+ break;
+
+ case TYPE_CODE_UNION:
+ resolved_type = resolve_dynamic_union (type, addr_stack);
+ break;
+
+ case TYPE_CODE_STRUCT:
+ resolved_type = resolve_dynamic_struct (type, addr_stack);
+ break;
+ }
+ }
+
+ /* Resolve data_location attribute. */
+ prop = TYPE_DATA_LOCATION (resolved_type);
+ if (prop != NULL
+ && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ {
+ TYPE_DYN_PROP_ADDR (prop) = value;
+ TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
+ }
+
+ return resolved_type;
+}
+
+/* See gdbtypes.h */
+
+struct type *
+resolve_dynamic_type (struct type *type, const gdb_byte *valaddr,
+ CORE_ADDR addr)
+{
+ struct property_addr_info pinfo
+ = {check_typedef (type), valaddr, addr, NULL};
+
+ return resolve_dynamic_type_internal (type, &pinfo, 1);
+}
+
+/* See gdbtypes.h */
+
+struct dynamic_prop *
+get_dyn_prop (enum dynamic_prop_node_kind prop_kind, const struct type *type)
+{
+ struct dynamic_prop_list *node = TYPE_DYN_PROP_LIST (type);
+
+ while (node != NULL)
+ {
+ if (node->prop_kind == prop_kind)
+ return &node->prop;
+ node = node->next;
+ }
+ return NULL;
+}
+
+/* See gdbtypes.h */
+
+void
+add_dyn_prop (enum dynamic_prop_node_kind prop_kind, struct dynamic_prop prop,
+ struct type *type, struct objfile *objfile)
+{
+ struct dynamic_prop_list *temp;
+
+ gdb_assert (TYPE_OBJFILE_OWNED (type));
+
+ temp = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop_list);
+ temp->prop_kind = prop_kind;
+ temp->prop = prop;
+ temp->next = TYPE_DYN_PROP_LIST (type);
+
+ TYPE_DYN_PROP_LIST (type) = temp;
+}
+
+
/* Find the real type of TYPE. This function returns the real type,
after removing all layers of typedefs, and completing opaque or stub
types. Completion changes the TYPE argument, but stripping of
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
if (sym)
TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
else /* TYPE_CODE_UNDEF */
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
if (sym)
{
/* Same as above for opaque types, we can replace the stub
{
/* Nothing we can do. */
}
- else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
- && TYPE_NFIELDS (type) == 1
- && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
- == TYPE_CODE_RANGE))
- {
- /* Now recompute the length of the array type, based on its
- number of elements and the target type's length.
- Watch out for Ada null Ada arrays where the high bound
- is smaller than the low bound. */
- const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
- const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
- ULONGEST len;
-
- if (high_bound < low_bound)
- len = 0;
- else
- {
- /* For now, we conservatively take the array length to be 0
- if its length exceeds UINT_MAX. The code below assumes
- that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
- which is technically not guaranteed by C, but is usually true
- (because it would be true if x were unsigned with its
- high-order bit on). It uses the fact that
- high_bound-low_bound is always representable in
- ULONGEST and that if high_bound-low_bound+1 overflows,
- it overflows to 0. We must change these tests if we
- decide to increase the representation of TYPE_LENGTH
- from unsigned int to ULONGEST. */
- ULONGEST ulow = low_bound, uhigh = high_bound;
- ULONGEST tlen = TYPE_LENGTH (target_type);
-
- len = tlen * (uhigh - ulow + 1);
- if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
- || len > UINT_MAX)
- len = 0;
- }
- TYPE_LENGTH (type) = len;
- TYPE_TARGET_STUB (type) = 0;
- }
else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
{
struct ui_file *saved_gdb_stderr;
struct type *type = NULL; /* Initialize to keep gcc happy. */
- volatile struct gdb_exception except;
/* Suppress error messages. */
saved_gdb_stderr = gdb_stderr;
gdb_stderr = ui_file_new ();
/* Call parse_and_eval_type() without fear of longjmp()s. */
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
type = parse_and_eval_type (p, length);
}
-
- if (except.reason < 0)
- type = builtin_type (gdbarch)->builtin_void;
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ type = builtin_type (gdbarch)->builtin_void;
+ }
+ END_CATCH
/* Stop suppressing error messages. */
ui_file_delete (gdb_stderr);
}
/* If we read one argument and it was ``void'', don't count it. */
- if (strncmp (argtypetext, "(void)", 6) == 0)
+ if (startswith (argtypetext, "(void)"))
argcount -= 1;
/* We need one extra slot, for the THIS pointer. */
/* Now update the old "stub" type into a real type. */
mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
- TYPE_DOMAIN_TYPE (mtype) = type;
- TYPE_FIELDS (mtype) = argtypes;
- TYPE_NFIELDS (mtype) = argcount;
+ /* MTYPE may currently be a function (TYPE_CODE_FUNC).
+ We want a method (TYPE_CODE_METHOD). */
+ smash_to_method_type (mtype, type, TYPE_TARGET_TYPE (mtype),
+ argtypes, argcount, p[-2] == '.');
TYPE_STUB (mtype) = 0;
TYPE_FN_FIELD_STUB (f, signature_id) = 0;
- if (p[-2] == '.')
- TYPE_VARARGS (mtype) = 1;
xfree (demangled_name);
}
Therefore the only thing we need to handle here are v2 operator
names. */
- if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
+ if (found_stub && !startswith (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z"))
{
int ret;
char dem_opname[256];
TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
*(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
+ set_type_vptr_fieldno (type, -1);
}
const struct gnat_aux_type gnat_aux_default =
{
/* FIXME: Should we return true for references as well as
pointers? */
- CHECK_TYPEDEF (t);
+ t = check_typedef (t);
return
(t != NULL
&& TYPE_CODE (t) == TYPE_CODE_PTR
int
is_integral_type (struct type *t)
{
- CHECK_TYPEDEF (t);
+ t = check_typedef (t);
return
((t != NULL)
&& ((TYPE_CODE (t) == TYPE_CODE_INT)
/* Return true if TYPE is scalar. */
-static int
+int
is_scalar_type (struct type *type)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
switch (TYPE_CODE (type))
{
int
is_scalar_type_recursive (struct type *t)
{
- CHECK_TYPEDEF (t);
+ t = check_typedef (t);
if (is_scalar_type (t))
return 1;
return 0;
}
+/* Return true is T is a class or a union. False otherwise. */
+
+int
+class_or_union_p (const struct type *t)
+{
+ return (TYPE_CODE (t) == TYPE_CODE_STRUCT
+ || TYPE_CODE (t) == TYPE_CODE_UNION);
+}
+
/* A helper function which returns true if types A and B represent the
"same" class type. This is true if the types have the same main
type, or the same name. */
distance_to_ancestor (A, D, 1) = -1. */
static int
-distance_to_ancestor (struct type *base, struct type *dclass, int public)
+distance_to_ancestor (struct type *base, struct type *dclass, int is_public)
{
int i;
int d;
- CHECK_TYPEDEF (base);
- CHECK_TYPEDEF (dclass);
+ base = check_typedef (base);
+ dclass = check_typedef (dclass);
if (class_types_same_p (base, dclass))
return 0;
for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
{
- if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
+ if (is_public && ! BASETYPE_VIA_PUBLIC (dclass, i))
continue;
- d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
+ d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), is_public);
if (d >= 0)
return 1 + d;
}
{
int i, count = 0;
- CHECK_TYPEDEF (base);
- CHECK_TYPEDEF (dclass);
+ base = check_typedef (base);
+ dclass = check_typedef (dclass);
for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
{
struct value **args, int nargs)
{
int i;
- struct badness_vector *bv;
+ struct badness_vector *bv = XNEW (struct badness_vector);
int min_len = nparms < nargs ? nparms : nargs;
- bv = xmalloc (sizeof (struct badness_vector));
bv->length = nargs + 1; /* add 1 for the length-match rank. */
- bv->rank = xmalloc ((nargs + 1) * sizeof (int));
+ bv->rank = XNEWVEC (struct rank, nargs + 1);
/* First compare the lengths of the supplied lists.
If there is a mismatch, set it to a high value. */
return 0;
}
+\f
+/* Deep comparison of types. */
+
+/* An entry in the type-equality bcache. */
+
+typedef struct type_equality_entry
+{
+ struct type *type1, *type2;
+} type_equality_entry_d;
+DEF_VEC_O (type_equality_entry_d);
+
+/* A helper function to compare two strings. Returns 1 if they are
+ the same, 0 otherwise. Handles NULLs properly. */
+
+static int
+compare_maybe_null_strings (const char *s, const char *t)
+{
+ if (s == NULL && t != NULL)
+ return 0;
+ else if (s != NULL && t == NULL)
+ return 0;
+ else if (s == NULL && t== NULL)
+ return 1;
+ return strcmp (s, t) == 0;
+}
+
+/* A helper function for check_types_worklist that checks two types for
+ "deep" equality. Returns non-zero if the types are considered the
+ same, zero otherwise. */
+
+static int
+check_types_equal (struct type *type1, struct type *type2,
+ VEC (type_equality_entry_d) **worklist)
+{
+ type1 = check_typedef (type1);
+ type2 = check_typedef (type2);
+
+ if (type1 == type2)
+ return 1;
+
+ if (TYPE_CODE (type1) != TYPE_CODE (type2)
+ || TYPE_LENGTH (type1) != TYPE_LENGTH (type2)
+ || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2)
+ || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2)
+ || TYPE_VARARGS (type1) != TYPE_VARARGS (type2)
+ || TYPE_VECTOR (type1) != TYPE_VECTOR (type2)
+ || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
+ || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
+ || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
+ return 0;
+
+ if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1),
+ TYPE_TAG_NAME (type2)))
+ return 0;
+ if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
+ return 0;
+
+ if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
+ {
+ if (memcmp (TYPE_RANGE_DATA (type1), TYPE_RANGE_DATA (type2),
+ sizeof (*TYPE_RANGE_DATA (type1))) != 0)
+ return 0;
+ }
+ else
+ {
+ int i;
+
+ for (i = 0; i < TYPE_NFIELDS (type1); ++i)
+ {
+ const struct field *field1 = &TYPE_FIELD (type1, i);
+ const struct field *field2 = &TYPE_FIELD (type2, i);
+ struct type_equality_entry entry;
+
+ if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2)
+ || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2)
+ || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2))
+ return 0;
+ if (!compare_maybe_null_strings (FIELD_NAME (*field1),
+ FIELD_NAME (*field2)))
+ return 0;
+ switch (FIELD_LOC_KIND (*field1))
+ {
+ case FIELD_LOC_KIND_BITPOS:
+ if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2))
+ return 0;
+ break;
+ case FIELD_LOC_KIND_ENUMVAL:
+ if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2))
+ return 0;
+ break;
+ case FIELD_LOC_KIND_PHYSADDR:
+ if (FIELD_STATIC_PHYSADDR (*field1)
+ != FIELD_STATIC_PHYSADDR (*field2))
+ return 0;
+ break;
+ case FIELD_LOC_KIND_PHYSNAME:
+ if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1),
+ FIELD_STATIC_PHYSNAME (*field2)))
+ return 0;
+ break;
+ case FIELD_LOC_KIND_DWARF_BLOCK:
+ {
+ struct dwarf2_locexpr_baton *block1, *block2;
+
+ block1 = FIELD_DWARF_BLOCK (*field1);
+ block2 = FIELD_DWARF_BLOCK (*field2);
+ if (block1->per_cu != block2->per_cu
+ || block1->size != block2->size
+ || memcmp (block1->data, block2->data, block1->size) != 0)
+ return 0;
+ }
+ break;
+ default:
+ internal_error (__FILE__, __LINE__, _("Unsupported field kind "
+ "%d by check_types_equal"),
+ FIELD_LOC_KIND (*field1));
+ }
+
+ entry.type1 = FIELD_TYPE (*field1);
+ entry.type2 = FIELD_TYPE (*field2);
+ VEC_safe_push (type_equality_entry_d, *worklist, &entry);
+ }
+ }
+
+ if (TYPE_TARGET_TYPE (type1) != NULL)
+ {
+ struct type_equality_entry entry;
+
+ if (TYPE_TARGET_TYPE (type2) == NULL)
+ return 0;
+
+ entry.type1 = TYPE_TARGET_TYPE (type1);
+ entry.type2 = TYPE_TARGET_TYPE (type2);
+ VEC_safe_push (type_equality_entry_d, *worklist, &entry);
+ }
+ else if (TYPE_TARGET_TYPE (type2) != NULL)
+ return 0;
+
+ return 1;
+}
+
+/* Check types on a worklist for equality. Returns zero if any pair
+ is not equal, non-zero if they are all considered equal. */
+
+static int
+check_types_worklist (VEC (type_equality_entry_d) **worklist,
+ struct bcache *cache)
+{
+ while (!VEC_empty (type_equality_entry_d, *worklist))
+ {
+ struct type_equality_entry entry;
+ int added;
+
+ entry = *VEC_last (type_equality_entry_d, *worklist);
+ VEC_pop (type_equality_entry_d, *worklist);
+
+ /* If the type pair has already been visited, we know it is
+ ok. */
+ bcache_full (&entry, sizeof (entry), cache, &added);
+ if (!added)
+ continue;
+
+ if (check_types_equal (entry.type1, entry.type2, worklist) == 0)
+ return 0;
+ }
+
+ return 1;
+}
+
+/* Return non-zero if types TYPE1 and TYPE2 are equal, as determined by a
+ "deep comparison". Otherwise return zero. */
+
+int
+types_deeply_equal (struct type *type1, struct type *type2)
+{
+ struct gdb_exception except = exception_none;
+ int result = 0;
+ struct bcache *cache;
+ VEC (type_equality_entry_d) *worklist = NULL;
+ struct type_equality_entry entry;
+
+ gdb_assert (type1 != NULL && type2 != NULL);
+
+ /* Early exit for the simple case. */
+ if (type1 == type2)
+ return 1;
+
+ cache = bcache_xmalloc (NULL, NULL);
+
+ entry.type1 = type1;
+ entry.type2 = type2;
+ VEC_safe_push (type_equality_entry_d, worklist, &entry);
+
+ /* check_types_worklist calls several nested helper functions, some
+ of which can raise a GDB exception, so we just check and rethrow
+ here. If there is a GDB exception, a comparison is not capable
+ (or trusted), so exit. */
+ TRY
+ {
+ result = check_types_worklist (&worklist, cache);
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ except = ex;
+ }
+ END_CATCH
+
+ bcache_xfree (cache);
+ VEC_free (type_equality_entry_d, worklist);
+
+ /* Rethrow if there was a problem. */
+ if (except.reason < 0)
+ throw_exception (except);
+
+ return result;
+}
+
+/* Allocated status of type TYPE. Return zero if type TYPE is allocated.
+ Otherwise return one. */
+
+int
+type_not_allocated (const struct type *type)
+{
+ struct dynamic_prop *prop = TYPE_ALLOCATED_PROP (type);
+
+ return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
+ && !TYPE_DYN_PROP_ADDR (prop));
+}
+
+/* Associated status of type TYPE. Return zero if type TYPE is associated.
+ Otherwise return one. */
+
+int
+type_not_associated (const struct type *type)
+{
+ struct dynamic_prop *prop = TYPE_ASSOCIATED_PROP (type);
+
+ return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
+ && !TYPE_DYN_PROP_ADDR (prop));
+}
+\f
/* Compare one type (PARM) for compatibility with another (ARG).
* PARM is intended to be the parameter type of a function; and
* ARG is the supplied argument's type. This function tests if
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
+ if (TYPE_DECLARED_CLASS (arg))
+ return INCOMPATIBLE_TYPE_BADNESS;
return INTEGER_PROMOTION_BADNESS;
case TYPE_CODE_FLT:
return INT_FLOAT_CONVERSION_BADNESS;
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
+ if (TYPE_DECLARED_CLASS (parm) || TYPE_DECLARED_CLASS (arg))
+ return INCOMPATIBLE_TYPE_BADNESS;
return INTEGER_CONVERSION_BADNESS;
case TYPE_CODE_FLT:
return INT_FLOAT_CONVERSION_BADNESS;
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
+ if (TYPE_DECLARED_CLASS (arg))
+ return INCOMPATIBLE_TYPE_BADNESS;
return INTEGER_CONVERSION_BADNESS;
case TYPE_CODE_FLT:
return INT_FLOAT_CONVERSION_BADNESS;
}
break;
case TYPE_CODE_STRUCT:
- /* currently same as TYPE_CODE_CLASS. */
switch (TYPE_CODE (arg))
{
case TYPE_CODE_STRUCT:
situation. */
static void
-print_arg_types (struct field *args, int nargs, int spaces)
+print_args (struct field *args, int nargs, int spaces)
{
if (args != NULL)
{
int i;
for (i = 0; i < nargs; i++)
- recursive_dump_type (args[i].type, spaces + 2);
+ {
+ printfi_filtered (spaces, "[%d] name '%s'\n", i,
+ args[i].name != NULL ? args[i].name : "<NULL>");
+ recursive_dump_type (args[i].type, spaces + 2);
+ }
}
}
gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
gdb_stdout);
printf_filtered ("\n");
-
- print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
- TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
- overload_idx)),
- spaces);
+ print_args (TYPE_FN_FIELD_ARGS (f, overload_idx),
+ TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
+ spaces + 8 + 2);
printfi_filtered (spaces + 8, "fcontext ");
gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
gdb_stdout);
static void
print_cplus_stuff (struct type *type, int spaces)
{
+ printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
+ printfi_filtered (spaces, "vptr_basetype ");
+ gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
+ puts_filtered ("\n");
+ if (TYPE_VPTR_BASETYPE (type) != NULL)
+ recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
+
printfi_filtered (spaces, "n_baseclasses %d\n",
TYPE_N_BASECLASSES (type));
printfi_filtered (spaces, "nfn_fields %d\n",
{
struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
- recursive_dump_type (descriptive_type, spaces + 2);
+ if (descriptive_type == NULL)
+ printfi_filtered (spaces + 2, "no descriptive type\n");
+ else
+ {
+ printfi_filtered (spaces + 2, "descriptive type\n");
+ recursive_dump_type (descriptive_type, spaces + 4);
+ }
}
static struct obstack dont_print_type_obstack;
{
puts_filtered (" TYPE_FLAG_RESTRICT");
}
+ if (TYPE_ATOMIC (type))
+ {
+ puts_filtered (" TYPE_FLAG_ATOMIC");
+ }
puts_filtered ("\n");
printfi_filtered (spaces, "flags");
TYPE_HIGH_BOUND_UNDEFINED (type)
? " (undefined)" : "");
}
- printfi_filtered (spaces, "vptr_basetype ");
- gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
- puts_filtered ("\n");
- if (TYPE_VPTR_BASETYPE (type) != NULL)
- {
- recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
- }
- printfi_filtered (spaces, "vptr_fieldno %d\n",
- TYPE_VPTR_FIELDNO (type));
switch (TYPE_SPECIFIC_FIELD (type))
{
TYPE_CALLING_CONVENTION (type));
/* tail_call_list is not printed. */
break;
+
+ case TYPE_SPECIFIC_SELF_TYPE:
+ printfi_filtered (spaces, "self_type ");
+ gdb_print_host_address (TYPE_SELF_TYPE (type), gdb_stdout);
+ puts_filtered ("\n");
+ break;
}
if (spaces == 0)
struct type_pair
{
- struct type *old, *new;
+ struct type *old, *newobj;
};
static hashval_t
type_pair_hash (const void *item)
{
- const struct type_pair *pair = item;
+ const struct type_pair *pair = (const struct type_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;
+ const struct type_pair *lhs = (const struct type_pair *) item_lhs;
+ const struct type_pair *rhs = (const struct type_pair *) item_rhs;
return lhs->old == rhs->old;
}
dummy_obstack_deallocate);
}
+/* Recursively copy (deep copy) a dynamic attribute list of a type. */
+
+static struct dynamic_prop_list *
+copy_dynamic_prop_list (struct obstack *objfile_obstack,
+ struct dynamic_prop_list *list)
+{
+ struct dynamic_prop_list *copy = list;
+ struct dynamic_prop_list **node_ptr = ©
+
+ while (*node_ptr != NULL)
+ {
+ struct dynamic_prop_list *node_copy;
+
+ node_copy = ((struct dynamic_prop_list *)
+ obstack_copy (objfile_obstack, *node_ptr,
+ sizeof (struct dynamic_prop_list)));
+ node_copy->prop = (*node_ptr)->prop;
+ *node_ptr = node_copy;
+
+ node_ptr = &node_copy->next;
+ }
+
+ return copy;
+}
+
/* 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. */
+ OBJFILE. Return a new type owned by the gdbarch associated with the type, 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,
pair.old = type;
slot = htab_find_slot (copied_types, &pair, INSERT);
if (*slot != NULL)
- return ((struct type_pair *) *slot)->new;
+ return ((struct type_pair *) *slot)->newobj;
new_type = alloc_type_arch (get_type_arch (type));
/* We must add the new type to the hash table immediately, in case
we encounter this type again during a recursive call below. */
- stored
- = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
+ stored = XOBNEW (&objfile->objfile_obstack, struct type_pair);
stored->old = type;
- stored->new = new_type;
+ stored->newobj = new_type;
*slot = stored;
/* Copy the common fields of types. For the main type, we simply
int i, nfields;
nfields = TYPE_NFIELDS (type);
- TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
+ TYPE_FIELDS (new_type) = XCNEWVEC (struct field, nfields);
for (i = 0; i < nfields; i++)
{
TYPE_FIELD_ARTIFICIAL (new_type, i) =
/* For range types, copy the bounds information. */
if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
- TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
+ TYPE_RANGE_DATA (new_type) = XNEW (struct range_bounds);
*TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
}
+ if (TYPE_DYN_PROP_LIST (type) != NULL)
+ TYPE_DYN_PROP_LIST (new_type)
+ = copy_dynamic_prop_list (&objfile->objfile_obstack,
+ TYPE_DYN_PROP_LIST (type));
+
+
/* 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_NAMESPACE)
- INIT_CPLUS_SPECIFIC (new_type);
+ switch (TYPE_SPECIFIC_FIELD (type))
+ {
+ case TYPE_SPECIFIC_NONE:
+ break;
+ case TYPE_SPECIFIC_FUNC:
+ INIT_FUNC_SPECIFIC (new_type);
+ TYPE_CALLING_CONVENTION (new_type) = TYPE_CALLING_CONVENTION (type);
+ TYPE_NO_RETURN (new_type) = TYPE_NO_RETURN (type);
+ TYPE_TAIL_CALL_LIST (new_type) = NULL;
+ break;
+ case TYPE_SPECIFIC_FLOATFORMAT:
+ TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
+ break;
+ case TYPE_SPECIFIC_CPLUS_STUFF:
+ INIT_CPLUS_SPECIFIC (new_type);
+ break;
+ case TYPE_SPECIFIC_GNAT_STUFF:
+ INIT_GNAT_SPECIFIC (new_type);
+ break;
+ case TYPE_SPECIFIC_SELF_TYPE:
+ set_type_self_type (new_type,
+ copy_type_recursive (objfile, TYPE_SELF_TYPE (type),
+ copied_types));
+ break;
+ default:
+ gdb_assert_not_reached ("bad type_specific_kind");
+ }
return new_type;
}
TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
sizeof (struct main_type));
+ if (TYPE_DYN_PROP_LIST (type) != NULL)
+ TYPE_DYN_PROP_LIST (new_type)
+ = copy_dynamic_prop_list (&TYPE_OBJFILE (type) -> objfile_obstack,
+ TYPE_DYN_PROP_LIST (type));
return new_type;
}
TYPE_LENGTH (type) = length;
if (name)
- TYPE_NAME (type) = xstrdup (name);
+ TYPE_NAME (type) = gdbarch_obstack_strdup (gdbarch, name);
return type;
}
type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
TYPE_UNSIGNED (type) = 1;
TYPE_NFIELDS (type) = nfields;
- TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
+ TYPE_FIELDS (type)
+ = (struct field *) TYPE_ZALLOC (type, nfields * sizeof (struct field));
return type;
}
struct field *f;
TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
- TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
- sizeof (struct field) * TYPE_NFIELDS (t));
+ TYPE_FIELDS (t) = XRESIZEVEC (struct field, TYPE_FIELDS (t),
+ TYPE_NFIELDS (t));
f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
memset (f, 0, sizeof f[0]);
FIELD_TYPE (f[0]) = field;
const struct builtin_type *
builtin_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, gdbtypes_data);
+ return (const struct builtin_type *) gdbarch_data (gdbarch, gdbtypes_data);
}
static void *
= arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
"<internal function>");
+ /* This type represents an xmethod. */
+ builtin_type->xmethod
+ = arch_type (gdbarch, TYPE_CODE_XMETHOD, 0, "<xmethod>");
+
return builtin_type;
}
{
struct gdbarch *gdbarch;
struct objfile_type *objfile_type
- = objfile_data (objfile, objfile_type_data);
+ = (struct objfile_type *) objfile_data (objfile, objfile_type_data);
if (objfile_type)
return objfile_type;