This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: RFA (tree-inline): PATCH for more C++14 constexpr support
- From: Jason Merrill <jason at redhat dot com>
- To: Richard Biener <richard dot guenther at gmail dot com>
- Cc: gcc-patches List <gcc-patches at gcc dot gnu dot org>
- Date: Mon, 17 Nov 2014 13:15:04 -0500
- Subject: Re: RFA (tree-inline): PATCH for more C++14 constexpr support
- Authentication-results: sourceware.org; auth=none
- References: <54682F1E dot 3080307 at redhat dot com> <CAFiYyc0W7+F9=bWGUkceZhW1C=pUVVbxzH++HzXBNUR=-S5_jA at mail dot gmail dot com>
On 11/17/2014 05:29 AM, Richard Biener wrote:
can you rename it to copy_fn please? It really copies parameter and
result and then the body.
Ok with that change.
Done. Here's what I'm checking in, along with a second patch to enable
the new code for C++11 as well:
commit 71b7bdd54c7bf0734336a3e80989b07a81f0c201
Author: Jason Merrill <jason@redhat.com>
Date: Sat Nov 15 10:46:55 2014 -0500
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.
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 = ↦
- 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. */
commit e52e82e56507d1de1932abcafd80683c4dc00d1e
Author: Jason Merrill <jason@redhat.com>
Date: Sun Nov 16 17:14:12 2014 -0500
* constexpr.c (use_new_call): Always use new call handling.
diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index 57d0c46..8881271 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -1021,8 +1021,8 @@ adjust_temp_type (tree type, tree 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)
+ DECL_SAVED_TREE. */
+#define use_new_call true
/* Subroutine of cxx_eval_call_expression.
We are processing a call expression (either CALL_EXPR or