C++14 constexpr support (minus loops and multiple returns)

	C++14 constexpr support (minus loops and multiple returns)
gcc/
	* tree-inline.c (copy_fn): New.
	* tree-inline.h: Declare it.
gcc/cp/
	* constexpr.c (use_new_call): New macro.
	(build_data_member_initialization): Ignore non-mem-inits.
	(check_constexpr_bind_expr_vars): Remove C++14 checks.
	(constexpr_fn_retval): Likewise.
	(check_constexpr_ctor_body): Do nothing in C++14.
	(massage_constexpr_body): In C++14 only collect mem-inits.
	(get_function_named_in_call): Handle null CALL_EXPR_FN.
	(cxx_bind_parameters_in_call): Build bindings in same order as
	parameters.  Don't treat iniviref parms specially in new call mode.
	(cxx_eval_call_expression): If use_new_call, do constexpr expansion
	based on DECL_SAVED_TREE rather than the massaged constexpr body.
	Set up ctx->object from AGGR_INIT_EXPR_SLOT if we don't have one.
	(is_sub_constant_expr): Don't mess with ctx.ctor here.
	(cxx_eval_component_reference): A null element means we're mid-
	initialization.
	(cxx_eval_store_expression, cxx_eval_increment_expression): New.
	(cxx_eval_constant_expression): Handle RESULT_DECL, DECL_EXPR,
	MODIFY_EXPR, STATEMENT_LIST, BIND_EXPR, USING_STMT,
	PREINCREMENT_EXPR, POSTINCREMENT_EXPR, PREDECREMENT_EXPR,
	POSTDECREMENT_EXPR.  Don't look into DECL_INITIAL of variables in
	constexpr functions.  In new-call mode find parms in the values table.
	(potential_constant_expression_1): Handle null CALL_EXPR_FN.
	Handle STATEMENT_LIST, MODIFY_EXPR, MODOP_EXPR, IF_STMT,
	PREINCREMENT_EXPR, POSTINCREMENT_EXPR, PREDECREMENT_EXPR,
	POSTDECREMENT_EXPR, BIND_EXPR, WITH_CLEANUP_EXPR,
	CLEANUP_POINT_EXPR, MUST_NOT_THROW_EXPR, TRY_CATCH_EXPR,
	EH_SPEC_BLOCK, EXPR_STMT, DECL_EXPR, CASE_LABEL_EXPR, BREAK_STMT,
	CONTINUE_STMT, USING_STMT, IF_STMT, DO_STMT, FOR_STMT, WHILE_STMT,
	SWITCH_STMT, ASM_EXPR.
	(cxx_eval_vec_init_1): Call build_aggr_init_expr.
	(cxx_eval_indirect_ref): Don't return a CONSTRUCTOR when the
	caller wants an lvalue.
	(cxx_eval_outermost_constant_expr): Pull object out of AGGR_INIT_EXPR.
	(maybe_constant_init): Look through INIT_EXPR.
	(ensure_literal_type_for_constexpr_object): Set
	cp_function_chain->invalid_constexpr.
	* cp-tree.h (struct language_function): Add invalid_constexpr bitfield.
	* decl.c (start_decl): Set cp_function_chain->invalid_constexpr.
	(check_for_uninitialized_const_var): Likewise.
	(maybe_save_function_definition): Check it.
	* parser.c (cp_parser_jump_statement): Set
	cp_function_chain->invalid_constexpr.
	(cp_parser_asm_definition): Likewise.

From-SVN: r217663

13 files changed, 653 insertions, 93 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d661ec1..1b5d8a0 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+2014-11-17  Jason Merrill  <jason@redhat.com>
+
+	* tree-inline.c (copy_fn): New.
+	* tree-inline.h: Declare it.
+
 2014-11-17  Alan Lawrence  <alan.lawrence@arm.com>
 
 	* config/aarch64/aarch64-builtins.c (TYPES_CREATE): Remove.
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 42521c9..ae347d8 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,5 +1,50 @@
 2014-11-17  Jason Merrill  <jason@redhat.com>
 
+	C++14 constexpr support (minus loops and multiple returns)
+	* constexpr.c (use_new_call): New macro.
+	(build_data_member_initialization): Ignore non-mem-inits.
+	(check_constexpr_bind_expr_vars): Remove C++14 checks.
+	(constexpr_fn_retval): Likewise.
+	(check_constexpr_ctor_body): Do nothing in C++14.
+	(massage_constexpr_body): In C++14 only collect mem-inits.
+	(get_function_named_in_call): Handle null CALL_EXPR_FN.
+	(cxx_bind_parameters_in_call): Build bindings in same order as
+	parameters.  Don't treat iniviref parms specially in new call mode.
+	(cxx_eval_call_expression): If use_new_call, do constexpr expansion
+	based on DECL_SAVED_TREE rather than the massaged constexpr body.
+	Set up ctx->object from AGGR_INIT_EXPR_SLOT if we don't have one.
+	(is_sub_constant_expr): Don't mess with ctx.ctor here.
+	(cxx_eval_component_reference): A null element means we're mid-
+	initialization.
+	(cxx_eval_store_expression, cxx_eval_increment_expression): New.
+	(cxx_eval_constant_expression): Handle RESULT_DECL, DECL_EXPR,
+	MODIFY_EXPR, STATEMENT_LIST, BIND_EXPR, USING_STMT,
+	PREINCREMENT_EXPR, POSTINCREMENT_EXPR, PREDECREMENT_EXPR,
+	POSTDECREMENT_EXPR.  Don't look into DECL_INITIAL of variables in
+	constexpr functions.  In new-call mode find parms in the values table.
+	(potential_constant_expression_1): Handle null CALL_EXPR_FN.
+	Handle STATEMENT_LIST, MODIFY_EXPR, MODOP_EXPR, IF_STMT,
+	PREINCREMENT_EXPR, POSTINCREMENT_EXPR, PREDECREMENT_EXPR,
+	POSTDECREMENT_EXPR, BIND_EXPR, WITH_CLEANUP_EXPR,
+	CLEANUP_POINT_EXPR, MUST_NOT_THROW_EXPR, TRY_CATCH_EXPR,
+	EH_SPEC_BLOCK, EXPR_STMT, DECL_EXPR, CASE_LABEL_EXPR, BREAK_STMT,
+	CONTINUE_STMT, USING_STMT, IF_STMT, DO_STMT, FOR_STMT, WHILE_STMT,
+	SWITCH_STMT, ASM_EXPR.
+	(cxx_eval_vec_init_1): Call build_aggr_init_expr.
+	(cxx_eval_indirect_ref): Don't return a CONSTRUCTOR when the
+	caller wants an lvalue.
+	(cxx_eval_outermost_constant_expr): Pull object out of AGGR_INIT_EXPR.
+	(maybe_constant_init): Look through INIT_EXPR.
+	(ensure_literal_type_for_constexpr_object): Set
+	cp_function_chain->invalid_constexpr.
+	* cp-tree.h (struct language_function): Add invalid_constexpr bitfield.
+	* decl.c (start_decl): Set cp_function_chain->invalid_constexpr.
+	(check_for_uninitialized_const_var): Likewise.
+	(maybe_save_function_definition): Check it.
+	* parser.c (cp_parser_jump_statement): Set
+	cp_function_chain->invalid_constexpr.
+	(cp_parser_asm_definition): Likewise.
+
 	PR c++/52282
 	* decl.c (build_ptrmemfunc_type): Don't build a different
 	RECORD_TYPE for a qualified PMF.
diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index 66d356f..57d0c46 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-iterator.h"
 #include "gimplify.h"
 #include "builtins.h"
+#include "tree-inline.h"
 
 static bool verify_constant (tree, bool, bool *, bool *);
 #define VERIFY_CONSTANT(X)						\
@@ -93,8 +94,11 @@ ensure_literal_type_for_constexpr_object (tree decl)
 	    error ("the type %qT of constexpr variable %qD is not literal",
 		   type, decl);
 	  else
-	    error ("variable %qD of non-literal type %qT in %<constexpr%> "
-		   "function", decl, type);
+	    {
+	      error ("variable %qD of non-literal type %qT in %<constexpr%> "
+		     "function", decl, type);
+	      cp_function_chain->invalid_constexpr = true;
+	    }
 	  explain_non_literal_class (type);
 	  return NULL;
 	}
@@ -310,13 +314,20 @@ build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
   if (TREE_CODE (t) == CONVERT_EXPR)
     t = TREE_OPERAND (t, 0);
   if (TREE_CODE (t) == INIT_EXPR
-      || TREE_CODE (t) == MODIFY_EXPR)
+      /* vptr initialization shows up as a MODIFY_EXPR.  In C++14 we only
+	 use what this function builds for cx_check_missing_mem_inits, and
+	 assignment in the ctor body doesn't count.  */
+      || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR))
     {
       member = TREE_OPERAND (t, 0);
       init = break_out_target_exprs (TREE_OPERAND (t, 1));
     }
   else if (TREE_CODE (t) == CALL_EXPR)
     {
+      tree fn = get_callee_fndecl (t);
+      if (!fn || !DECL_CONSTRUCTOR_P (fn))
+	/* We're only interested in calls to subobject constructors.  */
+	return true;
       member = CALL_EXPR_ARG (t, 0);
       /* We don't use build_cplus_new here because it complains about
 	 abstract bases.  Leaving the call unwrapped means that it has the
@@ -325,13 +336,9 @@ build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
     }
   else if (TREE_CODE (t) == BIND_EXPR)
     return build_data_member_initialization (BIND_EXPR_BODY (t), vec);
-  else if (TREE_CODE (t) == DECL_EXPR
-	   || TREE_CODE (t) == USING_STMT)
-    /* Declaring a temporary, don't add it to the CONSTRUCTOR.
-       Likewise for using directives.  */
-    return true;
   else
-    gcc_unreachable ();
+    /* Don't add anything else to the CONSTRUCTOR.  */
+    return true;
   if (INDIRECT_REF_P (member))
     member = TREE_OPERAND (member, 0);
   if (TREE_CODE (member) == NOP_EXPR)
@@ -390,9 +397,6 @@ check_constexpr_bind_expr_vars (tree t)
 {
   gcc_assert (TREE_CODE (t) == BIND_EXPR);
 
-  if (cxx_dialect >= cxx14)
-    return true;
-
   for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var))
     if (TREE_CODE (var) == TYPE_DECL
 	&& DECL_IMPLICIT_TYPEDEF_P (var))
@@ -410,8 +414,6 @@ check_constexpr_ctor_body_1 (tree last, tree list)
     case DECL_EXPR:
       if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL)
 	return true;
-      if (cxx_dialect >= cxx14)
-	return true;
       return false;
 
     case CLEANUP_POINT_EXPR:
@@ -440,6 +442,10 @@ check_constexpr_ctor_body_1 (tree last, tree list)
 bool
 check_constexpr_ctor_body (tree last, tree list, bool complain)
 {
+  /* C++14 doesn't require a constexpr ctor to have an empty body.  */
+  if (cxx_dialect >= cxx14)
+    return true;
+
   bool ok = true;
   if (TREE_CODE (list) == STATEMENT_LIST)
     {
@@ -612,8 +618,6 @@ constexpr_fn_retval (tree body)
     case DECL_EXPR:
       if (TREE_CODE (DECL_EXPR_DECL (body)) == USING_DECL)
 	return NULL_TREE;
-      if (cxx_dialect >= cxx14)
-	return NULL_TREE;
       return error_mark_node;
 
     case CLEANUP_POINT_EXPR:
@@ -642,7 +646,7 @@ massage_constexpr_body (tree fun, tree body)
   if (DECL_CONSTRUCTOR_P (fun))
     body = build_constexpr_constructor_member_initializers
       (DECL_CONTEXT (fun), body);
-  else
+  else if (cxx_dialect < cxx14)
     {
       if (TREE_CODE (body) == EH_SPEC_BLOCK)
         body = EH_SPEC_STMTS (body);
@@ -936,7 +940,7 @@ get_function_named_in_call (tree t)
       gcc_unreachable();
       break;
     }
-  if (TREE_CODE (fun) == ADDR_EXPR
+  if (fun && TREE_CODE (fun) == ADDR_EXPR
       && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
     fun = TREE_OPERAND (fun, 0);
   return fun;
@@ -1016,6 +1020,10 @@ adjust_temp_type (tree type, tree temp)
   return cp_fold_convert (type, temp);
 }
 
+/* True if we want to use the new handling of constexpr calls based on
+   DECL_SAVED_TREE.  Currently only active for C++14 mode.  */
+#define use_new_call (cxx_dialect >= cxx14)
+
 /* Subroutine of cxx_eval_call_expression.
    We are processing a call expression (either CALL_EXPR or
    AGGR_INIT_EXPR) in the context of CTX.  Evaluate
@@ -1032,6 +1040,7 @@ cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
   tree fun = new_call->fundef->decl;
   tree parms = DECL_ARGUMENTS (fun);
   int i;
+  tree *p = &new_call->bindings;
   for (i = 0; i < nargs; ++i)
     {
       tree x, arg;
@@ -1039,19 +1048,19 @@ cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
       x = get_nth_callarg (t, i);
       /* For member function, the first argument is a pointer to the implied
          object.  For a constructor, it might still be a dummy object, in
-         which case we get the real argument from ctx or the AGGR_INIT_EXPR. */
+         which case we get the real argument from ctx. */
       if (i == 0 && DECL_CONSTRUCTOR_P (fun)
 	  && is_dummy_object (x))
 	{
 	  x = ctx->object;
-	  if (!x)
-	    x = AGGR_INIT_EXPR_SLOT (t);
 	  x = cp_build_addr_expr (x, tf_warning_or_error);
 	}
-      if (parms && DECL_BY_REFERENCE (parms))
+      if (parms && DECL_BY_REFERENCE (parms) && !use_new_call)
 	{
 	  /* cp_genericize made this a reference for argument passing, but
-	     we don't want to treat it like one for constexpr evaluation.  */
+	     we don't want to treat it like one for C++11 constexpr
+	     evaluation.  C++14 constexpr evaluation uses the genericized
+	     DECL_SAVED_TREE.  */
 	  gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
 	  gcc_assert (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE);
 	  type = TREE_TYPE (type);
@@ -1073,7 +1082,8 @@ cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
       /* Make sure the binding has the same type as the parm.  */
       if (TREE_CODE (type) != REFERENCE_TYPE)
 	arg = adjust_temp_type (type, arg);
-      new_call->bindings = tree_cons (parms, arg, new_call->bindings);
+      *p = build_tree_list (parms, arg);
+      p = &TREE_CHAIN (*p);
     next:
       parms = TREE_CHAIN (parms);
     }
@@ -1205,6 +1215,20 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
           return t;
         }
     }
+
+  constexpr_ctx new_ctx = *ctx;
+  if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
+      && TREE_CODE (t) == AGGR_INIT_EXPR)
+    {
+      /* We want to have an initialization target for an AGGR_INIT_EXPR.
+	 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT.  */
+      new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
+      tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
+      CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true;
+      ctx->values->put (new_ctx.object, ctor);
+      ctx = &new_ctx;
+    }
+
   cxx_bind_parameters_in_call (ctx, t, &new_call,
 			       allow_non_constant, non_constant_p, overflow_p);
   if (*non_constant_p)
@@ -1251,18 +1275,91 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
       result = entry->result;
       if (!result || result == error_mark_node)
 	{
-	  constexpr_ctx new_ctx = *ctx;
-	  new_ctx.call = &new_call;
-	  result = (cxx_eval_constant_expression
-		    (&new_ctx, new_call.fundef->body,
-		     allow_non_constant, addr,
-		     non_constant_p, overflow_p));
+	  if (!use_new_call)
+	    {
+	      new_ctx.call = &new_call;
+	      result = (cxx_eval_constant_expression
+			(&new_ctx, new_call.fundef->body,
+			 allow_non_constant, addr,
+			 non_constant_p, overflow_p));
+	    }
+	  else
+	    {
+	      if (DECL_SAVED_TREE (fun) == NULL_TREE
+		  && (DECL_CONSTRUCTOR_P (fun) || DECL_DESTRUCTOR_P (fun)))
+		/* The maybe-in-charge 'tor had its DECL_SAVED_TREE
+		   cleared, try the first clone.  */
+		fun = DECL_CHAIN (fun);
+	      gcc_assert (DECL_SAVED_TREE (fun));
+	      tree parms, res;
+
+	      /* Unshare the whole function body.  */
+	      tree body = copy_fn (fun, parms, res);
+
+	      /* Associate the bindings with the remapped parms.  */
+	      tree bound = new_call.bindings;
+	      tree remapped = parms;
+	      while (bound)
+		{
+		  tree oparm = TREE_PURPOSE (bound);
+		  tree arg = TREE_VALUE (bound);
+		  gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm));
+		  ctx->values->put (remapped, arg);
+		  bound = TREE_CHAIN (bound);
+		  remapped = DECL_CHAIN (remapped);
+		}
+	      /* Add the RESULT_DECL to the values map, too.  */
+	      tree slot = NULL_TREE;
+	      if (DECL_BY_REFERENCE (res))
+		{
+		  slot = AGGR_INIT_EXPR_SLOT (t);
+		  tree addr = build_address (slot);
+		  addr = build_nop (TREE_TYPE (res), addr);
+		  ctx->values->put (res, addr);
+		  ctx->values->put (slot, NULL_TREE);
+		}
+	      else
+		ctx->values->put (res, NULL_TREE);
+
+	      cxx_eval_constant_expression (ctx, body, allow_non_constant,
+					    addr, non_constant_p, overflow_p);
+
+	      if (VOID_TYPE_P (TREE_TYPE (res)))
+		/* This can be null for a subobject constructor call, in
+		   which case what we care about is the initialization
+		   side-effects rather than the value.  We could get at the
+		   value by evaluating *this, but we don't bother; there's
+		   no need to put such a call in the hash table.  */
+		result = addr ? ctx->object : ctx->ctor;
+	      else
+		{
+		  result = *ctx->values->get (slot ? slot : res);
+		  if (result == NULL_TREE)
+		    {
+		      if (!allow_non_constant)
+			error ("constexpr call flows off the end "
+			       "of the function");
+		      *non_constant_p = true;
+		    }
+		}
+
+	      /* Remove the parms/result from the values map.  Is it worth
+		 bothering to do this when the map itself is only live for
+		 one constexpr evaluation?  If so, maybe also clear out
+		 other vars from call, maybe in BIND_EXPR handling?  */
+	      ctx->values->remove (res);
+	      if (slot)
+		ctx->values->remove (slot);
+	      for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
+		ctx->values->remove (parm);
+	    }
 	}
+
       if (result == error_mark_node)
 	*non_constant_p = true;
       if (*non_constant_p)
 	entry->result = result = error_mark_node;
-      else
+      else if (result)
 	{
 	  /* If this was a call to initialize an object, set the type of
 	     the CONSTRUCTOR to the type of that object.  */
@@ -1277,6 +1374,8 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
 	    }
 	  entry->result = result;
 	}
+      else
+	result = void_node;
     }
 
   pop_cx_call_context ();
@@ -1537,7 +1636,13 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
     {
       if (field == part)
-        return value;
+	{
+	  if (value)
+	    return value;
+	  else
+	    /* We're in the middle of initializing it.  */
+	    break;
+	}
     }
   if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
       && CONSTRUCTOR_NELTS (whole) > 0)
@@ -1903,6 +2008,7 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
 					&argvec, elttype, LOOKUP_NORMAL,
 					tf_warning_or_error);
       release_tree_vector (argvec);
+      init = build_aggr_init_expr (TREE_TYPE (init), init);
       pre_init = true;
     }
 
@@ -2219,7 +2325,7 @@ cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
   /* If we're pulling out the value of an empty base, make sure
      that the whole object is constant and then return an empty
      CONSTRUCTOR.  */
-  if (empty_base)
+  if (empty_base && !addr)
     {
       VERIFY_CONSTANT (r);
       r = build_constructor (TREE_TYPE (t), NULL);
@@ -2317,9 +2423,163 @@ var_in_constexpr_fn (tree t)
 	  && DECL_DECLARED_CONSTEXPR_P (ctx));
 }
 
+/* Evaluate an INIT_EXPR or MODIFY_EXPR.  */
+
+static tree
+cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
+			   bool allow_non_constant, bool addr,
+			   bool *non_constant_p, bool *overflow_p)
+{
+  constexpr_ctx new_ctx = *ctx;
+
+  /* First we figure out where we're storing to.  */
+  tree target = TREE_OPERAND (t, 0);
+  target = cxx_eval_constant_expression (ctx, target,
+					 allow_non_constant, true,
+					 non_constant_p, overflow_p);
+  if (*non_constant_p)
+    return t;
+
+  /* And then find the underlying variable.  */
+  vec<tree,va_gc> *refs = make_tree_vector();
+  tree object = NULL_TREE;
+  for (tree probe = target; object == NULL_TREE; )
+    {
+      switch (TREE_CODE (probe))
+	{
+	case BIT_FIELD_REF:
+	case COMPONENT_REF:
+	case ARRAY_REF:
+	  vec_safe_push (refs, TREE_OPERAND (probe, 1));
+	  vec_safe_push (refs, TREE_TYPE (probe));
+	  probe = TREE_OPERAND (probe, 0);
+	  break;
+
+	default:
+	  object = probe;
+	  gcc_assert (DECL_P (object));
+	}
+    }
+
+  /* And then find/build up our initializer for the path to the subobject
+     we're initializing.  */
+  tree *valp = ctx->values->get (object);
+  if (!valp)
+    {
+      /* A constant-expression cannot modify objects from outside the
+	 constant-expression.  */
+      if (!allow_non_constant)
+	error ("modification of %qD is not a constant-expression", object);
+      *non_constant_p = true;
+      return t;
+    }
+  tree type = TREE_TYPE (object);
+  while (!refs->is_empty())
+    {
+      if (*valp == NULL_TREE)
+	{
+	  *valp = build_constructor (type, NULL);
+	  CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = true;
+	}
+
+      constructor_elt ce;
+      type = refs->pop();
+      ce.index = refs->pop();
+      ce.value = NULL_TREE;
+
+      unsigned HOST_WIDE_INT idx = 0;
+      constructor_elt *cep = NULL;
+      for (idx = 0;
+	   vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep);
+	   idx++)
+	/* ??? slow */
+	if (cp_tree_equal (ce.index, cep->index))
+	  break;
+      if (!cep)
+	cep = vec_safe_push (CONSTRUCTOR_ELTS (*valp), ce);
+      valp = &cep->value;
+    }
+  release_tree_vector (refs);
+
+  if ((AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t))))
+    {
+      /* Create a new CONSTRUCTOR in case evaluation of the initializer
+	 wants to modify it.  */
+      *valp = new_ctx.ctor = build_constructor (TREE_TYPE (t), NULL);
+      CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
+      new_ctx.object = target;
+    }
+
+  tree init = cxx_eval_constant_expression (&new_ctx, TREE_OPERAND (t, 1),
+					    allow_non_constant, false,
+					    non_constant_p, overflow_p);
+  if (target == object)
+    /* The hash table might have moved since the get earlier.  */
+    ctx->values->put (object, init);
+  else
+    *valp = init;
+
+  if (*non_constant_p)
+    return t;
+  else if (addr)
+    return target;
+  else
+    return *valp;
+}
+
+/* Evaluate a ++ or -- expression.  */
+
+static tree
+cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
+			      bool allow_non_constant, bool addr,
+			      bool *non_constant_p, bool *overflow_p)
+{
+  enum tree_code code = TREE_CODE (t);
+  tree type = TREE_TYPE (t);
+  tree op = TREE_OPERAND (t, 0);
+  tree offset = TREE_OPERAND (t, 1);
+  gcc_assert (TREE_CONSTANT (offset));
+
+  /* The operand as an lvalue.  */
+  op = cxx_eval_constant_expression (ctx, op, allow_non_constant, true,
+				     non_constant_p, overflow_p);
+
+  /* The operand as an rvalue.  */
+  tree val = rvalue (op);
+  val = cxx_eval_constant_expression (ctx, val, allow_non_constant, false,
+				      non_constant_p, overflow_p);
+  VERIFY_CONSTANT (val);
+
+  /* The modified value.  */
+  bool inc = (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR);
+  tree mod = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR,
+			  type, val, offset);
+  VERIFY_CONSTANT (mod);
+
+  /* Storing the modified value.  */
+  tree store = build2 (MODIFY_EXPR, type, op, mod);
+  cxx_eval_constant_expression (ctx, store, allow_non_constant,
+				true, non_constant_p, overflow_p);
+
+  /* And the value of the expression.  */
+  if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
+    {
+      /* Prefix ops are lvalues.  */
+      if (addr)
+	return op;
+      else
+	/* But we optimize when the caller wants an rvalue.  */
+	return mod;
+    }
+  else
+    /* Postfix ops are rvalues.  */
+    return val;
+}
+
 /* Attempt to reduce the expression T to a constant value.
    On failure, issue diagnostic and return error_mark_node.  */
 /* FIXME unify with c_fully_fold */
+/* FIXME overflow_p is too global */
 
 static tree
 cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
@@ -2348,6 +2608,14 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
 
   switch (TREE_CODE (t))
     {
+    case RESULT_DECL:
+      if (addr)
+	return t;
+      /* We ask for an rvalue for the RESULT_DECL when indirecting
+	 through an invisible reference.  */
+      gcc_assert (DECL_BY_REFERENCE (t));
+      return (*ctx->values->get (t));
+
     case VAR_DECL:
       if (addr)
 	return t;
@@ -2357,11 +2625,6 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
       if (TREE_CODE (r) == TARGET_EXPR
 	  && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR)
 	r = TARGET_EXPR_INITIAL (r);
-      if (TREE_CODE (r) == VAR_DECL && var_in_constexpr_fn (r)
-	  && DECL_INITIAL (r))
-	r = cxx_eval_constant_expression (ctx, DECL_INITIAL (r),
-					  allow_non_constant, false,
-					  non_constant_p, overflow_p);
       if (TREE_CODE (r) == VAR_DECL)
 	if (tree *p = ctx->values->get (r))
 	  r = *p;
@@ -2379,8 +2642,13 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
       return t;
 
     case PARM_DECL:
-      if (ctx && ctx->call && DECL_CONTEXT (t) == ctx->call->fundef->decl)
+      if (!use_new_call && ctx
+	  && ctx->call && DECL_CONTEXT (t) == ctx->call->fundef->decl)
 	r = lookup_parameter_binding (ctx->call, t);
+      else if (addr && TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
+	/* glvalue use.  */;
+      else if (tree *p = ctx->values->get (r))
+	r = *p;
       else if (addr)
 	/* Defer in case this is only used for its type.  */;
       else
@@ -2397,6 +2665,34 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
 				    non_constant_p, overflow_p);
       break;
 
+    case DECL_EXPR:
+      {
+	r = DECL_EXPR_DECL (t);
+	if (AGGREGATE_TYPE_P (TREE_TYPE (r))
+	    || VECTOR_TYPE_P (TREE_TYPE (r)))
+	  {
+	    new_ctx = *ctx;
+	    new_ctx.object = r;
+	    new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL);
+	    CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
+	    new_ctx.values->put (r, new_ctx.ctor);
+	    ctx = &new_ctx;
+	  }
+
+	if (tree init = DECL_INITIAL (r))
+	  {
+	    init = cxx_eval_constant_expression (ctx, init,
+						 allow_non_constant, false,
+						 non_constant_p, overflow_p);
+	    ctx->values->put (r, init);
+	  }
+	else if (ctx == &new_ctx)
+	  /* We gave it a CONSTRUCTOR above.  */;
+	else
+	  ctx->values->put (r, NULL_TREE);
+      }
+      break;
+
     case TARGET_EXPR:
       if (!literal_type_p (TREE_TYPE (t)))
 	{
@@ -2421,9 +2717,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
 	  ctx->values->put (new_ctx.object, new_ctx.ctor);
 	  ctx = &new_ctx;
 	}
-      /* else fall through.  */
-    case INIT_EXPR:
-      /* Pass false for 'addr' because these codes indicate
+      /* Pass false for 'addr' because this indicates
 	 initialization of a temporary.  */
       r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
 					allow_non_constant, false,
@@ -2433,6 +2727,22 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
 	r = adjust_temp_type (TREE_TYPE (t), r);
       break;
 
+    case INIT_EXPR:
+      if (!use_new_call)
+	{
+	  /* In C++11 constexpr evaluation we are looking for the value,
+	     not the side-effect of the initialization.  */
+	  r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
+					    allow_non_constant, false,
+					    non_constant_p, overflow_p);
+	  break;
+	}
+      /* else fall through */
+    case MODIFY_EXPR:
+      r = cxx_eval_store_expression (ctx, t, allow_non_constant, addr,
+				     non_constant_p, overflow_p);
+      break;
+
     case SCOPE_REF:
       r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
 					allow_non_constant, addr,
@@ -2445,6 +2755,8 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
     case CLEANUP_POINT_EXPR:
     case MUST_NOT_THROW_EXPR:
     case SAVE_EXPR:
+    case EXPR_STMT:
+    case EH_SPEC_BLOCK:
       r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
 					allow_non_constant, addr,
 					non_constant_p, overflow_p);
@@ -2679,27 +2991,47 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
 	 used, and they can't do anything with it, so just return it.  */
       return t;
 
-    case LAMBDA_EXPR:
+    case STATEMENT_LIST:
+      {
+	new_ctx = *ctx;
+	new_ctx.ctor = new_ctx.object = NULL_TREE;
+	tree_stmt_iterator i;
+	for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
+	  {
+	    cxx_eval_constant_expression (&new_ctx, tsi_stmt (i),
+					  allow_non_constant, false,
+					  non_constant_p, overflow_p);
+	    if (*non_constant_p)
+	      break;
+	  }
+      }
+      break;
+
+    case BIND_EXPR:
+      return cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (t),
+					   allow_non_constant, addr,
+					   non_constant_p, overflow_p);
+
     case PREINCREMENT_EXPR:
     case POSTINCREMENT_EXPR:
     case PREDECREMENT_EXPR:
     case POSTDECREMENT_EXPR:
+      return cxx_eval_increment_expression (ctx, t, allow_non_constant,
+					    addr, non_constant_p, overflow_p);
+
+    case LAMBDA_EXPR:
     case NEW_EXPR:
     case VEC_NEW_EXPR:
     case DELETE_EXPR:
     case VEC_DELETE_EXPR:
     case THROW_EXPR:
-    case MODIFY_EXPR:
     case MODOP_EXPR:
       /* GCC internal stuff.  */
     case VA_ARG_EXPR:
     case OBJ_TYPE_REF:
     case WITH_CLEANUP_EXPR:
-    case STATEMENT_LIST:
-    case BIND_EXPR:
     case NON_DEPENDENT_EXPR:
     case BASELINK:
-    case EXPR_STMT:
     case OFFSET_REF:
       if (!allow_non_constant)
         error_at (EXPR_LOC_OR_LOC (t, input_location),
@@ -2730,6 +3062,14 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
 	}
       break;
 
+    case GOTO_EXPR:
+    case LOOP_EXPR:
+    case SWITCH_EXPR:
+      if (!allow_non_constant)
+	sorry ("%qs in constant expression", get_tree_code_name (TREE_CODE (t)));
+      *non_constant_p = true;
+      break;
+
     default:
       internal_error ("unexpected expression %qE of kind %s", t,
 		      get_tree_code_name (TREE_CODE (t)));
@@ -2768,8 +3108,13 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
 	 initialized.  */
       ctx.ctor = build_constructor (type, NULL);
       CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx.ctor) = true;
-      if (!object && TREE_CODE (t) == TARGET_EXPR)
-	object = TARGET_EXPR_SLOT (t);
+      if (!object)
+	{
+	  if (TREE_CODE (t) == TARGET_EXPR)
+	    object = TARGET_EXPR_SLOT (t);
+	  else if (TREE_CODE (t) == AGGR_INIT_EXPR)
+	    object = AGGR_INIT_EXPR_SLOT (t);
+	}
       ctx.object = object;
       if (object)
 	gcc_assert (same_type_ignoring_top_level_qualifiers_p
@@ -2859,13 +3204,6 @@ is_sub_constant_expr (tree t)
   constexpr_ctx ctx = { NULL, NULL, NULL, NULL };
   hash_map <tree, tree> map;
   ctx.values = &map;
-  tree type = initialized_type (t);
-  if ((AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
-      && TREE_CODE (t) != TARGET_EXPR)
-    {
-      ctx.ctor = build_constructor (type, NULL);
-      CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx.ctor) = true;
-    }
   cxx_eval_constant_expression (&ctx, t, true, false, &non_constant_p,
 				&overflow_p);
   return !non_constant_p && !overflow_p;
@@ -2996,6 +3334,8 @@ maybe_constant_init (tree t, tree decl)
   if (TREE_CODE (t) == CONVERT_EXPR
       && VOID_TYPE_P (TREE_TYPE (t)))
     t = TREE_OPERAND (t, 0);
+  if (TREE_CODE (t) == INIT_EXPR)
+    t = TREE_OPERAND (t, 1);
   t = maybe_constant_value (t, decl);
   if (TREE_CODE (t) == TARGET_EXPR)
     {
@@ -3078,6 +3418,7 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
     case TEMPLATE_ID_EXPR:
     case LABEL_DECL:
     case LABEL_EXPR:
+    case CASE_LABEL_EXPR:
     case CONST_DECL:
     case SIZEOF_EXPR:
     case ALIGNOF_EXPR:
@@ -3091,7 +3432,10 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
     case FIELD_DECL:
     case PARM_DECL:
     case USING_DECL:
+    case USING_STMT:
     case PLACEHOLDER_EXPR:
+    case BREAK_STMT:
+    case CONTINUE_STMT:
       return true;
 
     case AGGR_INIT_EXPR:
@@ -3103,6 +3447,14 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
         const int nargs = call_expr_nargs (t);
 	i = 0;
 
+	if (fun == NULL_TREE)
+	  {
+	    /* fold_call_expr can't do anything with IFN calls.  */
+	    if (flags & tf_error)
+	      error_at (EXPR_LOC_OR_LOC (t, input_location),
+			"call to internal function");
+	    return false;
+	  }
 	if (is_overloaded_fn (fun))
 	  {
 	    if (TREE_CODE (fun) == FUNCTION_DECL)
@@ -3266,20 +3618,85 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
 	return potential_constant_expression_1 (x, rval, flags);
       }
 
+    case STATEMENT_LIST:
+      {
+	tree_stmt_iterator i;
+	for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
+	  {
+	    if (!potential_constant_expression_1 (tsi_stmt (i), any, flags))
+	      return false;
+	  }
+	return true;
+      }
+      break;
+
+    case MODIFY_EXPR:
+      if (cxx_dialect < cxx14)
+	goto fail;
+      if (!potential_constant_expression_1 (TREE_OPERAND (t, 0), any, flags))
+	return false;
+      if (!potential_constant_expression_1 (TREE_OPERAND (t, 1), rval, flags))
+	return false;
+      return true;
+
+    case MODOP_EXPR:
+      if (cxx_dialect < cxx14)
+	goto fail;
+      if (!potential_constant_expression_1 (TREE_OPERAND (t, 0), rval, flags))
+	return false;
+      if (!potential_constant_expression_1 (TREE_OPERAND (t, 2), rval, flags))
+	return false;
+      return true;
+
+    case IF_STMT:
+      if (!potential_constant_expression_1 (IF_COND (t), rval, flags))
+	return false;
+      if (!potential_constant_expression_1 (THEN_CLAUSE (t), any, flags))
+	return false;
+      if (!potential_constant_expression_1 (ELSE_CLAUSE (t), any, flags))
+	return false;
+      return true;
+
+    case DO_STMT:
+      if (!potential_constant_expression_1 (DO_COND (t), rval, flags))
+	return false;
+      if (!potential_constant_expression_1 (DO_BODY (t), any, flags))
+	return false;
+      return true;
+
+    case FOR_STMT:
+      if (!potential_constant_expression_1 (FOR_INIT_STMT (t), any, flags))
+	return false;
+      if (!potential_constant_expression_1 (FOR_COND (t), rval, flags))
+	return false;
+      if (!potential_constant_expression_1 (FOR_EXPR (t), any, flags))
+	return false;
+      if (!potential_constant_expression_1 (FOR_BODY (t), any, flags))
+	return false;
+      return true;
+
+    case WHILE_STMT:
+      if (!potential_constant_expression_1 (WHILE_COND (t), rval, flags))
+	return false;
+      if (!potential_constant_expression_1 (WHILE_BODY (t), any, flags))
+	return false;
+      return true;
+
+    case SWITCH_STMT:
+      if (!potential_constant_expression_1 (SWITCH_STMT_COND (t), rval, flags))
+	return false;
+      if (!potential_constant_expression_1 (SWITCH_STMT_BODY (t), any, flags))
+	return false;
+      return true;
+
     case LAMBDA_EXPR:
     case DYNAMIC_CAST_EXPR:
     case PSEUDO_DTOR_EXPR:
-    case PREINCREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-    case PREDECREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
     case NEW_EXPR:
     case VEC_NEW_EXPR:
     case DELETE_EXPR:
     case VEC_DELETE_EXPR:
     case THROW_EXPR:
-    case MODIFY_EXPR:
-    case MODOP_EXPR:
     case OMP_ATOMIC:
     case OMP_ATOMIC_READ:
     case OMP_ATOMIC_CAPTURE_OLD:
@@ -3287,22 +3704,10 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
       /* GCC internal stuff.  */
     case VA_ARG_EXPR:
     case OBJ_TYPE_REF:
-    case WITH_CLEANUP_EXPR:
-    case CLEANUP_POINT_EXPR:
-    case MUST_NOT_THROW_EXPR:
-    case TRY_CATCH_EXPR:
-    case STATEMENT_LIST:
-      /* Don't bother trying to define a subset of statement-expressions to
-	 be constant-expressions, at least for now.  */
     case STMT_EXPR:
-    case EXPR_STMT:
-    case BIND_EXPR:
     case TRANSACTION_EXPR:
-    case IF_STMT:
-    case DO_STMT:
-    case FOR_STMT:
-    case WHILE_STMT:
-    case DECL_EXPR:
+    case ASM_EXPR:
+    fail:
       if (flags & tf_error)
         error ("expression %qE is not a constant-expression", t);
       return false;
@@ -3355,6 +3760,14 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
       want_rval = true;
       goto binary;
 
+    case PREINCREMENT_EXPR:
+    case POSTINCREMENT_EXPR:
+    case PREDECREMENT_EXPR:
+    case POSTDECREMENT_EXPR:
+      if (cxx_dialect < cxx14)
+	goto fail;
+      goto unary;
+
     case BIT_NOT_EXPR:
       /* A destructor.  */
       if (TYPE_P (TREE_OPERAND (t, 0)))
@@ -3372,6 +3785,7 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
     case TRUTH_NOT_EXPR:
     case FIXED_CONVERT_EXPR:
     case UNARY_PLUS_EXPR:
+    unary:
       return potential_constant_expression_1 (TREE_OPERAND (t, 0), rval,
 					      flags);
 
@@ -3396,7 +3810,18 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
 	      (TREE_OPERAND (t, 0),
 	       TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE, flags));
 
+    case BIND_EXPR:
+      return potential_constant_expression_1 (BIND_EXPR_BODY (t),
+					      want_rval, flags);
+
+    case WITH_CLEANUP_EXPR:
+    case CLEANUP_POINT_EXPR:
+    case MUST_NOT_THROW_EXPR:
+    case TRY_CATCH_EXPR:
+    case EH_SPEC_BLOCK:
+    case EXPR_STMT:
     case PAREN_EXPR:
+    case DECL_EXPR:
     case NON_DEPENDENT_EXPR:
       /* For convenience.  */
     case RETURN_EXPR:
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 54f7e9b..adc8aa7 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -1182,6 +1182,8 @@ struct GTY(()) language_function {
   /* True if this function can throw an exception.  */
   BOOL_BITFIELD can_throw : 1;
 
+  BOOL_BITFIELD invalid_constexpr : 1;
+
   hash_table<named_label_hasher> *x_named_labels;
   cp_binding_level *bindings;
   vec<tree, va_gc> *x_local_names;
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 1f22c26..47da0ca 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -4779,11 +4779,16 @@ start_decl (const cp_declarator *declarator,
   if (current_function_decl && VAR_P (decl)
       && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
     {
+      bool ok = false;
       if (DECL_THREAD_LOCAL_P (decl))
 	error ("%qD declared %<thread_local%> in %<constexpr%> function",
 	       decl);
       else if (TREE_STATIC (decl))
 	error ("%qD declared %<static%> in %<constexpr%> function", decl);
+      else
+	ok = true;
+      if (!ok)
+	cp_function_chain->invalid_constexpr = true;
     }
 
   if (!processing_template_decl && VAR_P (decl))
@@ -5165,9 +5170,12 @@ check_for_uninitialized_const_var (tree decl)
 	permerror (DECL_SOURCE_LOCATION (decl),
 		   "uninitialized const %qD", decl);
       else
-	error_at (DECL_SOURCE_LOCATION (decl),
-		  "uninitialized variable %qD in %<constexpr%> function",
-		  decl);
+	{
+	  error_at (DECL_SOURCE_LOCATION (decl),
+		    "uninitialized variable %qD in %<constexpr%> function",
+		    decl);
+	  cp_function_chain->invalid_constexpr = true;
+	}
 
       if (CLASS_TYPE_P (type))
 	{
@@ -13995,6 +14003,7 @@ maybe_save_function_definition (tree fun)
 {
   if (!processing_template_decl
       && DECL_DECLARED_CONSTEXPR_P (fun)
+      && !cp_function_chain->invalid_constexpr
       && !DECL_CLONED_FUNCTION_P (fun))
     register_constexpr_fundef (fun, DECL_SAVED_TREE (fun));
 }
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 111ec10..3eff5fa 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -11004,7 +11004,10 @@ cp_parser_jump_statement (cp_parser* parser)
     case RID_GOTO:
       if (parser->in_function_body
 	  && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
-	error ("%<goto%> in %<constexpr%> function");
+	{
+	  error ("%<goto%> in %<constexpr%> function");
+	  cp_function_chain->invalid_constexpr = true;
+	}
 
       /* Create the goto-statement.  */
       if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
@@ -16588,7 +16591,10 @@ cp_parser_asm_definition (cp_parser* parser)
 
   if (parser->in_function_body
       && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
-    error ("%<asm%> in %<constexpr%> function");
+    {
+      error ("%<asm%> in %<constexpr%> function");
+      cp_function_chain->invalid_constexpr = true;
+    }
 
   /* See if the next token is `volatile'.  */
   if (cp_parser_allow_gnu_extensions_p (parser)
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-diag5.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-diag5.C
index c8043e3..708f5f2 100644
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-diag5.C
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-diag5.C
@@ -23,20 +23,20 @@ struct C
 
 struct D
 {
-    constexpr D() { return;} // { dg-error "does not have empty body" }
+    constexpr D() { return;} // { dg-error "does not have empty body" "" { target c++11_only } }
 };
 
 struct D1
 {
     A a;
-    constexpr D1() { return;} // { dg-error "does not have empty body" }
+    constexpr D1() { return;} // { dg-error "does not have empty body" "" { target c++11_only } }
 };
 
 struct D2
 {
     A a;
     A b;
-    constexpr D2() { return;} // { dg-error "does not have empty body" }
+    constexpr D2() { return;} // { dg-error "does not have empty body" "" { target c++11_only } }
 };
 
 struct D3
@@ -44,5 +44,5 @@ struct D3
     A a;
     A b;
     A c;
-    constexpr D3() { return;} // { dg-error "does not have empty body" }
+    constexpr D3() { return;} // { dg-error "does not have empty body" "" { target c++11_only } }
 };
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-friend.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-friend.C
index 55a2329..85dfca4 100644
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-friend.C
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-friend.C
@@ -12,12 +12,14 @@ template <class T>
 struct C
 {
   friend constexpr int f(C) { return 0; }
-  friend constexpr int g(C, A) { return 0; } // { dg-error "double" }
+  friend constexpr int g(C, A) { return 0; }
   constexpr int m(C) { return 0; }
-  constexpr int m(A) { return 0; } // { dg-error "double" }
+  constexpr int m(A) { return 0; }
 };
 
 constexpr int i = f(C<int>());
 constexpr int j = C<int>().m(C<int>());
-constexpr int k = C<double>().m(A()); // { dg-error "constexpr" }
-constexpr int l = g(C<double>(),A()); // { dg-error "constexpr" }
+constexpr int k = C<double>().m(A()); // { dg-error "" }
+constexpr int l = g(C<double>(),A()); // { dg-error "" }
+
+// { dg-prune-output "parameter" }
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-function2.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-function2.C
index 8cb32c9..8c51c9d 100644
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-function2.C
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-function2.C
@@ -27,14 +27,14 @@ constexpr void f(int x)       // { dg-error "return type .void" }
 { /* ... */ }
 
 constexpr int prev(int x)
-{ return --x; }               // { dg-error "--" }
+{ return --x; }               // { dg-error "--" "" { target c++11_only } }
 
 constexpr int g(int x, int n) // error: body not just ‘‘return expr’’
 {
    int r = 1;
    while (--n > 0) r *= x;
    return r;
-} // { dg-error "not a return-statement" }
+} // { dg-error "not a return-statement" "" { target c++11_only } }
 
 constexpr int
 bar(int x, int y) { return x + y + x * y; } // { dg-message "previously" }
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-neg1.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-neg1.C
index fb4c012..35f5e8e 100644
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-neg1.C
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-neg1.C
@@ -33,14 +33,14 @@ constexpr void f(int x)		// { dg-error "void" }
 { /* ... */ }
 // error: use of decrement
 constexpr int prev(int x)
-{ return --x; }			// { dg-error "-- x" }
+{ return --x; }			// { dg-error "-- x" "" { target c++11_only } }
 
 // error: body not just return expr
 constexpr int g(int x, int n) {
   int r = 1;
   while (--n > 0) r *= x;
   return r;
-} // { dg-error "body of constexpr function" }
+} // { dg-error "body of constexpr function" "" { target c++11_only } }
 
 class debug_flag {
 public:
diff --git a/gcc/testsuite/g++.dg/cpp1y/constexpr-incr1.C b/gcc/testsuite/g++.dg/cpp1y/constexpr-incr1.C
new file mode 100644
index 0000000..2b099c8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/constexpr-incr1.C
@@ -0,0 +1,13 @@
+// { dg-do compile { target c++14 } }
+
+constexpr int f (int i)
+{
+  ++i;
+  int x = i;
+  ++x;
+  return x;
+}
+
+constexpr int i = f(42);
+#define SA(X) static_assert((X),#X)
+SA(i==44);
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 510b53e..4b937ca 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -5817,3 +5817,55 @@ build_duplicate_type (tree type)
 
   return type;
 }
+
+/* Unshare the entire DECL_SAVED_TREE of FN and return the remapped
+   parameters and RESULT_DECL in PARMS and RESULT.  Used by C++ constexpr
+   evaluation.  */
+
+tree
+copy_fn (tree fn, tree& parms, tree& result)
+{
+  copy_body_data id;
+  tree param;
+  hash_map<tree, tree> decl_map;
+
+  tree *p = &parms;
+  *p = NULL_TREE;
+
+  memset (&id, 0, sizeof (id));
+  id.src_fn = fn;
+  id.dst_fn = current_function_decl;
+  id.src_cfun = DECL_STRUCT_FUNCTION (fn);
+  id.decl_map = &decl_map;
+
+  id.copy_decl = copy_decl_no_change;
+  id.transform_call_graph_edges = CB_CGE_DUPLICATE;
+  id.transform_new_cfg = false;
+  id.transform_return_to_modify = false;
+  id.transform_parameter = true;
+  id.transform_lang_insert_block = NULL;
+
+  /* Make sure not to unshare trees behind the front-end's back
+     since front-end specific mechanisms may rely on sharing.  */
+  id.regimplify = false;
+  id.do_not_unshare = true;
+
+  /* We're not inside any EH region.  */
+  id.eh_lp_nr = 0;
+
+  /* Remap the parameters and result and return them to the caller.  */
+  for (param = DECL_ARGUMENTS (fn);
+       param;
+       param = DECL_CHAIN (param))
+    {
+      *p = remap_decl (param, &id);
+      p = &DECL_CHAIN (*p);
+    }
+
+  if (DECL_RESULT (fn))
+    result = remap_decl (DECL_RESULT (fn), &id);
+  else
+    result = NULL_TREE;
+
+  return copy_tree_body (&id);
+}
diff --git a/gcc/tree-inline.h b/gcc/tree-inline.h
index 9eb75c7..9d70e3e 100644
--- a/gcc/tree-inline.h
+++ b/gcc/tree-inline.h
@@ -209,6 +209,7 @@ extern tree remap_decl (tree decl, copy_body_data *id);
 extern tree remap_type (tree type, copy_body_data *id);
 extern gimple_seq copy_gimple_seq_and_replace_locals (gimple_seq seq);
 extern bool debug_find_tree (tree, tree);
+extern tree copy_fn (tree, tree&, tree&);
 
 /* This is in tree-inline.c since the routine uses
    data structures from the inliner.  */