/* 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;
TYPE_PROTOTYPED (fn) = 1;
}
- 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];
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);
*highp = TYPE_HIGH_BOUND (type);
+ if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM)
+ {
+ if (!discrete_position (TYPE_TARGET_TYPE (type), *lowp, lowp)
+ || ! discrete_position (TYPE_TARGET_TYPE (type), *highp, highp))
+ return 0;
+ }
return 1;
case TYPE_CODE_ENUM:
- if (TYPE_NFIELDS (type) > 0)
+ if (type->num_fields () > 0)
{
/* The enums may not be sorted by value, so search all
entries. */
int i;
*lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
- for (i = 0; i < TYPE_NFIELDS (type); i++)
+ for (i = 0; i < type->num_fields (); i++)
{
if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
*lowp = TYPE_FIELD_ENUMVAL (type, i);
int
discrete_position (struct type *type, LONGEST val, LONGEST *pos)
{
- 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)
+ for (i = 0; i < type->num_fields (); i += 1)
{
if (val == TYPE_FIELD_ENUMVAL (type, i))
{
static bool
update_static_array_size (struct type *type)
{
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY);
+ gdb_assert (type->code () == TYPE_CODE_ARRAY);
struct type *range_type = TYPE_INDEX_TYPE (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;
- TYPE_NFIELDS (result_type) = 1;
- TYPE_FIELDS (result_type) =
- (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
+ result_type->set_num_fields (1);
+ result_type->set_fields
+ ((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);
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))
{
/* 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;
- TYPE_NFIELDS (type) = nargs;
+ type->set_fields (args);
+ type->set_num_fields (nargs);
if (varargs)
TYPE_VARARGS (type) = 1;
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);
+ name = saved_type->name ();
objfile = TYPE_OBJFILE (saved_type);
error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
name ? name : "<anonymous>",
{
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);
{
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);
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 ());
}
- 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, i), TYPE_FIELD_BITPOS (type, i)};
+ return {&type->field (i), TYPE_FIELD_BITPOS (type, i)};
}
else if (!t_field_name || *t_field_name == '\0')
{
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;
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_HAS_DYNAMIC_LENGTH (type))
return 1;
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
{
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))
bool is_cplus = HAVE_CPLUS_STRUCT (type);
- for (i = 0; i < TYPE_NFIELDS (type); ++i)
+ for (i = 0; i < type->num_fields (); ++i)
{
/* Static fields can be ignored here. */
- if (field_is_static (&TYPE_FIELD (type, i)))
+ 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_TYPE (type, i), 0))
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);
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
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),
const gdb::array_view<variant_part> &parts)
{
/* Assume all fields are included by default. */
- std::vector<bool> flags (TYPE_NFIELDS (resolved_type), true);
+ 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);
- TYPE_NFIELDS (resolved_type) = std::count (flags.begin (), flags.end (),
- true);
- TYPE_FIELDS (resolved_type)
- = (struct field *) TYPE_ALLOC (resolved_type,
- TYPE_NFIELDS (resolved_type)
- * sizeof (struct field));
+ 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_NFIELDS (type); ++i)
+ for (int i = 0; i < type->num_fields (); ++i)
{
if (!flags[i])
continue;
- TYPE_FIELD (resolved_type, out) = TYPE_FIELD (type, i);
+ resolved_type->field (out) = type->field (i);
++out;
}
}
int i;
unsigned resolved_type_bit_length = 0;
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
- gdb_assert (TYPE_NFIELDS (type) > 0);
+ gdb_assert (type->code () == TYPE_CODE_STRUCT);
+ gdb_assert (type->num_fields () > 0);
resolved_type = copy_type (type);
}
else
{
- 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));
+ 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 < TYPE_NFIELDS (resolved_type); ++i)
+ for (i = 0; i < resolved_type->num_fields (); ++i)
{
unsigned new_bit_length;
struct property_addr_info pinfo;
- if (field_is_static (&TYPE_FIELD (resolved_type, i)))
+ if (field_is_static (&resolved_type->field (i)))
continue;
if (TYPE_FIELD_LOC_KIND (resolved_type, i) == FIELD_LOC_KIND_DWARF_BLOCK)
CORE_ADDR addr;
if (dwarf2_evaluate_property (&prop, nullptr, addr_stack, &addr,
true))
- SET_FIELD_BITPOS (TYPE_FIELD (resolved_type, i),
+ SET_FIELD_BITPOS (resolved_type->field (i),
TARGET_CHAR_BIT * (addr - addr_stack->addr));
}
&& 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:
{
dynamic_prop *
type::dyn_prop (dynamic_prop_node_kind prop_kind) const
{
- dynamic_prop_list *node = TYPE_DYN_PROP_LIST (this);
+ dynamic_prop_list *node = this->main_type->dyn_prop_list;
while (node != NULL)
{
struct dynamic_prop_list);
temp->prop_kind = prop_kind;
temp->prop = prop;
- temp->next = TYPE_DYN_PROP_LIST (this);
+ temp->next = this->main_type->dyn_prop_list;
- TYPE_DYN_PROP_LIST (this) = temp;
+ this->main_type->dyn_prop_list = temp;
}
/* See gdbtypes.h. */
{
struct dynamic_prop_list *prev_node, *curr_node;
- curr_node = TYPE_DYN_PROP_LIST (this);
+ curr_node = this->main_type->dyn_prop_list;
prev_node = NULL;
while (NULL != curr_node)
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 (this) = 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))
{
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)
&& opaque_type_resolution
&& !currently_reading_symtab)
{
- const char *name = TYPE_NAME (type);
+ const char *name = type->name ();
struct type *newtype;
if (name == NULL)
types. */
else if (TYPE_STUB (type) && !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? */
struct symbol *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))
+ 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
+ else if (type->code () == TYPE_CODE_ARRAY
&& update_static_array_size (type))
TYPE_TARGET_STUB (type) = 0;
}
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);
}
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;
}
{
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)
{
{
char *new_name
= (char *) TYPE_ALLOC (target_type,
- strlen (TYPE_NAME (target_type))
+ strlen (target_type->name ())
+ strlen ("_Complex ") + 1);
strcpy (new_name, "_Complex ");
- strcat (new_name, TYPE_NAME (target_type));
+ 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);
- TYPE_NAME (t) = name;
+ t->set_name (name);
TYPE_TARGET_TYPE (t) = target_type;
TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type = t;
if (align != 0)
return align;
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_FUNC:
case TYPE_CODE_UNION:
{
int number_of_non_static_fields = 0;
- for (unsigned i = 0; i < TYPE_NFIELDS (type); ++i)
+ for (unsigned i = 0; i < type->num_fields (); ++i)
{
- if (!field_is_static (&TYPE_FIELD (type, i)))
+ if (!field_is_static (&type->field (i)))
{
number_of_non_static_fields++;
ULONGEST f_align = type_align (TYPE_FIELD_TYPE (type, i));
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) && t->num_fields () == 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 && t->num_fields () == 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 i, n = t->num_fields ();
/* If all elements of the union are scalar, then the union is scalar. */
for (i = 0; i < n; i++)
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.
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));
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)
+ if (a->name () && b->name ()
+ && strcmp (a->name (), b->name ()) == 0)
return true;
/* Check if identical after resolving typedefs. */
/* 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)
+ for (i = 0; i < a->num_fields (); ++i)
if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i)))
return false;
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_VECTOR (type1) != TYPE_VECTOR (type2)
|| TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
|| TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
- || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
+ || 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))
return false;
{
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)
{
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))
{
/* unsigned int -> unsigned int, or
unsigned long -> unsigned long */
- if (integer_types_same_name_p (TYPE_NAME (parm),
- TYPE_NAME (arg)))
+ 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
{
- if (integer_types_same_name_p (TYPE_NAME (arg),
+ if (integer_types_same_name_p (arg->name (),
"long")
- && integer_types_same_name_p (TYPE_NAME (parm),
+ && integer_types_same_name_p (parm->name (),
"int"))
/* signed long -> unsigned int */
return INTEGER_CONVERSION_BADNESS;
}
else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
{
- if (integer_types_same_name_p (TYPE_NAME (parm),
- TYPE_NAME (arg)))
+ 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"))
return INTEGER_PROMOTION_BADNESS;
else
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));
+ arg->name (), arg->code (),
+ parm->name (), 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. */
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 ");
gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
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));
+ 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));
+ 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");
}
}
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
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);
+ 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))
+ printfi_filtered (spaces, "code 0x%x ", type->code ());
+ switch (type->code ())
{
case TYPE_CODE_UNDEF:
printf_filtered ("(TYPE_CODE_UNDEF)");
puts_filtered (" TYPE_NOTTEXT");
}
puts_filtered ("\n");
- printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
- gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
+ printfi_filtered (spaces, "nfields %d ", type->num_fields ());
+ 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)
+ 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)),
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));
+ if (type->name ())
+ new_type->set_name (xstrdup (type->name ()));
TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
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) =
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);
}
- 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;
}
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;
}
type = arch_type (gdbarch, TYPE_CODE_FLAGS, bit, name);
TYPE_UNSIGNED (type) = 1;
- TYPE_NFIELDS (type) = 0;
+ 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);
+ 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.
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;
FIELD_NAME (f[0]) = name;
{
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])
projects / thirdparty / binutils-gdb.git / blobdiff