Remove deprecated_lval_hack

This removes deprecated_lval_hack and the VALUE_LVAL macro, replacing
all uses with a call to value::lval.

Approved-By: Simon Marchi <simon.marchi@efficios.com>

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 1fd424c60c215a0efcd9c670df4ddbd0aed062e0..ec85729042f60368d6955f5f47f8a8d6219461d2 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -559,7 +559,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
        result = value::allocate_optimized_out (type);
       else if (val->lazy ()
               /* Be careful not to make a lazy not_lval value.  */
-              || (VALUE_LVAL (val) != not_lval
+              || (val->lval () != not_lval
                   && type->length () > val->type ()->length ()))
        result = value::allocate_lazy (type);
       else
@@ -570,7 +570,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
       result->set_component_location (val);
       result->set_bitsize (val->bitsize ());
       result->set_bitpos (val->bitpos ());
-      if (VALUE_LVAL (result) == lval_memory)
+      if (result->lval () == lval_memory)
        result->set_address (val->address ());
       return result;
     }
@@ -2810,7 +2810,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
       v = value::allocate (type);
       src = valaddr + offset;
     }
-  else if (VALUE_LVAL (obj) == lval_memory && obj->lazy ())
+  else if (obj->lval () == lval_memory && obj->lazy ())
     {
       int src_len = (bit_size + bit_offset + HOST_CHAR_BIT - 1) / 8;
       gdb_byte *buf;
@@ -2891,7 +2891,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
   if (!toval->deprecated_modifiable ())
     error (_("Left operand of assignment is not a modifiable lvalue."));
 
-  if (VALUE_LVAL (toval) == lval_memory
+  if (toval->lval () == lval_memory
       && bits > 0
       && (type->code () == TYPE_CODE_FLT
          || type->code () == TYPE_CODE_STRUCT))
@@ -4349,8 +4349,8 @@ ada_read_renaming_var_value (struct symbol *renaming_sym,
 static struct value *
 ensure_lval (struct value *val)
 {
-  if (VALUE_LVAL (val) == not_lval
-      || VALUE_LVAL (val) == lval_internalvar)
+  if (val->lval () == not_lval
+      || val->lval () == lval_internalvar)
     {
       int len = ada_check_typedef (val->type ())->length ();
       const CORE_ADDR addr =
@@ -4523,7 +4523,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0)
        result = desc_data (actual);
       else if (formal_type->code () != TYPE_CODE_PTR)
        {
-         if (VALUE_LVAL (actual) != lval_memory)
+         if (actual->lval () != lval_memory)
            {
              struct value *val;
 
@@ -8841,7 +8841,7 @@ ada_to_fixed_value_create (struct type *type0, CORE_ADDR address,
   if (type == type0 && val0 != NULL)
     return val0;
 
-  if (VALUE_LVAL (val0) != lval_memory)
+  if (val0->lval () != lval_memory)
     {
       /* Our value does not live in memory; it could be a convenience
         variable, for instance.  Create a not_lval value using val0's
@@ -9771,12 +9771,12 @@ ada_assign_operation::evaluate (struct type *expect_type,
      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 = arg1->type ();
-  if (VALUE_LVAL (arg1) == lval_internalvar)
+  if (arg1->lval () == lval_internalvar)
     type = NULL;
   value *arg2 = std::get<1> (m_storage)->evaluate (type, exp, noside);
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     return arg1;
-  if (VALUE_LVAL (arg1) == lval_internalvar)
+  if (arg1->lval () == lval_internalvar)
     {
       /* Nothing.  */
     }
@@ -10279,7 +10279,7 @@ ada_ternop_slice (struct expression *exp,
      convert to a pointer.  */
   if (array->type ()->code () == TYPE_CODE_REF
       || (array->type ()->code () == TYPE_CODE_ARRAY
-         && VALUE_LVAL (array) == lval_memory))
+         && array->lval () == lval_memory))
     array = value_addr (array);
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS
@@ -10850,7 +10850,7 @@ ada_var_msym_value_operation::evaluate_for_cast (struct type *expect_type,
 
   /* Follow the Ada language semantics that do not allow taking
      an address of the result of a cast (view conversion in Ada).  */
-  if (VALUE_LVAL (val) == lval_memory)
+  if (val->lval () == lval_memory)
     {
       if (val->lazy ())
        val->fetch_lazy ();
@@ -10872,7 +10872,7 @@ ada_var_value_operation::evaluate_for_cast (struct type *expect_type,
 
   /* Follow the Ada language semantics that do not allow taking
      an address of the result of a cast (view conversion in Ada).  */
-  if (VALUE_LVAL (val) == lval_memory)
+  if (val->lval () == lval_memory)
     {
       if (val->lazy ())
        val->fetch_lazy ();
@@ -11169,7 +11169,7 @@ ada_funcall_operation::evaluate (struct type *expect_type,
       callee = ada_to_fixed_value (coerce_ref (callee));
     }
   else if (callee->type ()->code () == TYPE_CODE_ARRAY
-          && VALUE_LVAL (callee) == lval_memory)
+          && callee->lval () == lval_memory)
     callee = value_addr (callee);
 
   struct type *type = ada_check_typedef (callee->type ());

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 62ef31049fa70628739ffd905981df6966de5b58..ebb28432cab625d58588e524edc48b2d29770711 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -2074,7 +2074,7 @@ update_watchpoint (struct watchpoint *b, bool reparse)
             must watch it.  If the first value returned is
             still lazy, that means an error occurred reading it;
             watch it anyway in case it becomes readable.  */
-         if (VALUE_LVAL (v) == lval_memory
+         if (v->lval () == lval_memory
              && (v == val_chain[0] || ! v->lazy ()))
            {
              struct type *vtype = check_typedef (v->type ());
@@ -10412,7 +10412,7 @@ can_use_hardware_watchpoint (const std::vector<value_ref_ptr> &vals)
     {
       struct value *v = iter.get ();
 
-      if (VALUE_LVAL (v) == lval_memory)
+      if (v->lval () == lval_memory)
        {
          if (v != head && v->lazy ())
            /* A lazy memory lvalue in the chain is one that GDB never
@@ -10450,10 +10450,10 @@ can_use_hardware_watchpoint (const std::vector<value_ref_ptr> &vals)
                }
            }
        }
-      else if (VALUE_LVAL (v) != not_lval
+      else if (v->lval () != not_lval
               && v->deprecated_modifiable () == 0)
        return 0;       /* These are values from the history (e.g., $1).  */
-      else if (VALUE_LVAL (v) == lval_register)
+      else if (v->lval () == lval_register)
        return 0;       /* Cannot watch a register with a HW watchpoint.  */
     }
 

diff --git a/gdb/c-lang.c b/gdb/c-lang.c
index e4027d8ee9649363f95b4b5d80ab858fa4629a37..6535ab93498dd5507139d2def40561b2e6eedbc8 100644 (file)
--- a/gdb/c-lang.c
+++ b/gdb/c-lang.c
@@ -294,8 +294,8 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
      C struct hack.  So, only do this if either no length was
      specified, or the length is within the existing bounds.  This
      avoids running off the end of the value's contents.  */
-  if ((VALUE_LVAL (value) == not_lval
-       || VALUE_LVAL (value) == lval_internalvar
+  if ((value->lval () == not_lval
+       || value->lval () == lval_internalvar
        || type->code () == TYPE_CODE_ARRAY)
       && fetchlimit != UINT_MAX
       && (*length < 0 || *length <= fetchlimit))
@@ -328,7 +328,7 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
       CORE_ADDR addr;
       if (type->code () == TYPE_CODE_ARRAY)
        {
-         if (VALUE_LVAL (value) != lval_memory)
+         if (value->lval () != lval_memory)
            error (_("Attempt to take address of value "
                     "not located in memory."));
          addr = value->address ();

diff --git a/gdb/cli/cli-dump.c b/gdb/cli/cli-dump.c
index 769f6a589b60b88bcfb6f113cdec7b4be5f5cab4..08984f6fdf3005e7382065bde1a5c08dbe8b0042 100644 (file)
--- a/gdb/cli/cli-dump.c
+++ b/gdb/cli/cli-dump.c
@@ -230,7 +230,7 @@ dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
     {
       CORE_ADDR vaddr;
 
-      if (VALUE_LVAL (val))
+      if (val->lval ())
        {
          vaddr = val->address ();
        }

diff --git a/gdb/compile/compile-c-symbols.c b/gdb/compile/compile-c-symbols.c
index 5b53ab3263fa1305338a5cfe87c102c4460c7a40..6faff0eee06a7aa0bb257008597eba65db5f9877 100644 (file)
--- a/gdb/compile/compile-c-symbols.c
+++ b/gdb/compile/compile-c-symbols.c
@@ -156,7 +156,7 @@ convert_one_symbol (compile_c_instance *context,
              }
 
            val = read_var_value (sym.symbol, sym.block, frame);
-           if (VALUE_LVAL (val) != lval_memory)
+           if (val->lval () != lval_memory)
              error (_("Symbol \"%s\" cannot be used for compilation "
                       "evaluation as its address has not been found."),
                     sym.symbol->print_name ());

diff --git a/gdb/compile/compile-cplus-symbols.c b/gdb/compile/compile-cplus-symbols.c
index 28447776d4f3f10974cfb1ea69330837422d3e87..039aee34ab73769e4a8c091f317059da18a40560 100644 (file)
--- a/gdb/compile/compile-cplus-symbols.c
+++ b/gdb/compile/compile-cplus-symbols.c
@@ -150,7 +150,7 @@ convert_one_symbol (compile_cplus_instance *instance,
              }
 
            val = read_var_value (sym.symbol, sym.block, frame);
-           if (VALUE_LVAL (val) != lval_memory)
+           if (val->lval () != lval_memory)
              error (_("Symbol \"%s\" cannot be used for compilation "
                       "evaluation as its address has not been found."),
                     sym.symbol->print_name ());

diff --git a/gdb/compile/compile-loc2c.c b/gdb/compile/compile-loc2c.c
index ae30dd69dec7064e1633a9487a02513e87660e87..558460a7c572c23fbe0c10ec817aa2e851a46ad3 100644 (file)
--- a/gdb/compile/compile-loc2c.c
+++ b/gdb/compile/compile-loc2c.c
@@ -642,7 +642,7 @@ do_compile_dwarf_expr_to_c (int indent, string_file *stream,
               sym->print_name ());
 
       val = read_var_value (sym, NULL, frame);
-      if (VALUE_LVAL (val) != lval_memory)
+      if (val->lval () != lval_memory)
        error (_("Symbol \"%s\" cannot be used for compilation evaluation "
                 "as its address has not been found."),
               sym->print_name ());

diff --git a/gdb/dwarf2/frame.c b/gdb/dwarf2/frame.c
index a83df2192c32272e680a92ec436477a1b3612845..a561aaf31006f0531c1187994664bf35816d3e8b 100644 (file)
--- a/gdb/dwarf2/frame.c
+++ b/gdb/dwarf2/frame.c
@@ -235,7 +235,7 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
   ctx.push_address (initial, initial_in_stack_memory);
   value *result_val = ctx.evaluate (exp, len, true, nullptr, this_frame);
 
-  if (VALUE_LVAL (result_val) == lval_memory)
+  if (result_val->lval () == lval_memory)
     return result_val->address ();
   else
     return value_as_address (result_val);

diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c
index 616db13488b95be81b52765a59d78c588692dc40..27c4b7ce31a646e22c9e2e8dea9793c1982be388 100644 (file)
--- a/gdb/dwarf2/loc.c
+++ b/gdb/dwarf2/loc.c
@@ -684,7 +684,7 @@ call_site_target::iterate_over_addresses
                                        dwarf_block->per_cu,
                                        dwarf_block->per_objfile);
        /* DW_AT_call_target is a DWARF expression, not a DWARF location.  */
-       if (VALUE_LVAL (val) == lval_memory)
+       if (val->lval () == lval_memory)
          callback (val->address ());
        else
          callback (value_as_address (val));
@@ -1612,11 +1612,11 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
   if (result->optimized_out ())
     return 0;
 
-  if (VALUE_LVAL (result) == lval_memory)
+  if (result->lval () == lval_memory)
     *valp = result->address ();
   else
     {
-      if (VALUE_LVAL (result) == not_lval)
+      if (result->lval () == not_lval)
        *is_reference = false;
 
       *valp = value_as_address (result);

diff --git a/gdb/eval.c b/gdb/eval.c
index e043991c2545fe667f9a82dc00d6bfe4fa62d03f..f8bbb9ef7662d6b2df4c302fa365cd0e064a4d5c 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1224,7 +1224,7 @@ eval_op_structop_struct (struct type *expect_type, struct expression *exp,
   struct value *arg3 = value_struct_elt (&arg1, {}, string,
                                         NULL, "structure");
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    arg3 = value::zero (arg3->type (), VALUE_LVAL (arg3));
+    arg3 = value::zero (arg3->type (), arg3->lval ());
   return arg3;
 }
 
@@ -1280,7 +1280,7 @@ eval_op_structop_ptr (struct type *expect_type, struct expression *exp,
   struct value *arg3 = value_struct_elt (&arg1, {}, string,
                                         NULL, "structure pointer");
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    arg3 = value::zero (arg3->type (), VALUE_LVAL (arg3));
+    arg3 = value::zero (arg3->type (), arg3->lval ());
   return arg3;
 }
 
@@ -1447,7 +1447,7 @@ eval_op_subscript (struct type *expect_type, struct expression *exp,
        }
 
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
-       return value::zero (type->target_type (), VALUE_LVAL (arg1));
+       return value::zero (type->target_type (), arg1->lval ());
       else
        return value_subscript (arg1, value_as_long (arg2));
     }
@@ -2590,7 +2590,7 @@ evaluate_subexp_for_address_base (struct expression *exp, enum noside noside,
       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))
+      else if (x->lval () == lval_memory || value_must_coerce_to_target (x))
        return value::zero (lookup_pointer_type (x->type ()),
                           not_lval);
       else
@@ -2875,7 +2875,7 @@ var_msym_value_operation::evaluate_for_cast (struct type *to_type,
   val = value_cast (to_type, val);
 
   /* Don't allow e.g. '&(int)var_with_no_debug_info'.  */
-  if (VALUE_LVAL (val) == lval_memory)
+  if (val->lval () == lval_memory)
     {
       if (val->lazy ())
        val->fetch_lazy ();
@@ -2896,7 +2896,7 @@ var_value_operation::evaluate_for_cast (struct type *to_type,
   val = value_cast (to_type, val);
 
   /* Don't allow e.g. '&(int)var_with_no_debug_info'.  */
-  if (VALUE_LVAL (val) == lval_memory)
+  if (val->lval () == lval_memory)
     {
       if (val->lazy ())
        val->fetch_lazy ();

diff --git a/gdb/expop.h b/gdb/expop.h
index e53474711fe6a02df829068bb9ef95a8a25204af..d973d2314bb1c79499d7a195235782797567bcf5 100644 (file)
--- a/gdb/expop.h
+++ b/gdb/expop.h
@@ -1889,7 +1889,7 @@ public:
        expected type.  This avoids a weird case where re-assigning a
        string or array to an internal variable could error with "Too
        many array elements".  */
-    struct type *xtype = (VALUE_LVAL (lhs) == lval_internalvar
+    struct type *xtype = (lhs->lval () == lval_internalvar
                          ? nullptr
                          : lhs->type ());
     value *rhs = std::get<1> (m_storage)->evaluate (xtype, exp, noside);

diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index d935f59088f8fe63e685d0f06d7a55f369ec74ef..0d7863e4fd1987e6a4473e1846ec07c276b8d780 100644 (file)
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -1363,7 +1363,7 @@ fortran_undetermined::value_subarray (value *array,
          if (index < lb
              || (dim_type->index_type ()->bounds ()->high.kind () != PROP_UNDEFINED
                  && index > ub)
-             || (VALUE_LVAL (array) != lval_memory
+             || (array->lval () != lval_memory
                  && dim_type->index_type ()->bounds ()->high.kind () == PROP_UNDEFINED))
            {
              if (type_not_associated (dim_type))
@@ -1460,7 +1460,7 @@ fortran_undetermined::value_subarray (value *array,
     }
   else
     {
-      if (VALUE_LVAL (array) == lval_memory)
+      if (array->lval () == lval_memory)
        {
          /* If the value we're taking a slice from is not yet loaded, or
             the requested slice is outside the values content range then
@@ -1637,7 +1637,7 @@ fortran_structop_operation::evaluate (struct type *expect_type,
            = gdb::make_array_view (valaddr, elt_type->length ());
          elt_type = resolve_dynamic_type (elt_type, view, address);
        }
-      elt = value::zero (elt_type, VALUE_LVAL (elt));
+      elt = value::zero (elt_type, elt->lval ());
     }
 
   return elt;
@@ -1872,7 +1872,7 @@ fortran_argument_convert (struct value *value, bool is_artificial)
     {
       /* If the value is not in the inferior e.g. registers values,
         convenience variables and user input.  */
-      if (VALUE_LVAL (value) != lval_memory)
+      if (value->lval () != lval_memory)
        {
          struct type *type = value->type ();
          const int length = type->length ();

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 37ae518d6c4b6c24771c3d30142a48e593bea948..7006500574c2da2439defdd551d08ba386b3c9b2 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -846,7 +846,7 @@ read_frame_register_value (struct value *value, frame_info_ptr frame)
   int regnum = VALUE_REGNUM (value);
   int len = type_length_units (check_typedef (value->type ()));
 
-  gdb_assert (VALUE_LVAL (value) == lval_register);
+  gdb_assert (value->lval () == lval_register);
 
   /* Skip registers wholly inside of REG_OFFSET.  */
   while (reg_offset >= register_size (gdbarch, regnum))

diff --git a/gdb/frame.c b/gdb/frame.c
index bf9b055878a60eb947ed20699d4cc797d391e495..be4c58e4642379bb36ad1996ca6a8364464f1ff2 100644 (file)
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -930,7 +930,7 @@ frame_find_by_id (struct frame_id id)
      and get_prev_frame performs a series of checks that are relatively
      expensive).  This optimization is particularly useful when this function
      is called from another function (such as value_fetch_lazy, case
-     VALUE_LVAL (val) == lval_register) which already loops over all frames,
+     val->lval () == lval_register) which already loops over all frames,
      making the overall behavior O(n^2).  */
   frame = frame_stash_find (id);
   if (frame)
@@ -1191,7 +1191,7 @@ frame_register_unwind (frame_info_ptr next_frame, int regnum,
 
   *optimizedp = value->optimized_out ();
   *unavailablep = !value->entirely_available ();
-  *lvalp = VALUE_LVAL (value);
+  *lvalp = value->lval ();
   *addrp = value->address ();
   if (*lvalp == lval_register)
     *realnump = VALUE_REGNUM (value);
@@ -1296,10 +1296,10 @@ frame_unwind_register_value (frame_info_ptr next_frame, int regnum)
        }
       else
        {
-         if (VALUE_LVAL (value) == lval_register)
+         if (value->lval () == lval_register)
            gdb_printf (&debug_file, " register=%d",
                        VALUE_REGNUM (value));
-         else if (VALUE_LVAL (value) == lval_memory)
+         else if (value->lval () == lval_memory)
            gdb_printf (&debug_file, " address=%s",
                        paddress (gdbarch,
                                  value->address ()));

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 73ccd1cf3f871a6a93e59928f328e4e01524e82b..f22ba44a53887824bf441d7a5ccd75914cad0924 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -4908,7 +4908,7 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value)
 
   if (TYPE_IS_REFERENCE (parm) && value != NULL)
     {
-      if (VALUE_LVAL (value) == not_lval)
+      if (value->lval () == not_lval)
        {
          /* Rvalues should preferably bind to rvalue references or const
             lvalue references.  */

diff --git a/gdb/infcall.c b/gdb/infcall.c
index 81a073d2123c37e925b83030d23900c0889f4512..9ed17bf4f8bc65b22a4dcb4ad4299650b539e2c8 100644 (file)
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -343,7 +343,7 @@ find_function_addr (struct value *function,
          int found_descriptor = 0;
 
          funaddr = 0;  /* pacify "gcc -Werror" */
-         if (VALUE_LVAL (function) == lval_memory)
+         if (function->lval () == lval_memory)
            {
              CORE_ADDR nfunaddr;
 

diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c
index ffa2faa44a908aa2e38731623ace05bf5c8150d2..72d0b58d675c1239e4acf00fdbe5763343db3efd 100644 (file)
--- a/gdb/m2-lang.c
+++ b/gdb/m2-lang.c
@@ -104,7 +104,7 @@ eval_op_m2_subscript (struct type *expect_type, struct expression *exp,
       }
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    return value::zero (type->target_type (), VALUE_LVAL (arg1));
+    return value::zero (type->target_type (), arg1->lval ());
   else
     return value_subscript (arg1, value_as_long (arg2));
 }

diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index b3e82f4a6ae75c4aa6fad726dcd447abf77bdd89..3e4a9c360b2888fd48bae44839cd5cd5bda7544b 100644 (file)
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -300,7 +300,7 @@ create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
       else
        {
          /* Check whether to create a lvalue or not.  */
-         if (VALUE_LVAL (val) != not_lval && !array_has_dups (indices, n))
+         if (val->lval () != not_lval && !array_has_dups (indices, n))
            {
              struct lval_closure *c = allocate_lval_closure (indices, n, val);
              ret = value::allocate_computed (dst_type, &opencl_value_funcs, c);
@@ -687,7 +687,7 @@ eval_opencl_assign (struct type *expect_type, struct expression *exp,
 
   struct type *type1 = arg1->type ();
   if (arg1->deprecated_modifiable ()
-      && VALUE_LVAL (arg1) != lval_internalvar)
+      && arg1->lval () != lval_internalvar)
     arg2 = opencl_value_cast (type1, arg2);
 
   return value_assign (arg1, arg2);
@@ -714,7 +714,7 @@ opencl_structop_operation::evaluate (struct type *expect_type,
                                          NULL, "structure");
 
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
-       v = value::zero (v->type (), VALUE_LVAL (v));
+       v = value::zero (v->type (), v->lval ());
       return v;
     }
 }

diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c
index 6d4bf2cc618f28e90479c47e540fa271cb6a58e6..e4fcce694cf1da1b9a47e7f39fbe11e25cb3a324 100644 (file)
--- a/gdb/ppc-linux-nat.c
+++ b/gdb/ppc-linux-nat.c
@@ -2455,9 +2455,9 @@ ppc_linux_nat_target::num_memory_accesses (const std::vector<value_ref_ptr>
       struct value *v = iter.get ();
 
       /* Constants and values from the history are fine.  */
-      if (VALUE_LVAL (v) == not_lval || v->->deprecated_modifiable () == 0)
+      if (v->lval () == not_lval || v->->deprecated_modifiable () == 0)
        continue;
-      else if (VALUE_LVAL (v) == lval_memory)
+      else if (v->lval () == lval_memory)
        {
          /* A lazy memory lvalue is one that GDB never needed to fetch;
             we either just used its address (e.g., `a' in `a.b') or
@@ -2509,7 +2509,7 @@ ppc_linux_nat_target::check_condition (CORE_ADDR watch_addr,
     return 0;
 
   if (num_accesses_left == 1 && num_accesses_right == 0
-      && VALUE_LVAL (left_val) == lval_memory
+      && left_val->lval () == lval_memory
       && left_val->address () == watch_addr)
     {
       *data_value = value_as_long (right_val);
@@ -2519,7 +2519,7 @@ ppc_linux_nat_target::check_condition (CORE_ADDR watch_addr,
       *len = check_typedef (left_val->type ())->length ();
     }
   else if (num_accesses_left == 0 && num_accesses_right == 1
-          && VALUE_LVAL (right_val) == lval_memory
+          && right_val->lval () == lval_memory
           && right_val->address () == watch_addr)
     {
       *data_value = value_as_long (left_val);

diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index 58047c7bd02663ddedcb798b82f648fa2223b15a..13945abc36cc3d35e250c96d26a106c2585808d0 100644 (file)
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -297,7 +297,7 @@ print_formatted (struct value *val, int size,
   struct type *type = check_typedef (val->type ());
   int len = type->length ();
 
-  if (VALUE_LVAL (val) == lval_memory)
+  if (val->lval () == lval_memory)
     next_address = val->address () + len;
 
   if (size)
@@ -1904,7 +1904,7 @@ x_command (const char *exp, int from_tty)
       /* In rvalue contexts, such as this, functions are coerced into
         pointers to functions.  This makes "x/i main" work.  */
       if (val->type ()->code () == TYPE_CODE_FUNC
-          && VALUE_LVAL (val) == lval_memory)
+         && val->lval () == lval_memory)
        next_address = val->address ();
       else
        next_address = value_as_address (val);
@@ -2446,7 +2446,7 @@ printf_c_string (struct ui_file *stream, const char *format,
   const gdb_byte *str;
 
   if (value->type ()->code () != TYPE_CODE_PTR
-      && VALUE_LVAL (value) == lval_internalvar
+      && value->lval () == lval_internalvar
       && c_is_string_type_p (value->type ()))
     {
       size_t len = value->type ()->length ();
@@ -2518,7 +2518,7 @@ printf_wide_c_string (struct ui_file *stream, const char *format,
                                         "wchar_t", NULL, 0);
   int wcwidth = wctype->length ();
 
-  if (VALUE_LVAL (value) == lval_internalvar
+  if (value->lval () == lval_internalvar
       && c_is_string_type_p (value->type ()))
     {
       str = value->contents ().data ();

diff --git a/gdb/python/py-unwind.c b/gdb/python/py-unwind.c
index 97b472f25b120ae398ce9805bd8ffcb479610462..5b512c95dc78410360655370970f9f63cc467a1b 100644 (file)
--- a/gdb/python/py-unwind.c
+++ b/gdb/python/py-unwind.c
@@ -272,7 +272,7 @@ unwind_infopy_add_saved_register (PyObject *self, PyObject *args)
     {
       struct value *user_reg_value
        = value_of_user_reg (regnum, pending_frame->frame_info);
-      if (VALUE_LVAL (user_reg_value) == lval_register)
+      if (user_reg_value->lval () == lval_register)
        regnum = VALUE_REGNUM (user_reg_value);
       if (regnum >= gdbarch_num_cooked_regs (pending_frame->gdbarch))
        {

diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index 27b5928298f89493743b3e8669aa7f5142adacdb..fb9db9fe31b67a1e40870ef6e80c637dd4f5f1a4 100644 (file)
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -1204,7 +1204,7 @@ rust_subscript (struct type *expect_type, struct expression *exp,
       else
        new_type = base_type;
 
-      return value::zero (new_type, VALUE_LVAL (lhs));
+      return value::zero (new_type, lhs->lval ());
     }
   else
     {
@@ -1470,7 +1470,7 @@ rust_structop::evaluate (struct type *expect_type,
   else
     result = value_struct_elt (&lhs, {}, field_name, NULL, "structure");
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    result = value::zero (result->type (), VALUE_LVAL (result));
+    result = value::zero (result->type (), result->lval ());
   return result;
 }
 

diff --git a/gdb/stack.c b/gdb/stack.c
index 934220e7c330ec540d807fb19abd8e67a7e4c50a..a26f65af1c454a93a7d427e987506c45335c0d13 100644 (file)
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -1710,7 +1710,7 @@ info_frame_command_core (frame_info_ptr fi, bool selected_frame_p)
 
        if (!value->optimized_out () && value->entirely_available ())
          {
-           if (VALUE_LVAL (value) == not_lval)
+           if (value->lval () == not_lval)
              {
                CORE_ADDR sp;
                enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -1723,13 +1723,13 @@ info_frame_command_core (frame_info_ptr fi, bool selected_frame_p)
                gdb_puts (paddress (gdbarch, sp));
                gdb_printf ("\n");
              }
-           else if (VALUE_LVAL (value) == lval_memory)
+           else if (value->lval () == lval_memory)
              {
                gdb_printf (" Previous frame's sp at ");
                gdb_puts (paddress (gdbarch, value->address ()));
                gdb_printf ("\n");
              }
-           else if (VALUE_LVAL (value) == lval_register)
+           else if (value->lval () == lval_register)
              {
                gdb_printf (" Previous frame's sp in %s\n",
                            gdbarch_register_name (gdbarch,

diff --git a/gdb/valarith.c b/gdb/valarith.c
index 427cafd81a221e2e4c523da5f59ef5a371acd341..0ab684aa05b1c09dc95052994fc09593a8957a5a 100644 (file)
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -93,7 +93,7 @@ value_ptradd (struct value *arg1, LONGEST arg2)
 
   result = value_from_pointer (valptrtype,
                               value_as_address (arg1) + sz * arg2);
-  if (VALUE_LVAL (result) != lval_internalvar)
+  if (result->lval () != lval_internalvar)
     result->set_component_location (arg1);
   return result;
 }
@@ -159,7 +159,7 @@ value_subscript (struct value *array, LONGEST index)
       if (!lowerbound.has_value ())
        lowerbound = 0;
 
-      if (VALUE_LVAL (array) != lval_memory)
+      if (array->lval () != lval_memory)
        return value_subscripted_rvalue (array, index, *lowerbound);
 
       gdb::optional<LONGEST> upperbound
@@ -235,7 +235,7 @@ value_subscripted_rvalue (struct value *array, LONGEST index,
   if (index < lowerbound
       || (!array_upper_bound_undefined
          && elt_offs >= type_length_units (array_type))
-      || (VALUE_LVAL (array) != lval_memory && array_upper_bound_undefined))
+      || (array->lval () != lval_memory && array_upper_bound_undefined))
     {
       if (type_not_associated (array_type))
        error (_("no such vector element (vector not associated)"));
@@ -532,7 +532,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
 
              if (return_type == NULL)
                error (_("Xmethod is missing return type."));
-             return value::zero (return_type, VALUE_LVAL (arg1));
+             return value::zero (return_type, arg1->lval ());
            }
          return argvec[0]->call_xmethod (argvec.slice (1));
        }
@@ -541,7 +541,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
          struct type *return_type;
 
          return_type = check_typedef (argvec[0]->type ())->target_type ();
-         return value::zero (return_type, VALUE_LVAL (arg1));
+         return value::zero (return_type, arg1->lval ());
        }
       return call_function_by_hand (argvec[0], NULL,
                                    argvec.slice (1, 2 - static_memfuncp));
@@ -645,7 +645,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
 
              if (return_type == NULL)
                error (_("Xmethod is missing return type."));
-             return value::zero (return_type, VALUE_LVAL (arg1));
+             return value::zero (return_type, arg1->lval ());
            }
          return argvec[0]->call_xmethod (argvec[1]);
        }
@@ -654,7 +654,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
          struct type *return_type;
 
          return_type = check_typedef (argvec[0]->type ())->target_type ();
-         return value::zero (return_type, VALUE_LVAL (arg1));
+         return value::zero (return_type, arg1->lval ());
        }
       return call_function_by_hand (argvec[0], NULL,
                                    argvec.slice (1, nargs));

diff --git a/gdb/valops.c b/gdb/valops.c
index a90bcbe7f29c7da873786db7b1bd5b454298f2c5..3901053c7d563c94069fab105aa62693395e5b0e 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -653,7 +653,7 @@ value_cast (struct type *type, struct value *arg2)
       arg2->set_pointed_to_offset (0); /* pai: chk_val */
       return arg2;
     }
-  else if (VALUE_LVAL (arg2) == lval_memory)
+  else if (arg2->lval () == lval_memory)
     return value_at_lazy (to_type, arg2->address ());
   else
     {
@@ -971,7 +971,7 @@ value_one (struct type *type)
     }
 
   /* value_one result is never used for assignments to.  */
-  gdb_assert (VALUE_LVAL (val) == not_lval);
+  gdb_assert (val->lval () == not_lval);
 
   return val;
 }
@@ -1095,7 +1095,7 @@ value_assign (struct value *toval, struct value *fromval)
   toval = coerce_ref (toval);
 
   type = toval->type ();
-  if (VALUE_LVAL (toval) != lval_internalvar)
+  if (toval->lval () != lval_internalvar)
     fromval = value_cast (type, fromval);
   else
     {
@@ -1112,7 +1112,7 @@ value_assign (struct value *toval, struct value *fromval)
      and then restore the new frame afterwards.  */
   old_frame = get_frame_id (deprecated_safe_get_selected_frame ());
 
-  switch (VALUE_LVAL (toval))
+  switch (toval->lval ())
     {
     case lval_internalvar:
       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
@@ -1292,7 +1292,7 @@ value_assign (struct value *toval, struct value *fromval)
      cause the frame cache and regcache to be out of date.  Assigning to memory
      also can.  We just do this on all assignments to registers or
      memory, for simplicity's sake; I doubt the slowdown matters.  */
-  switch (VALUE_LVAL (toval))
+  switch (toval->lval ())
     {
     case lval_memory:
     case lval_register:
@@ -1366,7 +1366,7 @@ value_repeat (struct value *arg1, int count)
 {
   struct value *val;
 
-  if (VALUE_LVAL (arg1) != lval_memory)
+  if (arg1->lval () != lval_memory)
     error (_("Only values in memory can be extended with '@'."));
   if (count < 1)
     error (_("Invalid number %d of repetitions."), count);
@@ -1406,7 +1406,7 @@ address_of_variable (struct symbol *var, const struct block *b)
   val = value_of_variable (var, b);
   type = val->type ();
 
-  if ((VALUE_LVAL (val) == lval_memory && val->lazy ())
+  if ((val->lval () == lval_memory && val->lazy ())
       || type->code () == TYPE_CODE_FUNC)
     {
       CORE_ADDR addr = val->address ();
@@ -1415,7 +1415,7 @@ address_of_variable (struct symbol *var, const struct block *b)
     }
 
   /* Not a memory address; check what the problem was.  */
-  switch (VALUE_LVAL (val))
+  switch (val->lval ())
     {
     case lval_register:
       {
@@ -1452,9 +1452,9 @@ value_must_coerce_to_target (struct value *val)
   struct type *valtype;
 
   /* The only lval kinds which do not live in target memory.  */
-  if (VALUE_LVAL (val) != not_lval
-      && VALUE_LVAL (val) != lval_internalvar
-      && VALUE_LVAL (val) != lval_xcallable)
+  if (val->lval () != not_lval
+      && val->lval () != lval_internalvar
+      && val->lval () != lval_xcallable)
     return false;
 
   valtype = check_typedef (val->type ());
@@ -1522,7 +1522,7 @@ value_coerce_array (struct value *arg1)
      be a good time to do so.  */
   arg1 = value_coerce_to_target (arg1);
 
-  if (VALUE_LVAL (arg1) != lval_memory)
+  if (arg1->lval () != lval_memory)
     error (_("Attempt to take address of value not located in memory."));
 
   return value_from_pointer (lookup_pointer_type (type->target_type ()),
@@ -1537,7 +1537,7 @@ value_coerce_function (struct value *arg1)
 {
   struct value *retval;
 
-  if (VALUE_LVAL (arg1) != lval_memory)
+  if (arg1->lval () != lval_memory)
     error (_("Attempt to take address of value not located in memory."));
 
   retval = value_from_pointer (lookup_pointer_type (arg1->type ()),
@@ -1586,7 +1586,7 @@ value_addr (struct value *arg1)
      then this would be a good time to force it to memory.  */
   arg1 = value_coerce_to_target (arg1);
 
-  if (VALUE_LVAL (arg1) != lval_memory)
+  if (arg1->lval () != lval_memory)
     error (_("Attempt to take address of value not located in memory."));
 
   /* Get target memory address.  */
@@ -1637,7 +1637,7 @@ value_ind (struct value *arg1)
 
   base_type = check_typedef (arg1->type ());
 
-  if (VALUE_LVAL (arg1) == lval_computed)
+  if (arg1->lval () == lval_computed)
     {
       const struct lval_funcs *funcs = arg1->computed_funcs ();
 
@@ -3963,7 +3963,7 @@ value_full_object (struct value *argp,
     }
 
   /* Check if object is in memory.  */
-  if (VALUE_LVAL (argp) != lval_memory)
+  if (argp->lval () != lval_memory)
     {
       warning (_("Couldn't retrieve complete object of RTTI "
                 "type %s; object may be in register(s)."), 
@@ -4077,7 +4077,7 @@ value_slice (struct value *array, int lowbound, int length)
                                    slice_range_type);
     slice_type->set_code (array_type->code ());
 
-    if (VALUE_LVAL (array) == lval_memory && array->lazy ())
+    if (array->lval () == lval_memory && array->lazy ())
       slice = value::allocate_lazy (slice_type);
     else
       {

diff --git a/gdb/value.c b/gdb/value.c
index 6b01d257b4dca50eb41a398a6d6f757089a8530c..0adf6faa152d72c702e474eaab0cb4f33316aaa2 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -149,14 +149,14 @@ static struct cmd_list_element *functionlist;
 
 value::~value ()
 {
-  if (VALUE_LVAL (this) == lval_computed)
+  if (this->lval () == lval_computed)
     {
       const struct lval_funcs *funcs = m_location.computed.funcs;
 
       if (funcs->free_closure)
        funcs->free_closure (this);
     }
-  else if (VALUE_LVAL (this) == lval_xcallable)
+  else if (this->lval () == lval_xcallable)
     delete m_location.xm_worker;
 }
 
@@ -1262,9 +1262,9 @@ value::optimized_out ()
     {
       /* See if we can compute the result without fetching the
         value.  */
-      if (VALUE_LVAL (this) == lval_memory)
+      if (this->lval () == lval_memory)
        return false;
-      else if (VALUE_LVAL (this) == lval_computed)
+      else if (this->lval () == lval_computed)
        {
          const struct lval_funcs *funcs = m_location.computed.funcs;
 
@@ -1515,7 +1515,7 @@ value::copy () const
       gdb::copy (arg_view, val_contents);
     }
 
-  if (VALUE_LVAL (val) == lval_computed)
+  if (val->lval () == lval_computed)
     {
       const struct lval_funcs *funcs = val->m_location.computed.funcs;
 
@@ -1549,7 +1549,7 @@ make_cv_value (int cnst, int voltl, struct value *v)
 struct value *
 value::non_lval ()
 {
-  if (VALUE_LVAL (this) != not_lval)
+  if (this->lval () != not_lval)
     {
       struct type *enc_type = enclosing_type ();
       struct value *val = value::allocate (enc_type);
@@ -1568,7 +1568,7 @@ value::non_lval ()
 void
 value::force_lval (CORE_ADDR addr)
 {
-  gdb_assert (VALUE_LVAL (this) == not_lval);
+  gdb_assert (this->lval () == not_lval);
 
   write_memory (addr, contents_raw ().data (), type ()->length ());
   m_lval = lval_memory;
@@ -1626,13 +1626,13 @@ value::set_component_location (const struct value *whole)
          carry around both the parent value contents, and the contents of
          any dynamic fields within the parent.  This is a substantial
          change to how values work in GDB.  */
-      if (VALUE_LVAL (this) == lval_internalvar_component)
+      if (this->lval () == lval_internalvar_component)
        {
          gdb_assert (lazy ());
          m_lval = lval_memory;
        }
       else
-       gdb_assert (VALUE_LVAL (this) == lval_memory);
+       gdb_assert (this->lval () == lval_memory);
       set_address (TYPE_DATA_LOCATION_ADDR (type));
     }
 }
@@ -2159,7 +2159,7 @@ set_internalvar (struct internalvar *var, struct value *val)
       break;
 
     case TYPE_CODE_INTERNAL_FUNCTION:
-      gdb_assert (VALUE_LVAL (val) == lval_internalvar);
+      gdb_assert (val->lval () == lval_internalvar);
       new_kind = INTERNALVAR_FUNCTION;
       get_internalvar_function (VALUE_INTERNALVAR (val),
                                &new_data.fn.function);
@@ -2282,7 +2282,7 @@ value_internal_function_name (struct value *val)
   struct internal_function *ifn;
   int result;
 
-  gdb_assert (VALUE_LVAL (val) == lval_internalvar);
+  gdb_assert (val->lval () == lval_internalvar);
   result = get_internalvar_function (VALUE_INTERNALVAR (val), &ifn);
   gdb_assert (result);
 
@@ -2297,7 +2297,7 @@ call_internal_function (struct gdbarch *gdbarch,
   struct internal_function *ifn;
   int result;
 
-  gdb_assert (VALUE_LVAL (func) == lval_internalvar);
+  gdb_assert (func->lval () == lval_internalvar);
   result = get_internalvar_function (VALUE_INTERNALVAR (func), &ifn);
   gdb_assert (result);
 
@@ -2888,7 +2888,7 @@ value::primitive_field (LONGEST offset, int fieldno, struct type *arg_type)
       LONGEST boffset;
 
       /* Lazy register values with offsets are not supported.  */
-      if (VALUE_LVAL (this) == lval_register && lazy ())
+      if (this->lval () == lval_register && lazy ())
        fetch_lazy ();
 
       /* We special case virtual inheritance here because this
@@ -2932,7 +2932,7 @@ value::primitive_field (LONGEST offset, int fieldno, struct type *arg_type)
                 / (HOST_CHAR_BIT * unit_size));
 
       /* Lazy register values with offsets are not supported.  */
-      if (VALUE_LVAL (this) == lval_register && lazy ())
+      if (this->lval () == lval_register && lazy ())
        fetch_lazy ();
 
       if (lazy ())
@@ -3526,7 +3526,7 @@ value_from_component (struct value *whole, struct type *type, LONGEST offset)
 {
   struct value *v;
 
-  if (VALUE_LVAL (whole) == lval_memory && whole->lazy ())
+  if (whole->lval () == lval_memory && whole->lazy ())
     v = value::allocate_lazy (type);
   else
     {
@@ -3761,7 +3761,7 @@ value::fetch_lazy_register ()
      refer to the entire register.  */
   gdb_assert (offset () == 0);
 
-  while (VALUE_LVAL (new_val) == lval_register && new_val->lazy ())
+  while (new_val->lval () == lval_register && new_val->lazy ())
     {
       struct frame_id next_frame_id = VALUE_NEXT_FRAME_ID (new_val);
 
@@ -3796,7 +3796,7 @@ value::fetch_lazy_register ()
         sniffer trying to unwind), bypassing its validations.  In
         any case, it should always be an internal error to end up
         in this situation.  */
-      if (VALUE_LVAL (new_val) == lval_register
+      if (new_val->lval () == lval_register
          && new_val->lazy ()
          && VALUE_NEXT_FRAME_ID (new_val) == next_frame_id)
        internal_error (_("infinite loop while fetching a register"));
@@ -3840,10 +3840,10 @@ value::fetch_lazy_register ()
          int i;
          gdb::array_view<const gdb_byte> buf = new_val->contents ();
 
-         if (VALUE_LVAL (new_val) == lval_register)
+         if (new_val->lval () == lval_register)
            gdb_printf (&debug_file, " register=%d",
                        VALUE_REGNUM (new_val));
-         else if (VALUE_LVAL (new_val) == lval_memory)
+         else if (new_val->lval () == lval_memory)
            gdb_printf (&debug_file, " address=%s",
                        paddress (gdbarch,
                                  new_val->address ()));
@@ -3883,11 +3883,11 @@ value::fetch_lazy ()
     }
   else if (bitsize ())
     fetch_lazy_bitfield ();
-  else if (VALUE_LVAL (this) == lval_memory)
+  else if (this->lval () == lval_memory)
     fetch_lazy_memory ();
-  else if (VALUE_LVAL (this) == lval_register)
+  else if (this->lval () == lval_register)
     fetch_lazy_register ();
-  else if (VALUE_LVAL (this) == lval_computed
+  else if (this->lval () == lval_computed
           && computed_funcs ()->read != NULL)
     computed_funcs ()->read (this);
   else

diff --git a/gdb/value.h b/gdb/value.h
index 9b31511af47a4e1c3931b06d72923b7696d53d4d..8b45f7fdee878b2b9d242247966b7b630978662c 100644 (file)
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -329,9 +329,6 @@ public:
      uses.  */
   void *computed_closure () const;
 
-  enum lval_type *deprecated_lval_hack ()
-  { return &m_lval; }
-
   enum lval_type lval () const
   { return m_lval; }
 
@@ -952,13 +949,6 @@ struct lval_funcs
 
 extern void error_value_optimized_out (void);
 
-/* While the following fields are per- VALUE .CONTENT .PIECE (i.e., a
-   single value might have multiple LVALs), this hacked interface is
-   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.  */
-#define VALUE_LVAL(val) (*((val)->deprecated_lval_hack ()))
-
 /* Pointer to internal variable.  */
 #define VALUE_INTERNALVAR(val) (*((val)->deprecated_internalvar_hack ()))
 

diff --git a/gdb/varobj.c b/gdb/varobj.c
index 72d5e7f2a2543bbf28e2de73156fa039ae54ae75..37b64a0c4bda618ebe7bc31afb7ee40ff4639aa5 100644 (file)
--- a/gdb/varobj.c
+++ b/gdb/varobj.c
@@ -2270,7 +2270,7 @@ varobj_editable_p (const struct varobj *var)
   struct type *type;
 
   if (!(var->root->is_valid && var->value != nullptr
-       && VALUE_LVAL (var->value.get ())))
+       && var->value.get ()->lval ()))
     return false;
 
   type = varobj_get_value_type (var);