diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index d88e81c4a11..57c31efc980 100644
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -458,7 +458,7 @@ fortran_associated (struct gdbarch *gdbarch, const language_defn *lang,
      looking the value of the pointer itself.  We make the assumption that
      a non-associated pointer will be set to 0.  This is probably true for
      most targets, but might not be true for everyone.  */
-  if (value_lval_const (target) != lval_memory
+  if (target->lval () != lval_memory
       || type_not_associated (pointer_type)
       || (TYPE_ASSOCIATED_PROP (pointer_type) == nullptr
 	  && pointer_type->code () == TYPE_CODE_PTR
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 36d54b9312b..dc249f0980e 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -1102,7 +1102,7 @@ gnuv3_get_typeid (struct value *value)
   /* We have to handle values a bit trickily here, to allow this code
      to work properly with non_lvalue values that are really just
      disguised types.  */
-  if (value_lval_const (value) == lval_memory)
+  if (value->lval () == lval_memory)
     value = coerce_ref (value);
 
   type = check_typedef (value->type ());
@@ -1134,7 +1134,7 @@ gnuv3_get_typeid (struct value *value)
   /* We check for lval_memory because in the "typeid (type-id)" case,
      the type is passed via a not_lval value object.  */
   if (type->code () == TYPE_CODE_STRUCT
-      && value_lval_const (value) == lval_memory
+      && value->lval () == lval_memory
       && gnuv3_dynamic_class (type))
     {
       struct value *vtable, *typeinfo_value;
diff --git a/gdb/valprint.c b/gdb/valprint.c
index 6aef98e37c1..d2fbc93284f 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -392,7 +392,7 @@ valprint_check_validity (struct ui_file *stream,
 	      const struct value *deref_val = coerce_ref_if_computed (val);
 
 	      if (deref_val != NULL)
-		ref_is_addressable = value_lval_const (deref_val) == lval_memory;
+		ref_is_addressable = deref_val->lval () == lval_memory;
 	    }
 
 	  if (!is_ref || !ref_is_addressable)
@@ -416,7 +416,7 @@ valprint_check_validity (struct ui_file *stream,
 void
 val_print_optimized_out (const struct value *val, struct ui_file *stream)
 {
-  if (val != NULL && value_lval_const (val) == lval_register)
+  if (val != NULL && val->lval () == lval_register)
     val_print_not_saved (stream);
   else
     fprintf_styled (stream, metadata_style.style (), _("<optimized out>"));
@@ -548,7 +548,7 @@ get_value_addr_contents (struct value *deref_val)
 {
   gdb_assert (deref_val != NULL);
 
-  if (value_lval_const (deref_val) == lval_memory)
+  if (deref_val->lval () == lval_memory)
     return value_contents_for_printing_const (value_addr (deref_val)).data ();
   else
     {
diff --git a/gdb/value.c b/gdb/value.c
index 763cd0f296f..0473d406434 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -1268,18 +1268,6 @@ value::computed_closure () const
   return m_location.computed.closure;
 }
 
-enum lval_type *
-deprecated_value_lval_hack (struct value *value)
-{
-  return &value->m_lval;
-}
-
-enum lval_type
-value_lval_const (const struct value *value)
-{
-  return value->m_lval;
-}
-
 CORE_ADDR
 value_address (const struct value *value)
 {
@@ -3530,7 +3518,7 @@ coerce_ref_if_computed (const struct value *arg)
   if (!TYPE_IS_REFERENCE (check_typedef (arg->type ())))
     return NULL;
 
-  if (value_lval_const (arg) != lval_computed)
+  if (arg->lval () != lval_computed)
     return NULL;
 
   funcs = arg->computed_funcs ();
diff --git a/gdb/value.h b/gdb/value.h
index 4850790b79a..ee61f5aa19c 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -309,6 +309,12 @@ struct value
      uses.  */
   void *computed_closure () const;
 
+  enum lval_type *deprecated_lval_hack ()
+  { return &m_lval; }
+
+  enum lval_type lval () const
+  { return m_lval; }
+
 
   /* Type of value; either not an lval, or one of the various
      different possible kinds of lval.  */
@@ -655,11 +661,7 @@ extern void set_value_component_location (struct value *component,
    limited to just the first PIECE.  Expect further change.  */
 /* Type of value; either not an lval, or one of the various different
    possible kinds of lval.  */
-extern enum lval_type *deprecated_value_lval_hack (struct value *);
-#define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
-
-/* Like VALUE_LVAL, except the parameter can be const.  */
-extern enum lval_type value_lval_const (const struct value *value);
+#define VALUE_LVAL(val) (*((val)->deprecated_lval_hack ()))
 
 /* If lval == lval_memory, return the address in the inferior.  If
    lval == lval_register, return the byte offset into the registers
