Turn record_latest_value into a method

record_latest_value now access some internals of struct value, so turn
it into a method.

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

diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c
index bbdcb8d4ce6bdd1506d6909459f0a556270d2af4..bbf4846a8f83f7f86d3a082dfdba5df4ac153ff2 100644 (file)
--- a/gdb/arc-tdep.c
+++ b/gdb/arc-tdep.c
@@ -2437,7 +2437,7 @@ dump_arc_instruction_command (const char *args, int from_tty)
     val = evaluate_expression (parse_expression (args).get ());
   else
     val = access_value_history (0);
-  record_latest_value (val);
+  val->record_latest ();
 
   CORE_ADDR address = value_as_address (val);
   struct arc_instruction insn;

diff --git a/gdb/guile/scm-value.c b/gdb/guile/scm-value.c
index a0b7e6661b5efe7d38adf8c0c9a7572239a1cc79..ac948dcd1a270f75b17219b61900b11cc03b7bdf 100644 (file)
--- a/gdb/guile/scm-value.c
+++ b/gdb/guile/scm-value.c
@@ -1330,7 +1330,7 @@ gdbscm_history_append_x (SCM value)
     = vlscm_get_value_smob_arg_unsafe (value, SCM_ARG1, FUNC_NAME);
   return gdbscm_wrap ([=]
     {
-      return scm_from_int (record_latest_value (v_smob->value));
+      return scm_from_int (v_smob->value->record_latest ());
     });
 }
 \f

diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 3943a562590338747c8f9aed0acd9c665ac89cd1..a851fe1f8c85c391ab387fc8f8a6122b8e1b8083 100644 (file)
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -1657,7 +1657,7 @@ finish_command_fsm::should_stop (struct thread_info *tp)
              rv->value = get_return_value (function, func);
 
          if (rv->value != nullptr)
-           rv->value_history_index = record_latest_value (rv->value);
+           rv->value_history_index = rv->value->record_latest ();
        }
     }
   else if (tp->control.stop_step)

diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index 0b3c2e00b4c94cb39ba71a0e46faec7042b96cfe..58047c7bd02663ddedcb798b82f648fa2223b15a 100644 (file)
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -1247,7 +1247,7 @@ print_value (value *val, const value_print_options &opts)
      need to load as many array elements as we plan to print.  */
   scoped_array_length_limiting limit_large_arrays (opts.print_max);
 
-  int histindex = record_latest_value (val);
+  int histindex = val->record_latest ();
 
   annotate_value_history_begin (histindex, val->type ());
 

diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index 658a9a3f18c0fdb3d309c446690805aa0147d30f..c61de577de1944ab66693f58a16dd67af52b493d 100644 (file)
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -1959,7 +1959,7 @@ gdbpy_add_history (PyObject *self, PyObject *args)
 
   try
     {
-      int idx = record_latest_value (value);
+      int idx = value->record_latest ();
       return gdb_py_object_from_longest (idx).release ();
     }
   catch (const gdb_exception &except)

diff --git a/gdb/value.c b/gdb/value.c
index 640053ddce5b6edfc1a7136a861fb64435075630..a1ab853bcd11565c955404598dc8b068f14a5197 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -1643,46 +1643,42 @@ value::set_component_location (const struct value *whole)
    Returns the absolute history index of the entry.  */
 
 int
-record_latest_value (struct value *val)
+value::record_latest ()
 {
-  struct type *enclosing_type = val->enclosing_type ();
-  struct type *type = val->type ();
-
   /* We don't want this value to have anything to do with the inferior anymore.
      In particular, "set $1 = 50" should not affect the variable from which
      the value was taken, and fast watchpoints should be able to assume that
      a value on the value history never changes.  */
-  if (val->lazy ())
+  if (lazy ())
     {
       /* We know that this is a _huge_ array, any attempt to fetch this
         is going to cause GDB to throw an error.  However, to allow
         the array to still be displayed we fetch its contents up to
         `max_value_size' and mark anything beyond "unavailable" in
         the history.  */
-      if (type->code () == TYPE_CODE_ARRAY
-         && type->length () > max_value_size
+      if (m_type->code () == TYPE_CODE_ARRAY
+         && m_type->length () > max_value_size
          && array_length_limiting_element_count.has_value ()
-         && enclosing_type == type
-         && calculate_limited_array_length (type) <= max_value_size)
-       val->m_limited_length = max_value_size;
+         && m_enclosing_type == m_type
+         && calculate_limited_array_length (m_type) <= max_value_size)
+       m_limited_length = max_value_size;
 
-      val->fetch_lazy ();
+      fetch_lazy ();
     }
 
-  ULONGEST limit = val->m_limited_length;
+  ULONGEST limit = m_limited_length;
   if (limit != 0)
-    val->mark_bytes_unavailable (limit,
-                                enclosing_type->length () - limit);
+    mark_bytes_unavailable (limit, m_enclosing_type->length () - limit);
 
   /* Mark the value as recorded in the history for the availability check.  */
-  val->m_in_history = true;
+  m_in_history = true;
 
   /* 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...  */
-  val->set_modifiable (0);
+  set_modifiable (0);
 
-  value_history.push_back (release_value (val));
+  value_history.push_back (release_value (this));
 
   return value_history.size ();
 }

diff --git a/gdb/value.h b/gdb/value.h
index f35bfc7206c588ebc690b8b3766ebad46e24250c..225a3c851c41049a3c7ecb2117667c9b43a0e428 100644 (file)
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -605,6 +605,9 @@ public:
                                        LONGEST bit_offset,
                                        LONGEST bit_length);
 
+  /* Record this value on the value history, and return its location
+     in the history.  The value is removed from the value chain.  */
+  int record_latest ();
 
   /* Type of value; either not an lval, or one of the various
      different possible kinds of lval.  */
@@ -1451,8 +1454,6 @@ extern int destructor_name_p (const char *name, struct type *type);
 
 extern value_ref_ptr release_value (struct value *val);
 
-extern int record_latest_value (struct value *val);
-
 extern void modify_field (struct type *type, gdb_byte *addr,
                          LONGEST fieldval, LONGEST bitpos, LONGEST bitsize);