C++ PATCH for libstdc++ test failure in C++17 mode

[Jason Merrill]

Jonathan recently noticed that 20_util/shared_ptr/cons/constexpr.cc
was failing in C++17 mode.  This was due to the copy elision changes
introducing TARGET_EXPR that wasn't there before, and
maybe_constant_init deciding that it wasn't sufficiently constant.  I
fixed that by looking through the TARGET_EXPR, but that broke
self-assign-test-1.C, because we were optimizing away the
self-assignment of foo and returning the incomplete CONSTRUCTOR that
we were in the process of building up.  I fixed that by making sure
that we don't return an incomplete CONSTRUCTOR as the final value of a
constant expression.

Tested x86_64-pc-linux-gnu, applying to trunk.

commit f92fd1ca9864da0259320a8389321aac374c8740
Author: Jason Merrill <ja...@redhat.com>
Date:   Fri Oct 21 23:42:34 2016 -0400

            * constexpr.c (maybe_constant_init): Pull out TARGET_EXPR_INITIAL.
    
            (cxx_eval_outermost_constant_expr): Don't return a CONSTRUCTOR
            with CONSTRUCTOR_NO_IMPLICIT_ZERO.

diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index 8f7b7f3..1ebd647 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -1665,6 +1665,10 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree 
t,
        entry->result = result;
     }
 
+  /* The result of a constexpr function must be completely initialized.  */
+  if (TREE_CODE (result) == CONSTRUCTOR)
+    CONSTRUCTOR_NO_IMPLICIT_ZERO (result) = false;
+
   pop_cx_call_context ();
   return unshare_constructor (result);
 }
@@ -4483,6 +4487,16 @@ cxx_eval_outermost_constant_expr (tree t, bool 
allow_non_constant,
       non_constant_p = true;
     }
 
+  if (TREE_CODE (r) == CONSTRUCTOR
+      && CONSTRUCTOR_NO_IMPLICIT_ZERO (r))
+    {
+      if (!allow_non_constant)
+       error ("%qE is not a constant expression because it refers to "
+              "an incompletely initialized variable", t);
+      TREE_CONSTANT (r) = false;
+      non_constant_p = true;
+    }
+
   /* Technically we should check this for all subexpressions, but that
      runs into problems with our internal representation of pointer
      subtraction and the 5.19 rules are still in flux.  */
@@ -4781,6 +4795,8 @@ maybe_constant_init (tree t, tree decl)
     t = TREE_OPERAND (t, 0);
   if (TREE_CODE (t) == INIT_EXPR)
     t = TREE_OPERAND (t, 1);
+  if (TREE_CODE (t) == TARGET_EXPR)
+    t = TARGET_EXPR_INITIAL (t);
   if (!potential_nondependent_static_init_expression (t))
     /* Don't try to evaluate it.  */;
   else
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-static12.C 
b/gcc/testsuite/g++.dg/cpp0x/constexpr-static12.C
new file mode 100644
index 0000000..4faa8cf
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-static12.C
@@ -0,0 +1,20 @@
+// { dg-do compile { target c++11 } }
+// { dg-final { scan-assembler-not "_ZNSt10unique_ptrC1Ei" } }
+
+namespace std {
+  struct unique_ptr {
+    constexpr unique_ptr(int) : p() { }
+    ~unique_ptr() { }
+    void* p;
+  };
+}
+
+void f()
+{
+  static std::unique_ptr p(1);
+}
+
+int main()
+{
+  f();
+}