continue;
struct value *field = value_primitive_field (arg, 0, i, arg_type);
- struct type *field_type = check_typedef (value_type (field));
+ struct type *field_type = check_typedef (field->type ());
if (!pass_in_v_vfp_candidate (gdbarch, regcache, info, field_type,
field))
struct type *arg_type, *fundamental_type;
int len, elements;
- arg_type = check_typedef (value_type (arg));
+ arg_type = check_typedef (arg->type ());
len = arg_type->length ();
/* If arg can be passed in v registers as per the AAPCS64, then do so if
if (regcache->raw_read (v_regnum, reg_buf) != REG_VALID)
mark_value_bytes_unavailable (result_value, 0,
- value_type (result_value)->length ());
+ result_value->type ()->length ());
else
memcpy (value_contents_raw (result_value).data (), reg_buf, regsize);
enum noside noside) override
{
value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
- value *arg2 = std::get<2> (m_storage)->evaluate (value_type (arg1),
+ value *arg2 = std::get<2> (m_storage)->evaluate (arg1->type (),
exp, noside);
return ada_equal_binop (expect_type, exp, noside, std::get<0> (m_storage),
arg1, arg2);
value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
value *rhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
value *result = eval_op_binary (expect_type, exp, noside, OP, lhs, rhs);
- return value_cast (value_type (lhs), result);
+ return value_cast (lhs->type (), result);
}
enum exp_opcode opcode () const override
struct value *callee_v = callee->evaluate (nullptr,
pstate->expout.get (),
EVAL_AVOID_SIDE_EFFECTS);
- callee_t = ada_check_typedef (value_type (callee_v));
+ callee_t = ada_check_typedef (callee_v->type ());
array_arity = ada_array_arity (callee_t);
}
= lhs->evaluate (nullptr, pstate->expout.get (),
EVAL_AVOID_SIDE_EFFECTS);
rhs = resolve (std::move (rhs), true,
- value_type (lhs_val));
+ lhs_val->type ());
pstate->push_new<ada_assign_operation>
(std::move (lhs), std::move (rhs));
}
coerce_unspec_val_to_type (struct value *val, struct type *type)
{
type = ada_check_typedef (type);
- if (value_type (val) == type)
+ if (val->type () == type)
return val;
else
{
else if (value_lazy (val)
/* Be careful not to make a lazy not_lval value. */
|| (VALUE_LVAL (val) != not_lval
- && type->length () > value_type (val)->length ()))
+ && type->length () > val->type ()->length ()))
result = allocate_value_lazy (type);
else
{
struct value *
ada_get_decoded_value (struct value *value)
{
- struct type *type = ada_check_typedef (value_type (value));
+ struct type *type = ada_check_typedef (value->type ());
if (ada_is_array_descriptor_type (type)
|| (ada_is_constrained_packed_array_type (type)
static struct value *
thin_data_pntr (struct value *val)
{
- struct type *type = ada_check_typedef (value_type (val));
+ struct type *type = ada_check_typedef (val->type ());
struct type *data_type = desc_data_target_type (thin_descriptor_type (type));
data_type = lookup_pointer_type (data_type);
static struct value *
desc_bounds (struct value *arr)
{
- struct type *type = ada_check_typedef (value_type (arr));
+ struct type *type = ada_check_typedef (arr->type ());
if (is_thin_pntr (type))
{
{
struct value *p_bounds = value_struct_elt (&arr, {}, "P_BOUNDS", NULL,
_("Bad GNAT array descriptor"));
- struct type *p_bounds_type = value_type (p_bounds);
+ struct type *p_bounds_type = p_bounds->type ();
if (p_bounds_type
&& p_bounds_type->code () == TYPE_CODE_PTR)
static struct value *
desc_data (struct value *arr)
{
- struct type *type = value_type (arr);
+ struct type *type = arr->type ();
if (is_thin_pntr (type))
return thin_data_pntr (arr);
static struct type *
ada_type_of_array (struct value *arr, int bounds)
{
- if (ada_is_constrained_packed_array_type (value_type (arr)))
- return decode_constrained_packed_array_type (value_type (arr));
+ if (ada_is_constrained_packed_array_type (arr->type ()))
+ return decode_constrained_packed_array_type (arr->type ());
- if (!ada_is_array_descriptor_type (value_type (arr)))
- return value_type (arr);
+ if (!ada_is_array_descriptor_type (arr->type ()))
+ return arr->type ();
if (!bounds)
{
struct type *array_type =
- ada_check_typedef (desc_data_target_type (value_type (arr)));
+ ada_check_typedef (desc_data_target_type (arr->type ()));
- if (ada_is_unconstrained_packed_array_type (value_type (arr)))
+ if (ada_is_unconstrained_packed_array_type (arr->type ()))
TYPE_FIELD_BITSIZE (array_type, 0) =
- decode_packed_array_bitsize (value_type (arr));
+ decode_packed_array_bitsize (arr->type ());
return array_type;
}
int arity;
struct value *descriptor;
- elt_type = ada_array_element_type (value_type (arr), -1);
- arity = ada_array_arity (value_type (arr));
+ elt_type = ada_array_element_type (arr->type (), -1);
+ arity = ada_array_arity (arr->type ());
if (elt_type == NULL || arity == 0)
- return ada_check_typedef (value_type (arr));
+ return ada_check_typedef (arr->type ());
descriptor = desc_bounds (arr);
if (value_as_long (descriptor) == 0)
return NULL;
while (arity > 0)
{
- struct type *range_type = alloc_type_copy (value_type (arr));
- struct type *array_type = alloc_type_copy (value_type (arr));
+ struct type *range_type = alloc_type_copy (arr->type ());
+ struct type *array_type = alloc_type_copy (arr->type ());
struct value *low = desc_one_bound (descriptor, arity, 0);
struct value *high = desc_one_bound (descriptor, arity, 1);
arity -= 1;
- create_static_range_type (range_type, value_type (low),
+ create_static_range_type (range_type, low->type (),
longest_to_int (value_as_long (low)),
longest_to_int (value_as_long (high)));
elt_type = create_array_type (array_type, elt_type, range_type);
- if (ada_is_unconstrained_packed_array_type (value_type (arr)))
+ if (ada_is_unconstrained_packed_array_type (arr->type ()))
{
/* We need to store the element packed bitsize, as well as
recompute the array size, because it was previously
LONGEST hi = value_as_long (high);
TYPE_FIELD_BITSIZE (elt_type, 0) =
- decode_packed_array_bitsize (value_type (arr));
+ decode_packed_array_bitsize (arr->type ());
/* If the array has no element, then the size is already
zero, and does not need to be recomputed. */
if (lo < hi)
struct value *
ada_coerce_to_simple_array_ptr (struct value *arr)
{
- if (ada_is_array_descriptor_type (value_type (arr)))
+ if (ada_is_array_descriptor_type (arr->type ()))
{
struct type *arrType = ada_type_of_array (arr, 1);
return NULL;
return value_cast (arrType, value_copy (desc_data (arr)));
}
- else if (ada_is_constrained_packed_array_type (value_type (arr)))
+ else if (ada_is_constrained_packed_array_type (arr->type ()))
return decode_constrained_packed_array (arr);
else
return arr;
struct value *
ada_coerce_to_simple_array (struct value *arr)
{
- if (ada_is_array_descriptor_type (value_type (arr)))
+ if (ada_is_array_descriptor_type (arr->type ()))
{
struct value *arrVal = ada_coerce_to_simple_array_ptr (arr);
error (_("Bounds unavailable for null array pointer."));
return value_ind (arrVal);
}
- else if (ada_is_constrained_packed_array_type (value_type (arr)))
+ else if (ada_is_constrained_packed_array_type (arr->type ()))
return decode_constrained_packed_array (arr);
else
return arr;
and "value_ind" routines to perform the dereferencing, as opposed
to using "ada_coerce_ref" or "ada_value_ind". */
arr = coerce_ref (arr);
- if (ada_check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
+ if (ada_check_typedef (arr->type ())->code () == TYPE_CODE_PTR)
arr = value_ind (arr);
- type = decode_constrained_packed_array_type (value_type (arr));
+ type = decode_constrained_packed_array_type (arr->type ());
if (type == NULL)
{
error (_("can't unpack array"));
type = resolve_dynamic_type (type, view, address);
recursively_update_array_bitsize (type);
- if (type_byte_order (value_type (arr)) == BFD_ENDIAN_BIG
- && ada_is_modular_type (value_type (arr)))
+ if (type_byte_order (arr->type ()) == BFD_ENDIAN_BIG
+ && ada_is_modular_type (arr->type ()))
{
/* This is a (right-justified) modular type representing a packed
array with no wrapper. In order to interpret the value through
int bit_size, bit_pos;
ULONGEST mod;
- mod = ada_modulus (value_type (arr)) - 1;
+ mod = ada_modulus (arr->type ()) - 1;
bit_size = 0;
while (mod > 0)
{
bit_size += 1;
mod >>= 1;
}
- bit_pos = HOST_CHAR_BIT * value_type (arr)->length () - bit_size;
+ bit_pos = HOST_CHAR_BIT * arr->type ()->length () - bit_size;
arr = ada_value_primitive_packed_val (arr, NULL,
bit_pos / HOST_CHAR_BIT,
bit_pos % HOST_CHAR_BIT,
bits = 0;
elt_total_bit_offset = 0;
- elt_type = ada_check_typedef (value_type (arr));
+ elt_type = ada_check_typedef (arr->type ());
for (i = 0; i < arity; i += 1)
{
if (elt_type->code () != TYPE_CODE_ARRAY
static struct value *
ada_value_assign (struct value *toval, struct value *fromval)
{
- struct type *type = value_type (toval);
+ struct type *type = toval->type ();
int bits = value_bitsize (toval);
toval = ada_coerce_ref (toval);
fromval = ada_coerce_ref (fromval);
- if (ada_is_direct_array_type (value_type (toval)))
+ if (ada_is_direct_array_type (toval->type ()))
toval = ada_coerce_to_simple_array (toval);
- if (ada_is_direct_array_type (value_type (fromval)))
+ if (ada_is_direct_array_type (fromval->type ()))
fromval = ada_coerce_to_simple_array (fromval);
if (!deprecated_value_modifiable (toval))
read_memory (to_addr, buffer, len);
from_size = value_bitsize (fromval);
if (from_size == 0)
- from_size = value_type (fromval)->length () * TARGET_CHAR_BIT;
+ from_size = fromval->type ()->length () * TARGET_CHAR_BIT;
const int is_big_endian = type_byte_order (type) == BFD_ENDIAN_BIG;
ULONGEST from_offset = 0;
- if (is_big_endian && is_scalar_type (value_type (fromval)))
+ if (is_big_endian && is_scalar_type (fromval->type ()))
from_offset = from_size - bits;
copy_bitwise (buffer, value_bitpos (toval),
value_contents (fromval).data (), from_offset,
value_bitpos (component) - value_bitpos (container);
int bits;
- val = value_cast (value_type (component), val);
+ val = value_cast (component->type (), val);
if (value_bitsize (component) == 0)
- bits = TARGET_CHAR_BIT * value_type (component)->length ();
+ bits = TARGET_CHAR_BIT * component->type ()->length ();
else
bits = value_bitsize (component);
- if (type_byte_order (value_type (container)) == BFD_ENDIAN_BIG)
+ if (type_byte_order (container->type ()) == BFD_ENDIAN_BIG)
{
int src_offset;
- if (is_scalar_type (check_typedef (value_type (component))))
+ if (is_scalar_type (check_typedef (component->type ())))
src_offset
- = value_type (component)->length () * TARGET_CHAR_BIT - bits;
+ = component->type ()->length () * TARGET_CHAR_BIT - bits;
else
src_offset = 0;
copy_bitwise ((value_contents_writeable (container).data ()
elt = ada_coerce_to_simple_array (arr);
- elt_type = ada_check_typedef (value_type (elt));
+ elt_type = ada_check_typedef (elt->type ());
if (elt_type->code () == TYPE_CODE_ARRAY
&& TYPE_FIELD_BITSIZE (elt_type, 0) > 0)
return value_subscript_packed (elt, arity, ind);
elt = value_subscript (elt, pos_atr (ind[k]));
if (ada_is_access_to_unconstrained_array (saved_elt_type)
- && value_type (elt)->code () != TYPE_CODE_TYPEDEF)
+ && elt->type ()->code () != TYPE_CODE_TYPEDEF)
{
/* The element is a typedef to an unconstrained array,
except that the value_subscript call stripped the
deprecated_set_value_type (elt, saved_elt_type);
}
- elt_type = ada_check_typedef (value_type (elt));
+ elt_type = ada_check_typedef (elt->type ());
}
return elt;
static struct value *
ada_value_slice (struct value *array, int low, int high)
{
- struct type *type = ada_check_typedef (value_type (array));
+ struct type *type = ada_check_typedef (array->type ());
struct type *base_index_type = type->index_type ()->target_type ();
struct type *index_type
= create_static_range_type (NULL, type->index_type (), low, high);
{
struct type *arr_type;
- if (check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
+ if (check_typedef (arr->type ())->code () == TYPE_CODE_PTR)
arr = value_ind (arr);
arr_type = value_enclosing_type (arr);
struct type *arr_type, *index_type;
int low, high;
- if (check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
+ if (check_typedef (arr->type ())->code () == TYPE_CODE_PTR)
arr = value_ind (arr);
arr_type = value_enclosing_type (arr);
else
{
struct type *ftype = ada_check_typedef (func_type->field (i).type ());
- struct type *atype = ada_check_typedef (value_type (actuals[i]));
+ struct type *atype = ada_check_typedef (actuals[i]->type ());
if (!ada_type_match (ftype, atype))
return 0;
possible_user_operator_p (enum exp_opcode op, struct value *args[])
{
struct type *type0 =
- (args[0] == NULL) ? NULL : ada_check_typedef (value_type (args[0]));
+ (args[0] == NULL) ? NULL : ada_check_typedef (args[0]->type ());
struct type *type1 =
- (args[1] == NULL) ? NULL : ada_check_typedef (value_type (args[1]));
+ (args[1] == NULL) ? NULL : ada_check_typedef (args[1]->type ());
if (type0 == NULL)
return 0;
if (VALUE_LVAL (val) == not_lval
|| VALUE_LVAL (val) == lval_internalvar)
{
- int len = ada_check_typedef (value_type (val))->length ();
+ int len = ada_check_typedef (val->type ())->length ();
const CORE_ADDR addr =
value_as_long (value_allocate_space_in_inferior (len));
int check_tag;
v = NULL;
- t1 = t = ada_check_typedef (value_type (arg));
+ t1 = t = ada_check_typedef (arg->type ());
if (t->code () == TYPE_CODE_REF)
{
t1 = t->target_type ();
/* Resolve the dynamic type as well. */
arg = value_from_contents_and_address (t1, nullptr, address);
- t1 = value_type (arg);
+ t1 = arg->type ();
if (find_struct_field (name, t1, 0,
&field_type, &byte_offset, &bit_offset,
struct value *
ada_convert_actual (struct value *actual, struct type *formal_type0)
{
- struct type *actual_type = ada_check_typedef (value_type (actual));
+ struct type *actual_type = ada_check_typedef (actual->type ());
struct type *formal_type = ada_check_typedef (formal_type0);
struct type *formal_target =
formal_type->code () == TYPE_CODE_PTR
{
struct value *val;
- actual_type = ada_check_typedef (value_type (actual));
+ actual_type = ada_check_typedef (actual->type ());
val = allocate_value (actual_type);
copy (value_contents (actual), value_contents_raw (val));
actual = ensure_lval (val);
struct value *bounds = allocate_value (bounds_type);
int i;
- for (i = ada_array_arity (ada_check_typedef (value_type (arr)));
+ for (i = ada_array_arity (ada_check_typedef (arr->type ()));
i > 0; i -= 1)
{
- modify_field (value_type (bounds),
+ modify_field (bounds->type (),
value_contents_writeable (bounds).data (),
ada_array_bound (arr, i, 0),
desc_bound_bitpos (bounds_type, i, 0),
desc_bound_bitsize (bounds_type, i, 0));
- modify_field (value_type (bounds),
+ modify_field (bounds->type (),
value_contents_writeable (bounds).data (),
ada_array_bound (arr, i, 1),
desc_bound_bitpos (bounds_type, i, 1),
bounds = ensure_lval (bounds);
- modify_field (value_type (descriptor),
+ modify_field (descriptor->type (),
value_contents_writeable (descriptor).data (),
value_pointer (ensure_lval (arr),
desc_type->field (0).type ()),
fat_pntr_data_bitpos (desc_type),
fat_pntr_data_bitsize (desc_type));
- modify_field (value_type (descriptor),
+ modify_field (descriptor->type (),
value_contents_writeable (descriptor).data (),
value_pointer (bounds,
desc_type->field (1).type ()),
static struct type *
ada_tag_type (struct value *val)
{
- return ada_lookup_struct_elt_type (value_type (val), "_tag", 1, 0);
+ return ada_lookup_struct_elt_type (val->type (), "_tag", 1, 0);
}
/* Return 1 if TAG follows the old scheme for Ada tags (used for Ada 95,
struct value *tag;
CORE_ADDR base_address;
- obj_type = value_type (obj);
+ obj_type = obj->type ();
/* It is the responsability of the caller to deref pointers. */
{
gdb::unique_xmalloc_ptr<char> name;
- if (!ada_is_tag_type (value_type (tag)))
+ if (!ada_is_tag_type (tag->type ()))
return NULL;
/* It is perfectly possible that an exception be raised while trying
{
struct value *val = value_ind (val0);
- if (ada_is_tagged_type (value_type (val), 0))
+ if (ada_is_tagged_type (val->type (), 0))
val = ada_tag_value_at_base_address (val);
return ada_to_fixed_value (val);
static struct value *
ada_coerce_ref (struct value *val0)
{
- if (value_type (val0)->code () == TYPE_CODE_REF)
+ if (val0->type ()->code () == TYPE_CODE_REF)
{
struct value *val = val0;
val = coerce_ref (val);
- if (ada_is_tagged_type (value_type (val), 0))
+ if (ada_is_tagged_type (val->type (), 0))
val = ada_tag_value_at_base_address (val);
return ada_to_fixed_value (val);
the value of type TYPE at VALADDR or ADDRESS (see comments at
the beginning of this section) VAL according to GNAT conventions.
DVAL0 should describe the (portion of a) record that contains any
- necessary discriminants. It should be NULL if value_type (VAL) is
+ necessary discriminants. It should be NULL if VAL->type () is
an outer-level type (i.e., as opposed to a branch of a variant.) A
variant field (unless unchecked) is replaced by a particular branch
of the variant.
dval = value_from_contents_and_address_unresolved (rtype,
valaddr,
address);
- rtype = value_type (dval);
+ rtype = dval->type ();
}
else
dval = dval0;
that is currently being constructed. */
dval = value_from_contents_and_address_unresolved (rtype, valaddr,
address);
- rtype = value_type (dval);
+ rtype = dval->type ();
}
else
dval = dval0;
if (dval0 == NULL)
{
dval = value_from_contents_and_address (type, valaddr, address);
- type = value_type (dval);
+ type = dval->type ();
}
else
dval = dval0;
if (templ_type != NULL)
var_type = templ_type;
- if (is_unchecked_variant (var_type, value_type (dval)))
+ if (is_unchecked_variant (var_type, dval->type ()))
return var_type0;
which = ada_which_variant_applies (var_type, dval);
value_from_contents_and_address (fixed_record_type,
valaddr,
address);
- fixed_record_type = value_type (obj);
+ fixed_record_type = obj->type ();
if (real_type != NULL)
return to_fixed_record_type
(real_type, NULL,
ada_to_fixed_value (struct value *val)
{
val = unwrap_value (val);
- val = ada_to_fixed_value_create (value_type (val), value_address (val), val);
+ val = ada_to_fixed_value_create (val->type (), value_address (val), val);
return val;
}
\f
pos_atr (struct value *arg)
{
struct value *val = coerce_ref (arg);
- struct type *type = value_type (val);
+ struct type *type = val->type ();
if (!discrete_type_p (type))
error (_("'POS only defined on discrete types"));
if (!discrete_type_p (type))
error (_("'VAL only defined on discrete types"));
- if (!integer_type_p (value_type (arg)))
+ if (!integer_type_p (arg->type ()))
error (_("'VAL requires integral argument"));
return val_atr (type, value_as_long (arg));
static struct value *
unwrap_value (struct value *val)
{
- struct type *type = ada_check_typedef (value_type (val));
+ struct type *type = ada_check_typedef (val->type ());
if (ada_is_aligner_type (type))
{
struct value *v = ada_value_struct_elt (val, "F", 0);
- struct type *val_type = ada_check_typedef (value_type (v));
+ struct type *val_type = ada_check_typedef (v->type ());
if (ada_type_name (val_type) == NULL)
val_type->set_name (ada_type_name (type));
of type's element. */
gdb_assert (type->code () == TYPE_CODE_ARRAY);
gdb_assert (is_integral_type (type->target_type ()));
- gdb_assert (value_type (val)->code () == TYPE_CODE_ARRAY);
- gdb_assert (is_integral_type (value_type (val)->target_type ()));
+ gdb_assert (val->type ()->code () == TYPE_CODE_ARRAY);
+ gdb_assert (is_integral_type (val->type ()->target_type ()));
gdb_assert (type->target_type ()->length ()
- > value_type (val)->target_type ()->length ());
+ > val->type ()->target_type ()->length ());
if (!get_array_bounds (type, &lo, &hi))
error (_("unable to determine array bounds"));
static struct value *
coerce_for_assign (struct type *type, struct value *val)
{
- struct type *type2 = value_type (val);
+ struct type *type2 = val->type ();
if (type == type2)
return val;
&& type->code () == TYPE_CODE_ARRAY)
{
val = ada_value_ind (val);
- type2 = value_type (val);
+ type2 = val->type ();
}
if (type2->code () == TYPE_CODE_ARRAY
arg1 = coerce_ref (arg1);
arg2 = coerce_ref (arg2);
- type1 = get_base_type (ada_check_typedef (value_type (arg1)));
- type2 = get_base_type (ada_check_typedef (value_type (arg2)));
+ type1 = get_base_type (ada_check_typedef (arg1->type ()));
+ type2 = get_base_type (ada_check_typedef (arg2->type ()));
if (type1->code () != TYPE_CODE_INT
|| type2->code () != TYPE_CODE_INT)
val = allocate_value (type1);
store_unsigned_integer (value_contents_raw (val).data (),
- value_type (val)->length (),
+ val->type ()->length (),
type_byte_order (type1), v);
return val;
}
static int
ada_value_equal (struct value *arg1, struct value *arg2)
{
- if (ada_is_direct_array_type (value_type (arg1))
- || ada_is_direct_array_type (value_type (arg2)))
+ if (ada_is_direct_array_type (arg1->type ())
+ || ada_is_direct_array_type (arg2->type ()))
{
struct type *arg1_type, *arg2_type;
arg1 = ada_coerce_to_simple_array (arg1);
arg2 = ada_coerce_to_simple_array (arg2);
- arg1_type = ada_check_typedef (value_type (arg1));
- arg2_type = ada_check_typedef (value_type (arg2));
+ arg1_type = ada_check_typedef (arg1->type ());
+ arg2_type = ada_check_typedef (arg2->type ());
if (arg1_type->code () != TYPE_CODE_ARRAY
|| arg2_type->code () != TYPE_CODE_ARRAY)
scoped_value_mark mark;
struct value *elt;
- struct type *lhs_type = check_typedef (value_type (lhs));
+ struct type *lhs_type = check_typedef (lhs->type ());
if (lhs_type->code () == TYPE_CODE_ARRAY)
{
}
else
{
- elt = ada_index_struct_field (index, lhs, 0, value_type (lhs));
+ elt = ada_index_struct_field (index, lhs, 0, lhs->type ());
elt = ada_to_fixed_value (elt);
}
LONGEST low_index, high_index;
container = ada_coerce_ref (container);
- if (ada_is_direct_array_type (value_type (container)))
+ if (ada_is_direct_array_type (container->type ()))
container = ada_coerce_to_simple_array (container);
lhs = ada_coerce_ref (lhs);
if (!deprecated_value_modifiable (lhs))
error (_("Left operand of assignment is not a modifiable lvalue."));
- lhs_type = check_typedef (value_type (lhs));
+ lhs_type = check_typedef (lhs->type ());
if (ada_is_direct_array_type (lhs_type))
{
lhs = ada_coerce_to_simple_array (lhs);
- lhs_type = check_typedef (value_type (lhs));
+ lhs_type = check_typedef (lhs->type ());
low_index = lhs_type->bounds ()->low.const_val ();
high_index = lhs_type->bounds ()->high.const_val ();
}
{
int index;
- if (ada_is_direct_array_type (value_type (lhs)))
+ if (ada_is_direct_array_type (lhs->type ()))
index = longest_to_int (value_as_long (m_val->evaluate (nullptr, exp,
EVAL_NORMAL)));
else
}
index = 0;
- if (! find_struct_field (name, value_type (lhs), 0,
+ if (! find_struct_field (name, lhs->type (), 0,
NULL, NULL, NULL, NULL, &index))
error (_("Unknown component name: %s."), name);
}
except if the lhs of our assignment is a convenience variable.
In the case of assigning to a convenience variable, the lhs
should be exactly the result of the evaluation of the rhs. */
- struct type *type = value_type (arg1);
+ struct type *type = arg1->type ();
if (VALUE_LVAL (arg1) == lval_internalvar)
type = NULL;
value *arg2 = std::get<1> (m_storage)->evaluate (type, exp, noside);
/* Nothing. */
}
else
- arg2 = coerce_for_assign (value_type (arg1), arg2);
+ arg2 = coerce_for_assign (arg1->type (), arg2);
return ada_value_assign (arg1, arg2);
}
static struct value *
ada_value_cast (struct type *type, struct value *arg2)
{
- if (type == ada_check_typedef (value_type (arg2)))
+ if (type == ada_check_typedef (arg2->type ()))
return arg2;
return value_cast (type, arg2);
enum noside noside, enum exp_opcode op,
struct value *arg1)
{
- struct type *type = value_type (arg1);
+ struct type *type = arg1->type ();
/* If the argument is a reference, then dereference its type, since
the user is really asking for the size of the actual object,
struct value *arg1)
{
unop_promote (exp->language_defn, exp->gdbarch, &arg1);
- if (value_less (arg1, value_zero (value_type (arg1), not_lval)))
+ if (value_less (arg1, value_zero (arg1->type (), not_lval)))
return value_neg (arg1);
else
return arg1;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- return value_zero (value_type (arg1), not_lval);
+ return value_zero (arg1->type (), not_lval);
}
else
{
/* If this is a reference to an aligner type, then remove all
the aligners. */
- if (value_type (array)->code () == TYPE_CODE_REF
- && ada_is_aligner_type (value_type (array)->target_type ()))
- value_type (array)->set_target_type
- (ada_aligned_type (value_type (array)->target_type ()));
+ if (array->type ()->code () == TYPE_CODE_REF
+ && ada_is_aligner_type (array->type ()->target_type ()))
+ array->type ()->set_target_type
+ (ada_aligned_type (array->type ()->target_type ()));
- if (ada_is_any_packed_array_type (value_type (array)))
+ if (ada_is_any_packed_array_type (array->type ()))
error (_("cannot slice a packed array"));
/* If this is a reference to an array or an array lvalue,
convert to a pointer. */
- if (value_type (array)->code () == TYPE_CODE_REF
- || (value_type (array)->code () == TYPE_CODE_ARRAY
+ if (array->type ()->code () == TYPE_CODE_REF
+ || (array->type ()->code () == TYPE_CODE_ARRAY
&& VALUE_LVAL (array) == lval_memory))
array = value_addr (array);
if (noside == EVAL_AVOID_SIDE_EFFECTS
&& ada_is_array_descriptor_type (ada_check_typedef
- (value_type (array))))
+ (array->type ())))
return empty_array (ada_type_of_array (array, 0), low_bound,
high_bound);
/* If we have more than one level of pointer indirection,
dereference the value until we get only one level. */
- while (value_type (array)->code () == TYPE_CODE_PTR
- && (value_type (array)->target_type ()->code ()
+ while (array->type ()->code () == TYPE_CODE_PTR
+ && (array->type ()->target_type ()->code ()
== TYPE_CODE_PTR))
array = value_ind (array);
to avoid a SEGV when trying to get the index type or the target
type later down the road if the debug info generated by
the compiler is incorrect or incomplete. */
- if (!ada_is_simple_array_type (value_type (array)))
+ if (!ada_is_simple_array_type (array->type ()))
error (_("cannot take slice of non-array"));
- if (ada_check_typedef (value_type (array))->code ()
+ if (ada_check_typedef (array->type ())->code ()
== TYPE_CODE_PTR)
{
- struct type *type0 = ada_check_typedef (value_type (array));
+ struct type *type0 = ada_check_typedef (array->type ());
if (high_bound < low_bound || noside == EVAL_AVOID_SIDE_EFFECTS)
return empty_array (type0->target_type (), low_bound, high_bound);
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
return array;
else if (high_bound < low_bound)
- return empty_array (value_type (array), low_bound, high_bound);
+ return empty_array (array->type (), low_bound, high_bound);
else
return ada_value_slice (array, longest_to_int (low_bound),
longest_to_int (high_bound));
return value_zero (type, not_lval);
}
- struct type *type = ada_index_type (value_type (arg2), n, "range");
+ struct type *type = ada_index_type (arg2->type (), n, "range");
if (!type)
- type = value_type (arg1);
+ type = arg1->type ();
value *arg3 = value_from_longest (type, ada_array_bound (arg2, n, 1));
arg2 = value_from_longest (type, ada_array_bound (arg2, n, 0));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
if (type_arg == NULL)
- type_arg = value_type (arg1);
+ type_arg = arg1->type ();
if (ada_is_constrained_packed_array_type (type_arg))
type_arg = decode_constrained_packed_array_type (type_arg);
{
arg1 = ada_coerce_ref (arg1);
- if (ada_is_constrained_packed_array_type (value_type (arg1)))
+ if (ada_is_constrained_packed_array_type (arg1->type ()))
arg1 = ada_coerce_to_simple_array (arg1);
struct type *type;
type = builtin_type (exp->gdbarch)->builtin_int;
else
{
- type = ada_index_type (value_type (arg1), tem,
+ type = ada_index_type (arg1->type (), tem,
ada_attribute_name (op));
if (type == NULL)
type = builtin_type (exp->gdbarch)->builtin_int;
struct value *arg1, struct value *arg2)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (value_type (arg1), not_lval);
+ return value_zero (arg1->type (), not_lval);
else
{
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
struct value *arg1, struct value *arg2)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (value_type (arg1), not_lval);
+ return value_zero (arg1->type (), not_lval);
else
{
/* For integer exponentiation operations,
only promote the first argument. */
- if (is_integral_type (value_type (arg2)))
+ if (is_integral_type (arg2->type ()))
unop_promote (exp->language_defn, exp->gdbarch, &arg1);
else
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
if (dynamic_cast<ada_string_operation *> (lhs_expr.get ()) != nullptr)
{
rhs = rhs_expr->evaluate (nullptr, exp, noside);
- lhs = lhs_expr->evaluate (value_type (rhs), exp, noside);
+ lhs = lhs_expr->evaluate (rhs->type (), exp, noside);
}
else if (dynamic_cast<ada_char_operation *> (lhs_expr.get ()) != nullptr)
{
rhs = rhs_expr->evaluate (nullptr, exp, noside);
- struct type *rhs_type = check_typedef (value_type (rhs));
+ struct type *rhs_type = check_typedef (rhs->type ());
struct type *elt_type = nullptr;
if (rhs_type->code () == TYPE_CODE_ARRAY)
elt_type = rhs_type->target_type ();
else if (dynamic_cast<ada_string_operation *> (rhs_expr.get ()) != nullptr)
{
lhs = lhs_expr->evaluate (nullptr, exp, noside);
- rhs = rhs_expr->evaluate (value_type (lhs), exp, noside);
+ rhs = rhs_expr->evaluate (lhs->type (), exp, noside);
}
else if (dynamic_cast<ada_char_operation *> (rhs_expr.get ()) != nullptr)
{
lhs = lhs_expr->evaluate (nullptr, exp, noside);
- struct type *lhs_type = check_typedef (value_type (lhs));
+ struct type *lhs_type = check_typedef (lhs->type ());
struct type *elt_type = nullptr;
if (lhs_type->code () == TYPE_CODE_ARRAY)
elt_type = lhs_type->target_type ();
return x - y;
};
- if (value_type (arg1)->code () == TYPE_CODE_PTR)
+ if (arg1->type ()->code () == TYPE_CODE_PTR)
return (value_from_longest
- (value_type (arg1),
+ (arg1->type (),
do_op (value_as_long (arg1), value_as_long (arg2))));
- if (value_type (arg2)->code () == TYPE_CODE_PTR)
+ if (arg2->type ()->code () == TYPE_CODE_PTR)
return (value_from_longest
- (value_type (arg2),
+ (arg2->type (),
do_op (value_as_long (arg1), value_as_long (arg2))));
/* Preserve the original type for use by the range case below.
We cannot cast the result to a reference type, so if ARG1 is
a reference type, find its underlying type. */
- struct type *type = value_type (arg1);
+ struct type *type = arg1->type ();
while (type->code () == TYPE_CODE_REF)
type = type->target_type ();
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
{
value *tem = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- type_arg = value_type (tem);
+ type_arg = tem->type ();
}
else
val = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
{
value *arg1 = std::get<0> (m_storage)->evaluate (expect_type, exp, noside);
- struct type *type = ada_check_typedef (value_type (arg1));
+ struct type *type = ada_check_typedef (arg1->type ());
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
if (ada_is_array_descriptor_type (type))
{
arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_NORMAL);
- type = value_type (ada_value_ind (arg1));
+ type = ada_value_ind (arg1)->type ();
}
else
{
error (_("Attempt to take contents of a non-pointer value."));
}
arg1 = ada_coerce_ref (arg1); /* FIXME: What is this for?? */
- type = ada_check_typedef (value_type (arg1));
+ type = ada_check_typedef (arg1->type ());
if (type->code () == TYPE_CODE_INT)
/* GDB allows dereferencing an int. If we were given
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *type;
- struct type *type1 = value_type (arg1);
+ struct type *type1 = arg1->type ();
if (ada_is_tagged_type (type1, 1))
{
EVAL_NORMAL);
arg1 = ada_value_struct_elt (arg1, str, 0);
arg1 = unwrap_value (arg1);
- type = value_type (ada_to_fixed_value (arg1));
+ type = ada_to_fixed_value (arg1)->type ();
}
}
else
argvec[i] = args_up[i]->evaluate (nullptr, exp, noside);
if (ada_is_constrained_packed_array_type
- (desc_base_type (value_type (callee))))
+ (desc_base_type (callee->type ())))
callee = ada_coerce_to_simple_array (callee);
- else if (value_type (callee)->code () == TYPE_CODE_ARRAY
- && TYPE_FIELD_BITSIZE (value_type (callee), 0) != 0)
+ else if (callee->type ()->code () == TYPE_CODE_ARRAY
+ && TYPE_FIELD_BITSIZE (callee->type (), 0) != 0)
/* This is a packed array that has already been fixed, and
therefore already coerced to a simple array. Nothing further
to do. */
;
- else if (value_type (callee)->code () == TYPE_CODE_REF)
+ else if (callee->type ()->code () == TYPE_CODE_REF)
{
/* Make sure we dereference references so that all the code below
feels like it's really handling the referenced value. Wrapping
well. */
callee = ada_to_fixed_value (coerce_ref (callee));
}
- else if (value_type (callee)->code () == TYPE_CODE_ARRAY
+ else if (callee->type ()->code () == TYPE_CODE_ARRAY
&& VALUE_LVAL (callee) == lval_memory)
callee = value_addr (callee);
- struct type *type = ada_check_typedef (value_type (callee));
+ struct type *type = ada_check_typedef (callee->type ());
/* Ada allows us to implicitly dereference arrays when subscripting
them. So, if this is an array typedef (encoding use for array
break;
default:
error (_("cannot subscript or call something of type `%s'"),
- ada_type_name (value_type (callee)));
+ ada_type_name (callee->type ()));
break;
}
}
continue that here. */
value *v = std::get<0> (m_storage)->evaluate (context_type, exp,
EVAL_AVOID_SIDE_EFFECTS);
- if (ada_is_any_packed_array_type (value_type (v)))
+ if (ada_is_any_packed_array_type (v->type ()))
error (_("cannot slice a packed array"));
return false;
}
k = pend - str;
}
- bound_val = ada_search_struct_field (bound, dval, 0, value_type (dval));
+ bound_val = ada_search_struct_field (bound, dval, 0, dval->type ());
if (bound_val == NULL)
return 0;
e_msg_val = ada_coerce_to_simple_array (e_msg_val);
gdb_assert (e_msg_val != NULL);
- e_msg_len = value_type (e_msg_val)->length ();
+ e_msg_len = e_msg_val->type ()->length ();
/* If the message string is empty, then treat it as if there was
no exception message. */
to extract the string from the fat string. */
if (initialize_fieldnos)
{
- struct type *type = value_type (val);
+ struct type *type = val->type ();
struct type *bounds_type;
array_fieldno = ada_get_field_index (type, "P_ARRAY", 0);
value_subscript (entry_calls_value,
value_as_long (atc_nesting_level_value));
called_task_fieldno =
- ada_get_field_index (value_type (entry_calls_value_element),
+ ada_get_field_index (entry_calls_value_element->type (),
"called_task", 0);
task_info->called_task =
value_as_address (value_field (entry_calls_value_element,
(i * bitsize) / HOST_CHAR_BIT,
(i * bitsize) % HOST_CHAR_BIT,
bitsize, elttype);
- if (check_typedef (value_type (v0))->length ()
- != check_typedef (value_type (v1))->length ())
+ if (check_typedef (v0->type ())->length ()
+ != check_typedef (v1->type ())->length ())
break;
if (!value_contents_eq (v0, value_embedded_offset (v0),
v1, value_embedded_offset (v1),
- check_typedef (value_type (v0))->length ()))
+ check_typedef (v0->type ())->length ()))
break;
}
int comma_needed,
const struct language_defn *language)
{
- struct type *type = value_type (value);
+ struct type *type = value->type ();
struct type *var_type = type->field (field_num).type ();
int which = ada_which_variant_applies (var_type, outer_value);
{
int i, len;
- struct type *type = value_type (value);
+ struct type *type = value->type ();
len = type->num_fields ();
for (i = 0; i < len; i += 1)
const struct value_print_options *options)
{
if (!options->format
- && value_type (val)->target_type ()->code () == TYPE_CODE_INT
- && value_type (val)->target_type ()->length () == 0)
+ && val->type ()->target_type ()->code () == TYPE_CODE_INT
+ && val->type ()->target_type ()->length () == 0)
{
gdb_puts ("null", stream);
return;
common_val_print (val, stream, recurse, options, language_def (language_c));
- struct type *type = ada_check_typedef (value_type (val));
+ struct type *type = ada_check_typedef (val->type ());
if (ada_is_tag_type (type))
{
gdb::unique_xmalloc_ptr<char> name = ada_tag_name (val);
ada_value_print_num (struct value *val, struct ui_file *stream, int recurse,
const struct value_print_options *options)
{
- struct type *type = ada_check_typedef (value_type (val));
+ struct type *type = ada_check_typedef (val->type ());
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
if (type->code () == TYPE_CODE_RANGE
return;
}
- struct type *type = ada_check_typedef (value_type (value));
+ struct type *type = ada_check_typedef (value->type ());
const gdb_byte *valaddr = value_contents_for_printing (value).data ();
int offset_aligned = ada_aligned_value_addr (type, valaddr) - valaddr;
int recurse,
const struct value_print_options *options)
{
- if (ada_is_bogus_array_descriptor (value_type (value)))
+ if (ada_is_bogus_array_descriptor (value->type ()))
{
gdb_printf (stream, "(...?)");
return;
ada_value_print_array (struct value *val, struct ui_file *stream, int recurse,
const struct value_print_options *options)
{
- struct type *type = ada_check_typedef (value_type (val));
+ struct type *type = ada_check_typedef (val->type ());
/* For an array of characters, print with string syntax. */
if (ada_is_string_type (type)
deref_val = coerce_ref_if_computed (original_value);
if (deref_val)
{
- if (ada_is_tagged_type (value_type (deref_val), 1))
+ if (ada_is_tagged_type (deref_val->type (), 1))
deref_val = ada_tag_value_at_base_address (deref_val);
common_val_print (deref_val, stream, recurse + 1, options,
deref_val
= ada_value_ind (value_from_pointer (lookup_pointer_type (elttype),
deref_val_int));
- if (ada_is_tagged_type (value_type (deref_val), 1))
+ if (ada_is_tagged_type (deref_val->type (), 1))
deref_val = ada_tag_value_at_base_address (deref_val);
if (value_lazy (deref_val))
ada_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
const struct value_print_options *options)
{
- struct type *type = ada_check_typedef (value_type (val));
+ struct type *type = ada_check_typedef (val->type ());
if (ada_is_array_descriptor_type (type)
|| (ada_is_constrained_packed_array_type (type)
else
val = ada_to_fixed_value (val);
- type = value_type (val);
+ type = val->type ();
struct type *saved_type = type;
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
const struct value_print_options *options)
{
struct value *val = ada_to_fixed_value (val0);
- struct type *type = ada_check_typedef (value_type (val));
+ struct type *type = ada_check_typedef (val->type ());
struct value_print_options opts;
/* If it is a pointer, indicate what it points to; but not for
*value_ptr = ada_get_decoded_value (*value_ptr);
if (*value_ptr != nullptr)
- *type_ptr = ada_check_typedef (value_type (*value_ptr));
+ *type_ptr = ada_check_typedef ((*value_ptr)->type ());
else
*type_ptr = ada_get_decoded_type (*type_ptr);
}
if (parent_value)
{
value = value_field (parent_value, fieldno);
- type = value_type (value);
+ type = value->type ();
}
else
type = parent_type->field (fieldno).type ();
if (parent_value)
{
value = ada_value_ind (parent_value);
- type = value_type (value);
+ type = value->type ();
}
else
type = parent_type->target_type ();
value_from_longest (parent_type->index_type (), elt_index);
value = ada_value_subscript (parent_value, 1, &index_value);
- type = value_type (value);
+ type = value->type ();
}
else
type = parent_type->target_type ();
if (*value != NULL && ada_is_tagged_type (*type, 1))
{
*value = ada_tag_value_at_base_address (*value);
- *type = value_type (*value);
+ *type = (*value)->type ();
}
}
ada_value_is_changeable_p (const struct varobj *var)
{
struct type *type = (var->value != nullptr
- ? value_type (var->value.get ()) : var->type);
+ ? var->value.get ()->type () : var->type);
if (type->code () == TYPE_CODE_REF)
type = type->target_type ();
for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
{
struct value *arg = args[i];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
/* Cast argument to long if necessary as the compiler does it too. */
switch (arg_type->code ())
memcpy (buf, raw_buf + 1, 1);
else
mark_value_bytes_unavailable (result_value, 0,
- value_type (result_value)->length ());
+ result_value->type ()->length ());
}
else
{
memcpy (buf, raw_buf, 1);
else
mark_value_bytes_unavailable (result_value, 0,
- value_type (result_value)->length ());
+ result_value->type ()->length ());
}
}
else if (i386_dword_regnum_p (gdbarch, regnum))
memcpy (buf, raw_buf, 4);
else
mark_value_bytes_unavailable (result_value, 0,
- value_type (result_value)->length ());
+ result_value->type ()->length ());
}
else
i386_pseudo_register_read_into_value (gdbarch, regcache, regnum,
for (i = 0; i < nargs; i++)
{
- struct type *type = value_type (args[i]);
+ struct type *type = args[i]->type ();
int len = type->length ();
enum amd64_reg_class theclass[2];
int needed_integer_regs = 0;
/* Write out the arguments to the stack. */
for (i = 0; i < num_stack_args; i++)
{
- struct type *type = value_type (stack_args[i]);
+ struct type *type = stack_args[i]->type ();
const gdb_byte *valbuf = value_contents (stack_args[i]).data ();
int len = type->length ();
int i;
for (i = 0; i < nargs; i++)
- if (amd64_windows_passed_by_pointer (value_type (args[i])))
+ if (amd64_windows_passed_by_pointer (args[i]->type ()))
{
- struct type *type = value_type (args[i]);
+ struct type *type = args[i]->type ();
const gdb_byte *valbuf = value_contents (args[i]).data ();
const int len = type->length ();
amd64_windows_store_arg_in_reg (struct regcache *regcache,
struct value *arg, int regno)
{
- struct type *type = value_type (arg);
+ struct type *type = arg->type ();
const gdb_byte *valbuf = value_contents (arg).data ();
gdb_byte buf[8];
for (i = 0; i < nargs; i++)
{
- struct type *type = value_type (args[i]);
+ struct type *type = args[i]->type ();
int len = type->length ();
int on_stack_p = 1;
/* Write out the arguments to the stack. */
for (i = 0; i < num_stack_args; i++)
{
- struct type *type = value_type (stack_args[i]);
+ struct type *type = stack_args[i]->type ();
const gdb_byte *valbuf = value_contents (stack_args[i]).data ();
write_memory (sp + element * 8, valbuf, type->length ());
argument's size up to an integral number of words. */
for (int i = 0; i < nargs; i++)
{
- unsigned int len = value_type (args[i])->length ();
+ unsigned int len = args[i]->type ()->length ();
unsigned int space = align_up (len, 4);
total_space += space;
gdb_byte *data = memory_image;
for (int i = 0; i < nargs; i++)
{
- unsigned int len = value_type (args[i])->length ();
+ unsigned int len = args[i]->type ()->length ();
unsigned int space = align_up (len, 4);
memcpy (data, value_contents (args[i]).data (), (size_t) len);
/* Determine the type of this function and whether the VFP ABI
applies. */
- ftype = check_typedef (value_type (function));
+ ftype = check_typedef (function->type ());
if (ftype->code () == TYPE_CODE_PTR)
ftype = check_typedef (ftype->target_type ());
use_vfp_abi = arm_vfp_abi_for_function (gdbarch, ftype);
int vfp_base_count;
int may_use_core_reg = 1;
- arg_type = check_typedef (value_type (args[argnum]));
+ arg_type = check_typedef (args[argnum]->type ());
len = arg_type->length ();
target_type = arg_type->target_type ();
typecode = arg_type->code ();
struct value **read_value, const gdb_byte *writebuf)
{
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
- struct type *func_type = function ? value_type (function) : NULL;
+ struct type *func_type = function ? function->type () : NULL;
enum arm_vfp_cprc_base_type vfp_base_type;
int vfp_base_count;
int last_regnum;
int j;
struct value *arg = args[i];
- struct type *type = check_typedef (value_type (arg));
+ struct type *type = check_typedef (arg->type ());
const bfd_byte *contents = value_contents (arg).data ();
int len = type->length ();
struct value *v = evaluate (nullptr, exp, EVAL_AVOID_SIDE_EFFECTS);
ax_const_l (ax, value_as_long (v));
value->kind = axs_rvalue;
- value->type = check_typedef (value_type (v));
+ value->type = check_typedef (v->type ());
}
else
{
struct value *v
= std::get<1> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- if (value_type (v)->code () != TYPE_CODE_INT)
+ if (v->type ()->code () != TYPE_CODE_INT)
error (_("Right operand of `@' must be an integer."));
int length = value_as_long (v);
if (length <= 0)
struct value *val
= std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- struct type *type = value_type (val);
+ struct type *type = val->type ();
std::get<1> (m_storage)->generate_ax (exp, ax, value);
struct value *val
= std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- std::get<1> (m_storage)->generate_ax (exp, ax, value, value_type (val));
+ std::get<1> (m_storage)->generate_ax (exp, ax, value, val->type ());
}
void
if (val == NULL)
return NULL;
- bit_val = allocate_value (value_type (val));
+ bit_val = allocate_value (val->type ());
unpack_value_bitfield (bit_val,
w->val_bitpos,
if (VALUE_LVAL (v) == lval_memory
&& (v == val_chain[0] || ! value_lazy (v)))
{
- struct type *vtype = check_typedef (value_type (v));
+ struct type *vtype = check_typedef (v->type ());
/* We only watch structs and arrays if user asked
for it explicitly, never if they just happen to
for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
;
*tmp = loc;
- loc->gdbarch = value_type (v)->arch ();
+ loc->gdbarch = v->type ()->arch ();
loc->pspace = frame_pspace;
loc->address
loc->length = ((bitpos % 8) + bitsize + 7) / 8;
}
else
- loc->length = value_type (v)->length ();
+ loc->length = v->type ()->length ();
loc->watchpoint_type = type;
}
w->cond_exp_valid_block = cond_exp_valid_block;
if (just_location)
{
- struct type *t = value_type (val.get ());
+ struct type *t = val.get ()->type ();
CORE_ADDR addr = value_as_address (val.get ());
w->exp_string_reparse
{
/* Ahh, memory we actually used! Check if we can cover
it with hardware watchpoints. */
- struct type *vtype = check_typedef (value_type (v));
+ struct type *vtype = check_typedef (v->type ());
/* We only watch structs and arrays if user asked for it
explicitly, never if they just happen to appear in a
len = (target_exact_watchpoints
&& is_scalar_type_recursive (vtype))?
- 1 : value_type (v)->length ();
+ 1 : v->type ()->length ();
num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
if (!num_regs)
value *lhs
= std::get<0> (this->m_storage)->evaluate (nullptr, exp, noside);
value *rhs
- = std::get<1> (this->m_storage)->evaluate (value_type (lhs), exp,
+ = std::get<1> (this->m_storage)->evaluate (lhs->type (), exp,
noside);
return FUNC (expect_type, exp, noside, OP, lhs, rhs);
}
{
int err, width;
unsigned int fetchlimit;
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
struct type *element_type = type->target_type ();
int req_length = *length;
enum bfd_endian byte_order
struct ui_file *stream, int recurse,
const struct value_print_options *options)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
CORE_ADDR address = value_address (val);
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
struct type *unresolved_elttype = type->target_type ();
return;
}
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
if (options->vtblprint && cp_is_vtbl_ptr_type (type))
c_value_print_struct (struct value *val, struct ui_file *stream, int recurse,
const struct value_print_options *options)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (type->code () == TYPE_CODE_UNION && recurse && !options->unionprint)
gdb_printf (stream, "{...}");
instead. Since we don't know whether the value is really
intended to be used as an integer or a character, print
the character equivalent as well. */
- struct type *type = value_type (val);
+ struct type *type = val->type ();
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
if (c_textual_element_type (type, options->format))
{
c_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
const struct value_print_options *options)
{
- struct type *type = value_type (val);
+ struct type *type = val->type ();
type = check_typedef (type);
switch (type->code ())
C++: if it is a member pointer, we will take care
of that when we print it. */
- type = check_typedef (value_type (val));
+ type = check_typedef (val->type ());
if (type->is_pointer_or_reference ())
{
- struct type *original_type = value_type (val);
+ struct type *original_type = val->type ();
/* Hack: remove (char *) for char strings. Their
type is indicated by the quoted string anyway.
if (is_ref)
val = value_ref (value_ind (val), refcode);
- type = value_type (val);
+ type = val->type ();
type_print (type, "", stream, -1);
gdb_printf (stream, ") ");
}
{
/* normal case */
gdb_printf (stream, "(");
- type_print (value_type (val), "", stream, -1);
+ type_print (val->type (), "", stream, -1);
gdb_printf (stream, ") ");
}
}
value_struct_element_index (struct value *value, int type_index)
{
struct value *result = NULL;
- struct type *type = value_type (value);
+ struct type *type = value->type ();
type = check_typedef (type);
if (argc != 1)
error (_("You can only provide one argument to %s"), fnname);
- struct type *type0 = check_typedef (value_type (argv[0]));
+ struct type *type0 = check_typedef (argv[0]->type ());
if (type0->code () != TYPE_CODE_ARRAY
&& type0->code () != TYPE_CODE_STRING)
/* Have everything. Open/write the data. */
if (file_format == NULL || strcmp (file_format, "binary") == 0)
dump_binary_file (filename.get (), mode, value_contents (val).data (),
- value_type (val)->length ());
+ val->type ()->length ());
else
{
CORE_ADDR vaddr;
dump_bfd_file (filename.get (), mode, file_format, vaddr,
value_contents (val).data (),
- value_type (val)->length ());
+ val->type ()->length ());
}
}
if (val != NULL) /* Value history reference */
{
- if (value_type (val)->code () == TYPE_CODE_INT)
+ if (val->type ()->code () == TYPE_CODE_INT)
retval = value_as_long (val);
else
error (_("History value must have integer type."));
if (val) /* Value history reference */
{
- if (value_type (val)->code () == TYPE_CODE_INT)
+ if (val->type ()->code () == TYPE_CODE_INT)
retval = value_as_long (val);
else
{
struct type *ret = NULL;
if ((current_cp_abi.rtti_type) == NULL
- || !HAVE_CPLUS_STRUCT (check_typedef (value_type (v))))
+ || !HAVE_CPLUS_STRUCT (check_typedef (v->type ())))
return NULL;
try
{
int fields_seen = 0;
static int last_set_recurse = -1;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (recurse == 0)
{
int recurse, const struct value_print_options *options,
struct type **dont_print_vb)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
CORE_ADDR address = value_address (val);
struct type **last_dont_print
= (struct type **) obstack_next_free (&dont_print_vb_obstack);
base_val = value_from_contents_and_address (baseclass,
buf.data (),
address + boffset);
- baseclass = value_type (base_val);
+ baseclass = base_val->type ();
boffset = 0;
}
else
int reg_demand;
int i;
- len = value_type (args[argnum])->length ();
+ len = args[argnum]->type ()->length ();
val = value_contents (args[argnum]).data ();
/* How may registers worth of storage do we need for this argument? */
struct type *arg_type;
const gdb_byte *val;
- arg_type = check_typedef (value_type (args[argnum]));
+ arg_type = check_typedef (args[argnum]->type ());
len = arg_type->length ();
val = value_contents (args[argnum]).data ();
true_type = lookup_array_range_type (true_type, 0, length - 1);
ival = value_at (true_type, addr);
- true_type = value_type (ival);
+ true_type = ival->type ();
d_value_print_inner (ival, stream, recurse + 1, options);
return 0;
{
int ret;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
switch (type->code ())
{
case TYPE_CODE_STRUCT:
expression_up expr = parse_expression (exp);
val = evaluate_expression (expr.get ());
- if (TYPE_IS_REFERENCE (value_type (val)))
+ if (TYPE_IS_REFERENCE (val->type ()))
{
val = value_ind (val);
}
}
if (expr != NULL && expr->first_opcode () == OP_TYPE)
- type = value_type (evaluate_type (expr.get ()));
+ type = evaluate_type (expr.get ())->type ();
args.emplace_back (type, std::move (type_str), std::move (expr));
}
piece_closure *c
= (piece_closure *) value_computed_closure (v);
gdb::byte_vector buffer;
- bool bits_big_endian = type_byte_order (value_type (v)) == BFD_ENDIAN_BIG;
+ bool bits_big_endian = type_byte_order (v->type ()) == BFD_ENDIAN_BIG;
gdb_assert (!check_optimized || from == nullptr);
if (from != nullptr)
bits_to_skip += (8 * value_offset (value_parent (v))
+ value_bitpos (v));
if (from != nullptr
- && (type_byte_order (value_type (from))
+ && (type_byte_order (from->type ())
== BFD_ENDIAN_BIG))
{
/* Use the least significant bits of FROM. */
- max_offset = 8 * value_type (from)->length ();
+ max_offset = 8 * from->type ()->length ();
offset = max_offset - value_bitsize (v);
}
else
max_offset = value_bitsize (v);
}
else
- max_offset = 8 * value_type (v)->length ();
+ max_offset = 8 * v->type ()->length ();
/* Advance to the first non-skipped piece. */
for (i = 0; i < c->pieces.size () && bits_to_skip >= c->pieces[i].size; i++)
gdbarch *objfile_gdbarch = c->per_objfile->objfile->arch ();
ULONGEST stack_value_size_bits
- = 8 * value_type (p->v.value)->length ();
+ = 8 * p->v.value->type ()->length ();
/* Use zeroes if piece reaches beyond stack value. */
if (p->offset + p->size > stack_value_size_bits)
int i;
dwarf_expr_piece *piece = NULL;
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
if (type->code () != TYPE_CODE_PTR)
return NULL;
static value *
coerce_pieced_ref (const value *value)
{
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
if (value_bits_synthetic_pointer (value, value_embedded_offset (value),
TARGET_CHAR_BIT * type->length ()))
case DWARF_VALUE_STACK:
{
value *val = this->fetch (0);
- size_t n = value_type (val)->length ();
+ size_t n = val->type ()->length ();
size_t len = subobj_type->length ();
size_t max = type->length ();
bfd_endian byte_order = gdbarch_byte_order (arch);
ULONGEST result;
- dwarf_require_integral (value_type (result_val));
+ dwarf_require_integral (result_val->type ());
result = extract_unsigned_integer (value_contents (result_val), byte_order);
/* For most architectures, calling extract_unsigned_integer() alone
{
gdb_byte *buf = (gdb_byte *) alloca (this->m_addr_size);
type *int_type = get_unsigned_type (arch,
- value_type (result_val));
+ result_val->type ());
store_unsigned_integer (buf, this->m_addr_size, byte_order, result);
return gdbarch_integer_to_address (arch, int_type, buf);
{
case DW_OP_abs:
if (value_less (result_val,
- value_zero (value_type (result_val), not_lval)))
+ value_zero (result_val->type (), not_lval)))
result_val = value_neg (result_val);
break;
case DW_OP_neg:
result_val = value_neg (result_val);
break;
case DW_OP_not:
- dwarf_require_integral (value_type (result_val));
+ dwarf_require_integral (result_val->type ());
result_val = value_complement (result_val);
break;
case DW_OP_plus_uconst:
- dwarf_require_integral (value_type (result_val));
+ dwarf_require_integral (result_val->type ());
result = value_as_long (result_val);
op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
result += reg;
first = fetch (0);
pop ();
- if (! base_types_equal_p (value_type (first), value_type (second)))
+ if (! base_types_equal_p (first->type (), second->type ()))
error (_("Incompatible types on DWARF stack"));
switch (op)
{
case DW_OP_and:
- dwarf_require_integral (value_type (first));
- dwarf_require_integral (value_type (second));
+ dwarf_require_integral (first->type ());
+ dwarf_require_integral (second->type ());
result_val = value_binop (first, second, BINOP_BITWISE_AND);
break;
case DW_OP_div:
case DW_OP_mod:
{
int cast_back = 0;
- struct type *orig_type = value_type (first);
+ struct type *orig_type = first->type ();
/* We have to special-case "old-style" untyped values
-- these must have mod computed using unsigned
result_val = value_binop (first, second, BINOP_MUL);
break;
case DW_OP_or:
- dwarf_require_integral (value_type (first));
- dwarf_require_integral (value_type (second));
+ dwarf_require_integral (first->type ());
+ dwarf_require_integral (second->type ());
result_val = value_binop (first, second, BINOP_BITWISE_IOR);
break;
case DW_OP_plus:
result_val = value_binop (first, second, BINOP_ADD);
break;
case DW_OP_shl:
- dwarf_require_integral (value_type (first));
- dwarf_require_integral (value_type (second));
+ dwarf_require_integral (first->type ());
+ dwarf_require_integral (second->type ());
result_val = value_binop (first, second, BINOP_LSH);
break;
case DW_OP_shr:
- dwarf_require_integral (value_type (first));
- dwarf_require_integral (value_type (second));
- if (!value_type (first)->is_unsigned ())
+ dwarf_require_integral (first->type ());
+ dwarf_require_integral (second->type ());
+ if (!first->type ()->is_unsigned ())
{
struct type *utype
- = get_unsigned_type (arch, value_type (first));
+ = get_unsigned_type (arch, first->type ());
first = value_cast (utype, first);
}
result_val = value_binop (first, second, BINOP_RSH);
/* Make sure we wind up with the same type we started
with. */
- if (value_type (result_val) != value_type (second))
- result_val = value_cast (value_type (second), result_val);
+ if (result_val->type () != second->type ())
+ result_val = value_cast (second->type (), result_val);
break;
case DW_OP_shra:
- dwarf_require_integral (value_type (first));
- dwarf_require_integral (value_type (second));
- if (value_type (first)->is_unsigned ())
+ dwarf_require_integral (first->type ());
+ dwarf_require_integral (second->type ());
+ if (first->type ()->is_unsigned ())
{
struct type *stype
- = get_signed_type (arch, value_type (first));
+ = get_signed_type (arch, first->type ());
first = value_cast (stype, first);
}
result_val = value_binop (first, second, BINOP_RSH);
/* Make sure we wind up with the same type we started
with. */
- if (value_type (result_val) != value_type (second))
- result_val = value_cast (value_type (second), result_val);
+ if (result_val->type () != second->type ())
+ result_val = value_cast (second->type (), result_val);
break;
case DW_OP_xor:
- dwarf_require_integral (value_type (first));
- dwarf_require_integral (value_type (second));
+ dwarf_require_integral (first->type ());
+ dwarf_require_integral (second->type ());
result_val = value_binop (first, second, BINOP_BITWISE_XOR);
break;
case DW_OP_le:
offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
val = fetch (0);
- dwarf_require_integral (value_type (val));
+ dwarf_require_integral (val->type ());
if (value_as_long (val) != 0)
op_ptr += offset;
pop ();
if (op == DW_OP_convert || op == DW_OP_GNU_convert)
result_val = value_cast (type, result_val);
- else if (type == value_type (result_val))
+ else if (type == result_val->type ())
{
/* Nothing. */
}
else if (type->length ()
- != value_type (result_val)->length ())
+ != result_val->type ()->length ())
error (_("DW_OP_reinterpret has wrong size"));
else
result_val
static struct value *
entry_data_value_coerce_ref (const struct value *value)
{
- struct type *checked_type = check_typedef (value_type (value));
+ struct type *checked_type = check_typedef (value->type ());
struct value *target_val;
if (!TYPE_IS_REFERENCE (checked_type))
struct type *type1;
*arg1 = coerce_ref (*arg1);
- type1 = check_typedef (value_type (*arg1));
+ type1 = check_typedef ((*arg1)->type ());
if (is_integral_type (type1))
{
*arg1 = coerce_ref (*arg1);
*arg2 = coerce_ref (*arg2);
- type1 = check_typedef (value_type (*arg1));
- type2 = check_typedef (value_type (*arg2));
+ type1 = check_typedef ((*arg1)->type ());
+ type2 = check_typedef ((*arg2)->type ());
if ((type1->code () != TYPE_CODE_FLT
&& type1->code () != TYPE_CODE_DECFLOAT
call an error. This can happen if somebody tries to turn
a variable into a function call. */
- type *ftype = value_type (callee);
+ type *ftype = callee->type ();
if (ftype->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
error (_("Expression of type other than "
"\"Function returning ...\" used as function"));
}
- switch (value_type (callee)->code ())
+ switch (callee->type ()->code ())
{
case TYPE_CODE_INTERNAL_FUNCTION:
return call_internal_function (exp->gdbarch, exp->language_defn,
std::vector<value *> vals (args.size ());
value *callee = evaluate_with_coercion (exp, noside);
- struct type *type = value_type (callee);
+ struct type *type = callee->type ();
if (type->code () == TYPE_CODE_PTR)
type = type->target_type ();
for (int i = 0; i < args.size (); ++i)
value *rhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
value *callee;
- type *a1_type = check_typedef (value_type (rhs));
+ type *a1_type = check_typedef (rhs->type ());
if (a1_type->code () == TYPE_CODE_METHODPTR)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
/* value_struct_elt updates temp with the correct value of the
``this'' pointer if necessary, so modify it to reflect any
``this'' changes. */
- vals[0] = value_from_longest (lookup_pointer_type (value_type (temp)),
+ vals[0] = value_from_longest (lookup_pointer_type (temp->type ()),
value_address (temp)
+ value_embedded_offset (temp));
}
value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- struct type *type = value_type (lhs);
+ struct type *type = lhs->type ();
for (;;)
{
type = check_typedef (type);
value *val = evaluate_var_msym_value (noside, msymbol.objfile,
msymbol.minsym);
- struct type *type = value_type (val);
+ struct type *type = val->type ();
if (type->code () == TYPE_CODE_ERROR
&& (noside != EVAL_AVOID_SIDE_EFFECTS || !outermost_p))
error_unknown_type (msymbol.minsym->print_name ());
struct value *arg3 = value_struct_elt (&arg1, {}, string,
NULL, "structure");
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
+ arg3 = value_zero (arg3->type (), VALUE_LVAL (arg3));
return arg3;
}
with rtti type in order to continue on with successful
lookup of member / method only available in the rtti type. */
{
- struct type *arg_type = value_type (arg1);
+ struct type *arg_type = arg1->type ();
struct type *real_type;
int full, using_enc;
LONGEST top;
struct value *arg3 = value_struct_elt (&arg1, {}, string,
NULL, "structure pointer");
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
+ arg3 = value_zero (arg3->type (), VALUE_LVAL (arg3));
return arg3;
}
long mem_offset;
struct value *arg3;
- struct type *type = check_typedef (value_type (arg2));
+ struct type *type = check_typedef (arg2->type ());
switch (type->code ())
{
case TYPE_CODE_METHODPTR:
else
{
arg2 = cplus_method_ptr_to_value (&arg1, arg2);
- gdb_assert (value_type (arg2)->code () == TYPE_CODE_PTR);
+ gdb_assert (arg2->type ()->code () == TYPE_CODE_PTR);
return value_ind (arg2);
}
case TYPE_CODE_MEMBERPTR:
/* Now, convert these values to an address. */
- if (check_typedef (value_type (arg1))->code () != TYPE_CODE_PTR)
+ if (check_typedef (arg1->type ())->code () != TYPE_CODE_PTR)
arg1 = value_addr (arg1);
arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
arg1, 1);
{
if (binop_user_defined_p (BINOP_ADD, arg1, arg2))
return value_x_binop (arg1, arg2, BINOP_ADD, OP_NULL, noside);
- else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && is_integral_or_integral_reference (value_type (arg2)))
+ else if (ptrmath_type_p (exp->language_defn, arg1->type ())
+ && is_integral_or_integral_reference (arg2->type ()))
return value_ptradd (arg1, value_as_long (arg2));
- else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
- && is_integral_or_integral_reference (value_type (arg1)))
+ else if (ptrmath_type_p (exp->language_defn, arg2->type ())
+ && is_integral_or_integral_reference (arg1->type ()))
return value_ptradd (arg2, value_as_long (arg1));
else
{
{
if (binop_user_defined_p (BINOP_SUB, arg1, arg2))
return value_x_binop (arg1, arg2, BINOP_SUB, OP_NULL, noside);
- else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && ptrmath_type_p (exp->language_defn, value_type (arg2)))
+ else if (ptrmath_type_p (exp->language_defn, arg1->type ())
+ && ptrmath_type_p (exp->language_defn, arg2->type ()))
{
/* FIXME -- should be ptrdiff_t */
struct type *type = builtin_type (exp->gdbarch)->builtin_long;
return value_from_longest (type, value_ptrdiff (arg1, arg2));
}
- else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && is_integral_or_integral_reference (value_type (arg2)))
+ else if (ptrmath_type_p (exp->language_defn, arg1->type ())
+ && is_integral_or_integral_reference (arg2->type ()))
return value_ptradd (arg1, - value_as_long (arg2));
else
{
{
struct value *v_one;
- v_one = value_one (value_type (arg2));
+ v_one = value_one (arg2->type ());
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
return value_binop (arg1, v_one, op);
}
/* For shift and integer exponentiation operations,
only promote the first argument. */
if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
- && is_integral_type (value_type (arg2)))
+ && is_integral_type (arg2->type ()))
unop_promote (exp->language_defn, exp->gdbarch, &arg1);
else
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
then report this as an error. */
arg1 = coerce_ref (arg1);
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
if (type->code () != TYPE_CODE_ARRAY
&& type->code () != TYPE_CODE_PTR)
{
enum noside noside, enum exp_opcode op,
struct value *arg1, struct value *arg2)
{
- struct type *type = check_typedef (value_type (arg2));
+ struct type *type = check_typedef (arg2->type ());
if (type->code () != TYPE_CODE_INT
&& type->code () != TYPE_CODE_ENUM)
error (_("Non-integral right operand for \"@\" operator."));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- return allocate_repeat_value (value_type (arg1),
+ return allocate_repeat_value (arg1->type (),
longest_to_int (value_as_long (arg2)));
}
else
enum noside noside,
struct value *arg1)
{
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
if (type->code () == TYPE_CODE_METHODPTR
|| type->code () == TYPE_CODE_MEMBERPTR)
error (_("Attempt to dereference pointer "
return value_x_unop (arg1, UNOP_IND, noside);
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- type = check_typedef (value_type (arg1));
+ type = check_typedef (arg1->type ());
/* If the type pointed to is dynamic then in order to resolve the
dynamic properties we must actually dereference the pointer.
enum noside noside,
struct value *arg1)
{
- struct type *type = value_type (arg1);
+ struct type *type = arg1->type ();
/* FIXME: This should be size_t. */
struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
ULONGEST align = type_align (type);
else
{
struct value *arg2;
- if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+ if (ptrmath_type_p (exp->language_defn, arg1->type ()))
arg2 = value_ptradd (arg1, 1);
else
{
struct value *tmp = arg1;
- arg2 = value_one (value_type (arg1));
+ arg2 = value_one (arg1->type ());
binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
arg2 = value_binop (tmp, arg2, BINOP_ADD);
}
else
{
struct value *arg2;
- if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+ if (ptrmath_type_p (exp->language_defn, arg1->type ()))
arg2 = value_ptradd (arg1, -1);
else
{
struct value *tmp = arg1;
- arg2 = value_one (value_type (arg1));
+ arg2 = value_one (arg1->type ());
binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
arg2 = value_binop (tmp, arg2, BINOP_SUB);
}
struct value *arg3 = value_non_lval (arg1);
struct value *arg2;
- if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+ if (ptrmath_type_p (exp->language_defn, arg1->type ()))
arg2 = value_ptradd (arg1, 1);
else
{
struct value *tmp = arg1;
- arg2 = value_one (value_type (arg1));
+ arg2 = value_one (arg1->type ());
binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
arg2 = value_binop (tmp, arg2, BINOP_ADD);
}
struct value *arg3 = value_non_lval (arg1);
struct value *arg2;
- if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+ if (ptrmath_type_p (exp->language_defn, arg1->type ()))
arg2 = value_ptradd (arg1, -1);
else
{
struct value *tmp = arg1;
- arg2 = value_one (value_type (arg1));
+ arg2 = value_one (arg1->type ());
binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
arg2 = value_binop (tmp, arg2, BINOP_SUB);
}
if (binop_user_defined_p (op, arg1, arg2))
return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
- value_type (arg1))
- && is_integral_type (value_type (arg2)))
+ arg1->type ())
+ && is_integral_type (arg2->type ()))
arg2 = value_ptradd (arg1, value_as_long (arg2));
else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
- value_type (arg1))
- && is_integral_type (value_type (arg2)))
+ arg1->type ())
+ && is_integral_type (arg2->type ()))
arg2 = value_ptradd (arg1, - value_as_long (arg2));
else
{
/* For shift and integer exponentiation operations,
only promote the first argument. */
if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
- && is_integral_type (value_type (arg2)))
+ && is_integral_type (arg2->type ()))
unop_promote (exp->language_defn, exp->gdbarch, &tmp);
else
binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
if (method)
{
- if (value_type (method)->code () != TYPE_CODE_FUNC)
+ if (method->type ()->code () != TYPE_CODE_FUNC)
error (_("method address has symbol information "
"with non-function type; skipping"));
function descriptors. */
if (struct_return)
called_method
- = value_from_pointer (lookup_pointer_type (value_type (method)),
+ = value_from_pointer (lookup_pointer_type (method->type ()),
value_as_address (msg_send_stret));
else
called_method
- = value_from_pointer (lookup_pointer_type (value_type (method)),
+ = value_from_pointer (lookup_pointer_type (method->type ()),
value_as_address (msg_send));
}
else
it's opinion (ie. through "whatis"), it won't offer
it. */
- struct type *callee_type = value_type (called_method);
+ struct type *callee_type = called_method->type ();
if (callee_type && callee_type->code () == TYPE_CODE_PTR)
callee_type = callee_type->target_type ();
if (gnu_runtime && (method != NULL))
{
/* Function objc_msg_lookup returns a pointer. */
- struct type *tem_type = value_type (called_method);
+ struct type *tem_type = called_method->type ();
tem_type = lookup_pointer_type (lookup_function_type (tem_type));
deprecated_set_value_type (called_method, tem_type);
called_method = call_function_by_hand (called_method, NULL, args);
else
{
arg1 = coerce_ref (arg1);
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
switch (type->code ())
{
enum noside noside, int nargs)
{
const std::vector<operation_up> &in_args = std::get<2> (m_storage);
- struct type *struct_type = check_typedef (value_type (struct_val));
+ struct type *struct_type = check_typedef (struct_val->type ());
struct type *field_type;
int fieldno = -1;
/* Now actually set the field in struct_val. */
/* Assign val to field fieldno. */
- if (value_type (val) != field_type)
+ if (val->type () != field_type)
val = value_cast (field_type, val);
bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
value_as_long (val), bitpos % 8, bitsize);
else
memcpy (addr, value_contents (val).data (),
- value_type (val)->length ());
+ val->type ()->length ());
}
return struct_val;
element = in_args[index - low_bound]->evaluate (element_type,
exp, noside);
- if (value_type (element) != element_type)
+ if (element->type () != element_type)
element = value_cast (element_type, element);
if (index > high_bound)
/* To avoid memory corruption. */
struct value *elem_val;
elem_val = in_args[idx++]->evaluate (element_type, exp, noside);
- range_low_type = range_high_type = value_type (elem_val);
+ range_low_type = range_high_type = elem_val->type ();
range_low = range_high = value_as_long (elem_val);
/* Check types of elements to avoid mixture of elements from
value *old_value = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
struct type *type = get_type ();
- if (type->length () > value_type (old_value)->length ())
+ if (type->length () > old_value->type ()->length ())
error (_("length type is larger than the value type"));
struct value *result = allocate_value (type);
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct type *type = check_typedef (value_type (x));
+ struct type *type = check_typedef (x->type ());
if (TYPE_IS_REFERENCE (type))
return value_zero (lookup_pointer_type (type->target_type ()),
not_lval);
else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
- return value_zero (lookup_pointer_type (value_type (x)),
+ return value_zero (lookup_pointer_type (x->type ()),
not_lval);
else
error (_("Attempt to take address of "
value *val = evaluate_var_msym_value (noside, b.objfile, b.minsym);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct type *type = lookup_pointer_type (value_type (val));
+ struct type *type = lookup_pointer_type (val->type ());
return value_zero (type, not_lval);
}
else
{
value *typeval = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- struct type *type = value_type (typeval);
+ struct type *type = typeval->type ();
return value_cast (lookup_pointer_type (type),
std::get<1> (m_storage)->evaluate (nullptr, exp, noside));
}
operation::evaluate_for_sizeof (struct expression *exp, enum noside noside)
{
value *val = evaluate (nullptr, exp, EVAL_AVOID_SIDE_EFFECTS);
- return evaluate_subexp_for_sizeof_base (exp, value_type (val));
+ return evaluate_subexp_for_sizeof_base (exp, val->type ());
}
value *
const bound_minimal_symbol &b = std::get<0> (m_storage);
value *mval = evaluate_var_msym_value (noside, b.objfile, b.minsym);
- struct type *type = value_type (mval);
+ struct type *type = mval->type ();
if (type->code () == TYPE_CODE_ERROR)
error_unknown_type (b.minsym->print_name ());
{
value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (type->code () == TYPE_CODE_ARRAY)
{
type = check_typedef (type->target_type ());
struct type *size_type
= builtin_type (exp->gdbarch)->builtin_int;
return value_from_longest
- (size_type, (LONGEST) value_type (val)->length ());
+ (size_type, (LONGEST) val->type ()->length ());
}
}
}
{
value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (!type->is_pointer_or_reference ()
&& type->code () != TYPE_CODE_ARRAY)
error (_("Attempt to take contents of a non-pointer value."));
type = type->target_type ();
if (is_dynamic_type (type))
- type = value_type (value_ind (val));
+ type = value_ind (val)->type ();
/* FIXME: This should be size_t. */
struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
return value_from_longest (size_type, (LONGEST) type->length ());
{
value *typeval = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- return evaluate_subexp_for_sizeof_base (exp, value_type (typeval));
+ return evaluate_subexp_for_sizeof_base (exp, typeval->type ());
}
value *
if (is_dynamic_type (type))
{
value *val = evaluate (nullptr, exp, EVAL_NORMAL);
- type = value_type (val);
+ type = val->type ();
if (type->code () == TYPE_CODE_ARRAY)
{
/* FIXME: This should be size_t. */
value *lhs
= std::get<0> (this->m_storage)->evaluate (nullptr, exp, noside);
value *rhs
- = std::get<1> (this->m_storage)->evaluate (value_type (lhs), exp,
+ = std::get<1> (this->m_storage)->evaluate (lhs->type (), exp,
noside);
return FUNC (expect_type, exp, noside, OP, lhs, rhs);
}
|| sub_op == STRUCTOP_PTR
|| sub_op == OP_SCOPE)
{
- struct type *type = value_type (result);
+ struct type *type = result->type ();
if (!TYPE_IS_REFERENCE (type))
{
value *typeval
= std::get<0> (m_storage)->evaluate (expect_type, exp,
EVAL_AVOID_SIDE_EFFECTS);
- struct type *type = value_type (typeval);
+ struct type *type = typeval->type ();
value *val = std::get<1> (m_storage)->evaluate (expect_type, exp, noside);
return eval_op_memval (expect_type, exp, noside, val, type);
}
many array elements". */
struct type *xtype = (VALUE_LVAL (lhs) == lval_internalvar
? nullptr
- : value_type (lhs));
+ : lhs->type ());
value *rhs = std::get<1> (m_storage)->evaluate (xtype, exp, noside);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- return std::get<1> (m_storage)->evaluate_for_cast (value_type (val),
+ return std::get<1> (m_storage)->evaluate_for_cast (val->type (),
exp, noside);
}
{
value *val = std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- struct type *type = value_type (val);
+ struct type *type = val->type ();
value *rhs = std::get<1> (m_storage)->evaluate (type, exp, noside);
return FUNC (type, rhs);
}
struct gdbarch *gdbarch,
struct value *array)
{
- type *array_type = check_typedef (value_type (array));
+ type *array_type = check_typedef (array->type ());
int ndimensions = calc_f77_array_dims (array_type);
/* Allocate a result value of the correct type. */
/* And copy the value into the result value. */
struct value *v = value_from_longest (elm_type, b);
- gdb_assert (dst_offset + value_type (v)->length ()
- <= value_type (result)->length ());
- gdb_assert (value_type (v)->length () == elm_len);
+ gdb_assert (dst_offset + v->type ()->length ()
+ <= result->type ()->length ());
+ gdb_assert (v->type ()->length () == elm_len);
value_contents_copy (result, dst_offset, v, 0, elm_len);
/* Peel another dimension of the array. */
type* result_type)
{
/* Check the requested dimension is valid for this array. */
- type *array_type = check_typedef (value_type (array));
+ type *array_type = check_typedef (array->type ());
int ndimensions = calc_f77_array_dims (array_type);
long dim = value_as_long (dim_val);
if (dim < 1 || dim > ndimensions)
void copy_element_to_dest (struct value *elt)
{
value_contents_copy (m_dest, m_dest_offset, elt, 0,
- value_type (elt)->length ());
- m_dest_offset += value_type (elt)->length ();
+ elt->type ()->length ());
+ m_dest_offset += elt->type ()->length ();
}
/* The value being written to. */
/* All Fortran pointers should have the associated property, this is
how we know the pointer is pointing at something or not. */
- struct type *pointer_type = check_typedef (value_type (pointer));
+ struct type *pointer_type = check_typedef (pointer->type ());
if (TYPE_ASSOCIATED_PROP (pointer_type) == nullptr
&& pointer_type->code () != TYPE_CODE_PTR)
error (_("ASSOCIATED can only be applied to pointers"));
/* The two argument case, is POINTER associated with TARGET? */
- struct type *target_type = check_typedef (value_type (target));
+ struct type *target_type = check_typedef (target->type ());
struct type *pointer_target_type;
if (pointer_type->code () == TYPE_CODE_PTR)
fortran_array_size (value *array, value *dim_val, type *result_type)
{
/* Check that ARRAY is the correct type. */
- struct type *array_type = check_typedef (value_type (array));
+ struct type *array_type = check_typedef (array->type ());
if (array_type->code () != TYPE_CODE_ARRAY)
error (_("SIZE can only be applied to arrays"));
if (type_not_allocated (array_type) || type_not_associated (array_type))
if (dim_val != nullptr)
{
- if (check_typedef (value_type (dim_val))->code () != TYPE_CODE_INT)
+ if (check_typedef (dim_val->type ())->code () != TYPE_CODE_INT)
error (_("DIM argument to SIZE must be an integer"));
dim = (int) value_as_long (dim_val);
fortran_array_shape (struct gdbarch *gdbarch, const language_defn *lang,
struct value *val)
{
- struct type *val_type = check_typedef (value_type (val));
+ struct type *val_type = check_typedef (val->type ());
/* If we are passed an array that is either not allocated, or not
associated, then this is explicitly not allowed according to the
/* And copy the value into the result value. */
struct value *v = value_from_longest (elm_type, dim_size);
- gdb_assert (dst_offset + value_type (v)->length ()
- <= value_type (result)->length ());
- gdb_assert (value_type (v)->length () == elm_len);
+ gdb_assert (dst_offset + v->type ()->length ()
+ <= result->type ()->length ());
+ gdb_assert (v->type ()->length () == elm_len);
value_contents_copy (result, dst_offset, v, 0, elm_len);
/* Peel another dimension of the array. */
enum exp_opcode opcode,
struct value *arg1)
{
- struct type *type = value_type (arg1);
+ struct type *type = arg1->type ();
switch (type->code ())
{
case TYPE_CODE_FLT:
{
double d
= fabs (target_float_to_host_double (value_contents (arg1).data (),
- value_type (arg1)));
+ arg1->type ()));
return value_from_host_double (type, d);
}
case TYPE_CODE_INT:
enum exp_opcode opcode,
struct value *arg1, struct value *arg2)
{
- struct type *type = value_type (arg1);
- if (type->code () != value_type (arg2)->code ())
+ struct type *type = arg1->type ();
+ if (type->code () != arg2->type ()->code ())
error (_("non-matching types for parameters to MOD ()"));
switch (type->code ())
{
{
double d1
= target_float_to_host_double (value_contents (arg1).data (),
- value_type (arg1));
+ arg1->type ());
double d2
= target_float_to_host_double (value_contents (arg2).data (),
- value_type (arg2));
+ arg2->type ());
double d3 = fmod (d1, d2);
return value_from_host_double (type, d3);
}
if (v2 == 0)
error (_("calling MOD (N, 0) is undefined"));
LONGEST v3 = v1 - (v1 / v2) * v2;
- return value_from_longest (value_type (arg1), v3);
+ return value_from_longest (arg1->type (), v3);
}
}
error (_("MOD of type %s not supported"), TYPE_SAFE_NAME (type));
static value *
fortran_ceil_operation (value *arg1, type *result_type)
{
- if (value_type (arg1)->code () != TYPE_CODE_FLT)
+ if (arg1->type ()->code () != TYPE_CODE_FLT)
error (_("argument to CEILING must be of type float"));
double val = target_float_to_host_double (value_contents (arg1).data (),
- value_type (arg1));
+ arg1->type ());
val = ceil (val);
return value_from_longest (result_type, val);
}
static value *
fortran_floor_operation (value *arg1, type *result_type)
{
- if (value_type (arg1)->code () != TYPE_CODE_FLT)
+ if (arg1->type ()->code () != TYPE_CODE_FLT)
error (_("argument to FLOOR must be of type float"));
double val = target_float_to_host_double (value_contents (arg1).data (),
- value_type (arg1));
+ arg1->type ());
val = floor (val);
return value_from_longest (result_type, val);
}
enum exp_opcode opcode,
struct value *arg1, struct value *arg2)
{
- struct type *type = value_type (arg1);
- if (type->code () != value_type (arg2)->code ())
+ struct type *type = arg1->type ();
+ if (type->code () != arg2->type ()->code ())
error (_("non-matching types for parameters to MODULO ()"));
/* MODULO(A, P) = A - FLOOR (A / P) * P */
switch (type->code ())
LONGEST result = a - (a / p) * p;
if (result != 0 && (a < 0) != (p < 0))
result += p;
- return value_from_longest (value_type (arg1), result);
+ return value_from_longest (arg1->type (), result);
}
case TYPE_CODE_FLT:
{
double a
= target_float_to_host_double (value_contents (arg1).data (),
- value_type (arg1));
+ arg1->type ());
double p
= target_float_to_host_double (value_contents (arg2).data (),
- value_type (arg2));
+ arg2->type ());
double result = fmod (a, p);
if (result != 0 && (a < 0.0) != (p < 0.0))
result += p;
type *result_type = builtin_f_type (exp->gdbarch)->builtin_complex;
- if (value_type (arg1)->code () == TYPE_CODE_COMPLEX)
+ if (arg1->type ()->code () == TYPE_CODE_COMPLEX)
return value_cast (result_type, arg1);
else
return value_literal_complex (arg1,
- value_zero (value_type (arg1), not_lval),
+ value_zero (arg1->type (), not_lval),
result_type);
}
enum exp_opcode opcode,
struct value *arg1, struct value *arg2)
{
- if (value_type (arg1)->code () == TYPE_CODE_COMPLEX
- || value_type (arg2)->code () == TYPE_CODE_COMPLEX)
+ if (arg1->type ()->code () == TYPE_CODE_COMPLEX
+ || arg2->type ()->code () == TYPE_CODE_COMPLEX)
error (_("Types of arguments for CMPLX called with more then one argument "
"must be REAL or INTEGER"));
exp_opcode opcode, value *arg1, value *arg2, type *kind_arg)
{
gdb_assert (kind_arg->code () == TYPE_CODE_COMPLEX);
- if (value_type (arg1)->code () == TYPE_CODE_COMPLEX
- || value_type (arg2)->code () == TYPE_CODE_COMPLEX)
+ if (arg1->type ()->code () == TYPE_CODE_COMPLEX
+ || arg2->type ()->code () == TYPE_CODE_COMPLEX)
error (_("Types of arguments for CMPLX called with more then one argument "
"must be REAL or INTEGER"));
enum exp_opcode opcode,
struct value *arg1)
{
- struct type *type = value_type (arg1);
+ struct type *type = arg1->type ();
switch (type->code ())
{
enum noside noside, enum exp_opcode op,
struct value *arg1)
{
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
if (type->code () != TYPE_CODE_ARRAY)
error (_("ALLOCATED can only be applied to arrays"));
struct type *result_type
struct type *result_type
= builtin_f_type (exp->gdbarch)->builtin_integer;
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
if (type->code () != TYPE_CODE_ARRAY)
return value_from_longest (result_type, 0);
LONGEST ndim = calc_f77_array_dims (type);
struct expression *exp,
enum noside noside)
{
- type *original_array_type = check_typedef (value_type (array));
+ type *original_array_type = check_typedef (array->type ());
bool is_string_p = original_array_type->code () == TYPE_CODE_STRING;
const std::vector<operation_up> &ops = std::get<1> (m_storage);
int nargs = ops.size ();
struct value *dest = allocate_value (repacked_array_type);
if (value_lazy (array)
|| (total_offset + array_slice_type->length ()
- > check_typedef (value_type (array))->length ()))
+ > check_typedef (array->type ())->length ()))
{
fortran_array_walker<fortran_lazy_array_repacker_impl> p
(array_slice_type, value_address (array) + total_offset, dest);
contents we're looking for exist. */
if (value_lazy (array)
|| (total_offset + array_slice_type->length ()
- > check_typedef (value_type (array))->length ()))
+ > check_typedef (array->type ())->length ()))
array = value_at_lazy (array_slice_type,
value_address (array) + total_offset);
else
{
value *callee = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
if (noside == EVAL_AVOID_SIDE_EFFECTS
- && is_dynamic_type (value_type (callee)))
+ && is_dynamic_type (callee->type ()))
callee = std::get<0> (m_storage)->evaluate (nullptr, exp, EVAL_NORMAL);
- struct type *type = check_typedef (value_type (callee));
+ struct type *type = check_typedef (callee->type ());
enum type_code code = type->code ();
if (code == TYPE_CODE_PTR)
|| target_type->code () == TYPE_CODE_FUNC)
{
callee = value_ind (callee);
- type = check_typedef (value_type (callee));
+ type = check_typedef (callee->type ());
code = type->code ();
}
}
for (int tem = 0; tem < argvec.size (); tem++)
argvec[tem] = fortran_prepare_argument (exp, actual[tem].get (),
tem, is_internal_func,
- value_type (callee),
+ callee->type (),
noside);
return evaluate_subexp_do_call (exp, noside, callee, argvec,
nullptr, expect_type);
{
bool lbound_p = std::get<0> (m_storage) == FORTRAN_LBOUND;
value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
- fortran_require_array (value_type (arg1), lbound_p);
+ fortran_require_array (arg1->type (), lbound_p);
return fortran_bounds_all_dims (lbound_p, exp->gdbarch, arg1);
}
{
bool lbound_p = std::get<0> (m_storage) == FORTRAN_LBOUND;
value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
- fortran_require_array (value_type (arg1), lbound_p);
+ fortran_require_array (arg1->type (), lbound_p);
/* User asked for the bounds of a specific dimension of the array. */
value *arg2 = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
- type *type_arg2 = check_typedef (value_type (arg2));
+ type *type_arg2 = check_typedef (arg2->type ());
if (type_arg2->code () != TYPE_CODE_INT)
{
if (lbound_p)
{
const bool lbound_p = std::get<0> (m_storage) == FORTRAN_LBOUND;
value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
- fortran_require_array (value_type (arg1), lbound_p);
+ fortran_require_array (arg1->type (), lbound_p);
/* User asked for the bounds of a specific dimension of the array. */
value *arg2 = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
- type *type_arg2 = check_typedef (value_type (arg2));
+ type *type_arg2 = check_typedef (arg2->type ());
if (type_arg2->code () != TYPE_CODE_INT)
{
if (lbound_p)
const char *str = std::get<1> (m_storage).c_str ();
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct type *type = lookup_struct_elt_type (value_type (arg1), str, 1);
+ struct type *type = lookup_struct_elt_type (arg1->type (), str, 1);
if (type != nullptr && is_dynamic_type (type))
arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, EVAL_NORMAL);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct type *elt_type = value_type (elt);
+ struct type *elt_type = elt->type ();
if (is_dynamic_type (elt_type))
{
const gdb_byte *valaddr = value_contents_for_printing (elt).data ();
convenience variables and user input. */
if (VALUE_LVAL (value) != lval_memory)
{
- struct type *type = value_type (value);
+ struct type *type = value->type ();
const int length = type->length ();
const CORE_ADDR addr
= value_as_long (value_allocate_space_in_inferior (length));
struct type *
fortran_preserve_arg_pointer (struct value *arg, struct type *type)
{
- if (value_type (arg)->code () == TYPE_CODE_PTR)
- return value_type (arg);
+ if (arg->type ()->code () == TYPE_CODE_PTR)
+ return arg->type ();
return type;
}
int recurse,
const struct value_print_options *options) const
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
struct gdbarch *gdbarch = type->arch ();
int printed_field = 0; /* Number of fields printed. */
struct type *elttype;
s = skip_spaces (s);
v = parse_to_comma_and_eval (&s);
- t = value_type (v);
+ t = v->type ();
if (size != '\0')
{
LONGEST offset = 0;
LONGEST reg_offset = value_offset (value);
int regnum = VALUE_REGNUM (value);
- int len = type_length_units (check_typedef (value_type (value)));
+ int len = type_length_units (check_typedef (value->type ()));
gdb_assert (VALUE_LVAL (value) == lval_register);
while (len > 0)
{
struct value *regval = get_frame_register_value (frame, regnum);
- int reg_len = type_length_units (value_type (regval)) - reg_offset;
+ int reg_len = type_length_units (regval->type ()) - reg_offset;
/* If the register length is larger than the number of bytes
remaining to copy, then only copy the appropriate bytes. */
{
if (!*optimizedp && !*unavailablep)
memcpy (bufferp, value_contents_all (value).data (),
- value_type (value)->length ());
+ value->type ()->length ());
else
- memset (bufferp, 0, value_type (value)->length ());
+ memset (bufferp, 0, value->type ()->length ());
}
/* Dispose of the new value. This prevents watchpoints from
stack_space = 0;
for (argnum = 0; argnum < nargs; ++argnum)
- stack_space += align_up (value_type (args[argnum])->length (), 4);
+ stack_space += align_up (args[argnum]->type ()->length (), 4);
stack_space -= (6 * 4);
if (stack_space > 0)
for (argnum = 0; argnum < nargs; ++argnum)
{
arg = args[argnum];
- arg_type = check_typedef (value_type (arg));
+ arg_type = check_typedef (arg->type ());
len = arg_type->length ();
typecode = arg_type->code ();
{
int offset = -1;
- return is_unique_ancestor_worker (base, value_type (val), &offset,
+ return is_unique_ancestor_worker (base, val->type (), &offset,
value_contents_for_printing (val).data (),
value_embedded_offset (val),
value_address (val), val) == 1;
size_t min_len = std::min (parms.size (), args.size ());
for (size_t i = 0; i < min_len; i++)
- bv.push_back (rank_one_type (parms[i], value_type (args[i]),
+ bv.push_back (rank_one_type (parms[i], args[i]->type (),
args[i]));
/* If more arguments than parameters, add dummy entries. */
case TYPE_CODE_FUNC:
return rank_one_type (parm->target_type (), arg, NULL);
case TYPE_CODE_INT:
- if (value != NULL && value_type (value)->code () == TYPE_CODE_INT)
+ if (value != NULL && value->type ()->code () == TYPE_CODE_INT)
{
if (value_as_long (value) == 0)
{
/* Note that if thistype is a TYPEDEF type, you have to call check_typedef.
But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
so you only have to call check_typedef once. Since allocate_value
- calls check_typedef, VALUE_TYPE (X)->length () is safe. */
+ calls check_typedef, X->type ()->length () is safe. */
ULONGEST length () const
{
return this->m_length;
struct type * type, int offset)
{
struct value *arg1 = *arg1p;
- struct type *type1 = check_typedef (value_type (arg1));
+ struct type *type1 = check_typedef (arg1->type ());
struct type *entry_type;
/* First, get the virtual function table pointer. That comes
with a strange type, so cast it to type `pointer to long' (which
struct value *tmp = value_cast (context, value_addr (arg1));
arg1 = value_ind (tmp);
- type1 = check_typedef (value_type (arg1));
+ type1 = check_typedef (arg1->type ());
}
context = type1;
/* With older versions of g++, the vtbl field pointed to an array
of structures. Nowadays it points directly to the structure. */
- if (value_type (vtbl)->code () == TYPE_CODE_PTR
- && value_type (vtbl)->target_type ()->code () == TYPE_CODE_ARRAY)
+ if (vtbl->type ()->code () == TYPE_CODE_PTR
+ && vtbl->type ()->target_type ()->code () == TYPE_CODE_ARRAY)
{
/* Handle the case where the vtbl field points to an
array of structures. */
entry = value_ind (vtbl);
}
- entry_type = check_typedef (value_type (entry));
+ entry_type = check_typedef (entry->type ());
if (entry_type->code () == TYPE_CODE_STRUCT)
{
*using_enc = 0;
/* Get declared type. */
- known_type = value_type (v);
+ known_type = v->type ();
known_type = check_typedef (known_type);
/* RTTI works only or class objects. */
if (known_type->code () != TYPE_CODE_STRUCT)
int *full_p, LONGEST *top_p, int *using_enc_p)
{
struct gdbarch *gdbarch;
- struct type *values_type = check_typedef (value_type (value));
+ struct type *values_type = check_typedef (value->type ());
struct value *vtable;
struct minimal_symbol *vtable_symbol;
const char *vtable_symbol_name;
struct value *vtable, *vfn;
/* Every class with virtual functions must have a vtable. */
- vtable = gnuv3_get_vtable (gdbarch, value_type (container),
+ vtable = gnuv3_get_vtable (gdbarch, container->type (),
value_as_address (value_addr (container)));
gdb_assert (vtable != NULL);
struct fn_field *f, int j,
struct type *vfn_base, int offset)
{
- struct type *values_type = check_typedef (value_type (*value_p));
+ struct type *values_type = check_typedef ((*value_p)->type ());
struct gdbarch *gdbarch;
/* Some simple sanity checks. */
LONGEST adjustment;
int vbit;
- self_type = TYPE_SELF_TYPE (check_typedef (value_type (method_ptr)));
+ self_type = TYPE_SELF_TYPE (check_typedef (method_ptr->type ()));
final_type = lookup_pointer_type (self_type);
- method_type = check_typedef (value_type (method_ptr))->target_type ();
+ method_type = check_typedef (method_ptr->type ())->target_type ();
/* Extract the pointer to member. */
gdbarch = self_type->arch ();
struct value *value)
{
int i;
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
void **slot;
struct value_and_voffset search_vo, *current_vo;
struct value_print_options *opts)
{
int i;
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
struct value *vtable;
CORE_ADDR vt_addr;
int count;
value = coerce_ref (value);
- type = check_typedef (value_type (value));
+ type = check_typedef (value->type ());
if (type->code () == TYPE_CODE_PTR)
{
value = value_ind (value);
- type = check_typedef (value_type (value));
+ type = check_typedef (value->type ());
}
get_user_print_options (&opts);
if (opts.objectprint)
{
value = value_full_object (value, NULL, 0, 0, 0);
- type = check_typedef (value_type (value));
+ type = check_typedef (value->type ());
}
gdbarch = type->arch ();
if (value_lval_const (value) == lval_memory)
value = coerce_ref (value);
- type = check_typedef (value_type (value));
+ type = check_typedef (value->type ());
/* In the non_lvalue case, a reference might have slipped through
here. */
static std::string
gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
{
- struct gdbarch *gdbarch = value_type (type_info_ptr)->arch ();
+ struct gdbarch *gdbarch = type_info_ptr->type ()->arch ();
struct bound_minimal_symbol typeinfo_sym;
CORE_ADDR addr;
const char *symname;
std::string type_name = gnuv3_get_typename_from_type_info (type_info_ptr);
expression_up expr (parse_expression (type_name.c_str ()));
struct value *type_val = evaluate_type (expr.get ());
- return value_type (type_val);
+ return type_val->type ();
}
/* Determine if we are currently in a C++ thunk. If so, get the address
int recurse,
const struct value_print_options *options) const
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
switch (type->code ())
{
res_val = arg1;
break;
case VALSCM_ABS:
- if (value_less (arg1, value_zero (value_type (arg1), not_lval)))
+ if (value_less (arg1, value_zero (arg1->type (), not_lval)))
res_val = value_neg (arg1);
else
res_val = arg1;
{
case VALSCM_ADD:
{
- struct type *ltype = value_type (arg1);
- struct type *rtype = value_type (arg2);
+ struct type *ltype = arg1->type ();
+ struct type *rtype = arg2->type ();
ltype = check_typedef (ltype);
ltype = STRIP_REFERENCE (ltype);
break;
case VALSCM_SUB:
{
- struct type *ltype = value_type (arg1);
- struct type *rtype = value_type (arg2);
+ struct type *ltype = arg1->type ();
+ struct type *rtype = arg2->type ();
ltype = check_typedef (ltype);
ltype = STRIP_REFERENCE (ltype);
const struct value_print_options *options,
const struct language_defn *language)
{
- struct type *type = value_type (value);
+ struct type *type = value->type ();
struct gdbarch *gdbarch = type->arch ();
SCM exception = SCM_BOOL_F;
SCM printer = SCM_BOOL_F;
struct value *res_val;
- switch (check_typedef (value_type (value))->code ())
+ switch (check_typedef (value->type ())->code ())
{
case TYPE_CODE_PTR:
res_val = value_ind (value);
struct value *value = v_smob->value;
if (SCM_UNBNDP (v_smob->type))
- v_smob->type = tyscm_scm_from_type (value_type (value));
+ v_smob->type = tyscm_scm_from_type (value->type ());
return v_smob->type;
}
{
scoped_value_mark free_values;
- type = value_type (value);
+ type = value->type ();
type = check_typedef (type);
if (((type->code () == TYPE_CODE_PTR)
value_smob *v_smob
= vlscm_get_value_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
struct value *value = v_smob->value;
- struct type *type = value_type (value);
+ struct type *type = value->type ();
SCM_ASSERT (type != NULL, self, SCM_ARG2, FUNC_NAME);
Check the value's type is something that can be accessed via
a subscript. */
struct value *tmp = coerce_ref (value);
- struct type *tmp_type = check_typedef (value_type (tmp));
+ struct type *tmp_type = check_typedef (tmp->type ());
if (tmp_type->code () != TYPE_CODE_ARRAY
&& tmp_type->code () != TYPE_CODE_PTR)
error (_("Cannot subscript requested type"));
gdbscm_gdb_exception exc {};
try
{
- ftype = check_typedef (value_type (function));
+ ftype = check_typedef (function->type ());
}
catch (const gdb_exception &except)
{
const gdb_byte *contents = NULL;
SCM bv;
- type = value_type (value);
+ type = value->type ();
gdbscm_gdb_exception exc {};
try
struct type *type;
LONGEST l = 0;
- type = value_type (value);
+ type = value->type ();
gdbscm_gdb_exception exc {};
try
struct type *type;
LONGEST l = 0;
- type = value_type (value);
+ type = value->type ();
gdbscm_gdb_exception exc {};
try
double d = 0;
struct value *check = nullptr;
- type = value_type (value);
+ type = value->type ();
gdbscm_gdb_exception exc {};
try
struct type *type, *realtype;
CORE_ADDR addr;
- type = value_type (value);
+ type = value->type ();
realtype = check_typedef (type);
switch (realtype->code ())
/* Now make sure there's space on the stack for the arguments. We
may over-allocate a little here, but that won't hurt anything. */
for (argument = 0; argument < nargs; argument++)
- stack_alloc += align_up (value_type (args[argument])->length (), wordsize);
+ stack_alloc += align_up (args[argument]->type ()->length (), wordsize);
sp -= stack_alloc;
/* Now load as many arguments as possible into registers, and push
for (argument = 0; argument < nargs; argument++)
{
- struct type *type = value_type (args[argument]);
+ struct type *type = args[argument]->type ();
int len = type->length ();
char *contents = (char *) value_contents (args[argument]).data ();
for (i = 0; i < nargs; i++)
{
struct value *arg = args[i];
- struct type *type = check_typedef (value_type (arg));
+ struct type *type = check_typedef (arg->type ());
/* The corresponding parameter that is pushed onto the
stack, and [possibly] passed in a register. */
gdb_byte param_val[8];
for (i = 0; i < nargs; i++)
{
struct value *arg = args[i];
- struct type *type = value_type (arg);
+ struct type *type = arg->type ();
int len = type->length ();
const bfd_byte *valbuf;
bfd_byte fptrbuf[8];
status = regcache->raw_read (fpnum, raw_buf);
if (status != REG_VALID)
mark_value_bytes_unavailable (result_value, 0,
- value_type (result_value)->length ());
+ result_value->type ()->length ());
else
memcpy (buf, raw_buf, register_size (gdbarch, regnum));
}
status = regcache->raw_read (gpnum, raw_buf);
if (status != REG_VALID)
mark_value_bytes_unavailable (result_value, 0,
- value_type (result_value)->length ());
+ result_value->type ()->length ());
else
memcpy (buf, raw_buf, 2);
}
status = regcache->raw_read (gpnum % 4, raw_buf);
if (status != REG_VALID)
mark_value_bytes_unavailable (result_value, 0,
- value_type (result_value)->length ());
+ result_value->type ()->length ());
else if (gpnum >= 4)
memcpy (buf, raw_buf + 1, 1);
else
calling convention is used, so the 'this' pointer is passed in ECX. */
bool thiscall = false;
- struct type *type = check_typedef (value_type (function));
+ struct type *type = check_typedef (function->type ());
if (type->code () == TYPE_CODE_PTR)
type = check_typedef (type->target_type ());
for (argno = 0; argno < nargs; argno++)
{
arg = args[argno];
- type = check_typedef (value_type (arg));
+ type = check_typedef (arg->type ());
len = type->length ();
if ((nslots & 1) && slot_alignment_is_next_even (type))
struct type *float_elt_type;
arg = args[argno];
- type = check_typedef (value_type (arg));
+ type = check_typedef (arg->type ());
len = type->length ();
/* Special handling for function parameters. */
struct type *param_type, int is_prototyped)
{
const struct builtin_type *builtin = builtin_type (gdbarch);
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
struct type *type
= param_type ? check_typedef (param_type) : arg_type;
struct type **retval_type,
struct type **function_type)
{
- struct type *ftype = check_typedef (value_type (function));
+ struct type *ftype = check_typedef (function->type ());
struct gdbarch *gdbarch = ftype->arch ();
struct type *value_type = NULL;
/* Initialize it just to avoid a GCC false warning. */
else
{
gdb_assert (sp <= lastval_addr);
- sp = lastval_addr + value_type (lastval)->length ();
+ sp = lastval_addr + lastval->type ()->length ();
}
if (gdbarch_frame_align_p (gdbarch))
= check_typedef (func_symbol->type ()->target_type ());
gdb_assert (value_type->code () != TYPE_CODE_VOID);
- if (is_nocall_function (check_typedef (::value_type (function))))
+ if (is_nocall_function (check_typedef (function->type ())))
{
warning (_("Function '%s' does not follow the target calling "
"convention, cannot determine its returned value."),
const char *name,
struct value *val)
{
- struct type *regtype = value_type (val);
+ struct type *regtype = val->type ();
int print_raw_format;
string_file format_stream;
enum tab_stops
nullptr,
value_contents_all_raw (v).data (),
value_offset (v),
- value_type (v)->length ());
+ v->type ()->length ());
- if (transferred != value_type (v)->length ())
+ if (transferred != v->type ()->length ())
error (_("Unable to read siginfo"));
}
nullptr,
value_contents_all_raw (fromval).data (),
value_offset (v),
- value_type (fromval)->length ());
+ fromval->type ()->length ());
- if (transferred != value_type (fromval)->length ())
+ if (transferred != fromval->type ()->length ())
error (_("Unable to write siginfo"));
}
i < nargs;
i++)
{
- type = value_type (args[i]);
+ type = args[i]->type ();
typelen = type->length ();
if (typelen <= 4)
{
for (i = 0; i < nargs; i++)
{
- type = value_type (args[i]);
+ type = args[i]->type ();
typelen = type->length ();
val = value_contents (args[i]).data ();
if (typelen <= 4)
sscanf ((variable[1] == '$') ? variable + 2 : variable + 1, "%d", &index);
val_history
= access_value_history ((variable[1] == '$') ? -index : index);
- if (value_type (val_history)->code () != TYPE_CODE_INT)
+ if (val_history->type ()->code () != TYPE_CODE_INT)
error (_("History values used in line "
"specs must have integer values."));
offset.offset = value_as_long (val_history);
for (i = 0; i < nargs; i++)
{
struct value *arg = args[i];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
gdb_byte *contents;
ULONGEST val;
{
struct value *arg = args[i];
const gdb_byte *val = value_contents (arg).data ();
- struct type *type = check_typedef (value_type (arg));
+ struct type *type = check_typedef (arg->type ());
size_t len = type->length ();
int align = type_align (type);
enum type_code code = type->code ();
- struct type *func_type = check_typedef (value_type (function));
+ struct type *func_type = check_typedef (function->type ());
bool varargs = (func_type->has_varargs () && i >= func_type->num_fields ());
switch (code)
else
{
arg1 = coerce_ref (arg1);
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
if (m2_is_unbounded_array (type))
{
_("unbounded structure "
"missing _m2_high field"));
- if (value_type (arg1) != type)
+ if (arg1->type () != type)
arg1 = value_cast (type, arg1);
}
}
then report this as an error. */
arg1 = coerce_ref (arg1);
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
if (m2_is_unbounded_array (type))
{
_("unbounded structure "
"missing _m2_contents field"));
- if (value_type (arg1) != type)
+ if (arg1->type () != type)
arg1 = value_cast (type, arg1);
- check_typedef (value_type (arg1));
+ check_typedef (arg1->type ());
return value_ind (value_ptradd (arg1, value_as_long (arg2)));
}
else
LONGEST len;
struct value *val;
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
const gdb_byte *valaddr = value_contents_for_printing (value).data ();
addr = unpack_pointer (type->field (0).type (),
const struct value_print_options *options,
int len)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (type->length () > 0)
{
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
const CORE_ADDR address = value_address (val);
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
switch (type->code ())
{
case TYPE_CODE_ARRAY:
int num_prototyped_args = 0;
{
- struct type *func_type = value_type (function);
+ struct type *func_type = function->type ();
/* Dereference function pointer types. */
if (func_type->code () == TYPE_CODE_PTR)
{
struct value *arg = args[i];
const gdb_byte *arg_bits = value_contents (arg).data ();
- struct type *arg_type = value_type (arg);
+ struct type *arg_type = arg->type ();
ULONGEST arg_size = arg_type->length ();
/* Can it go in r1 or r1l (for m16c) or r0 or r0l (for m32c)? */
/* Now make sure there's space on the stack. */
for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
- stack_alloc += ((value_type (args[argnum])->length () + 3) & ~3);
+ stack_alloc += ((args[argnum]->type ()->length () + 3) & ~3);
sp -= stack_alloc; /* Make room on stack for args. */
for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
{
- type = value_type (args[argnum]);
+ type = args[argnum]->type ();
typecode = type->code ();
len = type->length ();
regcache_cooked_write_unsigned (regcache, HARD_D_REGNUM, struct_addr);
else if (nargs > 0)
{
- type = value_type (args[0]);
+ type = args[0]->type ();
/* First argument is passed in D and X registers. */
if (type->length () <= 4)
for (argnum = nargs - 1; argnum >= first_stack_argnum; argnum--)
{
- type = value_type (args[argnum]);
+ type = args[argnum]->type ();
if (type->length () & 1)
{
for (i = 0; i < argc; i++)
{
- unsigned arg_len = value_type (argv[i])->length ();
+ unsigned arg_len = argv[i]->type ()->length ();
if (arg_len > MEP_GPR_SIZE)
{
ULONGEST value;
/* Arguments that fit in a GPR get expanded to fill the GPR. */
- if (value_type (argv[i])->length () <= MEP_GPR_SIZE)
+ if (argv[i]->type ()->length () <= MEP_GPR_SIZE)
value = extract_unsigned_integer (value_contents (argv[i]).data (),
- value_type (argv[i])->length (),
+ argv[i]->type ()->length (),
byte_order);
/* Arguments too large to fit in a GPR get copied to the stack,
/* A scalar object that does not have all bits available is
also considered unavailable, because all bits contribute
to its representation. */
- || (val_print_scalar_type_p (value_type (arg->val))
+ || (val_print_scalar_type_p (arg->val->type ())
&& !value_bytes_available (arg->val,
value_embedded_offset (arg->val),
- value_type (arg->val)->length ()))))
+ arg->val->type ()->length ()))))
return;
gdb::optional<ui_out_emit_tuple> tuple_emitter;
switch (values)
{
case PRINT_SIMPLE_VALUES:
- type = check_typedef (value_type (val));
- type_print (value_type (val), "", &stb, -1);
+ type = check_typedef (val->type ());
+ type_print (val->type (), "", &stb, -1);
uiout->field_stream ("type", stb);
if (type->code () != TYPE_CODE_ARRAY
&& type->code () != TYPE_CODE_STRUCT
than necessary for EABI, because the first few arguments are
passed in registers, but that's OK. */
for (argnum = 0; argnum < nargs; argnum++)
- arg_space += align_up (value_type (args[argnum])->length (),
+ arg_space += align_up (args[argnum]->type ()->length (),
abi_regsize);
sp -= align_up (arg_space, 16);
reference. */
gdb_byte ref_valbuf[MAX_MIPS_ABI_REGSIZE];
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
enum type_code typecode = arg_type->code ();
/* Now make space on the stack for the args. */
for (argnum = 0; argnum < nargs; argnum++)
- arg_space += align_up (value_type (args[argnum])->length (),
+ arg_space += align_up (args[argnum]->type ()->length (),
MIPS64_REGSIZE);
sp -= align_up (arg_space, 16);
{
const gdb_byte *val;
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
enum type_code typecode = arg_type->code ();
/* Now make space on the stack for the args. */
for (argnum = 0; argnum < nargs; argnum++)
{
- struct type *arg_type = check_typedef (value_type (args[argnum]));
+ struct type *arg_type = check_typedef (args[argnum]->type ());
/* Align to double-word if necessary. */
if (mips_type_needs_double_align (arg_type))
{
const gdb_byte *val;
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
enum type_code typecode = arg_type->code ();
/* Now make space on the stack for the args. */
for (argnum = 0; argnum < nargs; argnum++)
{
- struct type *arg_type = check_typedef (value_type (args[argnum]));
+ struct type *arg_type = check_typedef (args[argnum]->type ());
/* Allocate space on the stack. */
arg_space += align_up (arg_type->length (), MIPS64_REGSIZE);
{
const gdb_byte *val;
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
enum type_code typecode = arg_type->code ();
regs_used = (return_method == return_method_struct) ? 1 : 0;
for (len = 0, argnum = 0; argnum < nargs; argnum++)
{
- arg_len = (value_type (args[argnum])->length () + 3) & ~3;
+ arg_len = (args[argnum]->type ()->length () + 3) & ~3;
while (regs_used < 2 && arg_len > 0)
{
regs_used++;
for (argnum = 0; argnum < nargs; argnum++)
{
/* FIXME what about structs? Unions? */
- if (value_type (*args)->code () == TYPE_CODE_STRUCT
- && value_type (*args)->length () > 8)
+ if ((*args)->type ()->code () == TYPE_CODE_STRUCT
+ && (*args)->type ()->length () > 8)
{
/* Change to pointer-to-type. */
arg_len = push_size;
}
else
{
- arg_len = value_type (*args)->length ();
+ arg_len = (*args)->type ()->length ();
val = value_contents (*args).data ();
}
msp430_gdbarch_tdep *tdep = gdbarch_tdep<msp430_gdbarch_tdep> (gdbarch);
int code_model = tdep->code_model;
- struct type *func_type = value_type (function);
+ struct type *func_type = function->type ();
/* Dereference function pointer types. */
while (func_type->code () == TYPE_CODE_PTR)
{
struct value *arg = args[i];
const gdb_byte *arg_bits = value_contents_all (arg).data ();
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
ULONGEST arg_size = arg_type->length ();
int offset;
int current_arg_on_stack;
ULONGEST regval;
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
nds32_gdbarch_tdep *tdep = gdbarch_tdep<nds32_gdbarch_tdep> (gdbarch);
- struct type *func_type = value_type (function);
+ struct type *func_type = function->type ();
int abi_use_fpr = nds32_abi_use_fpr (tdep->elf_abi);
int abi_split = nds32_abi_split (tdep->elf_abi);
/* Now make sure there's space on the stack */
for (i = 0; i < nargs; i++)
{
- struct type *type = value_type (args[i]);
+ struct type *type = args[i]->type ();
int align = type_align (type);
/* If align is zero, it may be an empty struct.
int calling_use_fpr;
int use_fpr = 0;
- type = value_type (args[i]);
+ type = args[i]->type ();
calling_use_fpr = nds32_check_calling_use_fpr (type);
len = type->length ();
align = type_align (type);
/* Now make space on the stack for the args. */
for (argnum = 0; argnum < nargs; argnum++)
- arg_space += align_up (value_type (args[argnum])->length (), 4);
+ arg_space += align_up (args[argnum]->type ()->length (), 4);
sp -= arg_space;
/* Initialize the register pointer. */
{
const gdb_byte *val;
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
val = value_contents (arg).data ();
lval_func_read (struct value *v)
{
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
- struct type *type = check_typedef (value_type (v));
- struct type *eltype = check_typedef (value_type (c->val))->target_type ();
+ struct type *type = check_typedef (v->type ());
+ struct type *eltype = check_typedef (c->val->type ())->target_type ();
LONGEST offset = value_offset (v);
LONGEST elsize = eltype->length ();
int n, i, j = 0;
scoped_value_mark mark;
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
- struct type *type = check_typedef (value_type (v));
- struct type *eltype = check_typedef (value_type (c->val))->target_type ();
+ struct type *type = check_typedef (v->type ());
+ struct type *eltype = check_typedef (c->val->type ())->target_type ();
LONGEST offset = value_offset (v);
LONGEST elsize = eltype->length ();
int n, i, j = 0;
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
/* Size of the target type in bits. */
int elsize =
- check_typedef (value_type (c->val))->target_type ()->length () * 8;
+ check_typedef (c->val->type ())->target_type ()->length () * 8;
int startrest = offset % elsize;
int start = offset / elsize;
int endrest = (offset + length) % elsize;
create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
int *indices, int n)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
struct type *elm_type = type->target_type ();
struct value *ret;
int indices[16], i;
int dst_len;
- if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb))
+ if (!get_array_bounds (check_typedef (val->type ()), &lowb, &highb))
error (_("Could not determine the vector bounds"));
src_len = highb - lowb + 1;
enum noside noside, enum exp_opcode op,
struct value *arg)
{
- struct type *type = check_typedef (value_type (arg));
+ struct type *type = check_typedef (arg->type ());
struct type *rettype;
struct value *ret;
int t1_is_vec, t2_is_vec, i;
LONGEST lowb1, lowb2, highb1, highb2;
- type1 = check_typedef (value_type (val1));
- type2 = check_typedef (value_type (val2));
+ type1 = check_typedef (val1->type ());
+ type2 = check_typedef (val2->type ());
t1_is_vec = (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ());
t2_is_vec = (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ());
struct value *
opencl_value_cast (struct type *type, struct value *arg)
{
- if (type != value_type (arg))
+ if (type != arg->type ())
{
/* Casting scalar to vector is a special case for OpenCL, scalar
is cast to element type of vector then replicated into each
to_type = check_typedef (type);
code1 = to_type->code ();
- code2 = check_typedef (value_type (arg))->code ();
+ code2 = check_typedef (arg->type ())->code ();
if (code2 == TYPE_CODE_REF)
- code2 = check_typedef (value_type (coerce_ref(arg)))->code ();
+ code2 = check_typedef (coerce_ref(arg)->type ())->code ();
scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL
|| code2 == TYPE_CODE_CHAR || code2 == TYPE_CODE_FLT
struct value *arg1, struct value *arg2)
{
struct value *val;
- struct type *type1 = check_typedef (value_type (arg1));
- struct type *type2 = check_typedef (value_type (arg2));
+ struct type *type1 = check_typedef (arg1->type ());
+ struct type *type2 = check_typedef (arg2->type ());
int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
&& type1->is_vector ());
int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
- struct type *type1 = value_type (arg1);
+ struct type *type1 = arg1->type ();
if (deprecated_value_modifiable (arg1)
&& VALUE_LVAL (arg1) != lval_internalvar)
arg2 = opencl_value_cast (type1, arg2);
enum noside noside)
{
value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
- struct type *type1 = check_typedef (value_type (arg1));
+ struct type *type1 = check_typedef (arg1->type ());
if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
return opencl_component_ref (exp, arg1, std::get<1> (m_storage).c_str (),
NULL, "structure");
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- v = value_zero (value_type (v), VALUE_LVAL (v));
+ v = value_zero (v->type (), VALUE_LVAL (v));
return v;
}
}
Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */
value *arg2 = std::get<2> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
- struct type *type1 = check_typedef (value_type (arg1));
- struct type *type2 = check_typedef (value_type (arg2));
+ struct type *type1 = check_typedef (arg1->type ());
+ struct type *type2 = check_typedef (arg2->type ());
if ((type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
|| (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ()))
enum noside noside)
{
value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
- struct type *type1 = check_typedef (value_type (arg1));
+ struct type *type1 = check_typedef (arg1->type ());
if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
{
struct value *arg2, *arg3, *tmp, *ret;
arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
arg3 = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
- type2 = check_typedef (value_type (arg2));
- type3 = check_typedef (value_type (arg3));
+ type2 = check_typedef (arg2->type ());
+ type3 = check_typedef (arg3->type ());
t2_is_vec
= type2->code () == TYPE_CODE_ARRAY && type2->is_vector ();
t3_is_vec
if (t2_is_vec || !t3_is_vec)
{
arg3 = opencl_value_cast (type2, arg3);
- type3 = value_type (arg3);
+ type3 = arg3->type ();
}
else if (!t2_is_vec || t3_is_vec)
{
arg2 = opencl_value_cast (type3, arg2);
- type2 = value_type (arg2);
+ type2 = arg2->type ();
}
else if (!t2_is_vec || !t3_is_vec)
{
or1k_gdbarch_tdep *tdep = gdbarch_tdep<or1k_gdbarch_tdep> (gdbarch);
int bpa = tdep->bytes_per_address;
int bpw = tdep->bytes_per_word;
- struct type *func_type = value_type (function);
+ struct type *func_type = function->type ();
/* Return address */
regcache_cooked_write_unsigned (regcache, OR1K_LR_REGNUM, bp_addr);
gdb_byte valbuf[sizeof (ULONGEST)];
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
enum type_code typecode = arg_type->code ();
for (argnum = first_stack_arg; argnum < nargs; argnum++)
{
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
enum type_code typecode = arg_type->code ();
gdb_byte valbuf[sizeof (ULONGEST)];
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
enum type_code typecode = arg_type->code ();
/* The EABI passes structures that do not fit in a register by
value *val
= value_of_internalvar (pstate->gdbarch (),
intvar);
- current_type = value_type (val);
+ current_type = val->type ();
}
}
;
this_val
= value_of_this_silent (pstate->language ());
if (this_val)
- this_type = value_type (this_val);
+ this_type = this_val->type ();
else
this_type = NULL;
if (this_type)
this_val
= value_of_this_silent (pstate->language ());
if (this_val)
- this_type = value_type (this_val);
+ this_type = this_val->type ();
else
this_type = NULL;
if (this_type)
const struct value_print_options *options) const
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
struct gdbarch *gdbarch = type->arch ();
enum bfd_endian byte_order = type_byte_order (type);
unsigned int i = 0; /* Number of characters printed */
pascal_language::value_print (struct value *val, struct ui_file *stream,
const struct value_print_options *options) const
{
- struct type *type = value_type (val);
+ struct type *type = val->type ();
struct value_print_options opts = *options;
opts.deref_ref = true;
char *last_dont_print
= (char *) obstack_next_free (&dont_print_statmem_obstack);
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
gdb_printf (stream, "{");
len = type->num_fields ();
opts.deref_ref = false;
struct value *v = value_primitive_field (val, 0, i,
- value_type (val));
+ val->type ());
common_val_print (v, stream, recurse + 1, &opts,
current_language);
}
struct type **last_dont_print
= (struct type **) obstack_next_free (&dont_print_vb_obstack);
struct obstack tmp_obstack = dont_print_vb_obstack;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
int i, n_baseclasses = TYPE_N_BASECLASSES (type);
if (dont_print_vb == 0)
base_value = value_from_contents_and_address (baseclass,
buf.data (),
address + boffset);
- baseclass = value_type (base_value);
+ baseclass = base_value->type ();
boffset = 0;
}
}
int recurse,
const struct value_print_options *options)
{
- struct type *type = value_type (val);
+ struct type *type = val->type ();
struct value_print_options opts;
if (value_entirely_optimized_out (val))
/* DATA_VALUE is the constant in RIGHT_VAL, but actually has
the same type as the memory region referenced by LEFT_VAL. */
- *len = check_typedef (value_type (left_val))->length ();
+ *len = check_typedef (left_val->type ())->length ();
}
else if (num_accesses_left == 0 && num_accesses_right == 1
&& VALUE_LVAL (right_val) == lval_memory
/* DATA_VALUE is the constant in LEFT_VAL, but actually has
the same type as the memory region referenced by RIGHT_VAL. */
- *len = check_typedef (value_type (right_val))->length ();
+ *len = check_typedef (right_val->type ())->length ();
}
else
return 0;
{
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));
+ int opencl_abi = ppc_sysv_use_opencl_abi (function->type ());
ULONGEST saved_sp;
int argspace = 0; /* 0 is an initial wrong guess. */
int write_pass;
for (argno = 0; argno < nargs; argno++)
{
struct value *arg = args[argno];
- struct type *type = check_typedef (value_type (arg));
+ struct type *type = check_typedef (arg->type ());
int len = type->length ();
const bfd_byte *val = value_contents (arg).data ();
gdb_byte *readbuf, const gdb_byte *writebuf)
{
return do_ppc_sysv_return_value (gdbarch,
- function ? value_type (function) : NULL,
+ function ? function->type () : NULL,
valtype, regcache, readbuf, writebuf, 0);
}
gdb_byte *readbuf, const gdb_byte *writebuf)
{
return do_ppc_sysv_return_value (gdbarch,
- function ? value_type (function) : NULL,
+ function ? function->type () : NULL,
valtype, regcache, readbuf, writebuf, 1);
}
CORE_ADDR func_addr = find_function_addr (function, NULL);
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));
+ int opencl_abi = ppc_sysv_use_opencl_abi (function->type ());
ULONGEST back_chain;
/* See for-loop comment below. */
int write_pass;
for (argno = 0; argno < nargs; argno++)
{
struct value *arg = args[argno];
- struct type *type = check_typedef (value_type (arg));
+ struct type *type = check_typedef (arg->type ());
const bfd_byte *val = value_contents (arg).data ();
if (type->code () == TYPE_CODE_COMPLEX)
the pointer itself identifies the descriptor. */
if (tdep->elf_abi == POWERPC_ELF_V1)
{
- struct type *ftype = check_typedef (value_type (function));
+ struct type *ftype = check_typedef (function->type ());
CORE_ADDR desc_addr = value_as_address (function);
if (ftype->code () == TYPE_CODE_PTR
gdb_byte *readbuf, const gdb_byte *writebuf)
{
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
- struct type *func_type = function ? value_type (function) : NULL;
+ struct type *func_type = function ? function->type () : NULL;
int opencl_abi = func_type? ppc_sysv_use_opencl_abi (func_type) : 0;
struct type *eltype;
int nelt, ok;
const struct value_print_options *options,
struct ui_file *stream)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
int len = type->length ();
if (VALUE_LVAL (val) == lval_memory)
{
case 's':
{
- struct type *elttype = value_type (val);
+ struct type *elttype = val->type ();
next_address = (value_address (val)
+ val_print_string (elttype, NULL,
int histindex = record_latest_value (val);
- annotate_value_history_begin (histindex, value_type (val));
+ annotate_value_history_begin (histindex, val->type ());
gdb_printf ("$%d = ", histindex);
static bool
should_validate_memtags (struct value *value)
{
- gdb_assert (value != nullptr && value_type (value) != nullptr);
+ gdb_assert (value != nullptr && value->type () != nullptr);
if (!target_supports_memory_tagging ())
return false;
- enum type_code code = value_type (value)->code ();
+ enum type_code code = value->type ()->code ();
/* Skip non-address values. */
if (code != TYPE_CODE_PTR
- && !TYPE_IS_REFERENCE (value_type (value)))
+ && !TYPE_IS_REFERENCE (value->type ()))
return false;
/* OK, we have an address value. Check we have a complete value we
struct value *val = process_print_command_args (args, &print_opts, voidprint);
- if (voidprint || (val && value_type (val) &&
- value_type (val)->code () != TYPE_CODE_VOID))
+ if (voidprint || (val && val->type () &&
+ val->type ()->code () != TYPE_CODE_VOID))
{
/* If memory tagging validation is on, check if the tag is valid. */
if (print_opts.memory_tag_violations)
val = evaluate_expression (expr.get ());
- annotate_value_begin (value_type (val));
+ annotate_value_begin (val->type ());
get_formatted_print_options (&opts, format);
opts.raw = fmt.raw;
if (from_tty)
set_repeat_arguments ("");
val = evaluate_expression (expr.get ());
- if (TYPE_IS_REFERENCE (value_type (val)))
+ if (TYPE_IS_REFERENCE (val->type ()))
val = coerce_ref (val);
/* In rvalue contexts, such as this, functions are coerced into
pointers to functions. This makes "x/i main" work. */
- if (value_type (val)->code () == TYPE_CODE_FUNC
+ if (val->type ()->code () == TYPE_CODE_FUNC
&& VALUE_LVAL (val) == lval_memory)
next_address = value_address (val);
else
/* Make last address examined available to the user as $_. Use
the correct pointer type. */
struct type *pointer_type
- = lookup_pointer_type (value_type (last_examine_value.get ()));
+ = lookup_pointer_type (last_examine_value.get ()->type ());
set_internalvar (lookup_internalvar ("_"),
value_from_pointer (pointer_type,
last_examine_address));
{
const gdb_byte *str;
- if (value_type (value)->code () != TYPE_CODE_PTR
+ if (value->type ()->code () != TYPE_CODE_PTR
&& VALUE_LVAL (value) == lval_internalvar
- && c_is_string_type_p (value_type (value)))
+ && c_is_string_type_p (value->type ()))
{
- size_t len = value_type (value)->length ();
+ size_t len = value->type ()->length ();
/* Copy the internal var value to TEM_STR and append a terminating null
character. This protects against corrupted C-style strings that lack
{
const gdb_byte *str;
size_t len;
- struct gdbarch *gdbarch = value_type (value)->arch ();
+ struct gdbarch *gdbarch = value->type ()->arch ();
struct type *wctype = lookup_typename (current_language,
"wchar_t", NULL, 0);
int wcwidth = wctype->length ();
if (VALUE_LVAL (value) == lval_internalvar
- && c_is_string_type_p (value_type (value)))
+ && c_is_string_type_p (value->type ()))
{
str = value_contents (value).data ();
- len = value_type (value)->length ();
+ len = value->type ()->length ();
}
else
{
struct value *value, enum argclass argclass)
{
/* Parameter data. */
- struct type *param_type = value_type (value);
+ struct type *param_type = value->type ();
struct gdbarch *gdbarch = param_type->arch ();
/* Determine target type corresponding to the format string. */
if (fmt_type->code () == TYPE_CODE_FLT)
{
param_type = float_type_from_length (param_type);
- if (param_type != value_type (value))
+ if (param_type != value->type ())
value = value_from_contents (param_type,
value_contents (value).data ());
}
break;
case wide_char_arg:
{
- struct gdbarch *gdbarch = value_type (val_args[i])->arch ();
+ struct gdbarch *gdbarch = val_args[i]->type ()->arch ();
struct type *wctype = lookup_typename (current_language,
"wchar_t", NULL, 0);
struct type *valtype;
const gdb_byte *bytes;
- valtype = value_type (val_args[i]);
+ valtype = val_args[i]->type ();
if (valtype->length () != wctype->length ()
|| valtype->code () != TYPE_CODE_INT)
error (_("expected wchar_t argument for %%lc"));
static void
py_print_type (struct ui_out *out, struct value *val)
{
- check_typedef (value_type (val));
+ check_typedef (val->type ());
string_file stb;
- type_print (value_type (val), "", &stb, -1);
+ type_print (val->type (), "", &stb, -1);
out->field_stream ("type", stb);
}
if (args_type == MI_PRINT_SIMPLE_VALUES
|| args_type == MI_PRINT_ALL_VALUES)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (args_type == MI_PRINT_ALL_VALUES)
should_print = 1;
py_print_type (out, val);
if (val != NULL)
- annotate_arg_value (value_type (val));
+ annotate_arg_value (val->type ());
/* If the output is to the CLI, and the user option "set print
frame-arguments" is set to none, just output "...". */
{
struct value *val = value_object_to_value (handle_obj);
bytes = value_contents_all (val).data ();
- bytes_len = value_type (val)->length ();
+ bytes_len = val->type ()->length ();
}
else
{
const struct value_print_options *options,
const struct language_defn *language)
{
- struct type *type = value_type (value);
+ struct type *type = value->type ();
struct gdbarch *gdbarch = type->arch ();
enum gdbpy_string_repr_result print_result;
{
if ((value = value_object_to_value (pyo_value)) != NULL)
{
- *addr = unpack_pointer (value_type (value),
+ *addr = unpack_pointer (value->type (),
value_contents (value).data ());
rc = 1;
}
return NULL;
}
data_size = register_size (pending_frame->gdbarch, regnum);
- if (data_size != value_type (value)->length ())
+ if (data_size != value->type ()->length ())
{
PyErr_Format (
PyExc_ValueError,
"The value of the register returned by the Python "
"sniffer has unexpected size: %u instead of %u.",
- (unsigned) value_type (value)->length (),
+ (unsigned) value->type ()->length (),
(unsigned) data_size);
return NULL;
}
/* `value' validation was done before, just assert. */
gdb_assert (value != NULL);
- gdb_assert (data_size == value_type (value)->length ());
+ gdb_assert (data_size == value->type ()->length ());
cached_frame->reg[i].data = (gdb_byte *) xmalloc (data_size);
memcpy (cached_frame->reg[i].data,
scoped_value_mark free_values;
self_val = ((value_object *) self)->value;
- switch (check_typedef (value_type (self_val))->code ())
+ switch (check_typedef (self_val->type ())->code ())
{
case TYPE_CODE_PTR:
res_val = value_ind (self_val);
if (!obj->type)
{
- obj->type = type_to_type_object (value_type (obj->value));
+ obj->type = type_to_type_object (obj->value->type ());
if (!obj->type)
return NULL;
}
struct value *val = obj->value;
scoped_value_mark free_values;
- type = value_type (val);
+ type = val->type ();
type = check_typedef (type);
if (type->is_pointer_or_reference ()
struct type *type, *realtype;
CORE_ADDR addr;
- type = value_type (value);
+ type = value->type ();
realtype = check_typedef (type);
switch (realtype->code ())
try
{
- val_type = value_type (v);
+ val_type = v->type ();
val_type = check_typedef (val_type);
if (val_type->is_pointer_or_reference ())
val_type = check_typedef (val_type->target_type ());
{
struct type *val_type;
- val_type = check_typedef (value_type (tmp));
+ val_type = check_typedef (tmp->type ());
if (val_type->code () == TYPE_CODE_PTR)
res_val = value_cast (lookup_pointer_type (base_class_type), tmp);
else if (val_type->code () == TYPE_CODE_REF)
struct type *type;
tmp = coerce_ref (tmp);
- type = check_typedef (value_type (tmp));
+ type = check_typedef (tmp->type ());
if (type->code () != TYPE_CODE_ARRAY
&& type->code () != TYPE_CODE_PTR)
error (_("Cannot subscript requested type."));
try
{
- ftype = check_typedef (value_type (function));
+ ftype = check_typedef (function->type ());
}
catch (const gdb_exception &except)
{
{
case VALPY_ADD:
{
- struct type *ltype = value_type (arg1);
- struct type *rtype = value_type (arg2);
+ struct type *ltype = arg1->type ();
+ struct type *rtype = arg2->type ();
ltype = check_typedef (ltype);
ltype = STRIP_REFERENCE (ltype);
break;
case VALPY_SUB:
{
- struct type *ltype = value_type (arg1);
- struct type *rtype = value_type (arg2);
+ struct type *ltype = arg1->type ();
+ struct type *rtype = arg2->type ();
ltype = check_typedef (ltype);
ltype = STRIP_REFERENCE (ltype);
{
scoped_value_mark free_values;
- if (value_less (value, value_zero (value_type (value), not_lval)))
+ if (value_less (value, value_zero (value->type (), not_lval)))
isabs = 0;
}
catch (const gdb_exception &except)
try
{
- type = check_typedef (value_type (self_value->value));
+ type = check_typedef (self_value->value->type ());
if (is_integral_type (type) || type->code () == TYPE_CODE_PTR)
nonzero = !!value_as_long (self_value->value);
valpy_long (PyObject *self)
{
struct value *value = ((value_object *) self)->value;
- struct type *type = value_type (value);
+ struct type *type = value->type ();
LONGEST l = 0;
try
valpy_float (PyObject *self)
{
struct value *value = ((value_object *) self)->value;
- struct type *type = value_type (value);
+ struct type *type = value->type ();
double d = 0;
try
if (var != NULL)
{
res_val = value_of_internalvar (gdbpy_enter::get_gdbarch (), var);
- if (value_type (res_val)->code () == TYPE_CODE_VOID)
+ if (res_val->type ()->code () == TYPE_CODE_VOID)
res_val = NULL;
}
}
return EXT_LANG_RC_OK;
}
- obj_type = check_typedef (value_type (obj));
+ obj_type = check_typedef (obj->type ());
this_type = check_typedef (type_object_to_type (m_this_type));
if (obj_type->code () == TYPE_CODE_PTR)
{
struct type *obj_type, *this_type;
struct value *res = NULL;
- obj_type = check_typedef (value_type (obj));
+ obj_type = check_typedef (obj->type ());
this_type = check_typedef (type_object_to_type (m_this_type));
if (obj_type->code () == TYPE_CODE_PTR)
{
if (cooked_read (regnum,
value_contents_raw (result).data ()) == REG_UNAVAILABLE)
mark_value_bytes_unavailable (result, 0,
- value_type (result)->length ());
+ result->type ()->length ());
return result;
}
try
{
val = value_of_register (regnum, frame);
- regtype = value_type (val);
+ regtype = val->type ();
}
catch (const gdb_exception_error &ex)
{
CORE_ADDR osp = sp;
- struct type *ftype = check_typedef (value_type (function));
+ struct type *ftype = check_typedef (function->type ());
if (ftype->code () == TYPE_CODE_PTR)
ftype = check_typedef (ftype->target_type ());
struct riscv_arg_info *info = &arg_info[i];
arg_value = args[i];
- arg_type = check_typedef (value_type (arg_value));
+ arg_type = check_typedef (arg_value->type ());
riscv_arg_location (gdbarch, info, &call_info, arg_type,
ftype->has_varargs () && i >= ftype->num_fields ());
type of ABI_VAL will differ from ARG_TYPE due to
dynamic type resolution, and so will most likely
fail. */
- arg_type = value_type (abi_val);
+ arg_type = abi_val->type ();
}
if (writebuf != nullptr)
write_memory (addr, writebuf, info.length);
int reg_size = register_size (gdbarch, ii + 3);
arg = args[argno];
- type = check_typedef (value_type (arg));
+ type = check_typedef (arg->type ());
len = type->length ();
if (type->code () == TYPE_CODE_FLT)
for (; jj < nargs; ++jj)
{
struct value *val = args[jj];
- space += ((value_type (val)->length ()) + 3) & -4;
+ space += ((val->type ()->length ()) + 3) & -4;
}
/* Add location required for the rest of the parameters. */
{
arg = args[argno];
- type = check_typedef (value_type (arg));
+ type = check_typedef (arg->type ());
len = type->length ();
int reg_size = register_size (gdbarch, ii + 3);
arg = args[argno];
- type = check_typedef (value_type (arg));
+ type = check_typedef (arg->type ());
len = type->length ();
if (type->code () == TYPE_CODE_FLT)
{
struct value *val = args[jj];
- space += align_up (value_type (val)->length (), 4);
+ space += align_up (val->type ()->length (), 4);
}
/* Add location required for the rest of the parameters. */
{
arg = args[argno];
- type = check_typedef (value_type (arg));
+ type = check_typedef (arg->type ());
len = type->length ();
static struct value *
rust_get_trait_object_pointer (struct value *value)
{
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
if (type->code () != TYPE_CODE_STRUCT || type->num_fields () != 2)
return NULL;
"slice");
struct value *len = value_struct_elt (&val, {}, "length", NULL, "slice");
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (strcmp (type->name (), "&str") == 0)
- val_print_string (value_type (base)->target_type (), "UTF-8",
+ val_print_string (base->type ()->target_type (), "UTF-8",
value_as_address (base), value_as_long (len), stream,
options);
else
{
LONGEST llen = value_as_long (len);
- type_print (value_type (val), "", stream, -1);
+ type_print (val->type (), "", stream, -1);
gdb_printf (stream, " ");
if (llen == 0)
gdb_printf (stream, "[]");
else
{
- struct type *elt_type = value_type (base)->target_type ();
+ struct type *elt_type = base->type ()->target_type ();
struct type *array_type = lookup_array_range_type (elt_type, 0,
llen - 1);
struct value *array = allocate_value_lazy (array_type);
{
int i;
int first_field;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (rust_slice_type_p (type))
{
const struct value_print_options *options) const
{
struct value_print_options opts = *options;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
opts.deref_ref = false;
gdb_assert (rust_enum_p (type));
gdb::array_view<const gdb_byte> view
(value_contents_for_printing (val).data (),
- value_type (val)->length ());
+ val->type ()->length ());
type = resolve_dynamic_type (type, view, value_address (val));
if (rust_empty_enum_p (type))
opts.prettyformat = (opts.prettyformat_structs
? Val_prettyformat : Val_no_prettyformat);
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
switch (type->code ())
{
case TYPE_CODE_PTR:
value_print_options opts = *options;
opts.deref_ref = true;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (type->is_pointer_or_reference ())
{
gdb_printf (stream, "(");
- type_print (value_type (val), "", stream, -1);
+ type_print (val->type (), "", stream, -1);
gdb_printf (stream, ") ");
}
}
else
{
- index_type = value_type (high);
+ index_type = high->type ();
name = (inclusive
? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
}
{
if (high == NULL)
{
- index_type = value_type (low);
+ index_type = low->type ();
name = "std::ops::RangeFrom";
}
else
{
- if (!types_equal (value_type (low), value_type (high)))
+ if (!types_equal (low->type (), high->type ()))
error (_("Range expression with different types"));
- index_type = value_type (low);
+ index_type = low->type ();
name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range";
}
}
LONGEST high = 0;
int want_slice = 0;
- rhstype = check_typedef (value_type (rhs));
+ rhstype = check_typedef (rhs->type ());
if (rust_range_type_p (rhstype))
{
if (!for_addr)
else
low = value_as_long (rhs);
- struct type *type = check_typedef (value_type (lhs));
+ struct type *type = check_typedef (lhs->type ());
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *base_type = nullptr;
&& rust_slice_type_p (type))
? type->name () : "&[*gdb*]");
- slice = rust_slice_type (new_name, value_type (result), usize);
+ slice = rust_slice_type (new_name, result->type (), usize);
addrval = value_allocate_space_in_inferior (slice->length ());
addr = value_as_long (addrval);
enum exp_opcode opcode,
struct value *value)
{
- if (value_type (value)->code () == TYPE_CODE_BOOL)
- return value_from_longest (value_type (value), value_logical_not (value));
+ if (value->type ()->code () == TYPE_CODE_BOOL)
+ return value_from_longest (value->type (), value_logical_not (value));
return value_complement (value);
}
else
{
struct type *arraytype
- = lookup_array_range_type (value_type (elt), 0, copies - 1);
+ = lookup_array_range_type (elt->type (), 0, copies - 1);
return allocate_value (arraytype);
}
}
value *lhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
int field_number = std::get<0> (m_storage);
- struct type *type = value_type (lhs);
+ struct type *type = lhs->type ();
if (type->code () == TYPE_CODE_STRUCT)
{
int fieldno = rust_enum_variant (type);
lhs = value_primitive_field (lhs, 0, fieldno, type);
outer_type = type;
- type = value_type (lhs);
+ type = lhs->type ();
}
/* Tuples and tuple structs */
const char *field_name = std::get<1> (m_storage).c_str ();
struct value *result;
- struct type *type = value_type (lhs);
+ struct type *type = lhs->type ();
if (type->code () == TYPE_CODE_STRUCT && rust_enum_p (type))
{
type = resolve_dynamic_type (type, value_contents (lhs),
lhs = value_primitive_field (lhs, 0, fieldno, type);
struct type *outer_type = type;
- type = value_type (lhs);
+ type = lhs->type ();
if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type))
error (_("Attempting to access named field %s of tuple "
"variant %s::%s, which has only anonymous fields"),
else
result = value_struct_elt (&lhs, {}, field_name, NULL, "structure");
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- result = value_zero (value_type (result), VALUE_LVAL (result));
+ result = value_zero (result->type (), VALUE_LVAL (result));
return result;
}
type in order to look up the method. */
args[0] = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
/* We don't yet implement real Deref semantics. */
- while (value_type (args[0])->code () == TYPE_CODE_PTR)
+ while (args[0]->type ()->code () == TYPE_CODE_PTR)
args[0] = value_ind (args[0]);
- struct type *type = value_type (args[0]);
+ struct type *type = args[0]->type ();
if ((type->code () != TYPE_CODE_STRUCT
&& type->code () != TYPE_CODE_UNION
&& type->code () != TYPE_CODE_ENUM)
CORE_ADDR cfa;
int num_register_candidate_args;
- struct type *func_type = value_type (function);
+ struct type *func_type = function->type ();
/* Dereference function pointer types. */
while (func_type->code () == TYPE_CODE_PTR)
{
struct value *arg = args[i];
const gdb_byte *arg_bits = value_contents_all (arg).data ();
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
ULONGEST arg_size = arg_type->length ();
if (i == 0 && struct_addr != 0
s390_gdbarch_tdep *tdep, int word_size,
enum bfd_endian byte_order, int is_unnamed)
{
- struct type *type = check_typedef (value_type (arg));
+ struct type *type = check_typedef (arg->type ());
unsigned int length = type->length ();
int write_mode = as->regcache != NULL;
int i;
struct s390_arg_state arg_state, arg_prep;
CORE_ADDR param_area_start, new_sp;
- struct type *ftype = check_typedef (value_type (function));
+ struct type *ftype = check_typedef (function->type ());
if (ftype->code () == TYPE_CODE_PTR)
ftype = check_typedef (ftype->target_type ());
{
int stack_alloc = 0;
while (nargs-- > 0)
- stack_alloc += ((value_type (args[nargs])->length () + 3) & ~3);
+ stack_alloc += ((args[nargs]->type ()->length () + 3) & ~3);
return stack_alloc;
}
int argreg = ARG0_REGNUM;
int flt_argreg = 0;
int argnum;
- struct type *func_type = value_type (function);
+ struct type *func_type = function->type ();
struct type *type;
CORE_ADDR regval;
const gdb_byte *val;
in four registers available. Loop thru args from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
- type = value_type (args[argnum]);
+ type = args[argnum]->type ();
len = type->length ();
val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
int stack_offset = 0;
int argreg = ARG0_REGNUM;
int argnum;
- struct type *func_type = value_type (function);
+ struct type *func_type = function->type ();
struct type *type;
CORE_ADDR regval;
const gdb_byte *val;
in four registers available. Loop thru args from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
- type = value_type (args[argnum]);
+ type = args[argnum]->type ();
len = type->length ();
val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
- struct type *func_type = function ? value_type (function) : NULL;
+ struct type *func_type = function ? function->type () : NULL;
if (sh_use_struct_convention_nofpu
(sh_is_renesas_calling_convention (func_type), type))
struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
- struct type *func_type = function ? value_type (function) : NULL;
+ struct type *func_type = function ? function->type () : NULL;
if (sh_use_struct_convention (
sh_is_renesas_calling_convention (func_type), type))
for (i = 0; i < nargs; i++)
{
- struct type *type = value_type (args[i]);
+ struct type *type = args[i]->type ();
int len = type->length ();
if (sparc_arg_by_memory_p (type))
for (i = 0; i < nargs; i++)
{
const bfd_byte *valbuf = value_contents (args[i]).data ();
- struct type *type = value_type (args[i]);
+ struct type *type = args[i]->type ();
int len = type->length ();
gdb_byte buf[4];
for (i = 0; i < nargs; i++)
{
- struct type *type = value_type (args[i]);
+ struct type *type = args[i]->type ();
int len = type->length ();
if (sparc64_structure_or_union_p (type)
for (i = 0; i < nargs; i++)
{
const gdb_byte *valbuf = value_contents (args[i]).data ();
- struct type *type = value_type (args[i]);
+ struct type *type = args[i]->type ();
int len = type->length ();
int regnum = -1;
gdb_byte buf[16];
because our standard indentation here is 4 spaces, and
val_print indents 2 for each recurse. */
- annotate_arg_value (value_type (arg->val));
+ annotate_arg_value (arg->val->type ());
/* Use the appropriate language to display our symbol, unless the
user forced the language to a specific language. */
if (val && entryval && !current_uiout->is_mi_like_p ())
{
- struct type *type = value_type (val);
+ struct type *type = val->type ();
if (value_lazy (val))
value_fetch_lazy (val);
val_deref = coerce_ref (val);
if (value_lazy (val_deref))
value_fetch_lazy (val_deref);
- type_deref = value_type (val_deref);
+ type_deref = val_deref->type ();
entryval_deref = coerce_ref (entryval);
if (value_lazy (entryval_deref))
error (_("Return value type not available for selected "
"stack frame.\n"
"Please use an explicit cast of the value to return."));
- return_type = value_type (return_value);
+ return_type = return_value->type ();
}
return_type = check_typedef (return_type);
return_value = value_cast (return_type, return_value);
return_value = NULL;
else if (thisfun != NULL)
{
- if (is_nocall_function (check_typedef (value_type (function))))
+ if (is_nocall_function (check_typedef (function->type ())))
{
query_prefix =
string_printf ("Function '%s' does not follow the target "
/* Store RETURN_VALUE in the just-returned register set. */
if (return_value != NULL)
{
- struct type *return_type = value_type (return_value);
+ struct type *return_type = return_value->type ();
struct gdbarch *cache_arch = get_current_regcache ()->arch ();
gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
int stack_offset = 4;
int references_offset = 4;
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- struct type *func_type = value_type (function);
+ struct type *func_type = function->type ();
/* The first arg passed on stack. Mostly the first 10 args are passed by
registers. */
int first_arg_on_stack = 10;
/* Now make space on the stack for the args. */
for (argnum = 0; argnum < nargs; argnum++)
{
- int len = align_up (value_type (args[argnum])->length (), 4);
+ int len = align_up (args[argnum]->type ()->length (), 4);
if (argnum >= 10 - argreg)
references_offset += len;
stack_offset += len;
{
const gdb_byte *val;
struct value *arg = args[argnum];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
int len = arg_type->length ();
enum type_code typecode = arg_type->code ();
any typedef level. "ptype" always strips all levels of
typedefs. */
val = evaluate_type (expr.get ());
- type = value_type (val);
+ type = val->type ();
if (show == -1 && expr->first_opcode () == OP_TYPE)
{
else
{
val = access_value_history (0);
- type = value_type (val);
+ type = val->type ();
}
if (flags.print_offsets && is_dynamic_type (type))
{
expression_up expr = parse_expression (type_name);
struct value *val = evaluate_type (expr.get ());
- struct type *type = value_type (val);
+ struct type *type = val->type ();
if (type != nullptr)
recursive_dump_type (type, 0);
/* Now make space on the stack for the args. */
for (argnum = 0; argnum < nargs; argnum++)
- arg_space += ((value_type (args[argnum])->length () + 3) & ~3);
+ arg_space += ((args[argnum]->type ()->length () + 3) & ~3);
sp -= arg_space + stack_offset;
argreg = E_ARG0_REGNUM;
gdb_byte *val;
gdb_byte valbuf[v850_reg_size];
- if (!v850_type_is_scalar (value_type (*args))
+ if (!v850_type_is_scalar ((*args)->type ())
&& tdep->abi == V850_ABI_GCC
- && value_type (*args)->length () > E_MAX_RETTYPE_SIZE_IN_REGS)
+ && (*args)->type ()->length () > E_MAX_RETTYPE_SIZE_IN_REGS)
{
store_unsigned_integer (valbuf, 4, byte_order,
value_address (*args));
}
else
{
- len = value_type (*args)->length ();
+ len = (*args)->type ()->length ();
val = (gdb_byte *) value_contents (*args).data ();
}
if (tdep->eight_byte_align
- && v850_eight_byte_align_p (value_type (*args)))
+ && v850_eight_byte_align_p ((*args)->type ()))
{
if (argreg <= E_ARGLAST_REGNUM && (argreg & 1))
argreg++;
struct value *result;
arg1 = coerce_array (arg1);
- valptrtype = check_typedef (value_type (arg1));
+ valptrtype = check_typedef (arg1->type ());
sz = find_size_for_pointer_math (valptrtype);
result = value_from_pointer (valptrtype,
arg1 = coerce_array (arg1);
arg2 = coerce_array (arg2);
- type1 = check_typedef (value_type (arg1));
- type2 = check_typedef (value_type (arg2));
+ type1 = check_typedef (arg1->type ());
+ type2 = check_typedef (arg2->type ());
gdb_assert (type1->code () == TYPE_CODE_PTR);
gdb_assert (type2->code () == TYPE_CODE_PTR);
struct type *tarray;
array = coerce_ref (array);
- tarray = check_typedef (value_type (array));
+ tarray = check_typedef (array->type ());
if (tarray->code () == TYPE_CODE_ARRAY
|| tarray->code () == TYPE_CODE_STRING)
value_subscripted_rvalue (struct value *array, LONGEST index,
LONGEST lowerbound)
{
- struct type *array_type = check_typedef (value_type (array));
+ struct type *array_type = check_typedef (array->type ());
struct type *elt_type = array_type->target_type ();
LONGEST elt_size = type_length_units (elt_type);
binop_user_defined_p (enum exp_opcode op,
struct value *arg1, struct value *arg2)
{
- return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
+ return binop_types_user_defined_p (op, arg1->type (), arg2->type ());
}
/* Check to see if argument is a structure. This is called so
if (op == UNOP_ADDR)
return 0;
- type1 = check_typedef (value_type (arg1));
+ type1 = check_typedef (arg1->type ());
if (TYPE_IS_REFERENCE (type1))
type1 = check_typedef (type1->target_type ());
return type1->code () == TYPE_CODE_STRUCT;
/* now we know that what we have to do is construct our
arg vector and find the right function to call it with. */
- if (check_typedef (value_type (arg1))->code () != TYPE_CODE_STRUCT)
+ if (check_typedef (arg1->type ())->code () != TYPE_CODE_STRUCT)
error (_("Can't do that binary op on that type")); /* FIXME be explicit */
value *argvec_storage[3];
argvec[1] = argvec[0];
argvec = argvec.slice (1);
}
- if (value_type (argvec[0])->code () == TYPE_CODE_XMETHOD)
+ if (argvec[0]->type ()->code () == TYPE_CODE_XMETHOD)
{
/* Static xmethods are not supported yet. */
gdb_assert (static_memfuncp == 0);
{
struct type *return_type;
- return_type = check_typedef (value_type (argvec[0]))->target_type ();
+ return_type = check_typedef (argvec[0]->type ())->target_type ();
return value_zero (return_type, VALUE_LVAL (arg1));
}
return call_function_by_hand (argvec[0], NULL,
struct value *
value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
{
- struct gdbarch *gdbarch = value_type (arg1)->arch ();
+ struct gdbarch *gdbarch = arg1->type ()->arch ();
char *ptr;
char tstr[13], mangle_tstr[13];
int static_memfuncp, nargs;
/* now we know that what we have to do is construct our
arg vector and find the right function to call it with. */
- if (check_typedef (value_type (arg1))->code () != TYPE_CODE_STRUCT)
+ if (check_typedef (arg1->type ())->code () != TYPE_CODE_STRUCT)
error (_("Can't do that unary op on that type")); /* FIXME be explicit */
value *argvec_storage[3];
argvec[1] = argvec[0];
argvec = argvec.slice (1);
}
- if (value_type (argvec[0])->code () == TYPE_CODE_XMETHOD)
+ if (argvec[0]->type ()->code () == TYPE_CODE_XMETHOD)
{
/* Static xmethods are not supported yet. */
gdb_assert (static_memfuncp == 0);
{
struct type *return_type;
- return_type = check_typedef (value_type (argvec[0]))->target_type ();
+ return_type = check_typedef (argvec[0]->type ())->target_type ();
return value_zero (return_type, VALUE_LVAL (arg1));
}
return call_function_by_hand (argvec[0], NULL,
struct value *
value_concat (struct value *arg1, struct value *arg2)
{
- struct type *type1 = check_typedef (value_type (arg1));
- struct type *type2 = check_typedef (value_type (arg2));
+ struct type *type1 = check_typedef (arg1->type ());
+ struct type *type2 = check_typedef (arg2->type ());
if (type1->code () != TYPE_CODE_ARRAY && type2->code () != TYPE_CODE_ARRAY)
error ("no array provided to concatenation");
{
struct type *type1, *type2;
- type1 = check_typedef (value_type (arg1));
- type2 = check_typedef (value_type (arg2));
+ type1 = check_typedef (arg1->type ());
+ type2 = check_typedef (arg2->type ());
/* At least one of the arguments must be of floating-point type. */
gdb_assert (is_floating_type (type1) || is_floating_type (type2));
static struct value *
fixed_point_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
{
- struct type *type1 = check_typedef (value_type (arg1));
- struct type *type2 = check_typedef (value_type (arg2));
+ struct type *type1 = check_typedef (arg1->type ());
+ struct type *type2 = check_typedef (arg2->type ());
const struct language_defn *language = current_language;
struct gdbarch *gdbarch = type1->arch ();
static struct value *
complex_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
{
- struct type *arg1_type = check_typedef (value_type (arg1));
- struct type *arg2_type = check_typedef (value_type (arg2));
+ struct type *arg1_type = check_typedef (arg1->type ());
+ struct type *arg2_type = check_typedef (arg2->type ());
struct value *arg1_real, *arg1_imag, *arg2_real, *arg2_imag;
if (arg1_type->code () == TYPE_CODE_COMPLEX)
arg2_imag = value_zero (arg2_type, not_lval);
}
- struct type *comp_type = promotion_type (value_type (arg1_real),
- value_type (arg2_real));
+ struct type *comp_type = promotion_type (arg1_real->type (),
+ arg2_real->type ());
if (!can_create_complex_type (comp_type))
error (_("Argument to complex arithmetic operation not supported."));
else
v1 = v1 || v2;
- return value_from_longest (value_type (x1), v1);
+ return value_from_longest (x1->type (), v1);
}
break;
arg1 = coerce_ref (arg1);
arg2 = coerce_ref (arg2);
- type1 = check_typedef (value_type (arg1));
- type2 = check_typedef (value_type (arg2));
+ type1 = check_typedef (arg1->type ());
+ type2 = check_typedef (arg2->type ());
if (type1->code () == TYPE_CODE_COMPLEX
|| type2->code () == TYPE_CODE_COMPLEX)
val = allocate_value (result_type);
store_unsigned_integer (value_contents_raw (val).data (),
- value_type (val)->length (),
+ val->type ()->length (),
type_byte_order (result_type),
v);
}
val = allocate_value (result_type);
store_signed_integer (value_contents_raw (val).data (),
- value_type (val)->length (),
+ val->type ()->length (),
type_byte_order (result_type),
v);
}
eltype = check_typedef (vector_type->target_type ());
elval = value_cast (eltype, scalar_value);
- scalar_type = check_typedef (value_type (scalar_value));
+ scalar_type = check_typedef (scalar_value->type ());
/* If we reduced the length of the scalar then check we didn't loose any
important bits. */
int t1_is_vec, t2_is_vec, elsize, i;
LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
- type1 = check_typedef (value_type (val1));
- type2 = check_typedef (value_type (val2));
+ type1 = check_typedef (val1->type ());
+ type2 = check_typedef (val2->type ());
t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
&& type1->is_vector ()) ? 1 : 0;
value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
{
struct value *val;
- struct type *type1 = check_typedef (value_type (arg1));
- struct type *type2 = check_typedef (value_type (arg2));
+ struct type *type1 = check_typedef (arg1->type ());
+ struct type *type2 = check_typedef (arg2->type ());
int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
&& type1->is_vector ());
int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
struct type *type1;
arg1 = coerce_array (arg1);
- type1 = check_typedef (value_type (arg1));
+ type1 = check_typedef (arg1->type ());
if (is_floating_value (arg1))
return target_float_is_zero (value_contents (arg1).data (), type1);
static int
value_strcmp (struct value *arg1, struct value *arg2)
{
- int len1 = value_type (arg1)->length ();
- int len2 = value_type (arg2)->length ();
+ int len1 = arg1->type ()->length ();
+ int len2 = arg2->type ()->length ();
const gdb_byte *s1 = value_contents (arg1).data ();
const gdb_byte *s2 = value_contents (arg2).data ();
int i, len = len1 < len2 ? len1 : len2;
arg1 = coerce_array (arg1);
arg2 = coerce_array (arg2);
- type1 = check_typedef (value_type (arg1));
- type2 = check_typedef (value_type (arg2));
+ type1 = check_typedef (arg1->type ());
+ type2 = check_typedef (arg2->type ());
code1 = type1->code ();
code2 = type2->code ();
is_int1 = is_integral_type (type1);
{
struct type *type1, *type2;
- type1 = check_typedef (value_type (arg1));
- type2 = check_typedef (value_type (arg2));
+ type1 = check_typedef (arg1->type ());
+ type2 = check_typedef (arg2->type ());
return (type1->code () == type2->code ()
&& type1->length () == type2->length ()
arg1 = coerce_array (arg1);
arg2 = coerce_array (arg2);
- type1 = check_typedef (value_type (arg1));
- type2 = check_typedef (value_type (arg2));
+ type1 = check_typedef (arg1->type ());
+ type2 = check_typedef (arg2->type ());
code1 = type1->code ();
code2 = type2->code ();
is_int1 = is_integral_type (type1);
struct type *type;
arg1 = coerce_ref (arg1);
- type = check_typedef (value_type (arg1));
+ type = check_typedef (arg1->type ());
if (is_integral_type (type) || is_floating_value (arg1)
|| (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
struct type *type;
arg1 = coerce_ref (arg1);
- type = check_typedef (value_type (arg1));
+ type = check_typedef (arg1->type ());
if (is_integral_type (type) || is_floating_type (type))
return value_binop (value_from_longest (type, 0), arg1, BINOP_SUB);
struct value *val;
arg1 = coerce_ref (arg1);
- type = check_typedef (value_type (arg1));
+ type = check_typedef (arg1->type ());
if (is_integral_type (type))
val = value_from_longest (type, ~value_as_long (arg1));
value_in (struct value *element, struct value *set)
{
int member;
- struct type *settype = check_typedef (value_type (set));
- struct type *eltype = check_typedef (value_type (element));
+ struct type *settype = check_typedef (set->type ());
+ struct type *eltype = check_typedef (element->type ());
if (eltype->code () == TYPE_CODE_RANGE)
eltype = eltype->target_type ();
gdb_assert (type != NULL && v2 != NULL);
t1 = check_typedef (type);
- t2 = check_typedef (value_type (v2));
+ t2 = check_typedef (v2->type ());
/* Check preconditions. */
gdb_assert ((t1->code () == TYPE_CODE_STRUCT
{
v = value_full_object (v2, real_type, full, top, using_enc);
v = value_at_lazy (real_type, value_address (v));
- real_type = value_type (v);
+ real_type = v->type ();
/* We might be trying to cast to the outermost enclosing
type, in which case search_struct_field won't work. */
int subclass_check)
{
struct type *type1 = check_typedef (type);
- struct type *type2 = check_typedef (value_type (arg2));
+ struct type *type2 = check_typedef (arg2->type ());
struct type *t1 = check_typedef (type1->target_type ());
struct type *t2 = check_typedef (type2->target_type ());
v2 = coerce_ref (arg2);
else
v2 = value_ind (arg2);
- gdb_assert (check_typedef (value_type (v2))->code ()
+ gdb_assert (check_typedef (v2->type ())->code ()
== TYPE_CODE_STRUCT && !!"Why did coercion fail?");
v2 = value_cast_structs (t1, v2);
/* At this point we have what we can have, un-dereference if needed. */
gdb_mpq
value_to_gdb_mpq (struct value *value)
{
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
gdb_mpq result;
if (is_floating_type (type))
static struct value *
value_cast_to_fixed_point (struct type *to_type, struct value *from_val)
{
- struct type *from_type = value_type (from_val);
+ struct type *from_type = from_val->type ();
if (from_type == to_type)
return from_val;
/* TYPE might be equal in meaning to the existing type of ARG2, but for
many reasons, might be a different type object (e.g. TYPE might be a
- gdbarch owned type, while VALUE_TYPE (ARG2) could be an objfile owned
+ gdbarch owned type, while ARG2->type () could be an objfile owned
type).
In this case we want to preserve the LVAL of ARG2 as this allows the
resulting value to be used in more places. We do this by calling
VALUE_COPY if appropriate. */
- if (types_deeply_equal (value_type (arg2), type))
+ if (types_deeply_equal (arg2->type (), type))
{
/* If the types are exactly equal then we can avoid creating a new
value completely. */
- if (value_type (arg2) != type)
+ if (arg2->type () != type)
{
arg2 = value_copy (arg2);
deprecated_set_value_type (arg2, type);
return value_ref (val, t1->code ());
}
- if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2))))
+ if (TYPE_IS_REFERENCE (check_typedef (arg2->type ())))
/* We deref the value and then do the cast. */
return value_cast (type, coerce_ref (arg2));
type = check_typedef (type);
code1 = type->code ();
arg2 = coerce_ref (arg2);
- type2 = check_typedef (value_type (arg2));
+ type2 = check_typedef (arg2->type ());
/* You can't cast to a reference type. See value_cast_pointers
instead. */
if (type2->code () == TYPE_CODE_FUNC)
arg2 = value_coerce_function (arg2);
- type2 = check_typedef (value_type (arg2));
+ type2 = check_typedef (arg2->type ());
code2 = type2->code ();
if (code1 == TYPE_CODE_COMPLEX)
real_type = lookup_pointer_type (real_type);
}
- arg_type = value_type (arg);
+ arg_type = arg->type ();
dest_code = real_type->code ();
arg_code = arg_type->code ();
int full, using_enc;
LONGEST top;
struct type *resolved_type = check_typedef (type);
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
struct type *class_type, *rtti_type;
struct value *result, *tem, *original_arg = arg;
CORE_ADDR addr;
return value_at_lazy (type, addr);
tem = value_at (type, addr);
- type = value_type (tem);
+ type = tem->type ();
/* The first dynamic check specified in 5.2.7. */
if (is_public_ancestor (arg_type, resolved_type->target_type ()))
toval = coerce_ref (toval);
- type = value_type (toval);
+ type = toval->type ();
if (VALUE_LVAL (toval) != lval_internalvar)
fromval = value_cast (type, fromval);
else
Lazy evaluation pays off here. */
val = value_of_variable (var, b);
- type = value_type (val);
+ type = val->type ();
if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
|| type->code () == TYPE_CODE_FUNC)
&& VALUE_LVAL (val) != lval_xcallable)
return false;
- valtype = check_typedef (value_type (val));
+ valtype = check_typedef (val->type ());
switch (valtype->code ())
{
if (!value_must_coerce_to_target (val))
return val;
- length = check_typedef (value_type (val))->length ();
+ length = check_typedef (val->type ())->length ();
addr = allocate_space_in_inferior (length);
write_memory (addr, value_contents (val).data (), length);
- return value_at_lazy (value_type (val), addr);
+ return value_at_lazy (val->type (), addr);
}
/* Given a value which is an array, return a value which is a pointer
struct value *
value_coerce_array (struct value *arg1)
{
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
/* If the user tries to do something requiring a pointer with an
array that has not yet been pushed to the target, then this would
if (VALUE_LVAL (arg1) != lval_memory)
error (_("Attempt to take address of value not located in memory."));
- retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
+ retval = value_from_pointer (lookup_pointer_type (arg1->type ()),
value_address (arg1));
return retval;
}
value_addr (struct value *arg1)
{
struct value *arg2;
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
if (TYPE_IS_REFERENCE (type))
{
error (_("Attempt to take address of value not located in memory."));
/* Get target memory address. */
- arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
+ arg2 = value_from_pointer (lookup_pointer_type (arg1->type ()),
(value_address (arg1)
+ value_embedded_offset (arg1)));
value_ref (struct value *arg1, enum type_code refcode)
{
struct value *arg2;
- struct type *type = check_typedef (value_type (arg1));
+ struct type *type = check_typedef (arg1->type ());
gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
arg1 = coerce_array (arg1);
- base_type = check_typedef (value_type (arg1));
+ base_type = check_typedef (arg1->type ());
if (VALUE_LVAL (arg1) == lval_computed)
{
- value_pointed_to_offset (arg1));
}
arg2 = value_at_lazy (enc_type, base_addr);
- enc_type = value_type (arg2);
+ enc_type = arg2->type ();
return readjust_indirect_value_type (arg2, enc_type, base_type,
arg1, base_addr);
}
return i + 1;
tt1 = check_typedef (t1[i].type ());
- tt2 = check_typedef (value_type (t2[i]));
+ tt2 = check_typedef (t2[i]->type ());
if (TYPE_IS_REFERENCE (tt1)
/* We should be doing hairy argument matching, as below. */
/* We should be doing much hairier argument matching (see
section 13.2 of the ARM), but as a quick kludge, just check
for the same type code. */
- if (t1[i].type ()->code () != value_type (t2[i])->code ())
+ if (t1[i].type ()->code () != t2[i]->type ()->code ())
return i + 1;
}
if (varargs || i == t2.size ())
v2 = value_at_lazy (basetype, base_addr);
if (target_read_memory (base_addr,
value_contents_raw (v2).data (),
- value_type (v2)->length ()) != 0)
+ v2->type ()->length ()) != 0)
error (_("virtual baseclass botch"));
}
else
{
gdb_assert (!candidate.path.empty ());
- struct type *field_type = value_type (candidate.field_value);
+ struct type *field_type = candidate.field_value->type ();
struct type *struct_type = candidate.path.back ();
std::string path;
*argp = coerce_array (*argp);
- t = check_typedef (value_type (*argp));
+ t = check_typedef ((*argp)->type ());
/* Follow pointers until we get to a non-pointer. */
{
*argp = value_ind (*argp);
/* Don't coerce fn pointer to fn and then back again! */
- if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
+ if (check_typedef ((*argp)->type ())->code () != TYPE_CODE_FUNC)
*argp = coerce_array (*argp);
- t = check_typedef (value_type (*argp));
+ t = check_typedef ((*argp)->type ());
}
if (t->code () != TYPE_CODE_STRUCT
*argp = coerce_array (*argp);
- t = check_typedef (value_type (*argp));
+ t = check_typedef ((*argp)->type ());
while (t->is_pointer_or_reference ())
{
*argp = value_ind (*argp);
- if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
+ if (check_typedef ((*argp)->type ())->code () != TYPE_CODE_FUNC)
*argp = coerce_array (*argp);
- t = check_typedef (value_type (*argp));
+ t = check_typedef ((*argp)->type ());
}
if (t->code () != TYPE_CODE_STRUCT
{
struct type *t;
- t = check_typedef (value_type (*argp));
+ t = check_typedef ((*argp)->type ());
/* Code snarfed from value_struct_elt. */
while (t->is_pointer_or_reference ())
{
*argp = value_ind (*argp);
/* Don't coerce fn pointer to fn and then back again! */
- if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
+ if (check_typedef ((*argp)->type ())->code () != TYPE_CODE_FUNC)
*argp = coerce_array (*argp);
- t = check_typedef (value_type (*argp));
+ t = check_typedef ((*argp)->type ());
}
if (t->code () != TYPE_CODE_STRUCT
std::string incomplete_arg_names;
for (const struct value *arg : args)
{
- struct type *t = value_type (arg);
+ struct type *t = arg->type ();
while (t->code () == TYPE_CODE_PTR)
t = t->target_type ();
if (t->is_stub ())
if (incomplete_types > 0)
incomplete_arg_names += ", ";
- current_language->print_type (value_type (arg), "", &buffer,
+ current_language->print_type (arg->type (), "", &buffer,
-1, 0, &type_print_raw_options);
incomplete_types++;
const enum noside noside)
{
struct value *obj = (objp ? *objp : NULL);
- struct type *obj_type = obj ? value_type (obj) : NULL;
+ struct type *obj_type = obj ? obj->type () : NULL;
/* Index of best overloaded function. */
int func_oload_champ = -1;
int method_oload_champ = -1;
/* OBJ may be a pointer value rather than the object itself. */
obj = coerce_ref (obj);
- while (check_typedef (value_type (obj))->code () == TYPE_CODE_PTR)
+ while (check_typedef (obj->type ())->code () == TYPE_CODE_PTR)
obj = coerce_ref (value_ind (obj));
- obj_type_name = value_type (obj)->name ();
+ obj_type_name = obj->type ()->name ();
/* First check whether this is a data member, e.g. a pointer to
a function. */
- if (check_typedef (value_type (obj))->code () == TYPE_CODE_STRUCT)
+ if (check_typedef (obj->type ())->code () == TYPE_CODE_STRUCT)
{
*valp = search_struct_field (name, obj,
- check_typedef (value_type (obj)), 0);
+ check_typedef (obj->type ()), 0);
if (*valp)
{
*staticp = 1;
if (objp)
{
- struct type *temp_type = check_typedef (value_type (temp));
+ struct type *temp_type = check_typedef (temp->type ());
struct type *objtype = check_typedef (obj_type);
if (temp_type->code () != TYPE_CODE_PTR
arg_types = (struct type **)
alloca (args.size () * (sizeof (struct type *)));
for (ix = 0; ix < args.size (); ix++)
- arg_types[ix] = value_type (args[ix]);
+ arg_types[ix] = args[ix]->type ();
add_symbol_overload_list_adl ({arg_types, args.size ()}, func_name,
&new_oload_syms);
}
struct type *type, *tmp;
ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
- type = check_typedef (value_type (ptr));
+ type = check_typedef (ptr->type ());
gdb_assert (type != NULL
&& type->code () == TYPE_CODE_MEMBERPTR);
tmp = lookup_pointer_type (TYPE_SELF_TYPE (type));
mem_offset += boff;
else
{
- struct type *p = check_typedef (value_type (this_v));
+ struct type *p = check_typedef (this_v->type ());
p = check_typedef (p->target_type ());
if (get_baseclass_offset (p, curtype, this_v,
&boff, &isvirt))
{
result = allocate_value
(lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
- cplus_make_method_ptr (value_type (result),
+ cplus_make_method_ptr (result->type (),
value_contents_writeable (result).data (),
TYPE_FN_FIELD_VOFFSET (f, j), 1);
}
else
{
result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
- cplus_make_method_ptr (value_type (result),
+ cplus_make_method_ptr (result->type (),
value_contents_writeable (result).data (),
value_address (v), 0);
}
struct value *target = NULL;
struct type *type, *real_type, *target_type;
- type = value_type (v);
+ type = v->type ();
type = check_typedef (type);
if (TYPE_IS_REFERENCE (type))
target = coerce_ref (v);
if (real_type)
{
/* Copy qualifiers to the referenced object. */
- target_type = value_type (target);
+ target_type = target->type ();
real_type = make_cv_type (TYPE_CONST (target_type),
TYPE_VOLATILE (target_type), real_type, NULL);
if (TYPE_IS_REFERENCE (type))
value_rtti_type used for its computation. */
new_val = value_at_lazy (real_type, value_address (argp) - top +
(using_enc ? 0 : value_embedded_offset (argp)));
- deprecated_set_value_type (new_val, value_type (argp));
+ deprecated_set_value_type (new_val, argp->type ());
set_value_embedded_offset (new_val, (using_enc
? top + value_embedded_offset (argp)
: top));
struct value *slice;
struct type *array_type;
- array_type = check_typedef (value_type (array));
+ array_type = check_typedef (array->type ());
if (array_type->code () != TYPE_CODE_ARRAY
&& array_type->code () != TYPE_CODE_STRING)
error (_("cannot take slice of non-array"));
struct value *
value_real_part (struct value *value)
{
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
struct type *ttype = type->target_type ();
gdb_assert (type->code () == TYPE_CODE_COMPLEX);
struct value *
value_imaginary_part (struct value *value)
{
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
struct type *ttype = type->target_type ();
gdb_assert (type->code () == TYPE_CODE_COMPLEX);
{
struct type *real_type = type->target_type ();
- if (value_type (val)->code () == TYPE_CODE_COMPLEX)
+ if (val->type ()->code () == TYPE_CODE_COMPLEX)
{
- struct type *val_real_type = value_type (val)->target_type ();
+ struct type *val_real_type = val->type ()->target_type ();
struct value *re_val = allocate_value (val_real_type);
struct value *im_val = allocate_value (val_real_type);
int len = val_real_type->length ();
return value_literal_complex (re_val, im_val, type);
}
- else if (value_type (val)->code () == TYPE_CODE_FLT
- || value_type (val)->code () == TYPE_CODE_INT)
+ else if (val->type ()->code () == TYPE_CODE_FLT
+ || val->type ()->code () == TYPE_CODE_INT)
return value_literal_complex (val,
value_zero (real_type, not_lval),
type);
const struct
generic_val_print_decorations *decorations)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
struct type *unresolved_elttype = type->target_type ();
struct type *elttype = check_typedef (unresolved_elttype);
value_print_scalar_formatted (val, options, 0, stream);
else
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
struct type *elttype = check_typedef (type->target_type ());
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
CORE_ADDR addr = unpack_pointer (type, valaddr);
else
{
const gdb_byte *valaddr = value_contents_for_printing (value).data ();
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
LONGEST val = unpack_long (type, valaddr);
if (val == 0)
gdb_puts (decorations->false_name, stream);
}
else
{
- struct type *unresolved_type = value_type (value);
+ struct type *unresolved_type = value->type ();
struct type *type = check_typedef (unresolved_type);
const gdb_byte *valaddr = value_contents_for_printing (value).data ();
value_print_scalar_formatted (val, options, 0, stream);
else
{
- struct type *type = value_type (val);
+ struct type *type = val->type ();
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
gdb_mpf f;
{
/* Member pointers are essentially specific to C++, and so if we
encounter one, we should print it according to C++ rules. */
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
cp_print_class_member (valaddr, type, stream, "&");
}
const struct value_print_options *options,
const struct generic_val_print_decorations *decorations)
{
- struct type *type = value_type (val);
+ struct type *type = val->type ();
type = check_typedef (type);
value_fetch_lazy (value);
struct value_print_options local_opts = *options;
- struct type *type = value_type (value);
+ struct type *type = value->type ();
struct type *real_type = check_typedef (type);
if (local_opts.prettyformat == Val_prettyformat_default)
if (value_entirely_optimized_out (val))
{
- if (options->summary && !val_print_scalar_type_p (value_type (val)))
+ if (options->summary && !val_print_scalar_type_p (val->type ()))
gdb_printf (stream, "...");
else
val_print_optimized_out (val, stream);
if (value_entirely_unavailable (val))
{
- if (options->summary && !val_print_scalar_type_p (value_type (val)))
+ if (options->summary && !val_print_scalar_type_p (val->type ()))
gdb_printf (stream, "...");
else
val_print_unavailable (stream);
return 0;
}
- if (value_type (val)->code () == TYPE_CODE_INTERNAL_FUNCTION)
+ if (val->type ()->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
fprintf_styled (stream, metadata_style.style (),
_("<internal function %s>"),
return 0;
}
- if (type_not_associated (value_type (val)))
+ if (type_not_associated (val->type ()))
{
val_print_not_associated (stream);
return 0;
}
- if (type_not_allocated (value_type (val)))
+ if (type_not_allocated (val->type ()))
{
val_print_not_allocated (stream);
return 0;
int size,
struct ui_file *stream)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
gdb_assert (val != NULL);
unsigned int reps;
LONGEST low_bound, high_bound;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
elttype = type->target_type ();
unsigned bit_stride = type->bit_stride ();
struct gdbarch *
get_value_arch (const struct value *value)
{
- return value_type (value)->arch ();
+ return value->type ()->arch ();
}
int
set_limited_array_length (struct value *val)
{
ULONGEST limit = val->m_limited_length;
- ULONGEST len = value_type (val)->length ();
+ ULONGEST len = val->type ()->length ();
if (array_length_limiting_element_count.has_value ())
- len = calculate_limited_array_length (value_type (val));
+ len = calculate_limited_array_length (val->type ());
if (limit != 0 && len > limit)
len = limit;
an element limit in effect, then we can possibly try
to load only a sub-set of the array contents into
GDB's memory. */
- if (value_type (val) == enclosing_type
- && value_type (val)->code () == TYPE_CODE_ARRAY
+ if (val->type () == enclosing_type
+ && val->type ()->code () == TYPE_CODE_ARRAY
&& len > max_value_size
&& set_limited_array_length (val))
len = val->m_limited_length;
/* Accessor methods. */
-struct type *
-value_type (const struct value *value)
-{
- return value->m_type;
-}
void
deprecated_set_value_type (struct value *value, struct type *type)
{
allocate_value_contents (value, true);
- ULONGEST length = value_type (value)->length ();
+ ULONGEST length = value->type ()->length ();
return gdb::make_array_view
(value->m_contents.get () + value->m_embedded_offset * unit_size, length);
}
if (real_type_found)
*real_type_found = 0;
- result = value_type (value);
+ result = value->type ();
if (opts.objectprint)
{
/* If result's target type is TYPE_CODE_STRUCT, proceed to
copy_bitwise (dst_contents.data (), dst_bit_offset,
src_contents.data (), src_bit_offset,
bit_length,
- type_byte_order (value_type (src)) == BFD_ENDIAN_BIG);
+ type_byte_order (src->type ()) == BFD_ENDIAN_BIG);
/* Copy the meta-data. */
value_ranges_copy_adjusted (dst, dst_bit_offset,
return 0;
if (value->m_parent != NULL)
return value_address (value->m_parent.get ()) + value->m_offset;
- if (NULL != TYPE_DATA_LOCATION (value_type (value)))
+ if (NULL != TYPE_DATA_LOCATION (value->type ()))
{
- gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (value_type (value)));
- return TYPE_DATA_LOCATION_ADDR (value_type (value));
+ gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (value->type ()));
+ return TYPE_DATA_LOCATION_ADDR (value->type ());
}
return value->m_location.address + value->m_offset;
struct value *
make_cv_value (int cnst, int voltl, struct value *v)
{
- struct type *val_type = value_type (v);
+ struct type *val_type = v->type ();
struct type *m_enclosing_type = value_enclosing_type (v);
struct value *cv_val = value_copy (v);
{
gdb_assert (VALUE_LVAL (v) == not_lval);
- write_memory (addr, value_contents_raw (v).data (), value_type (v)->length ());
+ write_memory (addr, value_contents_raw (v).data (), v->type ()->length ());
v->m_lval = lval_memory;
v->m_location.address = addr;
}
/* If the WHOLE value has a dynamically resolved location property then
update the address of the COMPONENT. */
- type = value_type (whole);
+ type = whole->type ();
if (NULL != TYPE_DATA_LOCATION (type)
&& TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
set_value_address (component, TYPE_DATA_LOCATION_ADDR (type));
/* Similarly, if the COMPONENT value has a dynamically resolved location
property then update its address. */
- type = value_type (component);
+ type = component->type ();
if (NULL != TYPE_DATA_LOCATION (type)
&& TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
{
record_latest_value (struct value *val)
{
struct type *enclosing_type = value_enclosing_type (val);
- struct type *type = value_type (val);
+ struct type *type = val->type ();
/* We don't want this value to have anything to do with the inferior anymore.
In particular, "set $1 = 50" should not affect the variable from which
if (var->kind == INTERNALVAR_VALUE)
{
- struct type *type = check_typedef (value_type (var->u.value));
+ struct type *type = check_typedef (var->u.value->type ());
if (type->code () == TYPE_CODE_INT)
{
unit_size = gdbarch_addressable_memory_unit_size (arch);
if (bitsize)
- modify_field (value_type (var->u.value), addr + offset,
+ modify_field (var->u.value->type (), addr + offset,
value_as_long (newval), bitpos, bitsize);
else
memcpy (addr + offset * unit_size, value_contents (newval).data (),
- value_type (newval)->length ());
+ newval->type ()->length ());
break;
default:
error (_("Cannot overwrite convenience function %s"), var->name);
/* Prepare new contents. */
- switch (check_typedef (value_type (val))->code ())
+ switch (check_typedef (val->type ())->code ())
{
case TYPE_CODE_VOID:
new_kind = INTERNALVAR_VOID;
when accessing the value.
If we keep it, we would still refer to the origin value.
Remove the location property in case it exist. */
- value_type (new_data.value)->remove_dyn_prop (DYN_PROP_DATA_LOCATION);
+ new_data.value->type ()->remove_dyn_prop (DYN_PROP_DATA_LOCATION);
break;
}
struct type *
result_type_of_xmethod (struct value *method, gdb::array_view<value *> argv)
{
- gdb_assert (value_type (method)->code () == TYPE_CODE_XMETHOD
+ gdb_assert (method->type ()->code () == TYPE_CODE_XMETHOD
&& method->m_lval == lval_xcallable && !argv.empty ());
return method->m_location.xm_worker->get_result_type (argv[0], argv.slice (1));
struct value *
call_xmethod (struct value *method, gdb::array_view<value *> argv)
{
- gdb_assert (value_type (method)->code () == TYPE_CODE_XMETHOD
+ gdb_assert (method->type ()->code () == TYPE_CODE_XMETHOD
&& method->m_lval == lval_xcallable && !argv.empty ());
return method->m_location.xm_worker->invoke (argv[0], argv.slice (1));
in disassemble_command). It also dereferences references, which
I suspect is the most logical thing to do. */
val = coerce_array (val);
- return unpack_long (value_type (val), value_contents (val).data ());
+ return unpack_long (val->type (), value_contents (val).data ());
}
/* Extract a value as a C pointer. Does not deallocate the value.
CORE_ADDR
value_as_address (struct value *val)
{
- struct gdbarch *gdbarch = value_type (val)->arch ();
+ struct gdbarch *gdbarch = val->type ()->arch ();
/* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
whether we want this to be true eventually. */
cannot be modified.
Upon entry to this function, if VAL is a value of type `function'
- (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
+ (that is, TYPE_CODE (val->type ()) == TYPE_CODE_FUNC), then
value_address (val) is the address of the function. This is what
you'll get if you evaluate an expression like `main'. The call
to COERCE_ARRAY below actually does all the usual unary
The following shortcut avoids this whole mess. If VAL is a
function, just return its address directly. */
- if (value_type (val)->code () == TYPE_CODE_FUNC
- || value_type (val)->code () == TYPE_CODE_METHOD)
+ if (val->type ()->code () == TYPE_CODE_FUNC
+ || val->type ()->code () == TYPE_CODE_METHOD)
return value_address (val);
val = coerce_array (val);
converted to pointers; usually, the ABI doesn't either, but
ABI-specific code is a more reasonable place to handle it. */
- if (!value_type (val)->is_pointer_or_reference ()
+ if (!val->type ()->is_pointer_or_reference ()
&& gdbarch_integer_to_address_p (gdbarch))
- return gdbarch_integer_to_address (gdbarch, value_type (val),
+ return gdbarch_integer_to_address (gdbarch, val->type (),
value_contents (val).data ());
- return unpack_long (value_type (val), value_contents (val).data ());
+ return unpack_long (val->type (), value_contents (val).data ());
#endif
}
\f
bool
is_floating_value (struct value *val)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (is_floating_type (type))
{
struct value *
value_field (struct value *arg1, int fieldno)
{
- return value_primitive_field (arg1, 0, fieldno, value_type (arg1));
+ return value_primitive_field (arg1, 0, fieldno, arg1->type ());
}
/* Return a non-virtual function as a value.
if (arg1p)
{
- if (type != value_type (*arg1p))
+ if (type != (*arg1p)->type ())
*arg1p = value_ind (value_cast (lookup_pointer_type (type),
value_addr (*arg1p)));
enum bfd_endian byte_order;
int src_bit_offset;
int dst_bit_offset;
- struct type *field_type = value_type (dest_val);
+ struct type *field_type = dest_val->type ();
byte_order = type_byte_order (field_type);
struct value *value = allocate_value (type);
gdb_assert (type->code () == TYPE_CODE_FLT);
target_float_from_host_double (value_contents_raw (value).data (),
- value_type (value), d);
+ value->type (), d);
return value;
}
{
const struct lval_funcs *funcs;
- if (!TYPE_IS_REFERENCE (check_typedef (value_type (arg))))
+ if (!TYPE_IS_REFERENCE (check_typedef (arg->type ())))
return NULL;
if (value_lval_const (arg) != lval_computed)
struct value *
coerce_ref (struct value *arg)
{
- struct type *value_type_arg_tmp = check_typedef (value_type (arg));
+ struct type *value_type_arg_tmp = check_typedef (arg->type ());
struct value *retval;
struct type *enc_type;
enc_type = check_typedef (value_enclosing_type (arg));
enc_type = enc_type->target_type ();
- CORE_ADDR addr = unpack_pointer (value_type (arg), value_contents (arg).data ());
+ CORE_ADDR addr = unpack_pointer (arg->type (), value_contents (arg).data ());
retval = value_at_lazy (enc_type, addr);
- enc_type = value_type (retval);
+ enc_type = retval->type ();
return readjust_indirect_value_type (retval, enc_type, value_type_arg_tmp,
arg, addr);
}
struct type *type;
arg = coerce_ref (arg);
- type = check_typedef (value_type (arg));
+ type = check_typedef (arg->type ());
switch (type->code ())
{
int len = 0;
if (val->m_limited_length > 0)
{
- gdb_assert (value_type (val)->code () == TYPE_CODE_ARRAY);
+ gdb_assert (val->type ()->code () == TYPE_CODE_ARRAY);
len = val->m_limited_length;
}
else if (type->length () > 0)
{
frame_info_ptr next_frame;
int regnum;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
struct value *new_val = val, *mark = value_mark ();
/* Offsets are not supported here; lazy register values must
if (argc != 1)
error (_("You must provide one argument for $_isvoid."));
- ret = value_type (argv[0])->code () == TYPE_CODE_VOID;
+ ret = argv[0]->type ()->code () == TYPE_CODE_VOID;
return value_from_longest (builtin_type (gdbarch)->builtin_int, ret);
}
error (_("You must provide one argument for $_creal."));
value *cval = argv[0];
- type *ctype = check_typedef (value_type (cval));
+ type *ctype = check_typedef (cval->type ());
if (ctype->code () != TYPE_CODE_COMPLEX)
error (_("expected a complex number"));
return value_real_part (cval);
error (_("You must provide one argument for $_cimag."));
value *cval = argv[0];
- type *ctype = check_typedef (value_type (cval));
+ type *ctype = check_typedef (cval->type ());
if (ctype->code () != TYPE_CODE_COMPLEX)
error (_("expected a complex number"));
return value_imaginary_part (cval);
DISABLE_COPY_AND_ASSIGN (value);
+ /* Type of the value. */
+ struct type *type () const
+ { return m_type; }
+
+
/* Type of value; either not an lval, or one of the various
different possible kinds of lval. */
enum lval_type m_lval = not_lval;
ULONGEST m_limited_length = 0;
};
-/* Type of the value. */
-
-extern struct type *value_type (const struct value *);
-
/* Return the gdbarch associated with the value. */
extern struct gdbarch *get_value_arch (const struct value *value);
right type. */
struct value *type_only_value = evaluate_type (var->root->exp.get ());
- var->type = value_type (type_only_value);
+ var->type = type_only_value->type ();
}
if (value != NULL)
}
var->print_value = print_value;
- gdb_assert (var->value == nullptr || value_type (var->value.get ()));
+ gdb_assert (var->value == nullptr || var->value.get ()->type ());
return changed;
}
if (update_type_if_necessary (v, newobj))
r.type_changed = true;
if (newobj)
- new_type = value_type (newobj);
+ new_type = newobj->type ();
else
new_type = v->root->lang_ops->type_of_child (v->parent, v->index);
struct type *type;
if (var->value != nullptr)
- type = value_type (var->value.get ());
+ type = var->value.get ()->type ();
else
type = var->type;
/* For root varobj-s, a NULL value indicates a scoping issue.
So, nothing to do in terms of checking for mutations. */
}
- else if (varobj_value_has_mutated (var, value, value_type (value)))
+ else if (varobj_value_has_mutated (var, value, value->type ()))
{
/* The type has mutated, so the children are no longer valid.
Just delete them, and tell our caller that the type has
thevalue = std::string (s.get ());
len = thevalue.size ();
- gdbarch = value_type (value)->arch ();
+ gdbarch = value->type ()->arch ();
type = builtin_type (gdbarch)->builtin_char;
if (!string_print)
tlb_value_read (struct value *val)
{
CORE_ADDR tlb;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
if (!target_get_tib_address (inferior_ptid, &tlb))
error (_("Unable to read tlb"));
for (int i = 0; i < nargs; i++)
{
struct value *arg = args[i];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
gdb_printf (gdb_stdlog, "%2d: %s %3s ", i,
host_address_to_string (arg),
pulongest (arg_type->length ()));
{
struct argument_info *info = &arg_info[i];
struct value *arg = args[i];
- struct type *arg_type = check_typedef (value_type (arg));
+ struct type *arg_type = check_typedef (arg->type ());
switch (arg_type->code ())
{
projects / binutils-gdb.git / commitdiff