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>

7 files changed, 21 insertions, 24 deletions

diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c
index bbdcb8d..bbf4846 100644
--- 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 a0b7e66..ac948dc 100644
--- 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 ());
     });
 }
 
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 3943a56..a851fe1 100644
--- 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 0b3c2e0..58047c7 100644
--- 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 658a9a3..c61de57 100644
--- 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 640053d..a1ab853 100644
--- 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 f35bfc7..225a3c8 100644
--- 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);