@@ -10853,7 +10853,7 @@ ada_var_msym_value_operation::evaluate_for_cast (struct type *expect_type,
if (VALUE_LVAL (val) == lval_memory)
{
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
VALUE_LVAL (val) = not_lval;
}
return val;
@@ -10875,7 +10875,7 @@ ada_var_value_operation::evaluate_for_cast (struct type *expect_type,
if (VALUE_LVAL (val) == lval_memory)
{
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
VALUE_LVAL (val) = not_lval;
}
return val;
@@ -983,7 +983,7 @@ ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
deref_val = ada_tag_value_at_base_address (deref_val);
if (deref_val->lazy ())
- value_fetch_lazy (deref_val);
+ deref_val->fetch_lazy ();
common_val_print (deref_val, stream, recurse + 1,
options, language_def (language_ada));
@@ -212,7 +212,7 @@ fetch_subexp_value (struct expression *exp,
try
{
- value_fetch_lazy (result);
+ result->fetch_lazy ();
*valp = result;
}
catch (const gdb_exception_error &except)
@@ -2878,7 +2878,7 @@ var_msym_value_operation::evaluate_for_cast (struct type *to_type,
if (VALUE_LVAL (val) == lval_memory)
{
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
VALUE_LVAL (val) = not_lval;
}
return val;
@@ -2899,7 +2899,7 @@ var_value_operation::evaluate_for_cast (struct type *to_type,
if (VALUE_LVAL (val) == lval_memory)
{
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
VALUE_LVAL (val) = not_lval;
}
return val;
@@ -262,7 +262,7 @@ value_of_register (int regnum, frame_info_ptr frame)
return value_of_user_reg (regnum, frame);
reg_val = value_of_register_lazy (frame, regnum);
- value_fetch_lazy (reg_val);
+ reg_val->fetch_lazy ();
return reg_val;
}
@@ -164,7 +164,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
if (!arg1->lazy ())
{
arg1->set_lazy (1);
- value_fetch_lazy (arg1);
+ arg1->fetch_lazy ();
}
vfn = value_field (entry, 2);
@@ -966,7 +966,7 @@ gdbscm_apply_val_pretty_printer (const struct extension_language_defn *extlang,
enum guile_string_repr_result print_result;
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
/* No pretty-printer support for unavailable values. */
if (!value_bytes_available (value, 0, type->length ()))
@@ -1248,7 +1248,7 @@ gdbscm_value_fetch_lazy_x (SCM self)
return gdbscm_wrap ([=]
{
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
return SCM_UNSPECIFIED;
});
}
@@ -579,7 +579,7 @@ gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang,
enum gdbpy_string_repr_result print_result;
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
/* No pretty-printer support for unavailable values. */
if (!value_bytes_available (value, 0, type->length ()))
@@ -1241,7 +1241,7 @@ valpy_fetch_lazy (PyObject *self, PyObject *args)
try
{
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
}
catch (const gdb_exception &except)
{
@@ -352,7 +352,7 @@ rust_val_print_slice (struct value *val, struct ui_file *stream, int recurse,
struct value *array = value::allocate_lazy (array_type);
VALUE_LVAL (array) = lval_memory;
array->set_address (value_as_address (base));
- value_fetch_lazy (array);
+ array->fetch_lazy ();
generic_value_print (array, stream, recurse, options,
&rust_decorations);
}
@@ -581,9 +581,9 @@ read_frame_arg (const frame_print_options &fp_opts,
struct type *type = val->type ();
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
if (entryval->lazy ())
- value_fetch_lazy (entryval);
+ entryval->fetch_lazy ();
if (value_contents_eq (val, 0, entryval, 0, type->length ()))
{
@@ -600,12 +600,12 @@ read_frame_arg (const frame_print_options &fp_opts,
val_deref = coerce_ref (val);
if (val_deref->lazy ())
- value_fetch_lazy (val_deref);
+ val_deref->fetch_lazy ();
type_deref = val_deref->type ();
entryval_deref = coerce_ref (entryval);
if (entryval_deref->lazy ())
- value_fetch_lazy (entryval_deref);
+ entryval_deref->fetch_lazy ();
/* If the reference addresses match but dereferenced
content does not match print them. */
@@ -2750,7 +2750,7 @@ return_command (const char *retval_exp, int from_tty)
/* Make sure the value is fully evaluated. It may live in the
stack frame we're about to pop. */
if (return_value->lazy ())
- value_fetch_lazy (return_value);
+ return_value->fetch_lazy ();
if (thisfun != NULL)
function = read_var_value (thisfun, NULL, thisframe);
@@ -992,7 +992,7 @@ get_value_at (struct type *type, CORE_ADDR addr, int lazy)
val = value_from_contents_and_address (type, NULL, addr);
if (!lazy)
- value_fetch_lazy (val);
+ val->fetch_lazy ();
return val;
}
@@ -1044,7 +1044,7 @@ common_val_print (struct value *value, struct ui_file *stream, int recurse,
value = ada_to_fixed_value (value);
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
struct value_print_options local_opts = *options;
struct type *type = value->type ();
@@ -199,7 +199,7 @@ value_entirely_available (struct value *value)
/* We can only tell whether the whole value is available when we try
to read it. */
if (value->m_lazy)
- value_fetch_lazy (value);
+ value->fetch_lazy ();
if (value->m_unavailable.empty ())
return 1;
@@ -217,7 +217,7 @@ value_entirely_covered_by_range_vector (struct value *value,
/* We can only tell whether the whole value is optimized out /
unavailable when we try to read it. */
if (value->m_lazy)
- value_fetch_lazy (value);
+ value->fetch_lazy ();
if (ranges.size () == 1)
{
@@ -986,7 +986,7 @@ gdb::array_view<const gdb_byte>
value_contents_for_printing (struct value *value)
{
if (value->m_lazy)
- value_fetch_lazy (value);
+ value->fetch_lazy ();
ULONGEST length = value->enclosing_type ()->length ();
return gdb::make_array_view (value->m_contents.get (), length);
@@ -1152,7 +1152,7 @@ value_contents_copy (struct value *dst, LONGEST dst_offset,
struct value *src, LONGEST src_offset, LONGEST length)
{
if (src->m_lazy)
- value_fetch_lazy (src);
+ src->fetch_lazy ();
value_contents_copy_raw (dst, dst_offset, src, src_offset, length);
}
@@ -1170,7 +1170,7 @@ gdb::array_view<gdb_byte>
value::contents_writeable ()
{
if (m_lazy)
- value_fetch_lazy (this);
+ fetch_lazy ();
return contents_raw ();
}
@@ -1194,7 +1194,7 @@ value_optimized_out (struct value *value)
/* Fall back to fetching. */
try
{
- value_fetch_lazy (value);
+ value->fetch_lazy ();
}
catch (const gdb_exception_error &ex)
{
@@ -1578,7 +1578,7 @@ record_latest_value (struct value *val)
the value was taken, and fast watchpoints should be able to assume that
a value on the value history never changes. */
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
/* We preserve VALUE_LVAL so that the user can find out where it was fetched
from. This is a bit dubious, because then *&$1 does not just return $1
but the current contents of that location. c'est la vie... */
@@ -1941,7 +1941,7 @@ value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var)
case INTERNALVAR_VALUE:
val = value_copy (var->u.value);
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
break;
case INTERNALVAR_MAKE_VALUE:
@@ -2081,7 +2081,7 @@ set_internalvar (struct internalvar *var, struct value *val)
later when this internalvar is referenced and the target is gone or
has changed. */
if (copy->lazy ())
- value_fetch_lazy (copy);
+ copy->fetch_lazy ();
/* Release the value from the value chain to prevent it from being
deleted by free_all_values. From here on this function should not
@@ -2794,7 +2794,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
+ (bitpos - v->m_bitpos) / 8);
v->set_parent (arg1);
if (!arg1->lazy ())
- value_fetch_lazy (v);
+ v->fetch_lazy ();
}
else if (fieldno < TYPE_N_BASECLASSES (arg_type))
{
@@ -2805,7 +2805,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
/* Lazy register values with offsets are not supported. */
if (VALUE_LVAL (arg1) == lval_register && arg1->lazy ())
- value_fetch_lazy (arg1);
+ arg1->fetch_lazy ();
/* We special case virtual inheritance here because this
requires access to the contents, which we would rather avoid
@@ -2850,7 +2850,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
/* Lazy register values with offsets are not supported. */
if (VALUE_LVAL (arg1) == lval_register && arg1->lazy ())
- value_fetch_lazy (arg1);
+ arg1->fetch_lazy ();
if (arg1->lazy ())
v = value::allocate_lazy (type);
@@ -3638,7 +3638,7 @@ value_fetch_lazy_bitfield (struct value *val)
struct value *parent = val->parent ();
if (parent->lazy ())
- value_fetch_lazy (parent);
+ parent->fetch_lazy ();
unpack_value_bitfield (val, val->bitpos (), val->bitsize (),
value_contents_for_printing (parent).data (),
@@ -3719,7 +3719,7 @@ value_fetch_lazy_register (struct value *val)
/* If it's still lazy (for instance, a saved register on the
stack), fetch it. */
if (new_val->lazy ())
- value_fetch_lazy (new_val);
+ new_val->fetch_lazy ();
/* Copy the contents and the unavailability/optimized-out
meta-data from NEW_VAL to VAL. */
@@ -3779,41 +3779,35 @@ value_fetch_lazy_register (struct value *val)
value_free_to_mark (mark);
}
-/* Load the actual content of a lazy value. Fetch the data from the
- user's process and clear the lazy flag to indicate that the data in
- the buffer is valid.
-
- If the value is zero-length, we avoid calling read_memory, which
- would abort. We mark the value as fetched anyway -- all 0 bytes of
- it. */
+/* See value.h. */
void
-value_fetch_lazy (struct value *val)
+value::fetch_lazy ()
{
- gdb_assert (val->lazy ());
- allocate_value_contents (val);
+ gdb_assert (lazy ());
+ allocate_value_contents (this);
/* A value is either lazy, or fully fetched. The
availability/validity is only established as we try to fetch a
value. */
- gdb_assert (val->m_optimized_out.empty ());
- gdb_assert (val->m_unavailable.empty ());
- if (val->m_is_zero)
+ gdb_assert (m_optimized_out.empty ());
+ gdb_assert (m_unavailable.empty ());
+ if (m_is_zero)
{
/* Nothing. */
}
- else if (val->bitsize ())
- value_fetch_lazy_bitfield (val);
- else if (VALUE_LVAL (val) == lval_memory)
- value_fetch_lazy_memory (val);
- else if (VALUE_LVAL (val) == lval_register)
- value_fetch_lazy_register (val);
- else if (VALUE_LVAL (val) == lval_computed
- && val->computed_funcs ()->read != NULL)
- val->computed_funcs ()->read (val);
+ else if (bitsize ())
+ value_fetch_lazy_bitfield (this);
+ else if (VALUE_LVAL (this) == lval_memory)
+ value_fetch_lazy_memory (this);
+ else if (VALUE_LVAL (this) == lval_register)
+ value_fetch_lazy_register (this);
+ else if (VALUE_LVAL (this) == lval_computed
+ && computed_funcs ()->read != NULL)
+ computed_funcs ()->read (this);
else
internal_error (_("Unexpected lazy value type."));
- val->set_lazy (0);
+ set_lazy (0);
}
/* Implementation of the convenience function $_isvoid. */
@@ -387,6 +387,15 @@ struct value
gdb::array_view<gdb_byte> contents_all_raw ();
gdb::array_view<gdb_byte> contents_writeable ();
+ /* Load the actual content of a lazy value. Fetch the data from the
+ user's process and clear the lazy flag to indicate that the data in
+ the buffer is valid.
+
+ If the value is zero-length, we avoid calling read_memory, which
+ would abort. We mark the value as fetched anyway -- all 0 bytes of
+ it. */
+ void fetch_lazy ();
+
/* Type of value; either not an lval, or one of the various
different possible kinds of lval. */
@@ -660,8 +669,6 @@ extern gdb::array_view<const gdb_byte> value_contents_for_printing (struct value
extern gdb::array_view<const gdb_byte>
value_contents_for_printing_const (const struct value *value);
-extern void value_fetch_lazy (struct value *val);
-
/* If nonzero, this is the value of a variable which does not actually
exist in the program, at least partially. If the value is lazy,
this may fetch it now. */
@@ -1268,7 +1268,7 @@ install_new_value (struct varobj *var, struct value *value, bool initial)
try
{
- value_fetch_lazy (value);
+ value->fetch_lazy ();
}
catch (const gdb_exception_error &except)