1 files changed, 55 insertions, 41 deletions

diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc
index 8a11e62..7078839 100644
--- a/gcc/cp/constexpr.cc
+++ b/gcc/cp/constexpr.cc
@@ -1110,17 +1110,14 @@ explain_invalid_constexpr_fn (tree fun)
 	    body = fd->body;
 	  else
 	    body = DECL_SAVED_TREE (fun);
-	  body = massage_constexpr_body (fun, body);
-	  require_potential_rvalue_constant_expression (body);
+	  tree massaged = massage_constexpr_body (fun, body);
+	  require_potential_rvalue_constant_expression (massaged);
 	  if (DECL_CONSTRUCTOR_P (fun))
 	    {
-	      cx_check_missing_mem_inits (DECL_CONTEXT (fun), body, true);
+	      cx_check_missing_mem_inits (DECL_CONTEXT (fun), massaged, true);
 	      if (cxx_dialect > cxx11)
-		{
-		  /* Also check the body, not just the ctor-initializer.  */
-		  body = DECL_SAVED_TREE (fun);
-		  require_potential_rvalue_constant_expression (body);
-		}
+		/* Also check the body, not just the ctor-initializer.  */
+		require_potential_rvalue_constant_expression (body);
 	    }
 	}
     }
@@ -1550,7 +1547,6 @@ static tree cxx_eval_bare_aggregate (const constexpr_ctx *, tree,
 static tree cxx_fold_indirect_ref (const constexpr_ctx *, location_t, tree, tree,
 				   bool * = NULL);
 static tree find_heap_var_refs (tree *, int *, void *);
-static tree find_deleted_heap_var (tree *, int *, void *);
 
 /* Attempt to evaluate T which represents a call to a builtin function.
    We assume here that all builtin functions evaluate to scalar types
@@ -2975,14 +2971,6 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
 				     : heap_uninit_identifier,
 				     type);
 	      DECL_ARTIFICIAL (var) = 1;
-	      TREE_STATIC (var) = 1;
-	      // Temporarily register the artificial var in varpool,
-	      // so that comparisons of its address against NULL are folded
-	      // through nonzero_address even with
-	      // -fno-delete-null-pointer-checks or that comparison of
-	      // addresses of different heap artificial vars is folded too.
-	      // See PR98988 and PR99031.
-	      varpool_node::finalize_decl (var);
 	      ctx->global->heap_vars.safe_push (var);
 	      ctx->global->put_value (var, NULL_TREE);
 	      return fold_convert (ptr_type_node, build_address (var));
@@ -3454,11 +3442,6 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
 		      cacheable = false;
 		      break;
 		    }
-	      /* And don't cache a ref to a deleted heap variable (119162).  */
-	      if (cacheable
-		  && (cp_walk_tree_without_duplicates
-		      (&result, find_deleted_heap_var, NULL)))
-		cacheable = false;
 	    }
 
 	    /* Rewrite all occurrences of the function's RESULT_DECL with the
@@ -3546,6 +3529,9 @@ reduced_constant_expression_p (tree t)
       /* Even if we can't lower this yet, it's constant.  */
       return true;
 
+    case OMP_DECLARE_MAPPER:
+      return true;
+
     case CONSTRUCTOR:
       /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR.  */
       tree field;
@@ -6427,7 +6413,8 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
 
   if (TREE_CLOBBER_P (init)
       && CLOBBER_KIND (init) < CLOBBER_OBJECT_END)
-    /* Only handle clobbers ending the lifetime of objects.  */
+    /* Only handle clobbers ending the lifetime of objects.
+       ??? We should probably set CONSTRUCTOR_NO_CLEARING.  */
     return void_node;
 
   /* First we figure out where we're storing to.  */
@@ -7855,6 +7842,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
     case LABEL_EXPR:
     case CASE_LABEL_EXPR:
     case PREDICT_EXPR:
+    case OMP_DECLARE_MAPPER:
       return t;
 
     case PARM_DECL:
@@ -9025,20 +9013,6 @@ find_heap_var_refs (tree *tp, int *walk_subtrees, void */*data*/)
   return NULL_TREE;
 }
 
-/* Look for deleted heap variables in the expression *TP.  */
-
-static tree
-find_deleted_heap_var (tree *tp, int *walk_subtrees, void */*data*/)
-{
-  if (VAR_P (*tp)
-      && DECL_NAME (*tp) == heap_deleted_identifier)
-    return *tp;
-
-  if (TYPE_P (*tp))
-    *walk_subtrees = 0;
-  return NULL_TREE;
-}
-
 /* Find immediate function decls in *TP if any.  */
 
 static tree
@@ -9275,7 +9249,6 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
 	      r = t;
 	      non_constant_p = true;
 	    }
-	  varpool_node::get (heap_var)->remove ();
 	}
     }
 
@@ -9306,8 +9279,7 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
 
   /* After verify_constant because reduced_constant_expression_p can unset
      CONSTRUCTOR_NO_CLEARING.  */
-  if (!non_constant_p
-      && TREE_CODE (r) == CONSTRUCTOR && CONSTRUCTOR_NO_CLEARING (r))
+  if (TREE_CODE (r) == CONSTRUCTOR && CONSTRUCTOR_NO_CLEARING (r))
     {
       if (!allow_non_constant)
 	error ("%qE is not a constant expression because it refers to "
@@ -9516,8 +9488,35 @@ tree
 maybe_constant_value (tree t, tree decl /* = NULL_TREE */,
 		      mce_value manifestly_const_eval /* = mce_unknown */)
 {
+  tree orig_t = t;
   tree r;
 
+  if (EXPR_P (t) && manifestly_const_eval == mce_unknown)
+    {
+      /* Look up each operand in the cv_cache first to see if we've already
+	 reduced it, and reuse that result to avoid quadratic behavior if
+	 we're called when building up a large expression.  */
+      int n = cp_tree_operand_length (t);
+      tree *ops = XALLOCAVEC (tree, n);
+      bool rebuild = false;
+      for (int i = 0; i < n; ++i)
+	{
+	  ops[i] = TREE_OPERAND (t, i);
+	  if (tree *cached = hash_map_safe_get (cv_cache, ops[i]))
+	    if (*cached != ops[i])
+	      {
+		ops[i] = *cached;
+		rebuild = true;
+	      }
+	}
+      if (rebuild)
+	{
+	  t = copy_node (t);
+	  for (int i = 0; i < n; ++i)
+	    TREE_OPERAND (t, i) = ops[i];
+	}
+    }
+
   if (!is_nondependent_constant_expression (t))
     {
       if (TREE_OVERFLOW_P (t)
@@ -9535,6 +9534,10 @@ maybe_constant_value (tree t, tree decl /* = NULL_TREE */,
     return fold_to_constant (t);
 
   if (manifestly_const_eval != mce_unknown)
+    /* TODO: Extend the cache to be mce_value aware.  And if we have a
+       previously cached mce_unknown result that's TREE_CONSTANT, it means
+       the reduced value is independent of mce_value and so we should
+       be able to reuse it in the mce_true/false case.  */
     return cxx_eval_outermost_constant_expr (t, true, true,
 					     manifestly_const_eval, false, decl);
 
@@ -9564,7 +9567,7 @@ maybe_constant_value (tree t, tree decl /* = NULL_TREE */,
 		       || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
 		       || !cp_tree_equal (r, t));
   if (!c.evaluation_restricted_p ())
-    cv_cache->put (t, r);
+    cv_cache->put (orig_t, r);
   return r;
 }
 
@@ -10564,6 +10567,11 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,
 			  "expression", t);
       return false;
 
+    case OMP_DECLARE_MAPPER:
+      /* This can be used to initialize VAR_DECLs: it's treated as a magic
+	 constant.  */
+      return true;
+
     case ASM_EXPR:
       if (flags & tf_error)
 	inline_asm_in_constexpr_error (loc, fundef_p);
@@ -11011,6 +11019,9 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,
 	    *jump_target = *target;
 	    return true;
 	  }
+	if (DECL_ARTIFICIAL (*target))
+	  /* The user didn't write this goto, this isn't the problem.  */
+	  return true;
 	if (flags & tf_error)
 	  constexpr_error (loc, fundef_p, "%<goto%> is not a constant "
 			   "expression");
@@ -11044,6 +11055,9 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,
     case CO_AWAIT_EXPR:
     case CO_YIELD_EXPR:
     case CO_RETURN_EXPR:
+      if (flags & tf_error)
+	constexpr_error (cp_expr_loc_or_loc (t, input_location), fundef_p,
+			 "%qE is not a constant expression", t);
       return false;
 
     /* Assume a TU-local entity is not constant, we'll error later when