Add ability to return rvalue reference values from value_ref

Parameterize value_ref() by the kind of reference type the value of which
is requested. Change all callers to use the new API.

gdb/ChangeLog

	PR gdb/14441
	* ada-lang.c (ada_evaluate_subexp): Adhere to the new
	value_ref() interface.
	* c-valprint.c (c_value_print): Likewise.
	* infcall.c (value_arg_coerce): Likewise.
	* python/py-value.c (valpy_reference_value): Likewise.
	* valops.c (value_cast, value_reinterpret_cast)
	(value_dynamic_cast, typecmp): Likewise.
	(value_ref): Parameterize by kind of return value reference type.
	* value.h (value_ref): Add new parameter "refcode".

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 872f661..0645273 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,6 +1,19 @@
 2017-03-20  Artemiy Volkov  <artemiyv@acm.org>
 
        PR gdb/14441
+       * ada-lang.c (ada_evaluate_subexp): Adhere to the new
+       value_ref() interface.
+       * c-valprint.c (c_value_print): Likewise.
+       * infcall.c (value_arg_coerce): Likewise.
+       * python/py-value.c (valpy_reference_value): Likewise.
+       * valops.c (value_cast, value_reinterpret_cast)
+       (value_dynamic_cast, typecmp): Likewise.
+       (value_ref): Parameterize by kind of return value reference type.
+       * value.h (value_ref): Add new parameter "refcode".
+
+2017-03-20  Artemiy Volkov  <artemiyv@acm.org>
+
+       PR gdb/14441
        * dwarf2read.c (read_tag_reference_type): Use
        lookup_lvalue_reference_type() instead of lookup_reference_type().
        * eval.c (evaluate_subexp_standard): Likewise.

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 753409c..9b91e0c 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -10707,7 +10707,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
                     should return a ref as it should be valid to ask
                     for its address; so rebuild a ref after coerce.  */
                  arg1 = ada_coerce_ref (arg1);
-                 return value_ref (arg1);
+                 return value_ref (arg1, TYPE_CODE_REF);
                }
            }
 

diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 5993195..d29b20e 100644 (file)
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -606,10 +606,14 @@ c_value_print (struct value *val, struct ui_file *stream,
       else if (options->objectprint
               && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
        {
-         int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
+         int is_ref = TYPE_IS_REFERENCE (type);
+         enum type_code refcode = TYPE_CODE_UNDEF;
 
          if (is_ref)
-           val = value_addr (val);
+           {
+             val = value_addr (val);
+             refcode = TYPE_CODE (type);
+           }
 
          /* Pointer to class, check real type of object.  */
          fprintf_filtered (stream, "(");
@@ -635,7 +639,7 @@ c_value_print (struct value *val, struct ui_file *stream,
 
          if (is_ref)
            {
-             val = value_ref (value_ind (val));
+             val = value_ref (value_ind (val), refcode);
              type = value_type (val);
            }
 

diff --git a/gdb/infcall.c b/gdb/infcall.c
index f55acb5..713738e 100644 (file)
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -168,7 +168,7 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
           if the value was not previously in memory - in some cases
           we should clearly be allowing this, but how?  */
        new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
-       new_value = value_ref (new_value);
+       new_value = value_ref (new_value, TYPE_CODE (type));
        return new_value;
       }
     case TYPE_CODE_INT:

diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index a56e555..c848f0f 100644 (file)
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -248,7 +248,7 @@ valpy_reference_value (PyObject *self, PyObject *args)
       scoped_value_mark free_values;
 
       self_val = ((value_object *) self)->value;
-      result = value_to_value_object (value_ref (self_val));
+      result = value_to_value_object (value_ref (self_val, TYPE_CODE_REF));
     }
   CATCH (except, RETURN_MASK_ALL)
     {

diff --git a/gdb/python/py-xmethods.c b/gdb/python/py-xmethods.c
index 8a9bb9b..d01488f 100644 (file)
--- a/gdb/python/py-xmethods.c
+++ b/gdb/python/py-xmethods.c
@@ -552,9 +552,10 @@ gdbpy_invoke_xmethod (const struct extension_language_defn *extlang,
       if (!types_equal (obj_type, this_ptr))
        obj = value_cast (this_ptr, obj);
     }
-  else if (TYPE_CODE (obj_type) == TYPE_CODE_REF)
+  else if (TYPE_IS_REFERENCE (obj_type))
     {
-      struct type *this_ref = lookup_lvalue_reference_type (this_type);
+      struct type *this_ref
+       = lookup_reference_type (this_type, TYPE_CODE (obj_type));
 
       if (!types_equal (obj_type, this_ref))
        obj = value_cast (this_ref, obj);

diff --git a/gdb/valops.c b/gdb/valops.c
index d218c92..21f4008 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -373,7 +373,7 @@ value_cast (struct type *type, struct value *arg2)
       struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
       struct value *val =  value_cast (dereftype, arg2);
 
-      return value_ref (val); 
+      return value_ref (val, TYPE_CODE (t1));
     }
 
   code2 = TYPE_CODE (check_typedef (value_type (arg2)));
@@ -623,7 +623,8 @@ value_reinterpret_cast (struct type *type, struct value *arg)
     error (_("Invalid reinterpret_cast"));
 
   if (is_ref)
-    result = value_cast (type, value_ref (value_ind (result)));
+    result = value_cast (type, value_ref (value_ind (result),
+                                          TYPE_CODE (type)));
 
   return result;
 }
@@ -819,7 +820,9 @@ value_dynamic_cast (struct type *type, struct value *arg)
                                arg_type,
                                &result) == 1)
        return value_cast (type,
-                          is_ref ? value_ref (result) : value_addr (result));
+                          is_ref
+                          ? value_ref (result, TYPE_CODE (resolved_type))
+                          : value_addr (result));
     }
 
   /* The second dynamic check specified in 5.2.7.  */
@@ -831,7 +834,9 @@ value_dynamic_cast (struct type *type, struct value *arg)
                               value_address (tem), tem,
                               rtti_type, &result) == 1)
     return value_cast (type,
-                      is_ref ? value_ref (result) : value_addr (result));
+                      is_ref
+                      ? value_ref (result, TYPE_CODE (resolved_type))
+                      : value_addr (result));
 
   if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
     return value_zero (type, not_lval);
@@ -1527,16 +1532,20 @@ value_addr (struct value *arg1)
    contents.  */
 
 struct value *
-value_ref (struct value *arg1)
+value_ref (struct value *arg1, enum type_code refcode)
 {
   struct value *arg2;
   struct type *type = check_typedef (value_type (arg1));
 
-  if (TYPE_CODE (type) == TYPE_CODE_REF)
+  gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
+
+  if ((TYPE_CODE (type) == TYPE_CODE_REF
+       || TYPE_CODE (type) == TYPE_CODE_RVALUE_REF)
+      && TYPE_CODE (type) == refcode)
     return arg1;
 
   arg2 = value_addr (arg1);
-  deprecated_set_value_type (arg2, lookup_lvalue_reference_type (type));
+  deprecated_set_value_type (arg2, lookup_reference_type (type, refcode));
   return arg2;
 }
 
@@ -1743,7 +1752,7 @@ typecmp (int staticp, int varargs, int nargs,
          if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
            t2[i] = value_coerce_array (t2[i]);
          else
-           t2[i] = value_ref (t2[i]);
+           t2[i] = value_ref (t2[i], TYPE_CODE (tt1));
          continue;
        }
 

diff --git a/gdb/value.h b/gdb/value.h
index c57ea79..a1d1609 100644 (file)
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -775,7 +775,7 @@ extern struct value *value_ind (struct value *arg1);
 
 extern struct value *value_addr (struct value *arg1);
 
-extern struct value *value_ref (struct value *arg1);
+extern struct value *value_ref (struct value *arg1, enum type_code refcode);
 
 extern struct value *value_assign (struct value *toval,
                                   struct value *fromval);