[PATCH v3 45/50] Turn record_latest_value into a method

[Tom Tromey <tom@tromey.com>]

record_latest_value now access some internals of struct value, so turn
it into a method.
---
 gdb/arc-tdep.c        |  2 +-
 gdb/guile/scm-value.c |  2 +-
 gdb/infcmd.c          |  2 +-
 gdb/printcmd.c        |  2 +-
 gdb/python/py-value.c |  2 +-
 gdb/value.c           | 30 +++++++++++++-----------------
 gdb/value.h           |  5 +++--
 7 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c
index bbdcb8d4ce6..bbf4846a8f8 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 a0b7e6661b5..ac948dcd1a2 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 ());
     });
 }
 \f
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 3943a562590..a851fe1f8c8 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 0b3c2e00b4c..58047c7bd02 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 658a9a3f18c..c61de577de1 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 640053ddce5..a1ab853bcd1 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 f35bfc7206c..225a3c851c4 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -605,6 +605,9 @@ struct value
 					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);
 

-- 
2.39.1