Turn value_copy into a method

This turns value_copy into a method of value.  Much of this was
written by script.

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

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index c11182a5a0f8584a02643b0386247ded8b51cd29..e2aa4041263f22eec9f595600fd9803706e80414 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -1762,7 +1762,7 @@ thin_data_pntr (struct value *val)
   data_type = lookup_pointer_type (data_type);
 
   if (type->code () == TYPE_CODE_PTR)
-    return value_cast (data_type, value_copy (val));
+    return value_cast (data_type, val->copy ());
   else
     return value_from_longest (data_type, val->address ());
 }
@@ -2190,7 +2190,7 @@ ada_coerce_to_simple_array_ptr (struct value *arr)
 
       if (arrType == NULL)
        return NULL;
-      return value_cast (arrType, value_copy (desc_data (arr)));
+      return value_cast (arrType, desc_data (arr)->copy ());
     }
   else if (ada_is_constrained_packed_array_type (arr->type ()))
     return decode_constrained_packed_array (arr);
@@ -2920,7 +2920,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
                    bits, is_big_endian);
       write_memory_with_notification (to_addr, buffer, len);
 
-      val = value_copy (toval);
+      val = toval->copy ();
       memcpy (val->contents_raw ().data (),
              fromval->contents ().data (),
              type->length ());
@@ -3073,7 +3073,7 @@ ada_value_ptr_subscript (struct value *arr, int arity, struct value **ind)
       if (type->code () != TYPE_CODE_ARRAY)
        error (_("too many subscripts (%d expected)"), k);
       arr = value_cast (lookup_pointer_type (type->target_type ()),
-                       value_copy (arr));
+                       arr->copy ());
       get_discrete_bounds (type->index_type (), &lwb, &upb);
       arr = value_ptradd (arr, pos_atr (ind[k]) - lwb);
       type = type->target_type ();

diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index a56c8a1de8131d1a0742b4dac5127c9dd8063525..16e865c5de6fc6ca56876833070dc900566a2e80 100644 (file)
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -1028,7 +1028,7 @@ ada_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
   type = ada_check_typedef (resolve_dynamic_type (type, view, address));
   if (type != saved_type)
     {
-      val = value_copy (val);
+      val = val->copy ();
       val->deprecated_set_type (type);
     }
 

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 752b28778bcf9cd9d0f3d4bc6f1c3325f8f5e22a..4653dbfbd74d15a7140e47863a48d96d593e2a01 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -4416,7 +4416,7 @@ bpstat::bpstat (const bpstat &other)
     print_it (other.print_it)
 {
   if (other.old_val != NULL)
-    old_val = release_value (value_copy (other.old_val.get ()));
+    old_val = release_value (other.old_val.get ()->copy ());
 }
 
 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that

diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c
index 64a7e035b06ec3074cceaf82f659789af1536f90..f9706a0bc05ee876aa4adefd87c6f6cfb863bf78 100644 (file)
--- a/gdb/dwarf2/loc.c
+++ b/gdb/dwarf2/loc.c
@@ -1538,7 +1538,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, frame_info_ptr frame,
   value_ref_ptr value_holder = value_ref_ptr::new_reference (retval);
   free_values.free_to_mark ();
 
-  return value_copy (retval);
+  return retval->copy ();
 }
 
 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always

diff --git a/gdb/guile/scm-math.c b/gdb/guile/scm-math.c
index dcbdef5f4b0547b46e1e44f65bb3689a23c3f9ad..5036871c5f15e9b1d05481d6ffb1112731288cba 100644 (file)
--- a/gdb/guile/scm-math.c
+++ b/gdb/guile/scm-math.c
@@ -744,7 +744,7 @@ vlscm_convert_typed_value_from_scheme (const char *func_name,
              value = NULL;
            }
          else
-           value = value_copy (vlscm_scm_to_value (obj));
+           value = vlscm_scm_to_value (obj)->copy ();
        }
       else if (gdbscm_is_true (scm_bytevector_p (obj)))
        {

diff --git a/gdb/python/py-prettyprint.c b/gdb/python/py-prettyprint.c
index 18d2b7f5ba431f411fbb184991a7561b31cce9ab..dd72e2301576415b30680bed042c5e1c6204349b 100644 (file)
--- a/gdb/python/py-prettyprint.c
+++ b/gdb/python/py-prettyprint.c
@@ -663,7 +663,7 @@ gdbpy_get_varobj_pretty_printer (struct value *value)
 {
   try
     {
-      value = value_copy (value);
+      value = value->copy ();
     }
   catch (const gdb_exception &except)
     {

diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index 26cbac3586cdcc583e6614ed254ac9e7ec5e65ec..f339845c272a3acf852e84a0a6351a61d88f38e0 100644 (file)
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -1900,13 +1900,13 @@ convert_value_from_python (PyObject *obj)
                                   builtin_type_pychar);
        }
       else if (PyObject_TypeCheck (obj, &value_object_type))
-       value = value_copy (((value_object *) obj)->value);
+       value = ((value_object *) obj)->value->copy ();
       else if (gdbpy_is_lazy_string (obj))
        {
          PyObject *result;
 
          result = PyObject_CallMethodObjArgs (obj, gdbpy_value_cst,  NULL);
-         value = value_copy (((value_object *) result)->value);
+         value = ((value_object *) result)->value->copy ();
        }
       else
        PyErr_Format (PyExc_TypeError,

diff --git a/gdb/valops.c b/gdb/valops.c
index 2923d9fc0d14bdc5f58b33872a54a214ad669f96..aac32cc091765b129463832de8ef955e55eaf752 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -325,7 +325,7 @@ value_cast_pointers (struct type *type, struct value *arg2,
     }
 
   /* No superclass found, just change the pointer type.  */
-  arg2 = value_copy (arg2);
+  arg2 = arg2->copy ();
   arg2->deprecated_set_type (type);
   arg2->set_enclosing_type (type);
   arg2->set_pointed_to_offset (0);     /* pai: chk_val */
@@ -428,7 +428,7 @@ value_cast (struct type *type, struct value *arg2)
         value completely.  */
       if (arg2->type () != type)
        {
-         arg2 = value_copy (arg2);
+         arg2 = arg2->copy ();
          arg2->deprecated_set_type (type);
        }
       return arg2;
@@ -647,7 +647,7 @@ value_cast (struct type *type, struct value *arg2)
       if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
        return value_cast_pointers (to_type, arg2, 0);
 
-      arg2 = value_copy (arg2);
+      arg2 = arg2->copy ();
       arg2->deprecated_set_type (to_type);
       arg2->set_enclosing_type (to_type);
       arg2->set_pointed_to_offset (0); /* pai: chk_val */
@@ -1342,7 +1342,7 @@ value_assign (struct value *toval, struct value *fromval)
   /* The return value is a copy of TOVAL so it shares its location
      information, but its contents are updated from FROMVAL.  This
      implies the returned value is not lazy, even if TOVAL was.  */
-  val = value_copy (toval);
+  val = toval->copy ();
   val->set_lazy (0);
   copy (fromval->contents (), val->contents_raw ());
 
@@ -1572,7 +1572,7 @@ value_addr (struct value *arg1)
          struct type *enclosing_type_ptr
            = lookup_pointer_type (enclosing_type->target_type ());
 
-         arg2 = value_copy (arg1);
+         arg2 = arg1->copy ();
          arg2->deprecated_set_type (type_ptr);
          arg2->set_enclosing_type (enclosing_type_ptr);
 
@@ -2107,7 +2107,7 @@ struct_field_searcher::search (struct value *arg1, LONGEST offset,
            }
          else
            {
-             v2 = value_copy (arg1);
+             v2 = arg1->copy ();
              v2->deprecated_set_type (basetype);
              v2->set_embedded_offset (boffset);
            }
@@ -3958,7 +3958,7 @@ value_full_object (struct value *argp,
   /* pai: FIXME -- sounds iffy */
   if (full)
     {
-      argp = value_copy (argp);
+      argp = argp->copy ();
       argp->set_enclosing_type (real_type);
       return argp;
     }

diff --git a/gdb/value.c b/gdb/value.c
index 804444221ba7836f23195d1e2f08d634563cce60..b8a032ed30d04a993d5761d58633713aa9d3b13f 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -1517,34 +1517,33 @@ value_release_to_mark (const struct value *mark)
   return result;
 }
 
-/* Return a copy of the value ARG.  It contains the same contents,
-   for the same memory address, but it's a different block of storage.  */
+/* See value.h.  */
 
 struct value *
-value_copy (const value *arg)
+value::copy () const
 {
-  struct type *encl_type = arg->enclosing_type ();
+  struct type *encl_type = enclosing_type ();
   struct value *val;
 
   val = value::allocate_lazy (encl_type);
-  val->m_type = arg->m_type;
-  VALUE_LVAL (val) = arg->m_lval;
-  val->m_location = arg->m_location;
-  val->m_offset = arg->m_offset;
-  val->m_bitpos = arg->m_bitpos;
-  val->m_bitsize = arg->m_bitsize;
-  val->m_lazy = arg->m_lazy;
-  val->m_embedded_offset = arg->embedded_offset ();
-  val->m_pointed_to_offset = arg->m_pointed_to_offset;
-  val->m_modifiable = arg->m_modifiable;
-  val->m_stack = arg->m_stack;
-  val->m_is_zero = arg->m_is_zero;
-  val->m_in_history = arg->m_in_history;
-  val->m_initialized = arg->m_initialized;
-  val->m_unavailable = arg->m_unavailable;
-  val->m_optimized_out = arg->m_optimized_out;
-  val->m_parent = arg->m_parent;
-  val->m_limited_length = arg->m_limited_length;
+  val->m_type = m_type;
+  VALUE_LVAL (val) = m_lval;
+  val->m_location = m_location;
+  val->m_offset = m_offset;
+  val->m_bitpos = m_bitpos;
+  val->m_bitsize = m_bitsize;
+  val->m_lazy = m_lazy;
+  val->m_embedded_offset = embedded_offset ();
+  val->m_pointed_to_offset = m_pointed_to_offset;
+  val->m_modifiable = m_modifiable;
+  val->m_stack = m_stack;
+  val->m_is_zero = m_is_zero;
+  val->m_in_history = m_in_history;
+  val->m_initialized = m_initialized;
+  val->m_unavailable = m_unavailable;
+  val->m_optimized_out = m_optimized_out;
+  val->m_parent = m_parent;
+  val->m_limited_length = m_limited_length;
 
   if (!val->lazy ()
       && !(value_entirely_optimized_out (val)
@@ -1554,9 +1553,9 @@ value_copy (const value *arg)
       if (length == 0)
        length = val->enclosing_type ()->length ();
 
-      gdb_assert (arg->m_contents != nullptr);
+      gdb_assert (m_contents != nullptr);
       const auto &arg_view
-       = gdb::make_array_view (arg->m_contents.get (), length);
+       = gdb::make_array_view (m_contents.get (), length);
 
       val->allocate_contents (false);
       gdb::array_view<gdb_byte> val_contents
@@ -1586,7 +1585,7 @@ make_cv_value (int cnst, int voltl, struct value *v)
 {
   struct type *val_type = v->type ();
   struct type *m_enclosing_type = v->enclosing_type ();
-  struct value *cv_val = value_copy (v);
+  struct value *cv_val = v->copy ();
 
   cv_val->deprecated_set_type (make_cv_type (cnst, voltl, val_type, NULL));
   cv_val->set_enclosing_type (make_cv_type (cnst, voltl, m_enclosing_type, NULL));
@@ -1762,7 +1761,7 @@ access_value_history (int num)
 
   absnum--;
 
-  return value_copy (value_history[absnum].get ());
+  return value_history[absnum].get ()->copy ();
 }
 
 /* See value.h.  */
@@ -2088,7 +2087,7 @@ value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var)
       break;
 
     case INTERNALVAR_VALUE:
-      val = value_copy (var->u.value);
+      val = var->u.value->copy ();
       if (val->lazy ())
        val->fetch_lazy ();
       break;
@@ -2223,7 +2222,7 @@ set_internalvar (struct internalvar *var, struct value *val)
 
     default:
       new_kind = INTERNALVAR_VALUE;
-      struct value *copy = value_copy (val);
+      struct value *copy = val->copy ();
       copy->m_modifiable = 1;
 
       /* Force the value to be fetched from the target now, to avoid problems
@@ -4173,7 +4172,7 @@ test_value_copy ()
   /* Verify that we can copy an entirely optimized out value, that may not have
      its contents allocated.  */
   value_ref_ptr val = release_value (value::allocate_optimized_out (type));
-  value_ref_ptr copy = release_value (value_copy (val.get ()));
+  value_ref_ptr copy = release_value (val.get ()->copy ());
 
   SELF_CHECK (value_entirely_optimized_out (val.get ()));
   SELF_CHECK (value_entirely_optimized_out (copy.get ()));

diff --git a/gdb/value.h b/gdb/value.h
index f38241f1a5b737ef2611029ab5817bcc6eb41562..6b0250c0e51fa9a5768171528753c1cf3340e63f 100644 (file)
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -165,6 +165,11 @@ public:
   /* Create a value of type TYPE that is zero, and return it.  */
   static struct value *zero (struct type *type, enum lval_type lv);
 
+  /* Return a copy of the value.  It contains the same contents, for
+     the same memory address, but it's a different block of
+     storage.  */
+  struct value *copy () const;
+
   ~value ();
 
   DISABLE_COPY_AND_ASSIGN (value);
@@ -1447,8 +1452,6 @@ extern void preserve_values (struct objfile *);
 
 /* From values.c */
 
-extern struct value *value_copy (const value *);
-
 extern struct value *value_non_lval (struct value *);
 
 extern void value_force_lval (struct value *, CORE_ADDR);