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>

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;

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 ());
     });
 }
 

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)

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 ());
 

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)

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
+      if (m_type->code () == TYPE_CODE_ARRAY
-	  && type->length () > max_value_size
+	  && m_type->length () > max_value_size
 	  && array_length_limiting_element_count.has_value ()
-	  && enclosing_type == type
+	  && m_enclosing_type == m_type
-	  && calculate_limited_array_length (type) <= max_value_size)
+	  && calculate_limited_array_length (m_type) <= max_value_size)
-	val->m_limited_length = 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,
+    mark_bytes_unavailable (limit, m_enclosing_type->length () - limit);
-				 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 ();
 }

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);