c++: fix class-valued ?: extension

When the gimplifier encounters the same TARGET_EXPR twice, it evaluates
TARGET_EXPR_INITIAL the first time and clears it so that the later
evaluation is just the temporary.  With this testcase, using the extension
to treat an omitted middle operand as repeating the first operand, that led
to doing a bitwise copy of the S(1) temporary on return rather than properly
calling the copy constructor.

We can't use S(1) to initialize the return value here anyway, because we
need to materialize it into a temporary so we can convert it to bool and
determine which arm we're evaluating.  So let's just treat the middle
operand as an xvalue.

	PR c++/93046

gcc/cp/ChangeLog:

	* call.cc (build_conditional_expr): For a?:c extension, treat
	a reused class prvalue as an xvalue.

gcc/testsuite/ChangeLog:

	* g++.dg/ext/cond4.C: Add runtime test.

diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 9fad3cb950b59693efead3cba6a20b08cc75804f..bd04a1d309a735dd08e480243f09addae995b7d9 100644 (file)
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -5402,6 +5402,11 @@ build_conditional_expr (const op_location_t &loc,
          arg1 = cp_stabilize_reference (arg1);
          arg2 = arg1 = prevent_lifetime_extension (arg1);
        }
+      else if (TREE_CODE (arg1) == TARGET_EXPR)
+       /* arg1 can't be a prvalue result of the conditional
+          expression, since it needs to be materialized for the
+          conversion to bool, so treat it as an xvalue in arg2.  */
+       arg2 = move (TARGET_EXPR_SLOT (arg1));
       else
        arg2 = arg1 = cp_save_expr (arg1);
     }

diff --git a/gcc/testsuite/g++.dg/ext/cond4.C b/gcc/testsuite/g++.dg/ext/cond4.C
index d2853f403873e760ce225b121462d9c87e645b08..86993306aa5063fe6e411c29612a8f489466b7d2 100644 (file)
--- a/gcc/testsuite/g++.dg/ext/cond4.C
+++ b/gcc/testsuite/g++.dg/ext/cond4.C
@@ -1,10 +1,14 @@
 // PR c++/93046
-// { dg-do compile }
+// { dg-do run }
 // { dg-options "" }
 
+int c;
+
 struct S {
-  S (int);
-  operator bool ();
+  int i;
+  S (int i) : i(i) { ++c; }
+  S (const S &s): i(s.i) { ++c; }
+  operator bool () { return i; }
 };
 
 S
@@ -12,3 +16,10 @@ foo ()
 {
   return S (1) ? : S (2);
 }
+
+int main()
+{
+  S s = foo();
+  if (s.i != 1 || c != 2)
+    __builtin_abort ();
+}