/* Support routines for manipulating internal types for GDB.
- Copyright (C) 1992-2019 Free Software Foundation, Inc.
+ Copyright (C) 1992-2021 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
#include "hashtab.h"
#include "cp-support.h"
#include "bcache.h"
-#include "dwarf2loc.h"
+#include "dwarf2/loc.h"
#include "gdbcore.h"
#include "floatformat.h"
+#include "f-lang.h"
+#include <algorithm>
+#include "gmp-utils.h"
/* Initialize BADNESS constants. */
const struct rank BOOL_CONVERSION_BADNESS = {3,0};
const struct rank BASE_CONVERSION_BADNESS = {2,0};
const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
+const struct rank REFERENCE_SEE_THROUGH_BADNESS = {0,1};
const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0};
&floatformat_ibm_long_double_big,
&floatformat_ibm_long_double_little
};
+const struct floatformat *floatformats_bfloat16[BFD_ENDIAN_UNKNOWN] = {
+ &floatformat_bfloat16_big,
+ &floatformat_bfloat16_little
+};
/* Should opaque types be resolved? */
-static int opaque_type_resolution = 1;
+static bool opaque_type_resolution = true;
-/* A flag to enable printing of debugging information of C++
- overloading. */
+/* See gdbtypes.h. */
unsigned int overload_debug = 0;
/* A flag to enable strict type checking. */
-static int strict_type_checking = 1;
+static bool strict_type_checking = true;
/* A function to show whether opaque types are resolved. */
struct main_type);
OBJSTAT (objfile, n_types++);
- TYPE_OBJFILE_OWNED (type) = 1;
- TYPE_OWNER (type).objfile = objfile;
+ type->set_owner (objfile);
/* Initialize the fields that might not be zero. */
- TYPE_CODE (type) = TYPE_CODE_UNDEF;
+ type->set_code (TYPE_CODE_UNDEF);
TYPE_CHAIN (type) = type; /* Chain back to itself. */
return 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;
+ type->set_owner (gdbarch);
/* Initialize the fields that might not be zero. */
- TYPE_CODE (type) = TYPE_CODE_UNDEF;
+ type->set_code (TYPE_CODE_UNDEF);
TYPE_CHAIN (type) = type; /* Chain back to itself. */
return type;
struct type *
alloc_type_copy (const struct type *type)
{
- if (TYPE_OBJFILE_OWNED (type))
- return alloc_type (TYPE_OWNER (type).objfile);
+ if (type->is_objfile_owned ())
+ return alloc_type (type->objfile_owner ());
else
- return alloc_type_arch (TYPE_OWNER (type).gdbarch);
+ return alloc_type_arch (type->arch_owner ());
}
-/* If TYPE is gdbarch-associated, return that architecture.
- If TYPE is objfile-associated, return that objfile's architecture. */
+/* See gdbtypes.h. */
-struct gdbarch *
-get_type_arch (const struct type *type)
+gdbarch *
+type::arch () const
{
struct gdbarch *arch;
- if (TYPE_OBJFILE_OWNED (type))
- arch = get_objfile_arch (TYPE_OWNER (type).objfile);
+ if (this->is_objfile_owned ())
+ arch = this->objfile_owner ()->arch ();
else
- arch = TYPE_OWNER (type).gdbarch;
+ arch = this->arch_owner ();
/* The ARCH can be NULL if TYPE is associated with neither an objfile nor
a gdbarch, however, this is very rare, and even then, in most cases
- that get_type_arch is called, we assume that a non-NULL value is
+ that type::arch is called, we assume that a non-NULL value is
returned. */
- gdb_assert (arch != NULL);
+ gdb_assert (arch != nullptr);
return arch;
}
unsigned int
type_length_units (struct type *type)
{
- struct gdbarch *arch = get_type_arch (type);
- int unit_size = gdbarch_addressable_memory_unit_size (arch);
+ int unit_size = gdbarch_addressable_memory_unit_size (type->arch ());
return TYPE_LENGTH (type) / unit_size;
}
/* Allocate the structure. */
- if (! TYPE_OBJFILE_OWNED (oldtype))
- type = GDBARCH_OBSTACK_ZALLOC (get_type_arch (oldtype), struct type);
+ if (!oldtype->is_objfile_owned ())
+ type = GDBARCH_OBSTACK_ZALLOC (oldtype->arch_owner (), struct type);
else
- type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
+ type = OBSTACK_ZALLOC (&oldtype->objfile_owner ()->objfile_obstack,
struct type);
TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
static void
smash_type (struct type *type)
{
- int objfile_owned = TYPE_OBJFILE_OWNED (type);
- union type_owner owner = TYPE_OWNER (type);
+ bool objfile_owned = type->is_objfile_owned ();
+ objfile *objfile = type->objfile_owner ();
+ gdbarch *arch = type->arch_owner ();
memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
/* Restore owner information. */
- TYPE_OBJFILE_OWNED (type) = objfile_owned;
- TYPE_OWNER (type) = owner;
+ if (objfile_owned)
+ type->set_owner (objfile);
+ else
+ type->set_owner (arch);
/* For now, delete the rings. */
TYPE_CHAIN (type) = type;
/* FIXME! Assumes the machine has only one representation for pointers! */
- TYPE_LENGTH (ntype)
- = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
- TYPE_CODE (ntype) = TYPE_CODE_PTR;
+ TYPE_LENGTH (ntype) = gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT;
+ ntype->set_code (TYPE_CODE_PTR);
/* Mark pointers as unsigned. The target converts between pointers
and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
gdbarch_address_to_pointer. */
- TYPE_UNSIGNED (ntype) = 1;
+ ntype->set_is_unsigned (true);
/* Update the length of all the other variants of this type. */
chain = TYPE_CHAIN (ntype);
struct type *
make_reference_type (struct type *type, struct type **typeptr,
- enum type_code refcode)
+ enum type_code refcode)
{
struct type *ntype; /* New type */
struct type **reftype;
gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
ntype = (refcode == TYPE_CODE_REF ? TYPE_REFERENCE_TYPE (type)
- : TYPE_RVALUE_REFERENCE_TYPE (type));
+ : TYPE_RVALUE_REFERENCE_TYPE (type));
if (ntype)
{
TYPE_TARGET_TYPE (ntype) = type;
reftype = (refcode == TYPE_CODE_REF ? &TYPE_REFERENCE_TYPE (type)
- : &TYPE_RVALUE_REFERENCE_TYPE (type));
+ : &TYPE_RVALUE_REFERENCE_TYPE (type));
*reftype = ntype;
references, and that it matches the (only) representation for
pointers! */
- TYPE_LENGTH (ntype) =
- gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
- TYPE_CODE (ntype) = refcode;
+ TYPE_LENGTH (ntype) = gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT;
+ ntype->set_code (refcode);
*reftype = ntype;
TYPE_TARGET_TYPE (ntype) = type;
TYPE_LENGTH (ntype) = 1;
- TYPE_CODE (ntype) = TYPE_CODE_FUNC;
+ ntype->set_code (TYPE_CODE_FUNC);
INIT_FUNC_SPECIFIC (ntype);
if (param_types[nparams - 1] == NULL)
{
--nparams;
- TYPE_VARARGS (fn) = 1;
+ fn->set_has_varargs (true);
}
- else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
+ else if (check_typedef (param_types[nparams - 1])->code ()
== TYPE_CODE_VOID)
{
--nparams;
/* Caller should have ensured this. */
gdb_assert (nparams == 0);
- TYPE_PROTOTYPED (fn) = 1;
+ fn->set_is_prototyped (true);
}
else
- TYPE_PROTOTYPED (fn) = 1;
+ fn->set_is_prototyped (true);
}
- TYPE_NFIELDS (fn) = nparams;
- TYPE_FIELDS (fn)
- = (struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field));
+ fn->set_num_fields (nparams);
+ fn->set_fields
+ ((struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field)));
for (i = 0; i < nparams; ++i)
- TYPE_FIELD_TYPE (fn, i) = param_types[i];
+ fn->field (i).set_type (param_types[i]);
return fn;
}
-/* Identify address space identifier by name --
- return the integer flag defined in gdbtypes.h. */
+/* Identify address space identifier by name -- return a
+ type_instance_flags. */
-int
-address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
+type_instance_flags
+address_space_name_to_type_instance_flags (struct gdbarch *gdbarch,
+ const char *space_identifier)
{
- int type_flags;
+ type_instance_flags type_flags;
/* Check for known address space delimiters. */
if (!strcmp (space_identifier, "code"))
else if (!strcmp (space_identifier, "data"))
return TYPE_INSTANCE_FLAG_DATA_SPACE;
else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
- && gdbarch_address_class_name_to_type_flags (gdbarch,
+ && gdbarch_address_class_name_to_type_flags (gdbarch,
space_identifier,
&type_flags))
return type_flags;
error (_("Unknown address space specifier: \"%s\""), space_identifier);
}
-/* Identify address space identifier by integer flag as defined in
- gdbtypes.h -- return the string version of the adress space name. */
+/* Identify address space identifier by type_instance_flags and return
+ the string version of the adress space name. */
const char *
-address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
+address_space_type_instance_flags_to_name (struct gdbarch *gdbarch,
+ type_instance_flags space_flag)
{
if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
return "code";
else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
return "data";
else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
- && gdbarch_address_class_type_flags_to_name_p (gdbarch))
+ && gdbarch_address_class_type_flags_to_name_p (gdbarch))
return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
else
return NULL;
STORAGE must be in the same obstack as TYPE. */
static struct type *
-make_qualified_type (struct type *type, int new_flags,
+make_qualified_type (struct type *type, type_instance_flags new_flags,
struct type *storage)
{
struct type *ntype;
ntype = type;
do
{
- if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
+ if (ntype->instance_flags () == new_flags)
return ntype;
ntype = TYPE_CHAIN (ntype);
}
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));
+ gdb_assert (type->objfile_owner () == storage->objfile_owner ());
ntype = storage;
TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
TYPE_CHAIN (type) = ntype;
/* Now set the instance flags and return the new type. */
- TYPE_INSTANCE_FLAGS (ntype) = new_flags;
+ ntype->set_instance_flags (new_flags);
/* Set length of new type to that of the original type. */
TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
representations. */
struct type *
-make_type_with_address_space (struct type *type, int space_flag)
+make_type_with_address_space (struct type *type,
+ type_instance_flags space_flag)
{
- int new_flags = ((TYPE_INSTANCE_FLAGS (type)
- & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
- | TYPE_INSTANCE_FLAG_DATA_SPACE
- | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
- | space_flag);
+ type_instance_flags new_flags = ((type->instance_flags ()
+ & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
+ | TYPE_INSTANCE_FLAG_DATA_SPACE
+ | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
+ | space_flag);
return make_qualified_type (type, new_flags, NULL);
}
{
struct type *ntype; /* New type */
- int new_flags = (TYPE_INSTANCE_FLAGS (type)
- & ~(TYPE_INSTANCE_FLAG_CONST
- | TYPE_INSTANCE_FLAG_VOLATILE));
+ type_instance_flags new_flags = (type->instance_flags ()
+ & ~(TYPE_INSTANCE_FLAG_CONST
+ | TYPE_INSTANCE_FLAG_VOLATILE));
if (cnst)
new_flags |= TYPE_INSTANCE_FLAG_CONST;
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));
+ gdb_assert ((*typeptr)->objfile_owner () == type->objfile_owner ());
}
ntype = make_qualified_type (type, new_flags,
make_restrict_type (struct type *type)
{
return make_qualified_type (type,
- (TYPE_INSTANCE_FLAGS (type)
+ (type->instance_flags ()
| TYPE_INSTANCE_FLAG_RESTRICT),
NULL);
}
make_unqualified_type (struct type *type)
{
return make_qualified_type (type,
- (TYPE_INSTANCE_FLAGS (type)
+ (type->instance_flags ()
& ~(TYPE_INSTANCE_FLAG_CONST
| TYPE_INSTANCE_FLAG_VOLATILE
| TYPE_INSTANCE_FLAG_RESTRICT)),
make_atomic_type (struct type *type)
{
return make_qualified_type (type,
- (TYPE_INSTANCE_FLAGS (type)
+ (type->instance_flags ()
| TYPE_INSTANCE_FLAG_ATOMIC),
NULL);
}
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 (type));
+ gdb_assert (ntype->objfile_owner () == type->objfile_owner ());
*TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
/* Assert that the two types have equivalent instance qualifiers.
This should be true for at least all of our debug readers. */
- gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
+ gdb_assert (ntype->instance_flags () == type->instance_flags ());
}
/* Implement direct support for MEMBER_TYPE in GNU C++.
struct type *mtype;
mtype = alloc_type_copy (type);
- TYPE_CODE (mtype) = TYPE_CODE_METHOD;
+ mtype->set_code (TYPE_CODE_METHOD);
TYPE_LENGTH (mtype) = 1;
- TYPE_STUB (mtype) = 1;
+ mtype->set_is_stub (true);
TYPE_TARGET_TYPE (mtype) = type;
/* TYPE_SELF_TYPE (mtype) = unknown yet */
return mtype;
bool
operator== (const dynamic_prop &l, const dynamic_prop &r)
{
- if (l.kind != r.kind)
+ if (l.kind () != r.kind ())
return false;
- switch (l.kind)
+ switch (l.kind ())
{
case PROP_UNDEFINED:
return true;
case PROP_CONST:
- return l.data.const_val == r.data.const_val;
+ return l.const_val () == r.const_val ();
case PROP_ADDR_OFFSET:
case PROP_LOCEXPR:
case PROP_LOCLIST:
- return l.data.baton == r.data.baton;
+ return l.baton () == r.baton ();
+ case PROP_VARIANT_PARTS:
+ return l.variant_parts () == r.variant_parts ();
+ case PROP_TYPE:
+ return l.original_type () == r.original_type ();
}
gdb_assert_not_reached ("unhandled dynamic_prop kind");
return (FIELD_EQ (low)
&& FIELD_EQ (high)
&& FIELD_EQ (flag_upper_bound_is_count)
- && FIELD_EQ (flag_bound_evaluated));
+ && FIELD_EQ (flag_bound_evaluated)
+ && FIELD_EQ (bias));
#undef FIELD_EQ
}
struct type *
create_range_type (struct type *result_type, struct type *index_type,
const struct dynamic_prop *low_bound,
- const struct dynamic_prop *high_bound)
+ const struct dynamic_prop *high_bound,
+ LONGEST bias)
{
+ /* The INDEX_TYPE should be a type capable of holding the upper and lower
+ bounds, as such a zero sized, or void type makes no sense. */
+ gdb_assert (index_type->code () != TYPE_CODE_VOID);
+ gdb_assert (TYPE_LENGTH (index_type) > 0);
+
if (result_type == NULL)
result_type = alloc_type_copy (index_type);
- TYPE_CODE (result_type) = TYPE_CODE_RANGE;
+ result_type->set_code (TYPE_CODE_RANGE);
TYPE_TARGET_TYPE (result_type) = index_type;
- if (TYPE_STUB (index_type))
- TYPE_TARGET_STUB (result_type) = 1;
+ if (index_type->is_stub ())
+ result_type->set_target_is_stub (true);
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_RANGE_DATA (result_type)->low = *low_bound;
- TYPE_RANGE_DATA (result_type)->high = *high_bound;
-
- if (low_bound->kind == PROP_CONST && low_bound->data.const_val >= 0)
- TYPE_UNSIGNED (result_type) = 1;
-
+ range_bounds *bounds
+ = (struct range_bounds *) TYPE_ZALLOC (result_type, sizeof (range_bounds));
+ bounds->low = *low_bound;
+ bounds->high = *high_bound;
+ bounds->bias = bias;
+ bounds->stride.set_const_val (0);
+
+ result_type->set_bounds (bounds);
+
+ if (index_type->code () == TYPE_CODE_FIXED_POINT)
+ result_type->set_is_unsigned (index_type->is_unsigned ());
+ /* Note that the signed-ness of a range type can't simply be copied
+ from the underlying type. Consider a case where the underlying
+ type is 'int', but the range type can hold 0..65535, and where
+ the range is further specified to fit into 16 bits. In this
+ case, if we copy the underlying type's sign, then reading some
+ range values will cause an unwanted sign extension. So, we have
+ some heuristics here instead. */
+ else if (low_bound->kind () == PROP_CONST && low_bound->const_val () >= 0)
+ result_type->set_is_unsigned (true);
/* 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;
+ if (high_bound->kind () == PROP_CONST && high_bound->const_val () < 0)
+ result_type->set_is_unsigned (false);
+
+ result_type->set_endianity_is_not_default
+ (index_type->endianity_is_not_default ());
+
+ return result_type;
+}
+
+/* See gdbtypes.h. */
+
+struct type *
+create_range_type_with_stride (struct type *result_type,
+ struct type *index_type,
+ const struct dynamic_prop *low_bound,
+ const struct dynamic_prop *high_bound,
+ LONGEST bias,
+ const struct dynamic_prop *stride,
+ bool byte_stride_p)
+{
+ result_type = create_range_type (result_type, index_type, low_bound,
+ high_bound, bias);
+
+ gdb_assert (stride != nullptr);
+ result_type->bounds ()->stride = *stride;
+ result_type->bounds ()->flag_is_byte_stride = byte_stride_p;
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.
{
struct dynamic_prop low, high;
- low.kind = PROP_CONST;
- low.data.const_val = low_bound;
+ low.set_const_val (low_bound);
+ high.set_const_val (high_bound);
- high.kind = PROP_CONST;
- high.data.const_val = high_bound;
-
- result_type = create_range_type (result_type, index_type, &low, &high);
+ result_type = create_range_type (result_type, index_type, &low, &high, 0);
return result_type;
}
/* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values
are static, otherwise returns 0. */
-static int
+static bool
has_static_range (const struct range_bounds *bounds)
{
- return (bounds->low.kind == PROP_CONST
- && bounds->high.kind == PROP_CONST);
+ /* If the range doesn't have a defined stride then its stride field will
+ be initialized to the constant 0. */
+ return (bounds->low.kind () == PROP_CONST
+ && bounds->high.kind () == PROP_CONST
+ && bounds->stride.kind () == PROP_CONST);
}
+/* See gdbtypes.h. */
-/* 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)
+gdb::optional<LONGEST>
+get_discrete_low_bound (struct type *type)
{
type = check_typedef (type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
- *lowp = TYPE_LOW_BOUND (type);
- *highp = TYPE_HIGH_BOUND (type);
- return 1;
+ {
+ /* This function only works for ranges with a constant low bound. */
+ if (type->bounds ()->low.kind () != PROP_CONST)
+ return {};
+
+ LONGEST low = type->bounds ()->low.const_val ();
+
+ if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM)
+ {
+ gdb::optional<LONGEST> low_pos
+ = discrete_position (TYPE_TARGET_TYPE (type), low);
+
+ if (low_pos.has_value ())
+ low = *low_pos;
+ }
+
+ return low;
+ }
+
case TYPE_CODE_ENUM:
- if (TYPE_NFIELDS (type) > 0)
- {
- /* The enums may not be sorted by value, so search all
- entries. */
- int i;
+ {
+ if (type->num_fields () > 0)
+ {
+ /* The enums may not be sorted by value, so search all
+ entries. */
+ LONGEST low = TYPE_FIELD_ENUMVAL (type, 0);
- *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
- for (i = 0; i < TYPE_NFIELDS (type); i++)
- {
- if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
- *lowp = TYPE_FIELD_ENUMVAL (type, i);
- if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
- *highp = TYPE_FIELD_ENUMVAL (type, i);
- }
+ for (int i = 0; i < type->num_fields (); i++)
+ {
+ if (TYPE_FIELD_ENUMVAL (type, i) < low)
+ low = TYPE_FIELD_ENUMVAL (type, i);
+ }
+
+ /* Set unsigned indicator if warranted. */
+ if (low >= 0)
+ type->set_is_unsigned (true);
+
+ return low;
+ }
+ else
+ return 0;
+ }
- /* Set unsigned indicator if warranted. */
- if (*lowp >= 0)
- {
- TYPE_UNSIGNED (type) = 1;
- }
- }
- else
- {
- *lowp = 0;
- *highp = -1;
- }
- return 0;
case TYPE_CODE_BOOL:
- *lowp = 0;
- *highp = 1;
return 0;
+
case TYPE_CODE_INT:
if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
- return -1;
- if (!TYPE_UNSIGNED (type))
+ return {};
+
+ if (!type->is_unsigned ())
+ return -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
+
+ /* fall through */
+ case TYPE_CODE_CHAR:
+ return 0;
+
+ default:
+ return {};
+ }
+}
+
+/* See gdbtypes.h. */
+
+gdb::optional<LONGEST>
+get_discrete_high_bound (struct type *type)
+{
+ type = check_typedef (type);
+ switch (type->code ())
+ {
+ case TYPE_CODE_RANGE:
+ {
+ /* This function only works for ranges with a constant high bound. */
+ if (type->bounds ()->high.kind () != PROP_CONST)
+ return {};
+
+ LONGEST high = type->bounds ()->high.const_val ();
+
+ if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM)
+ {
+ gdb::optional<LONGEST> high_pos
+ = discrete_position (TYPE_TARGET_TYPE (type), high);
+
+ if (high_pos.has_value ())
+ high = *high_pos;
+ }
+
+ return high;
+ }
+
+ case TYPE_CODE_ENUM:
+ {
+ if (type->num_fields () > 0)
+ {
+ /* The enums may not be sorted by value, so search all
+ entries. */
+ LONGEST high = TYPE_FIELD_ENUMVAL (type, 0);
+
+ for (int i = 0; i < type->num_fields (); i++)
+ {
+ if (TYPE_FIELD_ENUMVAL (type, i) > high)
+ high = TYPE_FIELD_ENUMVAL (type, i);
+ }
+
+ return high;
+ }
+ else
+ return -1;
+ }
+
+ case TYPE_CODE_BOOL:
+ return 1;
+
+ case TYPE_CODE_INT:
+ if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
+ return {};
+
+ if (!type->is_unsigned ())
{
- *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
- *highp = -*lowp - 1;
- return 0;
+ LONGEST low = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
+ return -low - 1;
}
+
/* fall through */
case TYPE_CODE_CHAR:
- *lowp = 0;
- /* This round-about calculation is to avoid shifting by
- TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
- if TYPE_LENGTH (type) == sizeof (LONGEST). */
- *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
- *highp = (*highp - 1) | *highp;
- return 0;
+ {
+ /* This round-about calculation is to avoid shifting by
+ TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
+ if TYPE_LENGTH (type) == sizeof (LONGEST). */
+ LONGEST high = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
+ return (high - 1) | high;
+ }
+
default:
- return -1;
+ return {};
}
}
-/* Assuming TYPE is a simple, non-empty array type, compute its upper
- and lower bound. Save the low bound into LOW_BOUND if not NULL.
- Save the high bound into HIGH_BOUND if not NULL.
+/* See gdbtypes.h. */
- Return 1 if the operation was successful. Return zero otherwise,
- in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
+bool
+get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
+{
+ gdb::optional<LONGEST> low = get_discrete_low_bound (type);
+ if (!low.has_value ())
+ return false;
- We now simply use get_discrete_bounds call to get the values
- of the low and high bounds.
- get_discrete_bounds can return three values:
- 1, meaning that index is a range,
- 0, meaning that index is a discrete type,
- or -1 for failure. */
+ gdb::optional<LONGEST> high = get_discrete_high_bound (type);
+ if (!high.has_value ())
+ return false;
-int
+ *lowp = *low;
+ *highp = *high;
+
+ return true;
+}
+
+/* See gdbtypes.h */
+
+bool
get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
{
- struct type *index = TYPE_INDEX_TYPE (type);
+ struct type *index = type->index_type ();
LONGEST low = 0;
LONGEST high = 0;
- int res;
if (index == NULL)
- return 0;
-
- res = get_discrete_bounds (index, &low, &high);
- if (res == -1)
- return 0;
+ return false;
- /* Check if the array bounds are undefined. */
- if (res == 1
- && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
- || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
- return 0;
+ if (!get_discrete_bounds (index, &low, &high))
+ return false;
if (low_bound)
*low_bound = low;
if (high_bound)
*high_bound = high;
- return 1;
+ return true;
}
/* Assuming that TYPE is a discrete type and VAL is a valid integer
in which case the value of POS is unmodified.
*/
-int
-discrete_position (struct type *type, LONGEST val, LONGEST *pos)
+gdb::optional<LONGEST>
+discrete_position (struct type *type, LONGEST val)
{
- if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+ if (type->code () == TYPE_CODE_RANGE)
+ type = TYPE_TARGET_TYPE (type);
+
+ if (type->code () == 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;
- }
- }
+ for (i = 0; i < type->num_fields (); i += 1)
+ {
+ if (val == TYPE_FIELD_ENUMVAL (type, i))
+ return i;
+ }
+
/* Invalid enumeration value. */
- return 0;
+ return {};
}
else
+ return val;
+}
+
+/* If the array TYPE has static bounds calculate and update its
+ size, then return true. Otherwise return false and leave TYPE
+ unchanged. */
+
+static bool
+update_static_array_size (struct type *type)
+{
+ gdb_assert (type->code () == TYPE_CODE_ARRAY);
+
+ struct type *range_type = type->index_type ();
+
+ if (type->dyn_prop (DYN_PROP_BYTE_STRIDE) == nullptr
+ && has_static_range (range_type->bounds ())
+ && (!type_not_associated (type)
+ && !type_not_allocated (type)))
{
- *pos = val;
- return 1;
+ LONGEST low_bound, high_bound;
+ int stride;
+ struct type *element_type;
+
+ /* If the array itself doesn't provide a stride value then take
+ whatever stride the range provides. Don't update BIT_STRIDE as
+ we don't want to place the stride value from the range into this
+ arrays bit size field. */
+ stride = TYPE_FIELD_BITSIZE (type, 0);
+ if (stride == 0)
+ stride = range_type->bit_stride ();
+
+ if (!get_discrete_bounds (range_type, &low_bound, &high_bound))
+ low_bound = high_bound = 0;
+
+ element_type = check_typedef (TYPE_TARGET_TYPE (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 (type) = 0;
+ else if (stride != 0)
+ {
+ /* Ensure that the type length is always positive, even in the
+ case where (for example in Fortran) we have a negative
+ stride. It is possible to have a single element array with a
+ negative stride in Fortran (this doesn't mean anything
+ special, it's still just a single element array) so do
+ consider that case when touching this code. */
+ LONGEST element_count = std::abs (high_bound - low_bound + 1);
+ TYPE_LENGTH (type)
+ = ((std::abs (stride) * element_count) + 7) / 8;
+ }
+ else
+ TYPE_LENGTH (type) =
+ TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
+
+ /* If this array's element is itself an array with a bit stride,
+ then we want to update this array's bit stride to reflect the
+ size of the sub-array. Otherwise, we'll end up using the
+ wrong size when trying to find elements of the outer
+ array. */
+ if (element_type->code () == TYPE_CODE_ARRAY
+ && TYPE_LENGTH (element_type) != 0
+ && TYPE_FIELD_BITSIZE (element_type, 0) != 0
+ && get_array_bounds (element_type, &low_bound, &high_bound)
+ && high_bound >= low_bound)
+ TYPE_FIELD_BITSIZE (type, 0)
+ = ((high_bound - low_bound + 1)
+ * TYPE_FIELD_BITSIZE (element_type, 0));
+
+ return true;
}
+
+ return false;
}
/* Create an array type using either a blank type supplied in
unsigned int bit_stride)
{
if (byte_stride_prop != NULL
- && byte_stride_prop->kind == PROP_CONST)
+ && byte_stride_prop->kind () == PROP_CONST)
{
/* The byte stride is actually not dynamic. Pretend we were
called with bit_stride set instead of byte_stride_prop.
This will give us the same result type, while avoiding
the need to handle this as a special case. */
- bit_stride = byte_stride_prop->data.const_val * 8;
+ bit_stride = byte_stride_prop->const_val () * 8;
byte_stride_prop = NULL;
}
if (result_type == NULL)
result_type = alloc_type_copy (range_type);
- TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
+ result_type->set_code (TYPE_CODE_ARRAY);
TYPE_TARGET_TYPE (result_type) = element_type;
- if (byte_stride_prop == NULL
- && 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
+ result_type->set_num_fields (1);
+ result_type->set_fields
+ ((struct field *) TYPE_ZALLOC (result_type, sizeof (struct field)));
+ result_type->set_index_type (range_type);
+ if (byte_stride_prop != NULL)
+ result_type->add_dyn_prop (DYN_PROP_BYTE_STRIDE, *byte_stride_prop);
+ else if (bit_stride > 0)
+ TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
+
+ if (!update_static_array_size (result_type))
{
/* 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. */
+ 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;
- if (byte_stride_prop != NULL)
- add_dyn_prop (DYN_PROP_BYTE_STRIDE, *byte_stride_prop, result_type);
- else if (bit_stride > 0)
- TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
-
/* TYPE_TARGET_STUB will take care of zero length arrays. */
if (TYPE_LENGTH (result_type) == 0)
- TYPE_TARGET_STUB (result_type) = 1;
+ result_type->set_target_is_stub (true);
return result_type;
}
struct type *index_type;
struct type *range_type;
- if (TYPE_OBJFILE_OWNED (element_type))
- index_type = objfile_type (TYPE_OWNER (element_type).objfile)->builtin_int;
+ if (element_type->is_objfile_owned ())
+ index_type = objfile_type (element_type->objfile_owner ())->builtin_int;
else
- index_type = builtin_type (get_type_arch (element_type))->builtin_int;
+ index_type = builtin_type (element_type->arch_owner ())->builtin_int;
+
range_type = create_static_range_type (NULL, index_type,
low_bound, high_bound);
result_type = create_array_type (result_type,
string_char_type,
range_type);
- TYPE_CODE (result_type) = TYPE_CODE_STRING;
+ result_type->set_code (TYPE_CODE_STRING);
return result_type;
}
result_type = lookup_array_range_type (string_char_type,
low_bound, high_bound);
- TYPE_CODE (result_type) = TYPE_CODE_STRING;
+ result_type->set_code (TYPE_CODE_STRING);
return result_type;
}
if (result_type == NULL)
result_type = alloc_type_copy (domain_type);
- TYPE_CODE (result_type) = TYPE_CODE_SET;
- TYPE_NFIELDS (result_type) = 1;
- TYPE_FIELDS (result_type)
- = (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
+ result_type->set_code (TYPE_CODE_SET);
+ result_type->set_num_fields (1);
+ result_type->set_fields
+ ((struct field *) TYPE_ZALLOC (result_type, sizeof (struct field)));
- if (!TYPE_STUB (domain_type))
+ if (!domain_type->is_stub ())
{
LONGEST low_bound, high_bound, bit_length;
- if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
+ if (!get_discrete_bounds (domain_type, &low_bound, &high_bound))
low_bound = high_bound = 0;
+
bit_length = high_bound - low_bound + 1;
TYPE_LENGTH (result_type)
= (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
if (low_bound >= 0)
- TYPE_UNSIGNED (result_type) = 1;
+ result_type->set_is_unsigned (true);
}
- TYPE_FIELD_TYPE (result_type, 0) = domain_type;
+ result_type->field (0).set_type (domain_type);
return result_type;
}
make_vector_type (struct type *array_type)
{
struct type *inner_array, *elt_type;
- int flags;
/* Find the innermost array type, in case the array is
multi-dimensional. */
inner_array = array_type;
- while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
+ while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
inner_array = TYPE_TARGET_TYPE (inner_array);
elt_type = TYPE_TARGET_TYPE (inner_array);
- if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
+ if (elt_type->code () == TYPE_CODE_INT)
{
- flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
+ type_instance_flags flags
+ = elt_type->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT;
elt_type = make_qualified_type (elt_type, flags, NULL);
TYPE_TARGET_TYPE (inner_array) = elt_type;
}
- TYPE_VECTOR (array_type) = 1;
+ array_type->set_is_vector (true);
}
struct type *
struct type *
internal_type_self_type (struct type *type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_METHODPTR:
case TYPE_CODE_MEMBERPTR:
void
set_type_self_type (struct type *type, struct type *self_type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_METHODPTR:
case TYPE_CODE_MEMBERPTR:
struct type *to_type)
{
smash_type (type);
- TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
+ type->set_code (TYPE_CODE_MEMBERPTR);
TYPE_TARGET_TYPE (type) = to_type;
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_LENGTH (type) = gdbarch_ptr_bit (to_type->arch ()) / TARGET_CHAR_BIT;
}
/* 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->set_code (TYPE_CODE_METHODPTR);
TYPE_TARGET_TYPE (type) = to_type;
set_type_self_type (type, TYPE_SELF_TYPE (to_type));
TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
int nargs, int varargs)
{
smash_type (type);
- TYPE_CODE (type) = TYPE_CODE_METHOD;
+ type->set_code (TYPE_CODE_METHOD);
TYPE_TARGET_TYPE (type) = to_type;
set_type_self_type (type, self_type);
- TYPE_FIELDS (type) = args;
- TYPE_NFIELDS (type) = nargs;
+ type->set_fields (args);
+ type->set_num_fields (nargs);
if (varargs)
- TYPE_VARARGS (type) = 1;
+ type->set_has_varargs (true);
TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
}
type = check_typedef (type);
- name = TYPE_NAME (type);
+ name = type->name ();
if (name != NULL)
return name;
- name = TYPE_NAME (saved_type);
- objfile = TYPE_OBJFILE (saved_type);
+ name = saved_type->name ();
+ objfile = saved_type->objfile_owner ();
error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
name ? name : "<anonymous>",
objfile ? objfile_name (objfile) : "<arch>");
struct type *
lookup_typename (const struct language_defn *language,
- struct gdbarch *gdbarch, const char *name,
+ const char *name,
const struct block *block, int noerr)
{
struct symbol *sym;
struct type *
lookup_unsigned_typename (const struct language_defn *language,
- struct gdbarch *gdbarch, const char *name)
+ const char *name)
{
char *uns = (char *) alloca (strlen (name) + 10);
strcpy (uns, "unsigned ");
strcpy (uns + 9, name);
- return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
+ return lookup_typename (language, uns, NULL, 0);
}
struct type *
-lookup_signed_typename (const struct language_defn *language,
- struct gdbarch *gdbarch, const char *name)
+lookup_signed_typename (const struct language_defn *language, const char *name)
{
struct type *t;
char *uns = (char *) alloca (strlen (name) + 8);
strcpy (uns, "signed ");
strcpy (uns + 7, name);
- t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
+ t = lookup_typename (language, uns, NULL, 1);
/* If we don't find "signed FOO" just try again with plain "FOO". */
if (t != NULL)
return t;
- return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
+ return lookup_typename (language, name, NULL, 0);
}
/* Lookup a structure type named "struct NAME",
{
error (_("No struct type named %s."), name);
}
- if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
+ if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT)
{
error (_("This context has class, union or enum %s, not a struct."),
name);
t = SYMBOL_TYPE (sym);
- if (TYPE_CODE (t) == TYPE_CODE_UNION)
+ if (t->code () == TYPE_CODE_UNION)
return t;
/* If we get here, it's not a union. */
{
error (_("No enum type named %s."), name);
}
- if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
+ if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_ENUM)
{
error (_("This context has class, struct or union %s, not an enum."),
name);
visible in lexical block BLOCK. */
struct type *
-lookup_template_type (char *name, struct type *type,
+lookup_template_type (const char *name, struct type *type,
const struct block *block)
{
struct symbol *sym;
char *nam = (char *)
- alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
+ alloca (strlen (name) + strlen (type->name ()) + 4);
strcpy (nam, name);
strcat (nam, "<");
- strcat (nam, TYPE_NAME (type));
+ strcat (nam, type->name ());
strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
sym = lookup_symbol (nam, block, VAR_DOMAIN, 0).symbol;
{
error (_("No template type named %s."), name);
}
- if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
+ if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT)
{
error (_("This context has class, union or enum %s, not a struct."),
name);
return (SYMBOL_TYPE (sym));
}
-/* Given a type TYPE, lookup the type of the component of type named
- NAME.
-
- TYPE can be either a struct or union, or a pointer or reference to
- a struct or union. If it is a pointer or reference, its target
- type is automatically used. Thus '.' and '->' are interchangable,
- as specified for the definitions of the expression element types
- STRUCTOP_STRUCT and STRUCTOP_PTR.
-
- If NOERR is nonzero, return zero if NAME is not suitably defined.
- If NAME is the name of a baseclass type, return that type. */
+/* See gdbtypes.h. */
-struct type *
-lookup_struct_elt_type (struct type *type, const char *name, int noerr)
+struct_elt
+lookup_struct_elt (struct type *type, const char *name, int noerr)
{
int i;
for (;;)
{
type = check_typedef (type);
- if (TYPE_CODE (type) != TYPE_CODE_PTR
- && TYPE_CODE (type) != TYPE_CODE_REF)
+ if (type->code () != TYPE_CODE_PTR
+ && type->code () != TYPE_CODE_REF)
break;
type = TYPE_TARGET_TYPE (type);
}
- if (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_UNION)
+ if (type->code () != TYPE_CODE_STRUCT
+ && type->code () != TYPE_CODE_UNION)
{
std::string type_name = type_to_string (type);
error (_("Type %s is not a structure or union type."),
type_name.c_str ());
}
-#if 0
- /* FIXME: This change put in by Michael seems incorrect for the case
- where the structure tag name is the same as the member name.
- I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
- foo; } bell;" Disabled by fnf. */
- {
- char *type_name;
-
- type_name = TYPE_NAME (type);
- if (type_name != NULL && strcmp (type_name, name) == 0)
- return type;
- }
-#endif
-
- for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
+ for (i = type->num_fields () - 1; i >= TYPE_N_BASECLASSES (type); i--)
{
const char *t_field_name = TYPE_FIELD_NAME (type, i);
if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
- return TYPE_FIELD_TYPE (type, i);
+ return {&type->field (i), TYPE_FIELD_BITPOS (type, i)};
}
else if (!t_field_name || *t_field_name == '\0')
{
- struct type *subtype
- = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
-
- if (subtype != NULL)
- return subtype;
+ struct_elt elt
+ = lookup_struct_elt (type->field (i).type (), name, 1);
+ if (elt.field != NULL)
+ {
+ elt.offset += TYPE_FIELD_BITPOS (type, i);
+ return elt;
+ }
}
}
/* OK, it's not in this class. Recursively check the baseclasses. */
for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
{
- struct type *t;
-
- t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
- if (t != NULL)
- {
- return t;
- }
+ struct_elt elt = lookup_struct_elt (TYPE_BASECLASS (type, i), name, 1);
+ if (elt.field != NULL)
+ return elt;
}
if (noerr)
- {
- return NULL;
- }
+ return {nullptr, 0};
std::string type_name = type_to_string (type);
error (_("Type %s has no component named %s."), type_name.c_str (), name);
}
+/* See gdbtypes.h. */
+
+struct type *
+lookup_struct_elt_type (struct type *type, const char *name, int noerr)
+{
+ struct_elt elt = lookup_struct_elt (type, name, noerr);
+ if (elt.field != NULL)
+ return elt.field->type ();
+ else
+ return NULL;
+}
+
/* Store in *MAX the largest number representable by unsigned integer type
TYPE. */
unsigned int n;
type = check_typedef (type);
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_UNSIGNED (type));
+ gdb_assert (type->code () == TYPE_CODE_INT && type->is_unsigned ());
gdb_assert (TYPE_LENGTH (type) <= sizeof (ULONGEST));
/* Written this way to avoid overflow. */
unsigned int n;
type = check_typedef (type);
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && !TYPE_UNSIGNED (type));
+ gdb_assert (type->code () == TYPE_CODE_INT && !type->is_unsigned ());
gdb_assert (TYPE_LENGTH (type) <= sizeof (LONGEST));
n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
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);
+ gdb_assert (type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION);
if (!HAVE_CPLUS_STRUCT (type))
return -1;
return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno;
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);
+ gdb_assert (type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION);
if (!HAVE_CPLUS_STRUCT (type))
ALLOCATE_CPLUS_STRUCT_TYPE (type);
TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno = fieldno;
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->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION);
gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF);
return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype;
}
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);
+ gdb_assert (type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION);
if (!HAVE_CPLUS_STRUCT (type))
ALLOCATE_CPLUS_STRUCT_TYPE (type);
TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype = basetype;
int i;
/* We must start at zero in case the first (and only) baseclass
- is virtual (and hence we cannot share the table pointer). */
+ is virtual (and hence we cannot share the table pointer). */
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
{
/* If the type comes from a different objfile we can't cache
it, it may have a different lifetime. PR 2384 */
- if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
+ if (type->objfile_owner () == basetype->objfile_owner ())
{
set_type_vptr_fieldno (type, fieldno);
set_type_vptr_basetype (type, basetype);
static int
array_type_has_dynamic_stride (struct type *type)
{
- struct dynamic_prop *prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
+ struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE);
- return (prop != NULL && prop->kind != PROP_CONST);
+ return (prop != NULL && prop->kind () != PROP_CONST);
}
/* Worker for is_dynamic_type. */
type = check_typedef (type);
/* We only want to recognize references at the outermost level. */
- if (top_level && TYPE_CODE (type) == TYPE_CODE_REF)
+ if (top_level && type->code () == TYPE_CODE_REF)
type = check_typedef (TYPE_TARGET_TYPE (type));
/* Types that have a dynamic TYPE_DATA_LOCATION are considered
if (TYPE_ALLOCATED_PROP (type))
return 1;
- switch (TYPE_CODE (type))
+ struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
+ if (prop != nullptr && prop->kind () != PROP_TYPE)
+ return 1;
+
+ if (TYPE_HAS_DYNAMIC_LENGTH (type))
+ return 1;
+
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
{
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))
+ return (!has_static_range (type->bounds ())
|| is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0));
}
+ case TYPE_CODE_STRING:
+ /* Strings are very much like an array of characters, and can be
+ treated as one here. */
case TYPE_CODE_ARRAY:
{
- gdb_assert (TYPE_NFIELDS (type) == 1);
+ gdb_assert (type->num_fields () == 1);
/* The array is dynamic if either the bounds are dynamic... */
- if (is_dynamic_type_internal (TYPE_INDEX_TYPE (type), 0))
+ if (is_dynamic_type_internal (type->index_type (), 0))
return 1;
/* ... or the elements it contains have a dynamic contents... */
if (is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0))
{
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))
+ bool is_cplus = HAVE_CPLUS_STRUCT (type);
+
+ for (i = 0; i < type->num_fields (); ++i)
+ {
+ /* Static fields can be ignored here. */
+ if (field_is_static (&type->field (i)))
+ continue;
+ /* If the field has dynamic type, then so does TYPE. */
+ if (is_dynamic_type_internal (type->field (i).type (), 0))
+ return 1;
+ /* If the field is at a fixed offset, then it is not
+ dynamic. */
+ if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_DWARF_BLOCK)
+ continue;
+ /* Do not consider C++ virtual base types to be dynamic
+ due to the field's offset being dynamic; these are
+ handled via other means. */
+ if (is_cplus && BASETYPE_VIA_VIRTUAL (type, i))
+ continue;
return 1;
+ }
}
break;
}
/* Given a dynamic range type (dyn_range_type) and a stack of
struct property_addr_info elements, return a static version
- of that type. */
+ of that type.
+
+ When RESOLVE_P is true then the returned static range is created by
+ actually evaluating any dynamic properties within the range type, while
+ when RESOLVE_P is false the returned static range has all of the bounds
+ and stride information set to undefined. The RESOLVE_P set to false
+ case will be used when evaluating a dynamic array that is not
+ allocated, or not associated, i.e. the bounds information might not be
+ initialized yet. */
static struct type *
resolve_dynamic_range (struct type *dyn_range_type,
- struct property_addr_info *addr_stack)
+ struct property_addr_info *addr_stack,
+ bool resolve_p = true)
{
CORE_ADDR value;
struct type *static_range_type, *static_target_type;
- const struct dynamic_prop *prop;
- struct dynamic_prop low_bound, high_bound;
+ struct dynamic_prop low_bound, high_bound, stride;
- gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE);
+ gdb_assert (dyn_range_type->code () == 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;
- }
+ const struct dynamic_prop *prop = &dyn_range_type->bounds ()->low;
+ if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ low_bound.set_const_val (value);
else
- {
- low_bound.kind = PROP_UNDEFINED;
- low_bound.data.const_val = 0;
- }
+ low_bound.set_undefined ();
- prop = &TYPE_RANGE_DATA (dyn_range_type)->high;
- if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ prop = &dyn_range_type->bounds ()->high;
+ if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
- high_bound.kind = PROP_CONST;
- high_bound.data.const_val = value;
+ high_bound.set_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;
+ if (dyn_range_type->bounds ()->flag_upper_bound_is_count)
+ high_bound.set_const_val
+ (low_bound.const_val () + high_bound.const_val () - 1);
+ }
+ else
+ high_bound.set_undefined ();
+
+ bool byte_stride_p = dyn_range_type->bounds ()->flag_is_byte_stride;
+ prop = &dyn_range_type->bounds ()->stride;
+ if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ {
+ stride.set_const_val (value);
+
+ /* If we have a bit stride that is not an exact number of bytes then
+ I really don't think this is going to work with current GDB, the
+ array indexing code in GDB seems to be pretty heavily tied to byte
+ offsets right now. Assuming 8 bits in a byte. */
+ struct gdbarch *gdbarch = dyn_range_type->arch ();
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
+ if (!byte_stride_p && (value % (unit_size * 8)) != 0)
+ error (_("bit strides that are not a multiple of the byte size "
+ "are currently not supported"));
}
else
{
- high_bound.kind = PROP_UNDEFINED;
- high_bound.data.const_val = 0;
+ stride.set_undefined ();
+ byte_stride_p = true;
}
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;
+ LONGEST bias = dyn_range_type->bounds ()->bias;
+ static_range_type = create_range_type_with_stride
+ (copy_type (dyn_range_type), static_target_type,
+ &low_bound, &high_bound, bias, &stride, byte_stride_p);
+ static_range_type->bounds ()->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. */
+/* Resolves dynamic bound values of an array or string type TYPE to static
+ ones. ADDR_STACK is a stack of struct property_addr_info to be used if
+ needed during the dynamic resolution.
+
+ When RESOLVE_P is true then the dynamic properties of TYPE are
+ evaluated, otherwise the dynamic properties of TYPE are not evaluated,
+ instead we assume the array is not allocated/associated yet. */
static struct type *
-resolve_dynamic_array (struct type *type,
- struct property_addr_info *addr_stack)
+resolve_dynamic_array_or_string (struct type *type,
+ struct property_addr_info *addr_stack,
+ bool resolve_p = true)
{
CORE_ADDR value;
struct type *elt_type;
struct dynamic_prop *prop;
unsigned int bit_stride = 0;
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY);
+ /* For dynamic type resolution strings can be treated like arrays of
+ characters. */
+ gdb_assert (type->code () == TYPE_CODE_ARRAY
+ || type->code () == TYPE_CODE_STRING);
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. */
+ /* Resolve the allocated and associated properties before doing anything
+ else. If an array is not allocated or not associated then (at least
+ for Fortran) there is no guarantee that the data to define the upper
+ bound, lower bound, or stride will be correct. If RESOLVE_P is
+ already false at this point then this is not the first dimension of
+ the array and a more outer dimension has already marked this array as
+ not allocated/associated, as such we just ignore this property. This
+ is fine as GDB only checks the allocated/associated on the outer most
+ dimension of the array. */
prop = TYPE_ALLOCATED_PROP (type);
- if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ if (prop != NULL && resolve_p
+ && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
- TYPE_DYN_PROP_ADDR (prop) = value;
- TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
+ prop->set_const_val (value);
+ if (value == 0)
+ resolve_p = false;
}
+
prop = TYPE_ASSOCIATED_PROP (type);
- if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ if (prop != NULL && resolve_p
+ && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
- TYPE_DYN_PROP_ADDR (prop) = value;
- TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
+ prop->set_const_val (value);
+ if (value == 0)
+ resolve_p = false;
}
- ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type));
+ range_type = check_typedef (type->index_type ());
+ range_type = resolve_dynamic_range (range_type, addr_stack, resolve_p);
- if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY)
- elt_type = resolve_dynamic_array (ary_dim, addr_stack);
+ ary_dim = check_typedef (TYPE_TARGET_TYPE (type));
+ if (ary_dim != NULL && ary_dim->code () == TYPE_CODE_ARRAY)
+ elt_type = resolve_dynamic_array_or_string (ary_dim, addr_stack, resolve_p);
else
elt_type = TYPE_TARGET_TYPE (type);
- prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
- if (prop != NULL)
+ prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE);
+ if (prop != NULL && resolve_p)
{
- int prop_eval_ok
- = dwarf2_evaluate_property (prop, NULL, addr_stack, &value);
-
- if (prop_eval_ok)
+ if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
- remove_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
+ type->remove_dyn_prop (DYN_PROP_BYTE_STRIDE);
bit_stride = (unsigned int) (value * 8);
}
else
if the DWARF info is not correct. Issue a warning,
and assume no byte/bit stride (leave bit_stride = 0). */
warning (_("cannot determine array stride for type %s"),
- TYPE_NAME (type) ? TYPE_NAME (type) : "<no name>");
+ type->name () ? type->name () : "<no name>");
}
}
else
bit_stride = TYPE_FIELD_BITSIZE (type, 0);
return create_array_type_with_stride (type, elt_type, range_type, NULL,
- bit_stride);
+ bit_stride);
}
/* Resolve dynamic bounds of members of the union TYPE to static
int i;
unsigned int max_len = 0;
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
+ gdb_assert (type->code () == 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)
+ resolved_type->set_fields
+ ((struct field *)
+ TYPE_ALLOC (resolved_type,
+ resolved_type->num_fields () * sizeof (struct field)));
+ memcpy (resolved_type->fields (),
+ type->fields (),
+ resolved_type->num_fields () * sizeof (struct field));
+ for (i = 0; i < resolved_type->num_fields (); ++i)
{
struct type *t;
- if (field_is_static (&TYPE_FIELD (type, i)))
+ if (field_is_static (&type->field (i)))
continue;
- t = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i),
+ t = resolve_dynamic_type_internal (resolved_type->field (i).type (),
addr_stack, 0);
- TYPE_FIELD_TYPE (resolved_type, i) = t;
- if (TYPE_LENGTH (t) > max_len)
- max_len = TYPE_LENGTH (t);
+ resolved_type->field (i).set_type (t);
+
+ struct type *real_type = check_typedef (t);
+ if (TYPE_LENGTH (real_type) > max_len)
+ max_len = TYPE_LENGTH (real_type);
}
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. */
+/* See gdbtypes.h. */
-static struct type *
-resolve_dynamic_struct (struct type *type,
- struct property_addr_info *addr_stack)
+bool
+variant::matches (ULONGEST value, bool is_unsigned) const
{
- struct type *resolved_type;
- int i;
- unsigned resolved_type_bit_length = 0;
+ for (const discriminant_range &range : discriminants)
+ if (range.contains (value, is_unsigned))
+ return true;
+ return false;
+}
+
+static void
+compute_variant_fields_inner (struct type *type,
+ struct property_addr_info *addr_stack,
+ const variant_part &part,
+ std::vector<bool> &flags);
+
+/* A helper function to determine which variant fields will be active.
+ This handles both the variant's direct fields, and any variant
+ parts embedded in this variant. TYPE is the type we're examining.
+ ADDR_STACK holds information about the concrete object. VARIANT is
+ the current variant to be handled. FLAGS is where the results are
+ stored -- this function sets the Nth element in FLAGS if the
+ corresponding field is enabled. ENABLED is whether this variant is
+ enabled or not. */
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
- gdb_assert (TYPE_NFIELDS (type) > 0);
+static void
+compute_variant_fields_recurse (struct type *type,
+ struct property_addr_info *addr_stack,
+ const variant &variant,
+ std::vector<bool> &flags,
+ bool enabled)
+{
+ for (int field = variant.first_field; field < variant.last_field; ++field)
+ flags[field] = enabled;
- 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)
+ for (const variant_part &new_part : variant.parts)
+ {
+ if (enabled)
+ compute_variant_fields_inner (type, addr_stack, new_part, flags);
+ else
+ {
+ for (const auto &sub_variant : new_part.variants)
+ compute_variant_fields_recurse (type, addr_stack, sub_variant,
+ flags, enabled);
+ }
+ }
+}
+
+/* A helper function to determine which variant fields will be active.
+ This evaluates the discriminant, decides which variant (if any) is
+ active, and then updates FLAGS to reflect which fields should be
+ available. TYPE is the type we're examining. ADDR_STACK holds
+ information about the concrete object. VARIANT is the current
+ variant to be handled. FLAGS is where the results are stored --
+ this function sets the Nth element in FLAGS if the corresponding
+ field is enabled. */
+
+static void
+compute_variant_fields_inner (struct type *type,
+ struct property_addr_info *addr_stack,
+ const variant_part &part,
+ std::vector<bool> &flags)
+{
+ /* Evaluate the discriminant. */
+ gdb::optional<ULONGEST> discr_value;
+ if (part.discriminant_index != -1)
+ {
+ int idx = part.discriminant_index;
+
+ if (TYPE_FIELD_LOC_KIND (type, idx) != FIELD_LOC_KIND_BITPOS)
+ error (_("Cannot determine struct field location"
+ " (invalid location kind)"));
+
+ if (addr_stack->valaddr.data () != NULL)
+ discr_value = unpack_field_as_long (type, addr_stack->valaddr.data (),
+ idx);
+ else
+ {
+ CORE_ADDR addr = (addr_stack->addr
+ + (TYPE_FIELD_BITPOS (type, idx)
+ / TARGET_CHAR_BIT));
+
+ LONGEST bitsize = TYPE_FIELD_BITSIZE (type, idx);
+ LONGEST size = bitsize / 8;
+ if (size == 0)
+ size = TYPE_LENGTH (type->field (idx).type ());
+
+ gdb_byte bits[sizeof (ULONGEST)];
+ read_memory (addr, bits, size);
+
+ LONGEST bitpos = (TYPE_FIELD_BITPOS (type, idx)
+ % TARGET_CHAR_BIT);
+
+ discr_value = unpack_bits_as_long (type->field (idx).type (),
+ bits, bitpos, bitsize);
+ }
+ }
+
+ /* Go through each variant and see which applies. */
+ const variant *default_variant = nullptr;
+ const variant *applied_variant = nullptr;
+ for (const auto &variant : part.variants)
+ {
+ if (variant.is_default ())
+ default_variant = &variant;
+ else if (discr_value.has_value ()
+ && variant.matches (*discr_value, part.is_unsigned))
+ {
+ applied_variant = &variant;
+ break;
+ }
+ }
+ if (applied_variant == nullptr)
+ applied_variant = default_variant;
+
+ for (const auto &variant : part.variants)
+ compute_variant_fields_recurse (type, addr_stack, variant,
+ flags, applied_variant == &variant);
+}
+
+/* Determine which variant fields are available in TYPE. The enabled
+ fields are stored in RESOLVED_TYPE. ADDR_STACK holds information
+ about the concrete object. PARTS describes the top-level variant
+ parts for this type. */
+
+static void
+compute_variant_fields (struct type *type,
+ struct type *resolved_type,
+ struct property_addr_info *addr_stack,
+ const gdb::array_view<variant_part> &parts)
+{
+ /* Assume all fields are included by default. */
+ std::vector<bool> flags (resolved_type->num_fields (), true);
+
+ /* Now disable fields based on the variants that control them. */
+ for (const auto &part : parts)
+ compute_variant_fields_inner (type, addr_stack, part, flags);
+
+ resolved_type->set_num_fields
+ (std::count (flags.begin (), flags.end (), true));
+ resolved_type->set_fields
+ ((struct field *)
+ TYPE_ALLOC (resolved_type,
+ resolved_type->num_fields () * sizeof (struct field)));
+
+ int out = 0;
+ for (int i = 0; i < type->num_fields (); ++i)
+ {
+ if (!flags[i])
+ continue;
+
+ resolved_type->field (out) = type->field (i);
+ ++out;
+ }
+}
+
+/* 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_CODE_STRUCT);
+
+ resolved_type = copy_type (type);
+
+ dynamic_prop *variant_prop = resolved_type->dyn_prop (DYN_PROP_VARIANT_PARTS);
+ if (variant_prop != nullptr && variant_prop->kind () == PROP_VARIANT_PARTS)
+ {
+ compute_variant_fields (type, resolved_type, addr_stack,
+ *variant_prop->variant_parts ());
+ /* We want to leave the property attached, so that the Rust code
+ can tell whether the type was originally an enum. */
+ variant_prop->set_original_type (type);
+ }
+ else
+ {
+ resolved_type->set_fields
+ ((struct field *)
+ TYPE_ALLOC (resolved_type,
+ resolved_type->num_fields () * sizeof (struct field)));
+ if (type->num_fields () > 0)
+ memcpy (resolved_type->fields (),
+ type->fields (),
+ resolved_type->num_fields () * sizeof (struct field));
+ }
+
+ for (i = 0; i < resolved_type->num_fields (); ++i)
{
unsigned new_bit_length;
struct property_addr_info pinfo;
- if (field_is_static (&TYPE_FIELD (type, i)))
+ if (field_is_static (&resolved_type->field (i)))
continue;
+ if (TYPE_FIELD_LOC_KIND (resolved_type, i) == FIELD_LOC_KIND_DWARF_BLOCK)
+ {
+ struct dwarf2_property_baton baton;
+ baton.property_type
+ = lookup_pointer_type (resolved_type->field (i).type ());
+ baton.locexpr = *TYPE_FIELD_DWARF_BLOCK (resolved_type, i);
+
+ struct dynamic_prop prop;
+ prop.set_locexpr (&baton);
+
+ CORE_ADDR addr;
+ if (dwarf2_evaluate_property (&prop, nullptr, addr_stack, &addr,
+ true))
+ SET_FIELD_BITPOS (resolved_type->field (i),
+ TARGET_CHAR_BIT * (addr - addr_stack->addr));
+ }
+
/* 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
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)
+ if (TYPE_FIELD_LOC_KIND (resolved_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.type = check_typedef (resolved_type->field (i).type ());
pinfo.valaddr = addr_stack->valaddr;
pinfo.addr
= (addr_stack->addr
+ (TYPE_FIELD_BITPOS (resolved_type, i) / TARGET_CHAR_BIT));
pinfo.next = addr_stack;
- TYPE_FIELD_TYPE (resolved_type, i)
- = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i),
- &pinfo, 0);
+ resolved_type->field (i).set_type
+ (resolve_dynamic_type_internal (resolved_type->field (i).type (),
+ &pinfo, 0));
gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type, i)
== FIELD_LOC_KIND_BITPOS);
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);
+ {
+ struct type *real_type
+ = check_typedef (resolved_type->field (i).type ());
+
+ new_bit_length += (TYPE_LENGTH (real_type) * 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
int top_level)
{
struct type *real_type = check_typedef (type);
- struct type *resolved_type = type;
+ struct type *resolved_type = nullptr;
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)
+ gdb::optional<CORE_ADDR> type_length;
+ prop = TYPE_DYNAMIC_LENGTH (type);
+ if (prop != NULL
+ && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ type_length = value;
+
+ if (type->code () == TYPE_CODE_TYPEDEF)
{
resolved_type = copy_type (type);
TYPE_TARGET_TYPE (resolved_type)
/* Before trying to resolve TYPE, make sure it is not a stub. */
type = real_type;
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
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);
+ pinfo.valaddr = {};
+ if (addr_stack->valaddr.data () != NULL)
+ pinfo.addr = extract_typed_address (addr_stack->valaddr.data (),
+ type);
else
pinfo.addr = read_memory_typed_address (addr_stack->addr, type);
pinfo.next = addr_stack;
break;
}
+ case TYPE_CODE_STRING:
+ /* Strings are very much like an array of characters, and can be
+ treated as one here. */
case TYPE_CODE_ARRAY:
- resolved_type = resolve_dynamic_array (type, addr_stack);
+ resolved_type = resolve_dynamic_array_or_string (type, addr_stack);
break;
case TYPE_CODE_RANGE:
}
}
+ if (resolved_type == nullptr)
+ return type;
+
+ if (type_length.has_value ())
+ {
+ TYPE_LENGTH (resolved_type) = *type_length;
+ resolved_type->remove_dyn_prop (DYN_PROP_BYTE_SIZE);
+ }
+
/* 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;
+ /* Start of Fortran hack. See comment in f-lang.h for what is going
+ on here.*/
+ if (current_language->la_language == language_fortran
+ && resolved_type->code () == TYPE_CODE_ARRAY)
+ value = fortran_adjust_dynamic_array_base_address_hack (resolved_type,
+ value);
+ /* End of Fortran hack. */
+ prop->set_const_val (value);
}
return resolved_type;
/* See gdbtypes.h */
struct type *
-resolve_dynamic_type (struct type *type, const gdb_byte *valaddr,
+resolve_dynamic_type (struct type *type,
+ gdb::array_view<const gdb_byte> valaddr,
CORE_ADDR addr)
{
struct property_addr_info pinfo
/* See gdbtypes.h */
-struct dynamic_prop *
-get_dyn_prop (enum dynamic_prop_node_kind prop_kind, const struct type *type)
+dynamic_prop *
+type::dyn_prop (dynamic_prop_node_kind prop_kind) const
{
- struct dynamic_prop_list *node = TYPE_DYN_PROP_LIST (type);
+ dynamic_prop_list *node = this->main_type->dyn_prop_list;
while (node != NULL)
{
if (node->prop_kind == prop_kind)
- return &node->prop;
+ 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)
+type::add_dyn_prop (dynamic_prop_node_kind prop_kind, dynamic_prop prop)
{
struct dynamic_prop_list *temp;
- gdb_assert (TYPE_OBJFILE_OWNED (type));
+ gdb_assert (this->is_objfile_owned ());
- temp = XOBNEW (&TYPE_OBJFILE (type)->objfile_obstack,
+ temp = XOBNEW (&this->objfile_owner ()->objfile_obstack,
struct dynamic_prop_list);
temp->prop_kind = prop_kind;
temp->prop = prop;
- temp->next = TYPE_DYN_PROP_LIST (type);
+ temp->next = this->main_type->dyn_prop_list;
- TYPE_DYN_PROP_LIST (type) = temp;
+ this->main_type->dyn_prop_list = temp;
}
-/* Remove dynamic property from TYPE in case it exists. */
+/* See gdbtypes.h. */
void
-remove_dyn_prop (enum dynamic_prop_node_kind prop_kind,
- struct type *type)
+type::remove_dyn_prop (dynamic_prop_node_kind kind)
{
struct dynamic_prop_list *prev_node, *curr_node;
- curr_node = TYPE_DYN_PROP_LIST (type);
+ curr_node = this->main_type->dyn_prop_list;
prev_node = NULL;
while (NULL != curr_node)
{
- if (curr_node->prop_kind == prop_kind)
+ if (curr_node->prop_kind == kind)
{
/* Update the linked list but don't free anything.
The property was allocated on objstack and it is not known
if we are on top of it. Nevertheless, everything is released
when the complete objstack is freed. */
if (NULL == prev_node)
- TYPE_DYN_PROP_LIST (type) = curr_node->next;
+ this->main_type->dyn_prop_list = curr_node->next;
else
prev_node->next = curr_node->next;
check_typedef (struct type *type)
{
struct type *orig_type = type;
- /* While we're removing typedefs, we don't want to lose qualifiers.
- E.g., const/volatile. */
- int instance_flags = TYPE_INSTANCE_FLAGS (type);
gdb_assert (type);
- while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ /* While we're removing typedefs, we don't want to lose qualifiers.
+ E.g., const/volatile. */
+ type_instance_flags instance_flags = type->instance_flags ();
+
+ while (type->code () == TYPE_CODE_TYPEDEF)
{
if (!TYPE_TARGET_TYPE (type))
{
if (currently_reading_symtab)
return make_qualified_type (type, instance_flags, NULL);
- name = TYPE_NAME (type);
+ name = type->name ();
/* FIXME: shouldn't we look in STRUCT_DOMAIN and/or
VAR_DOMAIN as appropriate? */
if (name == NULL)
if (sym)
TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
else /* TYPE_CODE_UNDEF */
- TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
+ TYPE_TARGET_TYPE (type) = alloc_type_arch (type->arch ());
}
type = TYPE_TARGET_TYPE (type);
outer cast in a chain of casting win), instead of assuming
"it can't happen". */
{
- const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
- | TYPE_INSTANCE_FLAG_DATA_SPACE);
- const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
- int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
+ const type_instance_flags ALL_SPACES
+ = (TYPE_INSTANCE_FLAG_CODE_SPACE
+ | TYPE_INSTANCE_FLAG_DATA_SPACE);
+ const type_instance_flags ALL_CLASSES
+ = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
+
+ type_instance_flags new_instance_flags = type->instance_flags ();
/* Treat code vs data spaces and address classes separately. */
if ((instance_flags & ALL_SPACES) != 0)
&& opaque_type_resolution
&& !currently_reading_symtab)
{
- const char *name = TYPE_NAME (type);
+ const char *name = type->name ();
struct type *newtype;
if (name == NULL)
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))
- type = make_qualified_type (newtype,
- TYPE_INSTANCE_FLAGS (type),
- type);
+ if (newtype->objfile_owner () == type->objfile_owner ())
+ type = make_qualified_type (newtype, type->instance_flags (), type);
else
type = newtype;
}
}
/* Otherwise, rely on the stub flag being set for opaque/stubbed
types. */
- else if (TYPE_STUB (type) && !currently_reading_symtab)
+ else if (type->is_stub () && !currently_reading_symtab)
{
- const char *name = TYPE_NAME (type);
+ const char *name = type->name ();
/* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN
- as appropriate? */
+ as appropriate? */
struct symbol *sym;
if (name == NULL)
}
sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
if (sym)
- {
- /* Same as above for opaque types, we can replace the stub
- with the complete type only if they are in the same
- objfile. */
- if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
- type = make_qualified_type (SYMBOL_TYPE (sym),
- TYPE_INSTANCE_FLAGS (type),
- type);
+ {
+ /* Same as above for opaque types, we can replace the stub
+ with the complete type only if they are in the same
+ objfile. */
+ if (SYMBOL_TYPE (sym)->objfile_owner () == type->objfile_owner ())
+ type = make_qualified_type (SYMBOL_TYPE (sym),
+ type->instance_flags (), type);
else
type = SYMBOL_TYPE (sym);
- }
+ }
}
- if (TYPE_TARGET_STUB (type))
+ if (type->target_is_stub ())
{
struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
- if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
+ if (target_type->is_stub () || target_type->target_is_stub ())
{
/* Nothing we can do. */
}
- else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
+ else if (type->code () == TYPE_CODE_RANGE)
{
TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
- TYPE_TARGET_STUB (type) = 0;
+ type->set_target_is_stub (false);
}
+ else if (type->code () == TYPE_CODE_ARRAY
+ && update_static_array_size (type))
+ type->set_target_is_stub (false);
}
type = make_qualified_type (type, instance_flags, NULL);
occurs, silently return a void type. */
static struct type *
-safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
+safe_parse_type (struct gdbarch *gdbarch, const char *p, int length)
{
struct ui_file *saved_gdb_stderr;
struct type *type = NULL; /* Initialize to keep gcc happy. */
gdb_stderr = &null_stream;
/* Call parse_and_eval_type() without fear of longjmp()s. */
- TRY
+ try
{
type = parse_and_eval_type (p, length);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
type = builtin_type (gdbarch)->builtin_void;
}
- END_CATCH
/* Stop suppressing error messages. */
gdb_stderr = saved_gdb_stderr;
static void
check_stub_method (struct type *type, int method_id, int signature_id)
{
- struct gdbarch *gdbarch = get_type_arch (type);
+ struct gdbarch *gdbarch = type->arch ();
struct fn_field *f;
char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
char *demangled_name = gdb_demangle (mangled_name,
argcount = 0;
else
{
- argtypes[0].type = lookup_pointer_type (type);
+ argtypes[0].set_type (lookup_pointer_type (type));
argcount = 1;
}
if (depth <= 0 && (*p == ',' || *p == ')'))
{
/* Avoid parsing of ellipsis, they will be handled below.
- Also avoid ``void'' as above. */
+ Also avoid ``void'' as above. */
if (strncmp (argtypetext, "...", p - argtypetext) != 0
&& strncmp (argtypetext, "void", p - argtypetext) != 0)
{
- argtypes[argcount].type =
- safe_parse_type (gdbarch, argtypetext, p - argtypetext);
+ argtypes[argcount].set_type
+ (safe_parse_type (gdbarch, argtypetext, p - argtypetext));
argcount += 1;
}
argtypetext = p + 1;
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;
+ mtype->set_is_stub (false);
TYPE_FN_FIELD_STUB (f, signature_id) = 0;
xfree (demangled_name);
}
}
-/* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
+/* Ensure it is in .rodata (if available) by working around GCC PR 44690. */
const struct cplus_struct_type cplus_struct_default = { };
void
static void
set_type_code (struct type *type, enum type_code code)
{
- TYPE_CODE (type) = code;
+ type->set_code (code);
switch (code)
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
case TYPE_CODE_NAMESPACE:
- INIT_CPLUS_SPECIFIC (type);
- break;
+ INIT_CPLUS_SPECIFIC (type);
+ break;
case TYPE_CODE_FLT:
- TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
- break;
+ TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
+ break;
case TYPE_CODE_FUNC:
INIT_FUNC_SPECIFIC (type);
break;
+ case TYPE_CODE_FIXED_POINT:
+ INIT_FIXED_POINT_SPECIFIC (type);
+ break;
}
}
const struct floatformat *
floatformat_from_type (const struct type *type)
{
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
+ gdb_assert (type->code () == TYPE_CODE_FLT);
gdb_assert (TYPE_FLOATFORMAT (type));
return TYPE_FLOATFORMAT (type);
}
set_type_code (type, code);
gdb_assert ((bit % TARGET_CHAR_BIT) == 0);
TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT;
- TYPE_NAME (type) = name;
+ type->set_name (name);
return type;
}
t = init_type (objfile, TYPE_CODE_INT, bit, name);
if (unsigned_p)
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
+
+ TYPE_SPECIFIC_FIELD (t) = TYPE_SPECIFIC_INT;
+ TYPE_MAIN_TYPE (t)->type_specific.int_stuff.bit_size = bit;
+ TYPE_MAIN_TYPE (t)->type_specific.int_stuff.bit_offset = 0;
return t;
}
t = init_type (objfile, TYPE_CODE_CHAR, bit, name);
if (unsigned_p)
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
return t;
}
t = init_type (objfile, TYPE_CODE_BOOL, bit, name);
if (unsigned_p)
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
+
+ TYPE_SPECIFIC_FIELD (t) = TYPE_SPECIFIC_INT;
+ TYPE_MAIN_TYPE (t)->type_specific.int_stuff.bit_size = bit;
+ TYPE_MAIN_TYPE (t)->type_specific.int_stuff.bit_offset = 0;
return t;
}
/* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
BIT is the type size in bits; if BIT equals -1, the size is
determined by the floatformat. NAME is the type name. Set the
- TYPE_FLOATFORMAT from FLOATFORMATS. */
+ TYPE_FLOATFORMAT from FLOATFORMATS. BYTE_ORDER is the byte order
+ to use. If it is BFD_ENDIAN_UNKNOWN (the default), then the byte
+ order of the objfile's architecture is used. */
struct type *
init_float_type (struct objfile *objfile,
int bit, const char *name,
- const struct floatformat **floatformats)
+ const struct floatformat **floatformats,
+ enum bfd_endian byte_order)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
- const struct floatformat *fmt = floatformats[gdbarch_byte_order (gdbarch)];
+ if (byte_order == BFD_ENDIAN_UNKNOWN)
+ {
+ struct gdbarch *gdbarch = objfile->arch ();
+ byte_order = gdbarch_byte_order (gdbarch);
+ }
+ const struct floatformat *fmt = floatformats[byte_order];
struct type *t;
bit = verify_floatformat (bit, fmt);
return t;
}
-/* Allocate a TYPE_CODE_COMPLEX type structure associated with OBJFILE.
- NAME is the type name. TARGET_TYPE is the component float type. */
+/* Return true if init_complex_type can be called with TARGET_TYPE. */
+
+bool
+can_create_complex_type (struct type *target_type)
+{
+ return (target_type->code () == TYPE_CODE_INT
+ || target_type->code () == TYPE_CODE_FLT);
+}
+
+/* Allocate a TYPE_CODE_COMPLEX type structure. NAME is the type
+ name. TARGET_TYPE is the component type. */
struct type *
-init_complex_type (struct objfile *objfile,
- const char *name, struct type *target_type)
+init_complex_type (const char *name, struct type *target_type)
{
struct type *t;
- t = init_type (objfile, TYPE_CODE_COMPLEX,
- 2 * TYPE_LENGTH (target_type) * TARGET_CHAR_BIT, name);
- TYPE_TARGET_TYPE (t) = target_type;
- return t;
+ gdb_assert (can_create_complex_type (target_type));
+
+ if (TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type == nullptr)
+ {
+ if (name == nullptr && target_type->name () != nullptr)
+ {
+ char *new_name
+ = (char *) TYPE_ALLOC (target_type,
+ strlen (target_type->name ())
+ + strlen ("_Complex ") + 1);
+ strcpy (new_name, "_Complex ");
+ strcat (new_name, target_type->name ());
+ name = new_name;
+ }
+
+ t = alloc_type_copy (target_type);
+ set_type_code (t, TYPE_CODE_COMPLEX);
+ TYPE_LENGTH (t) = 2 * TYPE_LENGTH (target_type);
+ t->set_name (name);
+
+ TYPE_TARGET_TYPE (t) = target_type;
+ TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type = t;
+ }
+
+ return TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type;
}
/* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
t = init_type (objfile, TYPE_CODE_PTR, bit, name);
TYPE_TARGET_TYPE (t) = target_type;
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
+ return t;
+}
+
+/* Allocate a TYPE_CODE_FIXED_POINT type structure associated with OBJFILE.
+ BIT is the pointer type size in bits.
+ UNSIGNED_P should be nonzero if the type is unsigned.
+ NAME is the type name. */
+
+struct type *
+init_fixed_point_type (struct objfile *objfile,
+ int bit, int unsigned_p, const char *name)
+{
+ struct type *t;
+
+ t = init_type (objfile, TYPE_CODE_FIXED_POINT, bit, name);
+ if (unsigned_p)
+ t->set_is_unsigned (true);
+
return t;
}
return raw_align;
/* Allow the architecture to provide an alignment. */
- struct gdbarch *arch = get_type_arch (type);
- ULONGEST align = gdbarch_type_align (arch, type);
+ ULONGEST align = gdbarch_type_align (type->arch (), type);
if (align != 0)
return align;
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_FUNC:
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
{
- if (TYPE_NFIELDS (type) == 0)
+ int number_of_non_static_fields = 0;
+ for (unsigned i = 0; i < type->num_fields (); ++i)
{
- /* An empty struct has alignment 1. */
- align = 1;
- break;
- }
- for (unsigned i = 0; i < TYPE_NFIELDS (type); ++i)
- {
- if (!field_is_static (&TYPE_FIELD (type, i)))
+ if (!field_is_static (&type->field (i)))
{
- ULONGEST f_align = type_align (TYPE_FIELD_TYPE (type, i));
+ number_of_non_static_fields++;
+ ULONGEST f_align = type_align (type->field (i).type ());
if (f_align == 0)
{
/* Don't pretend we know something we don't. */
align = f_align;
}
}
+ /* A struct with no fields, or with only static fields has an
+ alignment of 1. */
+ if (number_of_non_static_fields == 0)
+ align = 1;
}
break;
t = check_typedef (t);
return
(t != NULL
- && TYPE_CODE (t) == TYPE_CODE_PTR
- && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
+ && t->code () == TYPE_CODE_PTR
+ && TYPE_TARGET_TYPE (t)->code () != TYPE_CODE_VOID);
}
int
t = check_typedef (t);
return
((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)));
+ && !is_fixed_point_type (t)
+ && ((t->code () == TYPE_CODE_INT)
+ || (t->code () == TYPE_CODE_ENUM)
+ || (t->code () == TYPE_CODE_FLAGS)
+ || (t->code () == TYPE_CODE_CHAR)
+ || (t->code () == TYPE_CODE_RANGE)
+ || (t->code () == TYPE_CODE_BOOL)));
}
int
t = check_typedef (t);
return
((t != NULL)
- && ((TYPE_CODE (t) == TYPE_CODE_FLT)
- || (TYPE_CODE (t) == TYPE_CODE_DECFLOAT)));
+ && ((t->code () == TYPE_CODE_FLT)
+ || (t->code () == TYPE_CODE_DECFLOAT)));
}
/* Return true if TYPE is scalar. */
{
type = check_typedef (type);
- switch (TYPE_CODE (type))
+ if (is_fixed_point_type (type))
+ return 0; /* Implemented as a scalar, but more like a floating point. */
+
+ switch (type->code ())
{
case TYPE_CODE_ARRAY:
case TYPE_CODE_STRUCT:
if (is_scalar_type (t))
return 1;
/* Are we dealing with an array or string of known dimensions? */
- else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
- || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
- && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
+ else if ((t->code () == TYPE_CODE_ARRAY
+ || t->code () == TYPE_CODE_STRING) && t->num_fields () == 1
+ && t->index_type ()->code () == TYPE_CODE_RANGE)
{
LONGEST low_bound, high_bound;
struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
- get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
-
- return high_bound == low_bound && is_scalar_type_recursive (elt_type);
+ if (get_discrete_bounds (t->index_type (), &low_bound, &high_bound))
+ return (high_bound == low_bound
+ && is_scalar_type_recursive (elt_type));
+ else
+ return 0;
}
/* Are we dealing with a struct with one element? */
- else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
- return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
- else if (TYPE_CODE (t) == TYPE_CODE_UNION)
+ else if (t->code () == TYPE_CODE_STRUCT && t->num_fields () == 1)
+ return is_scalar_type_recursive (t->field (0).type ());
+ else if (t->code () == TYPE_CODE_UNION)
{
- int i, n = TYPE_NFIELDS (t);
+ int i, n = t->num_fields ();
/* If all elements of the union are scalar, then the union is scalar. */
for (i = 0; i < n; i++)
- if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
+ if (!is_scalar_type_recursive (t->field (i).type ()))
return 0;
return 1;
int
class_or_union_p (const struct type *t)
{
- return (TYPE_CODE (t) == TYPE_CODE_STRUCT
- || TYPE_CODE (t) == TYPE_CODE_UNION);
+ return (t->code () == TYPE_CODE_STRUCT
+ || t->code () == TYPE_CODE_UNION);
}
/* A helper function which returns true if types A and B represent the
class_types_same_p (const struct type *a, const struct type *b)
{
return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
- || (TYPE_NAME (a) && TYPE_NAME (b)
- && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
+ || (a->name () && b->name ()
+ && !strcmp (a->name (), b->name ())));
}
/* If BASE is an ancestor of DCLASS return the distance between them.
value_address (val), val) == 1;
}
+/* See gdbtypes.h. */
+
+enum bfd_endian
+type_byte_order (const struct type *type)
+{
+ bfd_endian byteorder = gdbarch_byte_order (type->arch ());
+ if (type->endianity_is_not_default ())
+ {
+ if (byteorder == BFD_ENDIAN_BIG)
+ return BFD_ENDIAN_LITTLE;
+ else
+ {
+ gdb_assert (byteorder == BFD_ENDIAN_LITTLE);
+ return BFD_ENDIAN_BIG;
+ }
+ }
+
+ return byteorder;
+}
+
\f
/* Overload resolution. */
return true;
/* Resolve typedefs */
- if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
+ if (a->code () == TYPE_CODE_TYPEDEF)
a = check_typedef (a);
- if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
+ if (b->code () == TYPE_CODE_TYPEDEF)
b = check_typedef (b);
+ /* Check if identical after resolving typedefs. */
+ if (a == b)
+ return true;
+
/* If after resolving typedefs a and b are not of the same type
code then they are not equal. */
- if (TYPE_CODE (a) != TYPE_CODE (b))
+ if (a->code () != b->code ())
return false;
/* If a and b are both pointers types or both reference types then
they are equal of the same type iff the objects they refer to are
of the same type. */
- if (TYPE_CODE (a) == TYPE_CODE_PTR
- || TYPE_CODE (a) == TYPE_CODE_REF)
+ if (a->code () == TYPE_CODE_PTR
+ || a->code () == TYPE_CODE_REF)
return types_equal (TYPE_TARGET_TYPE (a),
- TYPE_TARGET_TYPE (b));
+ TYPE_TARGET_TYPE (b));
/* Well, damnit, if the names are exactly the same, I'll say they
are exactly the same. This happens when we generate method
stubs. The types won't point to the same address, but they
really are the same. */
- if (TYPE_NAME (a) && TYPE_NAME (b)
- && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
- return true;
-
- /* Check if identical after resolving typedefs. */
- if (a == b)
+ if (a->name () && b->name ()
+ && strcmp (a->name (), b->name ()) == 0)
return true;
/* Two function types are equal if their argument and return types
are equal. */
- if (TYPE_CODE (a) == TYPE_CODE_FUNC)
+ if (a->code () == TYPE_CODE_FUNC)
{
int i;
- if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b))
+ if (a->num_fields () != b->num_fields ())
return false;
if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b)))
return false;
- for (i = 0; i < TYPE_NFIELDS (a); ++i)
- if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i)))
+ for (i = 0; i < a->num_fields (); ++i)
+ if (!types_equal (a->field (i).type (), b->field (i).type ()))
return false;
return true;
if (type1 == type2)
return true;
- if (TYPE_CODE (type1) != TYPE_CODE (type2)
+ if (type1->code () != type2->code ()
|| 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)
+ || type1->is_unsigned () != type2->is_unsigned ()
+ || type1->has_no_signedness () != type2->has_no_signedness ()
+ || type1->endianity_is_not_default () != type2->endianity_is_not_default ()
+ || type1->has_varargs () != type2->has_varargs ()
+ || type1->is_vector () != type2->is_vector ()
|| TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
- || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
- || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
+ || type1->instance_flags () != type2->instance_flags ()
+ || type1->num_fields () != type2->num_fields ())
return false;
- if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
+ if (!compare_maybe_null_strings (type1->name (), type2->name ()))
return false;
- if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
+ if (!compare_maybe_null_strings (type1->name (), type2->name ()))
return false;
- if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
+ if (type1->code () == TYPE_CODE_RANGE)
{
- if (*TYPE_RANGE_DATA (type1) != *TYPE_RANGE_DATA (type2))
+ if (*type1->bounds () != *type2->bounds ())
return false;
}
else
{
int i;
- for (i = 0; i < TYPE_NFIELDS (type1); ++i)
+ for (i = 0; i < type1->num_fields (); ++i)
{
- const struct field *field1 = &TYPE_FIELD (type1, i);
- const struct field *field2 = &TYPE_FIELD (type2, i);
+ const struct field *field1 = &type1->field (i);
+ const struct field *field2 = &type2->field (i);
if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2)
|| FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2)
case FIELD_LOC_KIND_ENUMVAL:
if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2))
return false;
- break;
+ /* Don't compare types of enum fields, because they don't
+ have a type. */
+ continue;
case FIELD_LOC_KIND_PHYSADDR:
if (FIELD_STATIC_PHYSADDR (*field1)
!= FIELD_STATIC_PHYSADDR (*field2))
FIELD_LOC_KIND (*field1));
}
- worklist->emplace_back (FIELD_TYPE (*field1), FIELD_TYPE (*field2));
+ worklist->emplace_back (field1->type (), field2->type ());
}
}
static bool
check_types_worklist (std::vector<type_equality_entry> *worklist,
- struct bcache *cache)
+ gdb::bcache *cache)
{
while (!worklist->empty ())
{
- int added;
+ bool added;
struct type_equality_entry entry = std::move (worklist->back ());
worklist->pop_back ();
if (type1 == type2)
return true;
- struct bcache cache (nullptr, nullptr);
+ gdb::bcache cache;
worklist.emplace_back (type1, type2);
return check_types_worklist (&worklist, &cache);
}
{
struct dynamic_prop *prop = TYPE_ALLOCATED_PROP (type);
- return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
- && !TYPE_DYN_PROP_ADDR (prop));
+ return (prop != nullptr && prop->kind () == PROP_CONST
+ && prop->const_val () == 0);
}
/* Associated status of type TYPE. Return zero if type TYPE is associated.
{
struct dynamic_prop *prop = TYPE_ASSOCIATED_PROP (type);
- return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
- && !TYPE_DYN_PROP_ADDR (prop));
+ return (prop != nullptr && prop->kind () == PROP_CONST
+ && prop->const_val () == 0);
}
/* rank_one_type helper for when PARM's type code is TYPE_CODE_PTR. */
{
struct rank rank = {0,0};
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_PTR:
/* Allowed pointer conversions are:
(a) pointer to void-pointer conversion. */
- if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
+ if (TYPE_TARGET_TYPE (parm)->code () == TYPE_CODE_VOID)
return VOID_PTR_CONVERSION_BADNESS;
/* (b) pointer to ancestor-pointer conversion. */
case TYPE_CODE_FUNC:
return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
case TYPE_CODE_INT:
- if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT)
+ if (value != NULL && value_type (value)->code () == TYPE_CODE_INT)
{
if (value_as_long (value) == 0)
{
static struct rank
rank_one_type_parm_array (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_ARRAY:
}
}
-/* 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
- * the latter can be converted to the former.
- * VALUE is the argument's value or NULL if none (or called recursively)
- *
- * Return 0 if they are identical types;
- * Otherwise, return an integer which corresponds to how compatible
- * PARM is to ARG. The higher the return value, the worse the match.
- * Generally the "bad" conversions are all uniformly assigned a 100. */
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_FUNC. */
-struct rank
-rank_one_type (struct type *parm, struct type *arg, struct value *value)
+static struct rank
+rank_one_type_parm_func (struct type *parm, struct type *arg, struct value *value)
{
- struct rank rank = {0,0};
-
- /* Resolve typedefs */
- if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
- parm = check_typedef (parm);
- if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
- arg = check_typedef (arg);
-
- if (TYPE_IS_REFERENCE (parm) && value != NULL)
- {
- if (VALUE_LVAL (value) == not_lval)
- {
- /* Rvalues should preferably bind to rvalue references or const
- lvalue references. */
- if (TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF)
- rank.subrank = REFERENCE_CONVERSION_RVALUE;
- else if (TYPE_CONST (TYPE_TARGET_TYPE (parm)))
- rank.subrank = REFERENCE_CONVERSION_CONST_LVALUE;
- else
- return INCOMPATIBLE_TYPE_BADNESS;
- return sum_ranks (rank, REFERENCE_CONVERSION_BADNESS);
- }
- else
- {
- /* Lvalues should prefer lvalue overloads. */
- if (TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF)
- {
- rank.subrank = REFERENCE_CONVERSION_RVALUE;
- return sum_ranks (rank, REFERENCE_CONVERSION_BADNESS);
- }
- }
- }
-
- if (types_equal (parm, arg))
+ switch (arg->code ())
{
- struct type *t1 = parm;
- struct type *t2 = arg;
-
- /* For pointers and references, compare target type. */
- if (TYPE_CODE (parm) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (parm))
- {
- t1 = TYPE_TARGET_TYPE (parm);
- t2 = TYPE_TARGET_TYPE (arg);
- }
-
- /* Make sure they are CV equal, too. */
- if (TYPE_CONST (t1) != TYPE_CONST (t2))
- rank.subrank |= CV_CONVERSION_CONST;
- if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
- rank.subrank |= CV_CONVERSION_VOLATILE;
- if (rank.subrank != 0)
- return sum_ranks (CV_CONVERSION_BADNESS, rank);
- return EXACT_MATCH_BADNESS;
+ case TYPE_CODE_PTR: /* funcptr -> func */
+ return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
}
+}
- /* See through references, since we can almost make non-references
- references. */
-
- if (TYPE_IS_REFERENCE (arg))
- return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
- REFERENCE_CONVERSION_BADNESS));
- if (TYPE_IS_REFERENCE (parm))
- return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
- REFERENCE_CONVERSION_BADNESS));
- if (overload_debug)
- /* Debugging only. */
- fprintf_filtered (gdb_stderr,
- "------ Arg is %s [%d], parm is %s [%d]\n",
- TYPE_NAME (arg), TYPE_CODE (arg),
- TYPE_NAME (parm), TYPE_CODE (parm));
-
- /* x -> y means arg of type x being supplied for parameter of type y. */
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_INT. */
- switch (TYPE_CODE (parm))
+static struct rank
+rank_one_type_parm_int (struct type *parm, struct type *arg, struct value *value)
+{
+ switch (arg->code ())
{
- case TYPE_CODE_PTR:
- return rank_one_type_parm_ptr (parm, arg, value);
- case TYPE_CODE_ARRAY:
- return rank_one_type_parm_array (parm, arg, value);
- case TYPE_CODE_FUNC:
- switch (TYPE_CODE (arg))
- {
- case TYPE_CODE_PTR: /* funcptr -> func */
- return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
- }
case TYPE_CODE_INT:
- switch (TYPE_CODE (arg))
+ if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
{
- case TYPE_CODE_INT:
- if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
+ /* Deal with signed, unsigned, and plain chars and
+ signed and unsigned ints. */
+ if (parm->has_no_signedness ())
{
- /* Deal with signed, unsigned, and plain chars and
- signed and unsigned ints. */
- if (TYPE_NOSIGN (parm))
- {
- /* This case only for character types. */
- if (TYPE_NOSIGN (arg))
- return EXACT_MATCH_BADNESS; /* plain char -> plain char */
- else /* signed/unsigned char -> plain char */
- return INTEGER_CONVERSION_BADNESS;
- }
- else if (TYPE_UNSIGNED (parm))
- {
- if (TYPE_UNSIGNED (arg))
- {
- /* unsigned int -> unsigned int, or
- unsigned long -> unsigned long */
- if (integer_types_same_name_p (TYPE_NAME (parm),
- TYPE_NAME (arg)))
- return EXACT_MATCH_BADNESS;
- else if (integer_types_same_name_p (TYPE_NAME (arg),
- "int")
- && integer_types_same_name_p (TYPE_NAME (parm),
- "long"))
- /* unsigned int -> unsigned long */
- return INTEGER_PROMOTION_BADNESS;
- else
- /* unsigned long -> unsigned int */
- return INTEGER_CONVERSION_BADNESS;
- }
- else
- {
- if (integer_types_same_name_p (TYPE_NAME (arg),
- "long")
- && integer_types_same_name_p (TYPE_NAME (parm),
- "int"))
- /* signed long -> unsigned int */
- return INTEGER_CONVERSION_BADNESS;
- else
- /* signed int/long -> unsigned int/long */
- return INTEGER_CONVERSION_BADNESS;
- }
- }
- else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
+ /* This case only for character types. */
+ if (arg->has_no_signedness ())
+ return EXACT_MATCH_BADNESS; /* plain char -> plain char */
+ else /* signed/unsigned char -> plain char */
+ return INTEGER_CONVERSION_BADNESS;
+ }
+ else if (parm->is_unsigned ())
+ {
+ if (arg->is_unsigned ())
{
- if (integer_types_same_name_p (TYPE_NAME (parm),
- TYPE_NAME (arg)))
+ /* unsigned int -> unsigned int, or
+ unsigned long -> unsigned long */
+ if (integer_types_same_name_p (parm->name (),
+ arg->name ()))
return EXACT_MATCH_BADNESS;
- else if (integer_types_same_name_p (TYPE_NAME (arg),
+ else if (integer_types_same_name_p (arg->name (),
"int")
- && integer_types_same_name_p (TYPE_NAME (parm),
+ && integer_types_same_name_p (parm->name (),
"long"))
+ /* unsigned int -> unsigned long */
return INTEGER_PROMOTION_BADNESS;
else
+ /* unsigned long -> unsigned int */
+ return INTEGER_CONVERSION_BADNESS;
+ }
+ else
+ {
+ if (integer_types_same_name_p (arg->name (),
+ "long")
+ && integer_types_same_name_p (parm->name (),
+ "int"))
+ /* signed long -> unsigned int */
+ return INTEGER_CONVERSION_BADNESS;
+ else
+ /* signed int/long -> unsigned int/long */
return INTEGER_CONVERSION_BADNESS;
}
+ }
+ else if (!arg->has_no_signedness () && !arg->is_unsigned ())
+ {
+ if (integer_types_same_name_p (parm->name (),
+ arg->name ()))
+ return EXACT_MATCH_BADNESS;
+ else if (integer_types_same_name_p (arg->name (),
+ "int")
+ && integer_types_same_name_p (parm->name (),
+ "long"))
+ return INTEGER_PROMOTION_BADNESS;
else
return INTEGER_CONVERSION_BADNESS;
}
- else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
- return INTEGER_PROMOTION_BADNESS;
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:
- 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_PTR:
- return NS_POINTER_CONVERSION_BADNESS;
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
}
- break;
+ else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
+ return INTEGER_PROMOTION_BADNESS;
+ else
+ return INTEGER_CONVERSION_BADNESS;
case TYPE_CODE_ENUM:
- switch (TYPE_CODE (arg))
- {
- case TYPE_CODE_INT:
- case TYPE_CODE_CHAR:
- 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;
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
- }
- break;
+ case TYPE_CODE_FLAGS:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_BOOL:
+ if (arg->is_declared_class ())
+ return INCOMPATIBLE_TYPE_BADNESS;
+ return INTEGER_PROMOTION_BADNESS;
+ case TYPE_CODE_FLT:
+ return INT_FLOAT_CONVERSION_BADNESS;
+ case TYPE_CODE_PTR:
+ return NS_POINTER_CONVERSION_BADNESS;
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_ENUM. */
+
+static struct rank
+rank_one_type_parm_enum (struct type *parm, struct type *arg, struct value *value)
+{
+ switch (arg->code ())
+ {
+ case TYPE_CODE_INT:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_ENUM:
+ if (parm->is_declared_class () || arg->is_declared_class ())
+ return INCOMPATIBLE_TYPE_BADNESS;
+ return INTEGER_CONVERSION_BADNESS;
+ case TYPE_CODE_FLT:
+ return INT_FLOAT_CONVERSION_BADNESS;
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_CHAR. */
+
+static struct rank
+rank_one_type_parm_char (struct type *parm, struct type *arg, struct value *value)
+{
+ switch (arg->code ())
+ {
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_ENUM:
+ if (arg->is_declared_class ())
+ return INCOMPATIBLE_TYPE_BADNESS;
+ return INTEGER_CONVERSION_BADNESS;
+ case TYPE_CODE_FLT:
+ return INT_FLOAT_CONVERSION_BADNESS;
+ case TYPE_CODE_INT:
+ if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
+ return INTEGER_CONVERSION_BADNESS;
+ else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
+ return INTEGER_PROMOTION_BADNESS;
+ /* fall through */
case TYPE_CODE_CHAR:
- switch (TYPE_CODE (arg))
+ /* Deal with signed, unsigned, and plain chars for C++ and
+ with int cases falling through from previous case. */
+ if (parm->has_no_signedness ())
{
- 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;
- case TYPE_CODE_INT:
- if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
- return INTEGER_CONVERSION_BADNESS;
- else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
- return INTEGER_PROMOTION_BADNESS;
- /* fall through */
- case TYPE_CODE_CHAR:
- /* Deal with signed, unsigned, and plain chars for C++ and
- with int cases falling through from previous case. */
- if (TYPE_NOSIGN (parm))
- {
- if (TYPE_NOSIGN (arg))
- return EXACT_MATCH_BADNESS;
- else
- return INTEGER_CONVERSION_BADNESS;
- }
- else if (TYPE_UNSIGNED (parm))
- {
- if (TYPE_UNSIGNED (arg))
- return EXACT_MATCH_BADNESS;
- else
- return INTEGER_PROMOTION_BADNESS;
- }
- else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
+ if (arg->has_no_signedness ())
return EXACT_MATCH_BADNESS;
else
return INTEGER_CONVERSION_BADNESS;
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
}
- break;
- case TYPE_CODE_RANGE:
- switch (TYPE_CODE (arg))
+ else if (parm->is_unsigned ())
{
- case TYPE_CODE_INT:
- case TYPE_CODE_CHAR:
- case TYPE_CODE_RANGE:
- case TYPE_CODE_BOOL:
- case TYPE_CODE_ENUM:
- return INTEGER_CONVERSION_BADNESS;
- case TYPE_CODE_FLT:
- return INT_FLOAT_CONVERSION_BADNESS;
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
- }
- break;
- case TYPE_CODE_BOOL:
- switch (TYPE_CODE (arg))
- {
- /* n3290 draft, section 4.12.1 (conv.bool):
-
- "A prvalue of arithmetic, unscoped enumeration, pointer, or
- pointer to member type can be converted to a prvalue of type
- bool. A zero value, null pointer value, or null member pointer
- value is converted to false; any other value is converted to
- true. A prvalue of type std::nullptr_t can be converted to a
- prvalue of type bool; the resulting value is false." */
- case TYPE_CODE_INT:
- case TYPE_CODE_CHAR:
- case TYPE_CODE_ENUM:
- case TYPE_CODE_FLT:
- case TYPE_CODE_MEMBERPTR:
- case TYPE_CODE_PTR:
- return BOOL_CONVERSION_BADNESS;
- case TYPE_CODE_RANGE:
- return INCOMPATIBLE_TYPE_BADNESS;
- case TYPE_CODE_BOOL:
- return EXACT_MATCH_BADNESS;
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
- }
- break;
- case TYPE_CODE_FLT:
- switch (TYPE_CODE (arg))
- {
- case TYPE_CODE_FLT:
- if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
- return FLOAT_PROMOTION_BADNESS;
- else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
+ if (arg->is_unsigned ())
return EXACT_MATCH_BADNESS;
else
- return FLOAT_CONVERSION_BADNESS;
- case TYPE_CODE_INT:
- case TYPE_CODE_BOOL:
- case TYPE_CODE_ENUM:
- case TYPE_CODE_RANGE:
- case TYPE_CODE_CHAR:
- return INT_FLOAT_CONVERSION_BADNESS;
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
+ return INTEGER_PROMOTION_BADNESS;
}
- break;
+ else if (!arg->has_no_signedness () && !arg->is_unsigned ())
+ return EXACT_MATCH_BADNESS;
+ else
+ return INTEGER_CONVERSION_BADNESS;
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_RANGE. */
+
+static struct rank
+rank_one_type_parm_range (struct type *parm, struct type *arg, struct value *value)
+{
+ switch (arg->code ())
+ {
+ case TYPE_CODE_INT:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_ENUM:
+ return INTEGER_CONVERSION_BADNESS;
+ case TYPE_CODE_FLT:
+ return INT_FLOAT_CONVERSION_BADNESS;
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_BOOL. */
+
+static struct rank
+rank_one_type_parm_bool (struct type *parm, struct type *arg, struct value *value)
+{
+ switch (arg->code ())
+ {
+ /* n3290 draft, section 4.12.1 (conv.bool):
+
+ "A prvalue of arithmetic, unscoped enumeration, pointer, or
+ pointer to member type can be converted to a prvalue of type
+ bool. A zero value, null pointer value, or null member pointer
+ value is converted to false; any other value is converted to
+ true. A prvalue of type std::nullptr_t can be converted to a
+ prvalue of type bool; the resulting value is false." */
+ case TYPE_CODE_INT:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_FLT:
+ case TYPE_CODE_MEMBERPTR:
+ case TYPE_CODE_PTR:
+ return BOOL_CONVERSION_BADNESS;
+ case TYPE_CODE_RANGE:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ case TYPE_CODE_BOOL:
+ return EXACT_MATCH_BADNESS;
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_FLOAT. */
+
+static struct rank
+rank_one_type_parm_float (struct type *parm, struct type *arg, struct value *value)
+{
+ switch (arg->code ())
+ {
+ case TYPE_CODE_FLT:
+ if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
+ return FLOAT_PROMOTION_BADNESS;
+ else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
+ return EXACT_MATCH_BADNESS;
+ else
+ return FLOAT_CONVERSION_BADNESS;
+ case TYPE_CODE_INT:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_CHAR:
+ return INT_FLOAT_CONVERSION_BADNESS;
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_COMPLEX. */
+
+static struct rank
+rank_one_type_parm_complex (struct type *parm, struct type *arg, struct value *value)
+{
+ switch (arg->code ())
+ { /* Strictly not needed for C++, but... */
+ case TYPE_CODE_FLT:
+ return FLOAT_PROMOTION_BADNESS;
case TYPE_CODE_COMPLEX:
- switch (TYPE_CODE (arg))
- { /* Strictly not needed for C++, but... */
- case TYPE_CODE_FLT:
- return FLOAT_PROMOTION_BADNESS;
- case TYPE_CODE_COMPLEX:
- return EXACT_MATCH_BADNESS;
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
- }
- break;
+ return EXACT_MATCH_BADNESS;
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_STRUCT. */
+
+static struct rank
+rank_one_type_parm_struct (struct type *parm, struct type *arg, struct value *value)
+{
+ struct rank rank = {0, 0};
+
+ switch (arg->code ())
+ {
case TYPE_CODE_STRUCT:
- switch (TYPE_CODE (arg))
+ /* Check for derivation */
+ rank.subrank = distance_to_ancestor (parm, arg, 0);
+ if (rank.subrank >= 0)
+ return sum_ranks (BASE_CONVERSION_BADNESS, rank);
+ /* fall through */
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* rank_one_type helper for when PARM's type code is TYPE_CODE_SET. */
+
+static struct rank
+rank_one_type_parm_set (struct type *parm, struct type *arg, struct value *value)
+{
+ switch (arg->code ())
+ {
+ /* Not in C++ */
+ case TYPE_CODE_SET:
+ return rank_one_type (parm->field (0).type (),
+ arg->field (0).type (), NULL);
+ default:
+ return INCOMPATIBLE_TYPE_BADNESS;
+ }
+}
+
+/* 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
+ * the latter can be converted to the former.
+ * VALUE is the argument's value or NULL if none (or called recursively)
+ *
+ * Return 0 if they are identical types;
+ * Otherwise, return an integer which corresponds to how compatible
+ * PARM is to ARG. The higher the return value, the worse the match.
+ * Generally the "bad" conversions are all uniformly assigned a 100. */
+
+struct rank
+rank_one_type (struct type *parm, struct type *arg, struct value *value)
+{
+ struct rank rank = {0,0};
+
+ /* Resolve typedefs */
+ if (parm->code () == TYPE_CODE_TYPEDEF)
+ parm = check_typedef (parm);
+ if (arg->code () == TYPE_CODE_TYPEDEF)
+ arg = check_typedef (arg);
+
+ if (TYPE_IS_REFERENCE (parm) && value != NULL)
+ {
+ if (VALUE_LVAL (value) == not_lval)
{
- case TYPE_CODE_STRUCT:
- /* Check for derivation */
- rank.subrank = distance_to_ancestor (parm, arg, 0);
- if (rank.subrank >= 0)
- return sum_ranks (BASE_CONVERSION_BADNESS, rank);
- /* fall through */
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
+ /* Rvalues should preferably bind to rvalue references or const
+ lvalue references. */
+ if (parm->code () == TYPE_CODE_RVALUE_REF)
+ rank.subrank = REFERENCE_CONVERSION_RVALUE;
+ else if (TYPE_CONST (TYPE_TARGET_TYPE (parm)))
+ rank.subrank = REFERENCE_CONVERSION_CONST_LVALUE;
+ else
+ return INCOMPATIBLE_TYPE_BADNESS;
+ return sum_ranks (rank, REFERENCE_CONVERSION_BADNESS);
}
- break;
- case TYPE_CODE_UNION:
- switch (TYPE_CODE (arg))
+ else
{
- case TYPE_CODE_UNION:
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
+ /* It's illegal to pass an lvalue as an rvalue. */
+ if (parm->code () == TYPE_CODE_RVALUE_REF)
+ return INCOMPATIBLE_TYPE_BADNESS;
}
- break;
- case TYPE_CODE_MEMBERPTR:
- switch (TYPE_CODE (arg))
+ }
+
+ if (types_equal (parm, arg))
+ {
+ struct type *t1 = parm;
+ struct type *t2 = arg;
+
+ /* For pointers and references, compare target type. */
+ if (parm->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (parm))
{
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
+ t1 = TYPE_TARGET_TYPE (parm);
+ t2 = TYPE_TARGET_TYPE (arg);
}
- break;
- case TYPE_CODE_METHOD:
- switch (TYPE_CODE (arg))
- {
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
- }
- break;
- case TYPE_CODE_REF:
- switch (TYPE_CODE (arg))
- {
+ /* Make sure they are CV equal, too. */
+ if (TYPE_CONST (t1) != TYPE_CONST (t2))
+ rank.subrank |= CV_CONVERSION_CONST;
+ if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
+ rank.subrank |= CV_CONVERSION_VOLATILE;
+ if (rank.subrank != 0)
+ return sum_ranks (CV_CONVERSION_BADNESS, rank);
+ return EXACT_MATCH_BADNESS;
+ }
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
- }
+ /* See through references, since we can almost make non-references
+ references. */
- break;
+ if (TYPE_IS_REFERENCE (arg))
+ return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
+ REFERENCE_SEE_THROUGH_BADNESS));
+ if (TYPE_IS_REFERENCE (parm))
+ return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
+ REFERENCE_SEE_THROUGH_BADNESS));
+ if (overload_debug)
+ {
+ /* Debugging only. */
+ fprintf_filtered (gdb_stderr,
+ "------ Arg is %s [%d], parm is %s [%d]\n",
+ arg->name (), arg->code (),
+ parm->name (), parm->code ());
+ }
+
+ /* x -> y means arg of type x being supplied for parameter of type y. */
+
+ switch (parm->code ())
+ {
+ case TYPE_CODE_PTR:
+ return rank_one_type_parm_ptr (parm, arg, value);
+ case TYPE_CODE_ARRAY:
+ return rank_one_type_parm_array (parm, arg, value);
+ case TYPE_CODE_FUNC:
+ return rank_one_type_parm_func (parm, arg, value);
+ case TYPE_CODE_INT:
+ return rank_one_type_parm_int (parm, arg, value);
+ case TYPE_CODE_ENUM:
+ return rank_one_type_parm_enum (parm, arg, value);
+ case TYPE_CODE_CHAR:
+ return rank_one_type_parm_char (parm, arg, value);
+ case TYPE_CODE_RANGE:
+ return rank_one_type_parm_range (parm, arg, value);
+ case TYPE_CODE_BOOL:
+ return rank_one_type_parm_bool (parm, arg, value);
+ case TYPE_CODE_FLT:
+ return rank_one_type_parm_float (parm, arg, value);
+ case TYPE_CODE_COMPLEX:
+ return rank_one_type_parm_complex (parm, arg, value);
+ case TYPE_CODE_STRUCT:
+ return rank_one_type_parm_struct (parm, arg, value);
case TYPE_CODE_SET:
- switch (TYPE_CODE (arg))
- {
- /* Not in C++ */
- case TYPE_CODE_SET:
- return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
- TYPE_FIELD_TYPE (arg, 0), NULL);
- default:
- return INCOMPATIBLE_TYPE_BADNESS;
- }
- break;
- case TYPE_CODE_VOID:
+ return rank_one_type_parm_set (parm, arg, value);
default:
return INCOMPATIBLE_TYPE_BADNESS;
- } /* switch (TYPE_CODE (arg)) */
+ } /* switch (arg->code ()) */
}
/* End of functions for overload resolution. */
for (i = 0; i < nargs; i++)
{
- printfi_filtered (spaces, "[%d] name '%s'\n", i,
- args[i].name != NULL ? args[i].name : "<NULL>");
- recursive_dump_type (args[i].type, spaces + 2);
+ printf_filtered ("%*s[%d] name '%s'\n", spaces, "", i,
+ args[i].name != NULL ? args[i].name : "<NULL>");
+ recursive_dump_type (args[i].type (), spaces + 2);
}
}
}
int overload_idx;
struct fn_field *f;
- printfi_filtered (spaces, "fn_fieldlists ");
+ printf_filtered ("%*sfn_fieldlists ", spaces, "");
gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
printf_filtered ("\n");
for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
{
f = TYPE_FN_FIELDLIST1 (type, method_idx);
- printfi_filtered (spaces + 2, "[%d] name '%s' (",
- method_idx,
- TYPE_FN_FIELDLIST_NAME (type, method_idx));
+ printf_filtered ("%*s[%d] name '%s' (", spaces + 2, "",
+ method_idx,
+ 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"),
overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
overload_idx++)
{
- printfi_filtered (spaces + 4, "[%d] physname '%s' (",
- overload_idx,
- TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
+ printf_filtered ("%*s[%d] physname '%s' (",
+ spaces + 4, "", overload_idx,
+ TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
gdb_stdout);
printf_filtered (")\n");
- printfi_filtered (spaces + 8, "type ");
+ printf_filtered ("%*stype ", spaces + 8, "");
gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
gdb_stdout);
printf_filtered ("\n");
recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
spaces + 8 + 2);
- printfi_filtered (spaces + 8, "args ");
+ printf_filtered ("%*sargs ", spaces + 8, "");
gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
gdb_stdout);
printf_filtered ("\n");
print_args (TYPE_FN_FIELD_ARGS (f, overload_idx),
- TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
+ TYPE_FN_FIELD_TYPE (f, overload_idx)->num_fields (),
spaces + 8 + 2);
- printfi_filtered (spaces + 8, "fcontext ");
+ printf_filtered ("%*sfcontext ", spaces + 8, "");
gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
gdb_stdout);
printf_filtered ("\n");
- printfi_filtered (spaces + 8, "is_const %d\n",
- TYPE_FN_FIELD_CONST (f, overload_idx));
- printfi_filtered (spaces + 8, "is_volatile %d\n",
- TYPE_FN_FIELD_VOLATILE (f, overload_idx));
- printfi_filtered (spaces + 8, "is_private %d\n",
- TYPE_FN_FIELD_PRIVATE (f, overload_idx));
- printfi_filtered (spaces + 8, "is_protected %d\n",
- TYPE_FN_FIELD_PROTECTED (f, overload_idx));
- printfi_filtered (spaces + 8, "is_stub %d\n",
- TYPE_FN_FIELD_STUB (f, overload_idx));
- printfi_filtered (spaces + 8, "voffset %u\n",
- TYPE_FN_FIELD_VOFFSET (f, overload_idx));
+ printf_filtered ("%*sis_const %d\n", spaces + 8, "",
+ TYPE_FN_FIELD_CONST (f, overload_idx));
+ printf_filtered ("%*sis_volatile %d\n", spaces + 8, "",
+ TYPE_FN_FIELD_VOLATILE (f, overload_idx));
+ printf_filtered ("%*sis_private %d\n", spaces + 8, "",
+ TYPE_FN_FIELD_PRIVATE (f, overload_idx));
+ printf_filtered ("%*sis_protected %d\n", spaces + 8, "",
+ TYPE_FN_FIELD_PROTECTED (f, overload_idx));
+ printf_filtered ("%*sis_stub %d\n", spaces + 8, "",
+ TYPE_FN_FIELD_STUB (f, overload_idx));
+ printf_filtered ("%*sdefaulted %d\n", spaces + 8, "",
+ TYPE_FN_FIELD_DEFAULTED (f, overload_idx));
+ printf_filtered ("%*sis_deleted %d\n", spaces + 8, "",
+ TYPE_FN_FIELD_DELETED (f, overload_idx));
+ printf_filtered ("%*svoffset %u\n", spaces + 8, "",
+ TYPE_FN_FIELD_VOFFSET (f, overload_idx));
}
}
}
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 ");
+ printf_filtered ("%*svptr_fieldno %d\n", spaces, "",
+ TYPE_VPTR_FIELDNO (type));
+ printf_filtered ("%*svptr_basetype ", spaces, "");
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",
- TYPE_NFN_FIELDS (type));
+ printf_filtered ("%*sn_baseclasses %d\n", spaces, "",
+ TYPE_N_BASECLASSES (type));
+ printf_filtered ("%*snfn_fields %d\n", spaces, "",
+ TYPE_NFN_FIELDS (type));
if (TYPE_N_BASECLASSES (type) > 0)
{
- printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
- TYPE_N_BASECLASSES (type));
+ printf_filtered ("%*svirtual_field_bits (%d bits at *",
+ spaces, "", TYPE_N_BASECLASSES (type));
gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
gdb_stdout);
printf_filtered (")");
TYPE_N_BASECLASSES (type));
puts_filtered ("\n");
}
- if (TYPE_NFIELDS (type) > 0)
+ if (type->num_fields () > 0)
{
if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
{
- printfi_filtered (spaces,
- "private_field_bits (%d bits at *",
- TYPE_NFIELDS (type));
+ printf_filtered ("%*sprivate_field_bits (%d bits at *",
+ spaces, "", type->num_fields ());
gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
gdb_stdout);
printf_filtered (")");
print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
- TYPE_NFIELDS (type));
+ type->num_fields ());
puts_filtered ("\n");
}
if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
{
- printfi_filtered (spaces,
- "protected_field_bits (%d bits at *",
- TYPE_NFIELDS (type));
+ printf_filtered ("%*sprotected_field_bits (%d bits at *",
+ spaces, "", type->num_fields ());
gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
gdb_stdout);
printf_filtered (")");
print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
- TYPE_NFIELDS (type));
+ type->num_fields ());
puts_filtered ("\n");
}
}
{
dump_fn_fieldlists (type, spaces);
}
+
+ printf_filtered ("%*scalling_convention %d\n", spaces, "",
+ TYPE_CPLUS_CALLING_CONVENTION (type));
}
/* Print the contents of the TYPE's type_specific union, assuming that
struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
if (descriptive_type == NULL)
- printfi_filtered (spaces + 2, "no descriptive type\n");
+ printf_filtered ("%*sno descriptive type\n", spaces + 2, "");
else
{
- printfi_filtered (spaces + 2, "descriptive type\n");
+ printf_filtered ("%*sdescriptive type\n", spaces + 2, "");
recursive_dump_type (descriptive_type, spaces + 4);
}
}
+/* Print the contents of the TYPE's type_specific union, assuming that
+ its type-specific kind is TYPE_SPECIFIC_FIXED_POINT. */
+
+static void
+print_fixed_point_type_info (struct type *type, int spaces)
+{
+ printf_filtered ("%*sscaling factor: %s\n", spaces + 2, "",
+ type->fixed_point_scaling_factor ().str ().c_str ());
+}
+
static struct obstack dont_print_type_obstack;
+/* Print the dynamic_prop PROP. */
+
+static void
+dump_dynamic_prop (dynamic_prop const& prop)
+{
+ switch (prop.kind ())
+ {
+ case PROP_CONST:
+ printf_filtered ("%s", plongest (prop.const_val ()));
+ break;
+ case PROP_UNDEFINED:
+ printf_filtered ("(undefined)");
+ break;
+ case PROP_LOCEXPR:
+ case PROP_LOCLIST:
+ printf_filtered ("(dynamic)");
+ break;
+ default:
+ gdb_assert_not_reached ("unhandled prop kind");
+ break;
+ }
+}
+
void
recursive_dump_type (struct type *type, int spaces)
{
if (spaces == 0)
obstack_begin (&dont_print_type_obstack, 0);
- if (TYPE_NFIELDS (type) > 0
+ if (type->num_fields () > 0
|| (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
{
struct type **first_dont_print
{
if (type == first_dont_print[i])
{
- printfi_filtered (spaces, "type node ");
+ printf_filtered ("%*stype node ", spaces, "");
gdb_print_host_address (type, gdb_stdout);
printf_filtered (_(" <same as already seen type>\n"));
return;
obstack_ptr_grow (&dont_print_type_obstack, type);
}
- printfi_filtered (spaces, "type node ");
+ printf_filtered ("%*stype node ", spaces, "");
gdb_print_host_address (type, gdb_stdout);
printf_filtered ("\n");
- printfi_filtered (spaces, "name '%s' (",
- TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
- gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
+ printf_filtered ("%*sname '%s' (", spaces, "",
+ type->name () ? type->name () : "<NULL>");
+ gdb_print_host_address (type->name (), gdb_stdout);
printf_filtered (")\n");
- printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
- switch (TYPE_CODE (type))
+ printf_filtered ("%*scode 0x%x ", spaces, "", type->code ());
+ switch (type->code ())
{
case TYPE_CODE_UNDEF:
printf_filtered ("(TYPE_CODE_UNDEF)");
case TYPE_CODE_NAMESPACE:
printf_filtered ("(TYPE_CODE_NAMESPACE)");
break;
+ case TYPE_CODE_FIXED_POINT:
+ printf_filtered ("(TYPE_CODE_FIXED_POINT)");
+ break;
default:
printf_filtered ("(UNKNOWN TYPE CODE)");
break;
}
puts_filtered ("\n");
- printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
- if (TYPE_OBJFILE_OWNED (type))
+ printf_filtered ("%*slength %s\n", spaces, "",
+ pulongest (TYPE_LENGTH (type)));
+ if (type->is_objfile_owned ())
{
- printfi_filtered (spaces, "objfile ");
- gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
+ printf_filtered ("%*sobjfile ", spaces, "");
+ gdb_print_host_address (type->objfile_owner (), gdb_stdout);
}
else
{
- printfi_filtered (spaces, "gdbarch ");
- gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
+ printf_filtered ("%*sgdbarch ", spaces, "");
+ gdb_print_host_address (type->arch_owner (), gdb_stdout);
}
printf_filtered ("\n");
- printfi_filtered (spaces, "target_type ");
+ printf_filtered ("%*starget_type ", spaces, "");
gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
printf_filtered ("\n");
if (TYPE_TARGET_TYPE (type) != NULL)
{
recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
}
- printfi_filtered (spaces, "pointer_type ");
+ printf_filtered ("%*spointer_type ", spaces, "");
gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
printf_filtered ("\n");
- printfi_filtered (spaces, "reference_type ");
+ printf_filtered ("%*sreference_type ", spaces, "");
gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
printf_filtered ("\n");
- printfi_filtered (spaces, "type_chain ");
+ printf_filtered ("%*stype_chain ", spaces, "");
gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
printf_filtered ("\n");
- printfi_filtered (spaces, "instance_flags 0x%x",
- TYPE_INSTANCE_FLAGS (type));
+ printf_filtered ("%*sinstance_flags 0x%x", spaces, "",
+ (unsigned) type->instance_flags ());
if (TYPE_CONST (type))
{
puts_filtered (" TYPE_CONST");
}
puts_filtered ("\n");
- printfi_filtered (spaces, "flags");
- if (TYPE_UNSIGNED (type))
+ printf_filtered ("%*sflags", spaces, "");
+ if (type->is_unsigned ())
{
puts_filtered (" TYPE_UNSIGNED");
}
- if (TYPE_NOSIGN (type))
+ if (type->has_no_signedness ())
{
puts_filtered (" TYPE_NOSIGN");
}
- if (TYPE_STUB (type))
+ if (type->endianity_is_not_default ())
+ {
+ puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT");
+ }
+ if (type->is_stub ())
{
puts_filtered (" TYPE_STUB");
}
- if (TYPE_TARGET_STUB (type))
+ if (type->target_is_stub ())
{
puts_filtered (" TYPE_TARGET_STUB");
}
- if (TYPE_PROTOTYPED (type))
+ if (type->is_prototyped ())
{
puts_filtered (" TYPE_PROTOTYPED");
}
- if (TYPE_INCOMPLETE (type))
- {
- puts_filtered (" TYPE_INCOMPLETE");
- }
- if (TYPE_VARARGS (type))
+ if (type->has_varargs ())
{
puts_filtered (" TYPE_VARARGS");
}
/* This is used for things like AltiVec registers on ppc. Gcc emits
an attribute for the array type, which tells whether or not we
have a vector, instead of a regular array. */
- if (TYPE_VECTOR (type))
+ if (type->is_vector ())
{
puts_filtered (" TYPE_VECTOR");
}
- if (TYPE_FIXED_INSTANCE (type))
+ if (type->is_fixed_instance ())
{
puts_filtered (" TYPE_FIXED_INSTANCE");
}
- if (TYPE_STUB_SUPPORTED (type))
+ if (type->stub_is_supported ())
{
puts_filtered (" TYPE_STUB_SUPPORTED");
}
puts_filtered (" TYPE_NOTTEXT");
}
puts_filtered ("\n");
- printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
- gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
+ printf_filtered ("%*snfields %d ", spaces, "", type->num_fields ());
+ if (TYPE_ASSOCIATED_PROP (type) != nullptr
+ || TYPE_ALLOCATED_PROP (type) != nullptr)
+ {
+ printf_filtered ("%*s", spaces, "");
+ if (TYPE_ASSOCIATED_PROP (type) != nullptr)
+ {
+ printf_filtered ("associated ");
+ dump_dynamic_prop (*TYPE_ASSOCIATED_PROP (type));
+ }
+ if (TYPE_ALLOCATED_PROP (type) != nullptr)
+ {
+ if (TYPE_ASSOCIATED_PROP (type) != nullptr)
+ printf_filtered (" ");
+ printf_filtered ("allocated ");
+ dump_dynamic_prop (*TYPE_ALLOCATED_PROP (type));
+ }
+ printf_filtered ("\n");
+ }
+ gdb_print_host_address (type->fields (), gdb_stdout);
puts_filtered ("\n");
- for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
+ for (idx = 0; idx < type->num_fields (); idx++)
{
- if (TYPE_CODE (type) == TYPE_CODE_ENUM)
- printfi_filtered (spaces + 2,
- "[%d] enumval %s type ",
- idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
+ if (type->code () == TYPE_CODE_ENUM)
+ printf_filtered ("%*s[%d] enumval %s type ", spaces + 2, "",
+ idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
else
- printfi_filtered (spaces + 2,
- "[%d] bitpos %s bitsize %d type ",
- idx, plongest (TYPE_FIELD_BITPOS (type, idx)),
- TYPE_FIELD_BITSIZE (type, idx));
- gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
+ printf_filtered ("%*s[%d] bitpos %s bitsize %d type ", spaces + 2, "",
+ idx, plongest (TYPE_FIELD_BITPOS (type, idx)),
+ TYPE_FIELD_BITSIZE (type, idx));
+ gdb_print_host_address (type->field (idx).type (), gdb_stdout);
printf_filtered (" name '%s' (",
TYPE_FIELD_NAME (type, idx) != NULL
? TYPE_FIELD_NAME (type, idx)
: "<NULL>");
gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
printf_filtered (")\n");
- if (TYPE_FIELD_TYPE (type, idx) != NULL)
+ if (type->field (idx).type () != NULL)
{
- recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
+ recursive_dump_type (type->field (idx).type (), spaces + 4);
}
}
- if (TYPE_CODE (type) == TYPE_CODE_RANGE)
+ if (type->code () == TYPE_CODE_RANGE)
{
- printfi_filtered (spaces, "low %s%s high %s%s\n",
- plongest (TYPE_LOW_BOUND (type)),
- TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
- plongest (TYPE_HIGH_BOUND (type)),
- TYPE_HIGH_BOUND_UNDEFINED (type)
- ? " (undefined)" : "");
+ printf_filtered ("%*slow ", spaces, "");
+ dump_dynamic_prop (type->bounds ()->low);
+ printf_filtered (" high ");
+ dump_dynamic_prop (type->bounds ()->high);
+ printf_filtered ("\n");
}
switch (TYPE_SPECIFIC_FIELD (type))
{
case TYPE_SPECIFIC_CPLUS_STUFF:
- printfi_filtered (spaces, "cplus_stuff ");
+ printf_filtered ("%*scplus_stuff ", spaces, "");
gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
gdb_stdout);
puts_filtered ("\n");
break;
case TYPE_SPECIFIC_GNAT_STUFF:
- printfi_filtered (spaces, "gnat_stuff ");
+ printf_filtered ("%*sgnat_stuff ", spaces, "");
gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
puts_filtered ("\n");
print_gnat_stuff (type, spaces);
break;
case TYPE_SPECIFIC_FLOATFORMAT:
- printfi_filtered (spaces, "floatformat ");
+ printf_filtered ("%*sfloatformat ", spaces, "");
if (TYPE_FLOATFORMAT (type) == NULL
|| TYPE_FLOATFORMAT (type)->name == NULL)
puts_filtered ("(null)");
break;
case TYPE_SPECIFIC_FUNC:
- printfi_filtered (spaces, "calling_convention %d\n",
- TYPE_CALLING_CONVENTION (type));
+ printf_filtered ("%*scalling_convention %d\n", spaces, "",
+ TYPE_CALLING_CONVENTION (type));
/* tail_call_list is not printed. */
break;
case TYPE_SPECIFIC_SELF_TYPE:
- printfi_filtered (spaces, "self_type ");
+ printf_filtered ("%*sself_type ", spaces, "");
gdb_print_host_address (TYPE_SELF_TYPE (type), gdb_stdout);
puts_filtered ("\n");
break;
+
+ case TYPE_SPECIFIC_FIXED_POINT:
+ printf_filtered ("%*sfixed_point_info ", spaces, "");
+ print_fixed_point_type_info (type, spaces);
+ puts_filtered ("\n");
+ break;
+
+ case TYPE_SPECIFIC_INT:
+ if (type->bit_size_differs_p ())
+ {
+ unsigned bit_size = type->bit_size ();
+ unsigned bit_off = type->bit_offset ();
+ printf_filtered ("%*s bit size = %u, bit offset = %u\n", spaces, "",
+ bit_size, bit_off);
+ }
+ break;
}
if (spaces == 0)
types without duplicates. We use OBJFILE's obstack, because
OBJFILE is about to be deleted. */
-htab_t
+htab_up
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);
+ return htab_up (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) a dynamic attribute list of a type. */
void **slot;
struct type *new_type;
- if (! TYPE_OBJFILE_OWNED (type))
+ if (!type->is_objfile_owned ())
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);
+ gdb_assert (type->objfile_owner () == objfile);
struct type_pair pair (type, nullptr);
if (*slot != NULL)
return ((struct type_pair *) *slot)->newobj;
- new_type = alloc_type_arch (get_type_arch (type));
+ new_type = alloc_type_arch (type->arch ());
/* We must add the new type to the hash table immediately, in case
we encounter this type again during a recursive call below. */
/* Copy the common fields of types. For the main type, we simply
copy the entire thing and then update specific fields as needed. */
*TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
- TYPE_OBJFILE_OWNED (new_type) = 0;
- TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
- if (TYPE_NAME (type))
- TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
+ new_type->set_owner (type->arch ());
+
+ if (type->name ())
+ new_type->set_name (xstrdup (type->name ()));
- TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
+ new_type->set_instance_flags (type->instance_flags ());
TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
/* Copy the fields. */
- if (TYPE_NFIELDS (type))
+ if (type->num_fields ())
{
int i, nfields;
- nfields = TYPE_NFIELDS (type);
- TYPE_FIELDS (new_type) = (struct field *)
- TYPE_ZALLOC (new_type, nfields * sizeof (struct field));
+ nfields = type->num_fields ();
+ new_type->set_fields
+ ((struct field *)
+ TYPE_ZALLOC (new_type, nfields * sizeof (struct field)));
+
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 (i).type ())
+ new_type->field (i).set_type
+ (copy_type_recursive (objfile, type->field (i).type (),
+ copied_types));
if (TYPE_FIELD_NAME (type, i))
TYPE_FIELD_NAME (new_type, i) =
xstrdup (TYPE_FIELD_NAME (type, i));
switch (TYPE_FIELD_LOC_KIND (type, i))
{
case FIELD_LOC_KIND_BITPOS:
- SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
+ SET_FIELD_BITPOS (new_type->field (i),
TYPE_FIELD_BITPOS (type, i));
break;
case FIELD_LOC_KIND_ENUMVAL:
- SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
+ SET_FIELD_ENUMVAL (new_type->field (i),
TYPE_FIELD_ENUMVAL (type, i));
break;
case FIELD_LOC_KIND_PHYSADDR:
- SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
+ SET_FIELD_PHYSADDR (new_type->field (i),
TYPE_FIELD_STATIC_PHYSADDR (type, i));
break;
case FIELD_LOC_KIND_PHYSNAME:
- SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
+ SET_FIELD_PHYSNAME (new_type->field (i),
xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
i)));
break;
}
/* For range types, copy the bounds information. */
- if (TYPE_CODE (type) == TYPE_CODE_RANGE)
+ if (type->code () == TYPE_CODE_RANGE)
{
- TYPE_RANGE_DATA (new_type) = (struct range_bounds *)
- TYPE_ALLOC (new_type, sizeof (struct range_bounds));
- *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
+ range_bounds *bounds
+ = ((struct range_bounds *) TYPE_ALLOC
+ (new_type, sizeof (struct range_bounds)));
+
+ *bounds = *type->bounds ();
+ new_type->set_bounds (bounds);
}
- if (TYPE_DYN_PROP_LIST (type) != NULL)
- TYPE_DYN_PROP_LIST (new_type)
+ if (type->main_type->dyn_prop_list != NULL)
+ new_type->main_type->dyn_prop_list
= copy_dynamic_prop_list (&objfile->objfile_obstack,
- TYPE_DYN_PROP_LIST (type));
+ type->main_type->dyn_prop_list);
/* Copy pointers to other types. */
copy_type_recursive (objfile, TYPE_SELF_TYPE (type),
copied_types));
break;
+ case TYPE_SPECIFIC_FIXED_POINT:
+ INIT_FIXED_POINT_SPECIFIC (new_type);
+ new_type->fixed_point_info ().scaling_factor
+ = type->fixed_point_info ().scaling_factor;
+ break;
+ case TYPE_SPECIFIC_INT:
+ TYPE_SPECIFIC_FIELD (new_type) = TYPE_SPECIFIC_INT;
+ TYPE_MAIN_TYPE (new_type)->type_specific.int_stuff
+ = TYPE_MAIN_TYPE (type)->type_specific.int_stuff;
+ break;
+
default:
gdb_assert_not_reached ("bad type_specific_kind");
}
{
struct type *new_type;
- gdb_assert (TYPE_OBJFILE_OWNED (type));
+ gdb_assert (type->is_objfile_owned ());
new_type = alloc_type_copy (type);
- TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
+ new_type->set_instance_flags (type->instance_flags ());
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));
+ if (type->main_type->dyn_prop_list != NULL)
+ new_type->main_type->dyn_prop_list
+ = copy_dynamic_prop_list (&type->objfile_owner ()->objfile_obstack,
+ type->main_type->dyn_prop_list);
return new_type;
}
TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT;
if (name)
- TYPE_NAME (type) = gdbarch_obstack_strdup (gdbarch, name);
+ type->set_name (gdbarch_obstack_strdup (gdbarch, name));
return type;
}
t = arch_type (gdbarch, TYPE_CODE_INT, bit, name);
if (unsigned_p)
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
return t;
}
t = arch_type (gdbarch, TYPE_CODE_CHAR, bit, name);
if (unsigned_p)
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
return t;
}
t = arch_type (gdbarch, TYPE_CODE_BOOL, bit, name);
if (unsigned_p)
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
return t;
}
return t;
}
-/* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
- NAME is the type name. TARGET_TYPE is the component float type. */
-
-struct type *
-arch_complex_type (struct gdbarch *gdbarch,
- const char *name, struct type *target_type)
-{
- struct type *t;
-
- t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
- 2 * TYPE_LENGTH (target_type) * TARGET_CHAR_BIT, name);
- TYPE_TARGET_TYPE (t) = target_type;
- return t;
-}
-
/* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
BIT is the pointer type size in bits. NAME is the type name.
TARGET_TYPE is the pointer target type. Always sets the pointer type's
t = arch_type (gdbarch, TYPE_CODE_PTR, bit, name);
TYPE_TARGET_TYPE (t) = target_type;
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
return t;
}
struct type *type;
type = arch_type (gdbarch, TYPE_CODE_FLAGS, bit, name);
- TYPE_UNSIGNED (type) = 1;
- TYPE_NFIELDS (type) = 0;
+ type->set_is_unsigned (true);
+ type->set_num_fields (0);
/* Pre-allocate enough space assuming every field is one bit. */
- TYPE_FIELDS (type)
- = (struct field *) TYPE_ZALLOC (type, bit * sizeof (struct field));
+ type->set_fields
+ ((struct field *) TYPE_ZALLOC (type, bit * sizeof (struct field)));
return type;
}
struct type *field_type, const char *name)
{
int type_bitsize = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
- int field_nr = TYPE_NFIELDS (type);
+ int field_nr = type->num_fields ();
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
- gdb_assert (TYPE_NFIELDS (type) + 1 <= type_bitsize);
+ gdb_assert (type->code () == TYPE_CODE_FLAGS);
+ gdb_assert (type->num_fields () + 1 <= type_bitsize);
gdb_assert (start_bitpos >= 0 && start_bitpos < type_bitsize);
gdb_assert (nr_bits >= 1 && nr_bits <= type_bitsize);
gdb_assert (name != NULL);
TYPE_FIELD_NAME (type, field_nr) = xstrdup (name);
- TYPE_FIELD_TYPE (type, field_nr) = field_type;
- SET_FIELD_BITPOS (TYPE_FIELD (type, field_nr), start_bitpos);
+ type->field (field_nr).set_type (field_type);
+ SET_FIELD_BITPOS (type->field (field_nr), start_bitpos);
TYPE_FIELD_BITSIZE (type, field_nr) = nr_bits;
- ++TYPE_NFIELDS (type);
+ type->set_num_fields (type->num_fields () + 1);
}
/* Special version of append_flags_type_field to add a flag field.
void
append_flags_type_flag (struct type *type, int bitpos, const char *name)
{
- struct gdbarch *gdbarch = get_type_arch (type);
-
append_flags_type_field (type, bitpos, 1,
- builtin_type (gdbarch)->builtin_bool,
+ builtin_type (type->arch ())->builtin_bool,
name);
}
gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
t = arch_type (gdbarch, code, 0, NULL);
- TYPE_NAME (t) = name;
+ t->set_name (name);
INIT_CPLUS_SPECIFIC (t);
return t;
}
{
struct field *f;
- TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
- TYPE_FIELDS (t) = XRESIZEVEC (struct field, TYPE_FIELDS (t),
- TYPE_NFIELDS (t));
- f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
+ t->set_num_fields (t->num_fields () + 1);
+ t->set_fields (XRESIZEVEC (struct field, t->fields (),
+ t->num_fields ()));
+ f = &t->field (t->num_fields () - 1);
memset (f, 0, sizeof f[0]);
- FIELD_TYPE (f[0]) = field;
+ f[0].set_type (field);
FIELD_NAME (f[0]) = name;
return f;
}
{
struct field *f = append_composite_type_field_raw (t, name, field);
- if (TYPE_CODE (t) == TYPE_CODE_UNION)
+ if (t->code () == TYPE_CODE_UNION)
{
if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
TYPE_LENGTH (t) = TYPE_LENGTH (field);
}
- else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
+ else if (t->code () == TYPE_CODE_STRUCT)
{
TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
- if (TYPE_NFIELDS (t) > 1)
+ if (t->num_fields () > 1)
{
SET_FIELD_BITPOS (f[0],
(FIELD_BITPOS (f[-1])
- + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
+ + (TYPE_LENGTH (f[-1].type ())
* TARGET_CHAR_BIT)));
if (alignment)
append_composite_type_field_aligned (t, name, field, 0);
}
+\f
+
+/* We manage the lifetimes of fixed_point_type_info objects by
+ attaching them to the objfile. Currently, these objects are
+ modified during construction, and GMP does not provide a way to
+ hash the contents of an mpq_t; so it's a bit of a pain to hash-cons
+ them. If we did do this, they could be moved to the per-BFD and
+ shared across objfiles. */
+typedef std::vector<std::unique_ptr<fixed_point_type_info>>
+ fixed_point_type_storage;
+
+/* Key used for managing the storage of fixed-point type info. */
+static const struct objfile_key<fixed_point_type_storage>
+ fixed_point_objfile_key;
+
+/* See gdbtypes.h. */
+
+void
+allocate_fixed_point_type_info (struct type *type)
+{
+ std::unique_ptr<fixed_point_type_info> up (new fixed_point_type_info);
+ fixed_point_type_info *info;
+
+ if (type->is_objfile_owned ())
+ {
+ fixed_point_type_storage *storage
+ = fixed_point_objfile_key.get (type->objfile_owner ());
+ if (storage == nullptr)
+ storage = fixed_point_objfile_key.emplace (type->objfile_owner ());
+ info = up.get ();
+ storage->push_back (std::move (up));
+ }
+ else
+ {
+ /* We just leak the memory, because that's what we do generally
+ for non-objfile-attached types. */
+ info = up.release ();
+ }
+
+ type->set_fixed_point_info (info);
+}
+
+/* See gdbtypes.h. */
+
+bool
+is_fixed_point_type (struct type *type)
+{
+ while (check_typedef (type)->code () == TYPE_CODE_RANGE)
+ type = TYPE_TARGET_TYPE (check_typedef (type));
+ type = check_typedef (type);
+
+ return type->code () == TYPE_CODE_FIXED_POINT;
+}
+
+/* See gdbtypes.h. */
+
+struct type *
+type::fixed_point_type_base_type ()
+{
+ struct type *type = this;
+
+ while (check_typedef (type)->code () == TYPE_CODE_RANGE)
+ type = TYPE_TARGET_TYPE (check_typedef (type));
+ type = check_typedef (type);
+
+ gdb_assert (type->code () == TYPE_CODE_FIXED_POINT);
+ return type;
+}
+
+/* See gdbtypes.h. */
+
+const gdb_mpq &
+type::fixed_point_scaling_factor ()
+{
+ struct type *type = this->fixed_point_type_base_type ();
+
+ return type->fixed_point_info ().scaling_factor;
+}
+
+\f
+
static struct gdbarch_data *gdbtypes_data;
const struct builtin_type *
builtin_type->builtin_char
= arch_integer_type (gdbarch, TARGET_CHAR_BIT,
!gdbarch_char_signed (gdbarch), "char");
- TYPE_NOSIGN (builtin_type->builtin_char) = 1;
+ builtin_type->builtin_char->set_has_no_signedness (true);
builtin_type->builtin_signed_char
= arch_integer_type (gdbarch, TARGET_CHAR_BIT,
0, "signed char");
builtin_type->builtin_unsigned_long_long
= arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
1, "unsigned long long");
+ builtin_type->builtin_half
+ = arch_float_type (gdbarch, gdbarch_half_bit (gdbarch),
+ "half", gdbarch_half_format (gdbarch));
builtin_type->builtin_float
= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
"float", gdbarch_float_format (gdbarch));
+ builtin_type->builtin_bfloat16
+ = arch_float_type (gdbarch, gdbarch_bfloat16_bit (gdbarch),
+ "bfloat16", gdbarch_bfloat16_format (gdbarch));
builtin_type->builtin_double
= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
"double", gdbarch_double_format (gdbarch));
= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
"long double", gdbarch_long_double_format (gdbarch));
builtin_type->builtin_complex
- = arch_complex_type (gdbarch, "complex",
- builtin_type->builtin_float);
+ = init_complex_type ("complex", builtin_type->builtin_float);
builtin_type->builtin_double_complex
- = arch_complex_type (gdbarch, "double complex",
- builtin_type->builtin_double);
+ = init_complex_type ("double complex", builtin_type->builtin_double);
builtin_type->builtin_string
= arch_type (gdbarch, TYPE_CODE_STRING, TARGET_CHAR_BIT, "string");
builtin_type->builtin_bool
- = arch_type (gdbarch, TYPE_CODE_BOOL, TARGET_CHAR_BIT, "bool");
+ = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "bool");
/* The following three are about decimal floating point types, which
are 32-bits, 64-bits and 128-bits respectively. */
= arch_integer_type (gdbarch, 128, 0, "int128_t");
builtin_type->builtin_uint128
= arch_integer_type (gdbarch, 128, 1, "uint128_t");
- TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
- TYPE_INSTANCE_FLAG_NOTTEXT;
- TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
- TYPE_INSTANCE_FLAG_NOTTEXT;
+
+ builtin_type->builtin_int8->set_instance_flags
+ (builtin_type->builtin_int8->instance_flags ()
+ | TYPE_INSTANCE_FLAG_NOTTEXT);
+
+ builtin_type->builtin_uint8->set_instance_flags
+ (builtin_type->builtin_uint8->instance_flags ()
+ | TYPE_INSTANCE_FLAG_NOTTEXT);
/* Wide character types. */
builtin_type->builtin_char16
/* This set of objfile-based types is intended to be used by symbol
readers as basic types. */
-static const struct objfile_data *objfile_type_data;
+static const struct objfile_key<struct objfile_type,
+ gdb::noop_deleter<struct objfile_type>>
+ objfile_type_data;
const struct objfile_type *
objfile_type (struct objfile *objfile)
{
struct gdbarch *gdbarch;
- struct objfile_type *objfile_type
- = (struct objfile_type *) objfile_data (objfile, objfile_type_data);
+ struct objfile_type *objfile_type = objfile_type_data.get (objfile);
if (objfile_type)
return objfile_type;
1, struct objfile_type);
/* Use the objfile architecture to determine basic type properties. */
- gdbarch = get_objfile_arch (objfile);
+ gdbarch = objfile->arch ();
/* Basic types. */
objfile_type->builtin_void
objfile_type->builtin_char
= init_integer_type (objfile, TARGET_CHAR_BIT,
!gdbarch_char_signed (gdbarch), "char");
- TYPE_NOSIGN (objfile_type->builtin_char) = 1;
+ objfile_type->builtin_char->set_has_no_signedness (true);
objfile_type->builtin_signed_char
= init_integer_type (objfile, TARGET_CHAR_BIT,
0, "signed char");
objfile_type->nodebug_text_symbol
= init_type (objfile, TYPE_CODE_FUNC, TARGET_CHAR_BIT,
"<text variable, no debug info>");
+
objfile_type->nodebug_text_gnu_ifunc_symbol
= init_type (objfile, TYPE_CODE_FUNC, TARGET_CHAR_BIT,
"<text gnu-indirect-function variable, no debug info>");
- TYPE_GNU_IFUNC (objfile_type->nodebug_text_gnu_ifunc_symbol) = 1;
+ objfile_type->nodebug_text_gnu_ifunc_symbol->set_is_gnu_ifunc (true);
+
objfile_type->nodebug_got_plt_symbol
= init_pointer_type (objfile, gdbarch_addr_bit (gdbarch),
"<text from jump slot in .got.plt, no debug info>",
= init_integer_type (objfile, gdbarch_addr_bit (gdbarch), 1,
"__CORE_ADDR");
- set_objfile_data (objfile, objfile_type_data, objfile_type);
+ objfile_type_data.set (objfile, objfile_type);
return objfile_type;
}
+void _initialize_gdbtypes ();
void
-_initialize_gdbtypes (void)
+_initialize_gdbtypes ()
{
gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
- objfile_type_data = register_objfile_data ();
add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
_("Set debugging of C++ overloading."),
projects / deliverable / binutils-gdb.git / blobdiff