aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gdb/ada-lang.c4
-rw-r--r--gdb/ada-valprint.c2
-rw-r--r--gdb/eval.c6
-rw-r--r--gdb/findvar.c2
-rw-r--r--gdb/gnu-v2-abi.c2
-rw-r--r--gdb/guile/scm-pretty-print.c2
-rw-r--r--gdb/guile/scm-value.c2
-rw-r--r--gdb/python/py-prettyprint.c2
-rw-r--r--gdb/python/py-value.c2
-rw-r--r--gdb/rust-lang.c2
-rw-r--r--gdb/stack.c10
-rw-r--r--gdb/valops.c2
-rw-r--r--gdb/valprint.c2
-rw-r--r--gdb/value.c124
-rw-r--r--gdb/value.h20
-rw-r--r--gdb/varobj.c2
16 files changed, 98 insertions, 88 deletions
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 274b5e3..7f96220 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -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;
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 814678e..05d3064 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -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));
diff --git a/gdb/eval.c b/gdb/eval.c
index fbc72a5..74ce57a 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -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;
diff --git a/gdb/findvar.c b/gdb/findvar.c
index a64b35c..b4852b2 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -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;
}
diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
index 908581a..4636ad5 100644
--- a/gdb/gnu-v2-abi.c
+++ b/gdb/gnu-v2-abi.c
@@ -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);
diff --git a/gdb/guile/scm-pretty-print.c b/gdb/guile/scm-pretty-print.c
index 7a680c0..ca44133 100644
--- a/gdb/guile/scm-pretty-print.c
+++ b/gdb/guile/scm-pretty-print.c
@@ -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 ()))
diff --git a/gdb/guile/scm-value.c b/gdb/guile/scm-value.c
index 8f292c2..195fd3b 100644
--- a/gdb/guile/scm-value.c
+++ b/gdb/guile/scm-value.c
@@ -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;
});
}
diff --git a/gdb/python/py-prettyprint.c b/gdb/python/py-prettyprint.c
index 0bd54da..18d2b7f 100644
--- a/gdb/python/py-prettyprint.c
+++ b/gdb/python/py-prettyprint.c
@@ -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 ()))
diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index 6a176c7..465d8d9 100644
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -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)
{
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index ff30bab..cca2baa 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -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);
}
diff --git a/gdb/stack.c b/gdb/stack.c
index ca6087f..983c99e 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -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);
diff --git a/gdb/valops.c b/gdb/valops.c
index 99dede8..6896478 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -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;
}
diff --git a/gdb/valprint.c b/gdb/valprint.c
index 1ad964a..1beec19 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -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 ();
diff --git a/gdb/value.c b/gdb/value.c
index 811c635..d1f0617 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -214,7 +214,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;
@@ -232,7 +232,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)
{
@@ -1117,7 +1117,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);
@@ -1283,7 +1283,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);
}
@@ -1301,7 +1301,7 @@ gdb::array_view<gdb_byte>
value::contents_writeable ()
{
if (m_lazy)
- value_fetch_lazy (this);
+ fetch_lazy ();
return contents_raw ();
}
@@ -1325,7 +1325,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)
{
@@ -1733,7 +1733,7 @@ record_latest_value (struct value *val)
&& calculate_limited_array_length (type) <= max_value_size)
val->m_limited_length = max_value_size;
- value_fetch_lazy (val);
+ val->fetch_lazy ();
}
ULONGEST limit = val->m_limited_length;
@@ -2106,7 +2106,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:
@@ -2246,7 +2246,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
@@ -2959,7 +2959,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))
{
@@ -2970,7 +2970,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
@@ -3015,7 +3015,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);
@@ -3788,46 +3788,46 @@ using_struct_return (struct gdbarch *gdbarch,
!= RETURN_VALUE_REGISTER_CONVENTION);
}
-/* Helper for value_fetch_lazy when the value is a bitfield. */
+/* See value.h. */
-static void
-value_fetch_lazy_bitfield (struct value *val)
+void
+value::fetch_lazy_bitfield ()
{
- gdb_assert (val->bitsize () != 0);
+ gdb_assert (bitsize () != 0);
/* To read a lazy bitfield, read the entire enclosing value. This
prevents reading the same block of (possibly volatile) memory once
per bitfield. It would be even better to read only the containing
word, but we have no way to record that just specific bits of a
value have been fetched. */
- struct value *parent = val->parent ();
+ struct value *parent = this->parent ();
if (parent->lazy ())
- value_fetch_lazy (parent);
+ parent->fetch_lazy ();
- unpack_value_bitfield (val, val->bitpos (), val->bitsize (),
+ unpack_value_bitfield (this, bitpos (), bitsize (),
value_contents_for_printing (parent).data (),
- val->offset (), parent);
+ offset (), parent);
}
-/* Helper for value_fetch_lazy when the value is in memory. */
+/* See value.h. */
-static void
-value_fetch_lazy_memory (struct value *val)
+void
+value::fetch_lazy_memory ()
{
- gdb_assert (VALUE_LVAL (val) == lval_memory);
+ gdb_assert (m_lval == lval_memory);
- CORE_ADDR addr = val->address ();
- struct type *type = check_typedef (val->enclosing_type ());
+ CORE_ADDR addr = address ();
+ struct type *type = check_typedef (enclosing_type ());
/* Figure out how much we should copy from memory. Usually, this is just
the size of the type, but, for arrays, we might only be loading a
small part of the array (this is only done for very large arrays). */
int len = 0;
- if (val->m_limited_length > 0)
+ if (m_limited_length > 0)
{
- gdb_assert (val->type ()->code () == TYPE_CODE_ARRAY);
- len = val->m_limited_length;
+ gdb_assert (this->type ()->code () == TYPE_CODE_ARRAY);
+ len = m_limited_length;
}
else if (type->length () > 0)
len = type_length_units (type);
@@ -3835,23 +3835,23 @@ value_fetch_lazy_memory (struct value *val)
gdb_assert (len >= 0);
if (len > 0)
- read_value_memory (val, 0, val->stack (), addr,
- val->contents_all_raw ().data (), len);
+ read_value_memory (this, 0, stack (), addr,
+ contents_all_raw ().data (), len);
}
-/* Helper for value_fetch_lazy when the value is in a register. */
+/* See value.h. */
-static void
-value_fetch_lazy_register (struct value *val)
+void
+value::fetch_lazy_register ()
{
frame_info_ptr next_frame;
int regnum;
- struct type *type = check_typedef (val->type ());
- struct value *new_val = val, *mark = value_mark ();
+ struct type *type = check_typedef (this->type ());
+ struct value *new_val = this, *mark = value_mark ();
/* Offsets are not supported here; lazy register values must
refer to the entire register. */
- gdb_assert (val->offset () == 0);
+ gdb_assert (offset () == 0);
while (VALUE_LVAL (new_val) == lval_register && new_val->lazy ())
{
@@ -3897,12 +3897,12 @@ 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. */
- val->set_lazy (0);
- value_contents_copy (val, val->embedded_offset (),
+ set_lazy (0);
+ value_contents_copy (this, embedded_offset (),
new_val, new_val->embedded_offset (),
type_length_units (type));
@@ -3910,9 +3910,9 @@ value_fetch_lazy_register (struct value *val)
{
struct gdbarch *gdbarch;
frame_info_ptr frame;
- frame = frame_find_by_id (VALUE_NEXT_FRAME_ID (val));
+ frame = frame_find_by_id (VALUE_NEXT_FRAME_ID (this));
frame = get_prev_frame_always (frame);
- regnum = VALUE_REGNUM (val);
+ regnum = VALUE_REGNUM (this);
gdbarch = get_frame_arch (frame);
string_file debug_file;
@@ -3957,41 +3957,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, true);
+ gdb_assert (lazy ());
+ allocate_value_contents (this, true);
/* 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 ())
+ fetch_lazy_bitfield ();
+ else if (VALUE_LVAL (this) == lval_memory)
+ fetch_lazy_memory ();
+ else if (VALUE_LVAL (this) == lval_register)
+ fetch_lazy_register ();
+ 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. */
diff --git a/gdb/value.h b/gdb/value.h
index 66074a1..a7eed48 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -386,6 +386,15 @@ public:
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. */
@@ -568,6 +577,15 @@ private:
/* Allocate a value and its contents for type TYPE. If CHECK_SIZE
is true, then apply the usual max-value-size checks. */
static struct value *allocate (struct type *type, bool check_size);
+
+ /* Helper for fetch_lazy when the value is a bitfield. */
+ void fetch_lazy_bitfield ();
+
+ /* Helper for fetch_lazy when the value is in memory. */
+ void fetch_lazy_memory ();
+
+ /* Helper for fetch_lazy when the value is in a register. */
+ void fetch_lazy_register ();
};
/* Returns value_type or value_enclosing_type depending on
@@ -676,8 +694,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. */
diff --git a/gdb/varobj.c b/gdb/varobj.c
index 0e023c0..72d5e7f 100644
--- a/gdb/varobj.c
+++ b/gdb/varobj.c
@@ -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)
generated by cgit v1.1 at 2024-08-17 02:39:57 +0000