Turn set_value_component_location into method

This turns set_value_component_location into a method of value.

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

gdb/ada-lang.c

@@ -567,7 +567,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
 	  result = value::allocate (type);
 	  value_contents_copy (result, 0, val, 0, type->length ());
 	}
-      set_value_component_location (result, val);
+      result->set_component_location (val);
       result->set_bitsize (val->bitsize ());
       result->set_bitpos (val->bitpos ());
       if (VALUE_LVAL (result) == lval_memory)
@@ -2830,7 +2830,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
     {
       long new_offset = offset;
 
-      set_value_component_location (v, obj);
+      v->set_component_location (obj);
       v->set_bitpos (bit_offset + obj->bitpos ());
       v->set_bitsize (bit_size);
       if (v->bitpos () >= HOST_CHAR_BIT)

gdb/valarith.c

@@ -94,7 +94,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)
-    set_value_component_location (result, arg1);
+    result->set_component_location (arg1);
   return result;
 }
 

gdb/valops.c

@@ -4087,7 +4087,7 @@ value_slice (struct value *array, int lowbound, int length)
 			     type_length_units (slice_type));
       }
 
-    set_value_component_location (slice, array);
+    slice->set_component_location (array);
     slice->set_offset (array->offset () + offset);
   }
 

gdb/value.c

@@ -1599,25 +1599,24 @@ value::force_lval (CORE_ADDR addr)
 }
 
 void
-set_value_component_location (struct value *component,
+value::set_component_location (const struct value *whole)
-			      const struct value *whole)
 {
   struct type *type;
 
   gdb_assert (whole->m_lval != lval_xcallable);
 
   if (whole->m_lval == lval_internalvar)
-    VALUE_LVAL (component) = lval_internalvar_component;
+    VALUE_LVAL (this) = lval_internalvar_component;
   else
-    VALUE_LVAL (component) = whole->m_lval;
+    VALUE_LVAL (this) = whole->m_lval;
 
-  component->m_location = whole->m_location;
+  m_location = whole->m_location;
   if (whole->m_lval == lval_computed)
     {
       const struct lval_funcs *funcs = whole->m_location.computed.funcs;
 
       if (funcs->copy_closure)
-	component->m_location.computed.closure = funcs->copy_closure (whole);
+	m_location.computed.closure = funcs->copy_closure (whole);
     }
 
   /* If the WHOLE value has a dynamically resolved location property then
@@ -1625,11 +1624,11 @@ set_value_component_location (struct value *component,
   type = whole->type ();
   if (NULL != TYPE_DATA_LOCATION (type)
       && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
-    component->set_address (TYPE_DATA_LOCATION_ADDR (type));
+    set_address (TYPE_DATA_LOCATION_ADDR (type));
 
   /* Similarly, if the COMPONENT value has a dynamically resolved location
      property then update its address.  */
-  type = component->type ();
+  type = this->type ();
   if (NULL != TYPE_DATA_LOCATION (type)
       && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
     {
@@ -1650,14 +1649,14 @@ set_value_component_location (struct value *component,
          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 (component) == lval_internalvar_component)
+      if (VALUE_LVAL (this) == lval_internalvar_component)
 	{
-	  gdb_assert (component->lazy ());
+	  gdb_assert (lazy ());
-	  VALUE_LVAL (component) = lval_memory;
+	  VALUE_LVAL (this) = lval_memory;
 	}
       else
-	gdb_assert (VALUE_LVAL (component) == lval_memory);
+	gdb_assert (VALUE_LVAL (this) == lval_memory);
-      component->set_address (TYPE_DATA_LOCATION_ADDR (type));
+      set_address (TYPE_DATA_LOCATION_ADDR (type));
     }
 }
 
@@ -2986,7 +2985,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
       v->m_offset = (arg1->offset () + offset
 		     + arg1->embedded_offset ());
     }
-  set_value_component_location (v, arg1);
+  v->set_component_location (arg1);
   return v;
 }
 
@@ -3584,7 +3583,7 @@ value_from_component (struct value *whole, struct type *type, LONGEST offset)
 			   type_length_units (type));
     }
   v->m_offset = whole->offset () + offset + whole->embedded_offset ();
-  set_value_component_location (v, whole);
+  v->set_component_location (whole);
 
   return v;
 }

gdb/value.h

@@ -539,6 +539,10 @@ public:
      LVAL_MEMORY.  */
   void force_lval (CORE_ADDR);
 
+  /* Set this values's location as appropriate for a component of
+     WHOLE --- regardless of what kind of lvalue WHOLE is.  */
+  void set_component_location (const struct value *whole);
+
 
   /* Type of value; either not an lval, or one of the various
      different possible kinds of lval.  */
@@ -858,11 +862,6 @@ struct lval_funcs
 
 extern void error_value_optimized_out (void);
 
-/* Set COMPONENT's location as appropriate for a component of WHOLE
-   --- regardless of what kind of lvalue WHOLE is.  */
-extern void set_value_component_location (struct value *component,
-					  const struct value *whole);
-
 /* 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.  */