gdb/

	* c-valprint.c (c_value_print): Use value_rtti_indirect_type
	instead of value_rtti_target_type.
	* eval.c (evaluate_subexp_standard): Use value_rtti_indirect_type
	instead of value_rtti_target_type.
	* typeprint.c (whatis_exp): Use value_rtti_indirect_type instead of
	value_rtti_target_type.
	* valops.c (value_ind): Extract function readjust_indirect_value_type.
	(value_rtti_target_type): Rename to ...
	(value_rtti_indirect_type): ... here and make it indirect.  Update
	function comment.
	* value.c (readjust_indirect_value_type): New function.
	(coerce_ref): Support for enclosing type setting for references
	with readjust_indirect_value_type.
	* value.h (readjust_value_type): New declaration.
	(value_rtti_target_type): Rename to ...
	(value_rtti_indirect_type): ... here.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 57bb9b7..0b29feb 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,24 @@
 2012-02-21  Anton Gorenkov  <xgsa@yandex.ru>
 
+       * c-valprint.c (c_value_print): Use value_rtti_indirect_type
+       instead of value_rtti_target_type.
+       * eval.c (evaluate_subexp_standard): Use value_rtti_indirect_type
+       instead of value_rtti_target_type.
+       * typeprint.c (whatis_exp): Use value_rtti_indirect_type instead of
+       value_rtti_target_type.
+       * valops.c (value_ind): Extract function readjust_indirect_value_type.
+       (value_rtti_target_type): Rename to ...
+       (value_rtti_indirect_type): ... here and make it indirect.  Update
+       function comment.
+       * value.c (readjust_indirect_value_type): New function.
+       (coerce_ref): Support for enclosing type setting for references
+       with readjust_indirect_value_type.
+       * value.h (readjust_value_type): New declaration.
+       (value_rtti_target_type): Rename to ...
+       (value_rtti_indirect_type): ... here.
+
+2012-02-21  Anton Gorenkov  <xgsa@yandex.ru>
+
        * MAINTAINERS (Write After Approval): Add myself to the list.
 
 2012-02-20  Doug Evans  <dje@google.com>

diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 82551e9..25c6688 100644 (file)
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -728,22 +728,13 @@ c_value_print (struct value *val, struct ui_file *stream,
 
          if (value_entirely_available (val))
            {
-             real_type = value_rtti_target_type (val, &full, &top, &using_enc);
+             real_type = value_rtti_indirect_type (val, &full, &top,
+                                                   &using_enc);
              if (real_type)
                {
                  /* RTTI entry found.  */
-                 if (TYPE_CODE (type) == TYPE_CODE_PTR)
-                   {
-                     /* Create a pointer type pointing to the real
-                        type.  */
-                     type = lookup_pointer_type (real_type);
-                   }
-                 else
-                   {
-                     /* Create a reference type referencing the real
-                        type.  */
-                     type = lookup_reference_type (real_type);
-                   }
+                 type = real_type;
+
                  /* Need to adjust pointer value.  */
                  val = value_from_pointer (type, value_as_address (val) - top);
 

diff --git a/gdb/eval.c b/gdb/eval.c
index 9913a72..de1c4bd 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -2001,16 +2001,10 @@ evaluate_subexp_standard (struct type *expect_type,
         if (opts.objectprint && TYPE_TARGET_TYPE(type)
             && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
           {
-            real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
+            real_type = value_rtti_indirect_type (arg1, &full, &top,
+                                                 &using_enc);
             if (real_type)
-              {
-                if (TYPE_CODE (type) == TYPE_CODE_PTR)
-                  real_type = lookup_pointer_type (real_type);
-                else
-                  real_type = lookup_reference_type (real_type);
-
                 arg1 = value_cast (real_type, arg1);
-              }
           }
       }
 

diff --git a/gdb/typeprint.c b/gdb/typeprint.c
index 803d20b..f257f47 100644 (file)
--- a/gdb/typeprint.c
+++ b/gdb/typeprint.c
@@ -139,16 +139,7 @@ whatis_exp (char *exp, int show)
       if (((TYPE_CODE (type) == TYPE_CODE_PTR)
           || (TYPE_CODE (type) == TYPE_CODE_REF))
          && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
-        {
-          real_type = value_rtti_target_type (val, &full, &top, &using_enc);
-          if (real_type)
-            {
-              if (TYPE_CODE (type) == TYPE_CODE_PTR)
-                real_type = lookup_pointer_type (real_type);
-              else
-                real_type = lookup_reference_type (real_type);
-            }
-        }
+        real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
       else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
        real_type = value_rtti_type (val, &full, &top, &using_enc);
     }

diff --git a/gdb/valops.c b/gdb/valops.c
index fca601f..ee450e3 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -1772,15 +1772,7 @@ value_ind (struct value *arg1)
                              (value_as_address (arg1)
                               - value_pointed_to_offset (arg1)));
 
-      /* Re-adjust type.  */
-      deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
-      /* Add embedding info.  */
-      set_value_enclosing_type (arg2, enc_type);
-      set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
-
-      /* We may be pointing to an object of some derived type.  */
-      arg2 = value_full_object (arg2, NULL, 0, 0, 0);
-      return arg2;
+      return readjust_indirect_value_type (arg2, enc_type, base_type, arg1);
     }
 
   error (_("Attempt to take contents of a non-pointer value."));
@@ -3526,21 +3518,48 @@ value_maybe_namespace_elt (const struct type *curtype,
   return result;
 }
 
-/* Given a pointer value V, find the real (RTTI) type of the object it
-   points to.
+/* Given a pointer or a reference value V, find its real (RTTI) type.
 
    Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
    and refer to the values computed for the object pointed to.  */
 
 struct type *
-value_rtti_target_type (struct value *v, int *full, 
-                       int *top, int *using_enc)
+value_rtti_indirect_type (struct value *v, int *full, 
+                         int *top, int *using_enc)
 {
   struct value *target;
+  struct type *type, *real_type, *target_type;
+
+  type = value_type (v);
+  type = check_typedef (type);
+  if (TYPE_CODE (type) == TYPE_CODE_REF)
+    target = coerce_ref (v);
+  else if (TYPE_CODE (type) == TYPE_CODE_PTR)
+    target = value_ind (v);
+  else
+    return NULL;
 
-  target = value_ind (v);
+  real_type = value_rtti_type (target, full, top, using_enc);
+
+  if (real_type)
+    {
+      /* Copy qualifiers to the referenced object.  */
+      target_type = value_type (target);
+      real_type = make_cv_type (TYPE_CONST (target_type),
+                               TYPE_VOLATILE (target_type), real_type, NULL);
+      if (TYPE_CODE (type) == TYPE_CODE_REF)
+        real_type = lookup_reference_type (real_type);
+      else if (TYPE_CODE (type) == TYPE_CODE_PTR)
+        real_type = lookup_pointer_type (real_type);
+      else
+        internal_error (__FILE__, __LINE__, _("Unexpected value type."));
+
+      /* Copy qualifiers to the pointer/reference.  */
+      real_type = make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type),
+                               real_type, NULL);
+    }
 
-  return value_rtti_type (target, full, top, using_enc);
+  return real_type;
 }
 
 /* Given a value pointed to by ARGP, check its real run-time type, and

diff --git a/gdb/value.c b/gdb/value.c
index 583be33..85ea970 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -3134,11 +3134,30 @@ coerce_ref_if_computed (const struct value *arg)
   return funcs->coerce_ref (arg);
 }
 
+/* Look at value.h for description.  */
+
+struct value *
+readjust_indirect_value_type (struct value *value, struct type *enc_type,
+                             struct type *original_type,
+                             struct value *original_value)
+{
+  /* Re-adjust type.  */
+  deprecated_set_value_type (value, TYPE_TARGET_TYPE (original_type));
+
+  /* Add embedding info.  */
+  set_value_enclosing_type (value, enc_type);
+  set_value_embedded_offset (value, value_pointed_to_offset (original_value));
+
+  /* We may be pointing to an object of some derived type.  */
+  return value_full_object (value, NULL, 0, 0, 0);
+}
+
 struct value *
 coerce_ref (struct value *arg)
 {
   struct type *value_type_arg_tmp = check_typedef (value_type (arg));
   struct value *retval;
+  struct type *enc_type;
 
   retval = coerce_ref_if_computed (arg);
   if (retval)
@@ -3147,9 +3166,14 @@ coerce_ref (struct value *arg)
   if (TYPE_CODE (value_type_arg_tmp) != TYPE_CODE_REF)
     return arg;
 
-  return value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp),
-                       unpack_pointer (value_type (arg),
-                                       value_contents (arg)));
+  enc_type = check_typedef (value_enclosing_type (arg));
+  enc_type = TYPE_TARGET_TYPE (enc_type);
+
+  retval = value_at_lazy (enc_type,
+                          unpack_pointer (value_type (arg),
+                                          value_contents (arg)));
+  return readjust_indirect_value_type (retval, enc_type,
+                                       value_type_arg_tmp, arg);
 }
 
 struct value *

diff --git a/gdb/value.h b/gdb/value.h
index 2a2274d..d4c4a83 100644 (file)
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -351,6 +351,19 @@ extern short *deprecated_value_regnum_hack (struct value *);
 
 extern struct value *coerce_ref_if_computed (const struct value *arg);
 
+/* Setup a new value type and enclosing value type for dereferenced value VALUE.
+   ENC_TYPE is the new enclosing type that should be set.  ORIGINAL_TYPE and
+   ORIGINAL_VAL are the type and value of the original reference or pointer.
+
+   Note, that VALUE is modified by this function.
+
+   It is a common implementation for coerce_ref and value_ind.  */
+
+extern struct value * readjust_indirect_value_type (struct value *value,
+                                                   struct type *enc_type,
+                                                   struct type *original_type,
+                                                   struct value *original_val);
+
 /* Convert a REF to the object referenced.  */
 
 extern struct value *coerce_ref (struct value *value);
@@ -615,8 +628,8 @@ extern struct value *value_primitive_field (struct value *arg1, int offset,
                                            struct type *arg_type);
 
 
-extern struct type *value_rtti_target_type (struct value *, int *, int *,
-                                           int *);
+extern struct type *value_rtti_indirect_type (struct value *, int *, int *,
+                                             int *);
 
 extern struct value *value_full_object (struct value *, struct type *, int,
                                        int, int);