re PR c++/57599 (result of dynamic_cast<cv T> is just T)

/cp
2013-06-14  Paolo Carlini  <paolo.carlini@oracle.com>

	PR c++/57599
	* rtti.c (build_dynamic_cast_1): In case of cast to an unambiguous
	accessible base simply forward to build_static_cast.

/testsuite
2013-06-14  Paolo Carlini  <paolo.carlini@oracle.com>

	PR c++/57599
	* g++.dg/rtti/dyncast6.C: New.
	* g++.dg/cpp0x/dyncast1.C: Likewise.

From-SVN: r200088

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 48a9310bddcc80af118182f06719fecd6101af73..d4cded580847c2cb8e1d4d218a014516a19a0af8 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,9 @@
+2013-06-14  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/57599
+       * rtti.c (build_dynamic_cast_1): In case of cast to an unambiguous
+       accessible base simply forward to build_static_cast.
+
 2013-06-12  Paolo Carlini  <paolo.carlini@oracle.com>
 
        PR c++/38958

diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index 90104406dff28db4c2d1d41b44115f92644d41c1..f3094981dfb7a6e6819bc8ff4b4b6b8e489b81c7 100644 (file)
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -622,19 +622,10 @@ build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
   /* If *type is an unambiguous accessible base class of *exprtype,
      convert statically.  */
   {
-    tree binfo;
-
-    binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
-                        ba_check, NULL, complain);
-
+    tree binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
+                             ba_check, NULL, complain);
     if (binfo)
-      {
-       expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
-                               binfo, 0, complain);
-       if (TYPE_PTR_P (exprtype))
-         expr = rvalue (expr);
-       return expr;
-      }
+      return build_static_cast (type, expr, complain);
   }
 
   /* Otherwise *exprtype must be a polymorphic class (have a vtbl).  */

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index a209086b41b1f09c9f508fe86f11d40d5dc317a1..119a7648c7d81bd01ce5e53381d8ae4b2703dced 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+2013-06-14  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/57599
+       * g++.dg/rtti/dyncast6.C: New.
+       * g++.dg/cpp0x/dyncast1.C: Likewise.
+
 2013-06-14  Alan Modra  <amodra@gmail.com>
 
        PR middle-end/57134

diff --git a/gcc/testsuite/g++.dg/cpp0x/dyncast1.C b/gcc/testsuite/g++.dg/cpp0x/dyncast1.C
new file mode 100644 (file)
index 0000000..1224f36
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/dyncast1.C
@@ -0,0 +1,31 @@
+// PR c++/57599
+// { dg-do compile { target c++11 } }
+
+struct A { };
+struct B : public A { };
+
+template<class, class>
+struct is_same { static constexpr bool value = false; };
+
+template<class T>
+struct is_same<T, T> { static constexpr bool value = true; };
+
+template<class T>
+T val();
+
+static_assert(is_same<decltype(dynamic_cast<A*>(val<B*>())),
+             A*>::value, "Ouch");
+static_assert(is_same<decltype(dynamic_cast<A&>(val<B&>())),
+             A&>::value, "Ouch");
+static_assert(is_same<decltype(dynamic_cast<const A*>(val<B*>())),
+             const A*>::value, "Ouch");
+static_assert(is_same<decltype(dynamic_cast<const A&>(val<B&>())),
+             const A&>::value, "Ouch");
+static_assert(is_same<decltype(dynamic_cast<volatile A*>(val<B*>())),
+             volatile A*>::value, "Ouch");
+static_assert(is_same<decltype(dynamic_cast<volatile A&>(val<B&>())),
+             volatile A&>::value, "Ouch");
+static_assert(is_same<decltype(dynamic_cast<const volatile A*>(val<B*>())),
+             const volatile A*>::value, "Ouch");
+static_assert(is_same<decltype(dynamic_cast<const volatile A&>(val<B&>())),
+             const volatile A&>::value, "Ouch");

diff --git a/gcc/testsuite/g++.dg/rtti/dyncast6.C b/gcc/testsuite/g++.dg/rtti/dyncast6.C
new file mode 100644 (file)
index 0000000..a6329e9
--- /dev/null
+++ b/gcc/testsuite/g++.dg/rtti/dyncast6.C
@@ -0,0 +1,59 @@
+// PR c++/57599
+
+class A { };
+
+class B : public A { };
+
+void p()
+{
+  B* b;
+
+  A* a1;
+  a1 = dynamic_cast<A*>(b);
+  a1 = dynamic_cast<const A*>(b);          // { dg-error "invalid" }
+  a1 = dynamic_cast<volatile A*>(b);       // { dg-error "invalid" }
+  a1 = dynamic_cast<const volatile A*>(b); // { dg-error "invalid" }
+
+  const A* a2;
+  a2 = dynamic_cast<A*>(b);
+  a2 = dynamic_cast<const A*>(b);
+  a2 = dynamic_cast<volatile A*>(b);       // { dg-error "invalid" }
+  a2 = dynamic_cast<const volatile A*>(b); // { dg-error "invalid" }
+
+  volatile A* a3;
+  a3 = dynamic_cast<A*>(b);
+  a3 = dynamic_cast<const A*>(b);          // { dg-error "invalid" }
+  a3 = dynamic_cast<volatile A*>(b);
+  a3 = dynamic_cast<const volatile A*>(b); // { dg-error "invalid" }
+
+  const volatile A* a4;
+  a4 = dynamic_cast<A*>(b);
+  a4 = dynamic_cast<const A*>(b);
+  a4 = dynamic_cast<volatile A*>(b);
+  a4 = dynamic_cast<const volatile A*>(b);
+}
+
+void r()
+{
+  B b;
+
+  A& a1 = dynamic_cast<A&>(b);
+  A& a2 = dynamic_cast<const A&>(b);                // { dg-error "invalid" }
+  A& a3 = dynamic_cast<volatile A&>(b);             // { dg-error "invalid" }
+  A& a4 = dynamic_cast<const volatile A&>(b);       // { dg-error "invalid" }
+
+  const A& ca1 = dynamic_cast<A&>(b);
+  const A& ca2 = dynamic_cast<const A&>(b);
+  const A& ca3 = dynamic_cast<volatile A&>(b);       // { dg-error "invalid" }
+  const A& ca4 = dynamic_cast<const volatile A&>(b); // { dg-error "invalid" }
+
+  volatile A& va1 = dynamic_cast<A&>(b);
+  volatile A& va2 = dynamic_cast<const A&>(b);       // { dg-error "invalid" }
+  volatile A& va3 = dynamic_cast<volatile A&>(b);
+  volatile A& va4 = dynamic_cast<const volatile A&>(b);// { dg-error "invalid" }
+
+  const volatile A& cva1 = dynamic_cast<A&>(b);
+  const volatile A& cva2 = dynamic_cast<const A&>(b);
+  const volatile A& cva3 = dynamic_cast<volatile A&>(b);
+  const volatile A& cva4 = dynamic_cast<const volatile A&>(b);
+}