diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 274b5e3ce03..7f962200a1f 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 814678ea0e1..05d30649887 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 fbc72a5a34e..74ce57ac70c 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 a64b35c2bcf..b4852b2cfb3 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 908581a2063..4636ad55109 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 7a680c052d3..ca44133cd7f 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 8f292c25851..195fd3b8912 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 0bd54dab5c6..18d2b7f5ba4 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 6a176c7efda..465d8d92bd2 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 ff30babca75..cca2baa6f63 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 ca6087f3414..983c99e5860 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 738967cc88d..ceec461c483 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 8c6973ca1f1..8b565955e1c 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 c22c7670a6a..57f57f38b26 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -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.  */
diff --git a/gdb/value.h b/gdb/value.h
index 4f161a9ed4f..23fffb18158 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -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.  */
diff --git a/gdb/varobj.c b/gdb/varobj.c
index 0e023c09cf8..72d5e7f2a25 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)
