/* 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;
/* 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_LENGTH (ntype)
= gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
- TYPE_CODE (ntype) = TYPE_CODE_PTR;
+ 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
TYPE_LENGTH (ntype) =
gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
- TYPE_CODE (ntype) = refcode;
+ 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);
--nparams;
TYPE_VARARGS (fn) = 1;
}
- else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
+ else if (check_typedef (param_types[nparams - 1])->code ()
== TYPE_CODE_VOID)
{
--nparams;
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;
TYPE_TARGET_TYPE (mtype) = type;
{
/* 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 (TYPE_CODE (index_type) != TYPE_CODE_VOID);
+ 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;
get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
{
type = check_typedef (type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
*lowp = TYPE_LOW_BOUND (type);
int
discrete_position (struct type *type, LONGEST val, LONGEST *pos)
{
- if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+ if (type->code () == TYPE_CODE_ENUM)
{
int i;
}
}
+/* 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 (type);
+
+ if (type->dyn_prop (DYN_PROP_BYTE_STRIDE) == nullptr
+ && has_static_range (TYPE_RANGE_DATA (range_type))
+ && (!type_not_associated (type)
+ && !type_not_allocated (type)))
+ {
+ 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 = TYPE_BIT_STRIDE (range_type);
+
+ if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
+ 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);
+
+ return true;
+ }
+
+ return false;
+}
+
/* Create an array type using either a blank type supplied in
RESULT_TYPE, or creating a new type, inheriting the objfile from
RANGE_TYPE.
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;
- int stride;
- /* 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 = bit_stride;
- if (stride == 0)
- stride = TYPE_BIT_STRIDE (range_type);
+ 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)
+ 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 (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 (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 (result_type)
- = ((std::abs (stride) * element_count) + 7) / 8;
- }
- else
- TYPE_LENGTH (result_type) =
- TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
- }
- else
+ 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
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 = 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;
+ result_type->set_code (TYPE_CODE_SET);
TYPE_NFIELDS (result_type) = 1;
TYPE_FIELDS (result_type)
= (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
/* 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;
elt_type = make_qualified_type (elt_type, flags, NULL);
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
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;
{
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);
{
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);
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."),
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_UNSIGNED (type));
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_UNSIGNED (type));
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;
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);
}
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;
- struct dynamic_prop *prop = get_dyn_prop (DYN_PROP_VARIANT_PARTS, 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 (type))
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
{
const struct dynamic_prop *prop;
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))
/* For dynamic type resolution strings can be treated like arrays of
characters. */
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY
- || TYPE_CODE (type) == TYPE_CODE_STRING);
+ gdb_assert (type->code () == TYPE_CODE_ARRAY
+ || type->code () == TYPE_CODE_STRING);
type = copy_type (type);
ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type));
- if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY)
+ if (ary_dim != NULL && ary_dim->code () == TYPE_CODE_ARRAY)
elt_type = resolve_dynamic_array_or_string (ary_dim, addr_stack);
else
elt_type = TYPE_TARGET_TYPE (type);
- prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
+ prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE);
if (prop != NULL)
{
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
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)
int i;
unsigned resolved_type_bit_length = 0;
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
+ gdb_assert (type->code () == TYPE_CODE_STRUCT);
gdb_assert (TYPE_NFIELDS (type) > 0);
resolved_type = copy_type (type);
- struct dynamic_prop *variant_prop = get_dyn_prop (DYN_PROP_VARIANT_PARTS,
- resolved_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,
&& dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
type_length = value;
- if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ 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:
{
if (type_length.has_value ())
{
TYPE_LENGTH (resolved_type) = *type_length;
- remove_dyn_prop (DYN_PROP_BYTE_SIZE, resolved_type);
+ resolved_type->remove_dyn_prop (DYN_PROP_BYTE_SIZE);
}
/* Resolve data_location attribute. */
/* 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)
{
/* 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 (TYPE_OBJFILE_OWNED (this));
- temp = XOBNEW (&TYPE_OBJFILE (type)->objfile_obstack,
+ temp = XOBNEW (&TYPE_OBJFILE (this)->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;
gdb_assert (type);
- while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ while (type->code () == TYPE_CODE_TYPEDEF)
{
if (!TYPE_TARGET_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 (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
+ if (TYPE_OBJFILE (SYMBOL_TYPE (sym)) == TYPE_OBJFILE (type))
type = make_qualified_type (SYMBOL_TYPE (sym),
TYPE_INSTANCE_FLAGS (type),
type);
{
/* 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;
}
- else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
- {
- struct type *range_type = check_typedef (TYPE_INDEX_TYPE (type));
- if (has_static_range (TYPE_RANGE_DATA (range_type)))
- {
- ULONGEST len = 0;
- LONGEST low_bound = TYPE_LOW_BOUND (range_type);
- LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
- if (high_bound >= low_bound)
- len = (high_bound - low_bound + 1) * TYPE_LENGTH (target_type);
- TYPE_LENGTH (type) = len;
- TYPE_TARGET_STUB (type) = 0;
- }
- }
+ else if (type->code () == TYPE_CODE_ARRAY
+ && update_static_array_size (type))
+ TYPE_TARGET_STUB (type) = 0;
}
type = make_qualified_type (type, instance_flags, NULL);
static void
set_type_code (struct type *type, enum type_code code)
{
- TYPE_CODE (type) = code;
+ type->set_code (code);
switch (code)
{
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);
}
{
struct type *t;
- gdb_assert (TYPE_CODE (target_type) == TYPE_CODE_INT
- || TYPE_CODE (target_type) == TYPE_CODE_FLT);
+ gdb_assert (target_type->code () == TYPE_CODE_INT
+ || target_type->code () == TYPE_CODE_FLT);
if (TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type == nullptr)
{
if (align != 0)
return align;
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_FUNC:
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)));
+ && ((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))
+ 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) && TYPE_NFIELDS (t) == 1
+ && TYPE_INDEX_TYPE(t)->code () == TYPE_CODE_RANGE)
{
LONGEST low_bound, high_bound;
struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
return high_bound == low_bound && is_scalar_type_recursive (elt_type);
}
/* Are we dealing with a struct with one element? */
- else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
+ else if (t->code () == 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_UNION)
{
int i, n = TYPE_NFIELDS (t);
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
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);
/* 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));
/* 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 (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)
if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
return false;
- if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
+ if (type1->code () == TYPE_CODE_RANGE)
{
if (*TYPE_RANGE_DATA (type1) != *TYPE_RANGE_DATA (type2))
return false;
{
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:
static struct rank
rank_one_type_parm_func (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_PTR: /* funcptr -> func */
return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
static struct rank
rank_one_type_parm_int (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_INT:
if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
static struct rank
rank_one_type_parm_enum (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
static struct rank
rank_one_type_parm_char (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
static struct rank
rank_one_type_parm_range (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
static struct rank
rank_one_type_parm_bool (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
/* n3290 draft, section 4.12.1 (conv.bool):
static struct rank
rank_one_type_parm_float (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_FLT:
if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
static struct rank
rank_one_type_parm_complex (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{ /* Strictly not needed for C++, but... */
case TYPE_CODE_FLT:
return FLOAT_PROMOTION_BADNESS;
{
struct rank rank = {0, 0};
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
case TYPE_CODE_STRUCT:
/* Check for derivation */
static struct rank
rank_one_type_parm_set (struct type *parm, struct type *arg, struct value *value)
{
- switch (TYPE_CODE (arg))
+ switch (arg->code ())
{
/* Not in C++ */
case TYPE_CODE_SET:
struct rank rank = {0,0};
/* Resolve typedefs */
- if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
+ if (parm->code () == TYPE_CODE_TYPEDEF)
parm = check_typedef (parm);
- if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
+ if (arg->code () == TYPE_CODE_TYPEDEF)
arg = check_typedef (arg);
if (TYPE_IS_REFERENCE (parm) && value != NULL)
{
/* Rvalues should preferably bind to rvalue references or const
lvalue references. */
- if (TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF)
+ 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
{
/* It's illegal to pass an lvalue as an rvalue. */
- if (TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF)
+ if (parm->code () == TYPE_CODE_RVALUE_REF)
return INCOMPATIBLE_TYPE_BADNESS;
}
}
struct type *t2 = arg;
/* For pointers and references, compare target type. */
- if (TYPE_CODE (parm) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (parm))
+ if (parm->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (parm))
{
t1 = TYPE_TARGET_TYPE (parm);
t2 = TYPE_TARGET_TYPE (arg);
REFERENCE_SEE_THROUGH_BADNESS));
if (overload_debug)
/* Debugging only. */
- fprintf_filtered (gdb_stderr,
+ 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));
+ TYPE_NAME (arg), arg->code (),
+ TYPE_NAME (parm), parm->code ());
/* x -> y means arg of type x being supplied for parameter of type y. */
- switch (TYPE_CODE (parm))
+ switch (parm->code ())
{
case TYPE_CODE_PTR:
return rank_one_type_parm_ptr (parm, arg, value);
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. */
TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
printf_filtered (")\n");
- printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
- switch (TYPE_CODE (type))
+ printfi_filtered (spaces, "code 0x%x ", type->code ());
+ switch (type->code ())
{
case TYPE_CODE_UNDEF:
printf_filtered ("(TYPE_CODE_UNDEF)");
{
puts_filtered (" TYPE_PROTOTYPED");
}
- if (TYPE_INCOMPLETE (type))
- {
- puts_filtered (" TYPE_INCOMPLETE");
- }
if (TYPE_VARARGS (type))
{
puts_filtered (" TYPE_VARARGS");
puts_filtered ("\n");
for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
{
- if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+ if (type->code () == TYPE_CODE_ENUM)
printfi_filtered (spaces + 2,
"[%d] enumval %s type ",
idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
recursive_dump_type (TYPE_FIELD_TYPE (type, idx), 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)),
}
/* 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);
}
- 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. */
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)
+ if (type->main_type->dyn_prop_list != NULL)
+ new_type->main_type->dyn_prop_list
= copy_dynamic_prop_list (&TYPE_OBJFILE (type) -> objfile_obstack,
- TYPE_DYN_PROP_LIST (type));
+ type->main_type->dyn_prop_list);
return new_type;
}
int type_bitsize = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
int field_nr = TYPE_NFIELDS (type);
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
+ gdb_assert (type->code () == TYPE_CODE_FLAGS);
gdb_assert (TYPE_NFIELDS (type) + 1 <= type_bitsize);
gdb_assert (start_bitpos >= 0 && start_bitpos < type_bitsize);
gdb_assert (nr_bits >= 1 && nr_bits <= type_bitsize);
{
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)
projects / deliverable / binutils-gdb.git / blobdiff