OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

constexpr.c (struct constexpr_ctx): Add quiet field. 

* constexpr.c (struct constexpr_ctx): Add quiet field.
	(cxx_eval_outermost_constant_expr, is_sub_constant_expr): Set it.
	(lots): Replace allow_non_constant parameter with ctx->quiet.

From-SVN: r217746
This commit is contained in:
Jason Merrill 2014-11-18 22:03:28 -05:00 committed by Jason Merrill
parent 643266a5a5
commit 2b3ab879c7
2 changed files with 124 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gcc/cp/ChangeLog
View File

@ -1,5 +1,9 @@
2014-11-18 Jason Merrill <jason@redhat.com>
* constexpr.c (struct constexpr_ctx): Add quiet field.
(cxx_eval_outermost_constant_expr, is_sub_constant_expr): Set it.
(lots): Replace allow_non_constant parameter with ctx->quiet.
PR c++/63940
* constexpr.c (cxx_eval_binary_expression): Don't assume the
expression was already folded.

244
gcc/cp/constexpr.c
View File

@ -36,7 +36,7 @@ along with GCC; see the file COPYING3. If not see
static bool verify_constant (tree, bool, bool *, bool *);
#define VERIFY_CONSTANT(X) \
do { \
if (verify_constant ((X), allow_non_constant, non_constant_p, overflow_p)) \
if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
return t; \
} while (0)
@ -863,6 +863,7 @@ struct constexpr_ctx {
hash_map<tree,tree> *values;
tree ctor;
tree object;
bool quiet;
};
/* A table of all constexpr calls that have been evaluated by the
@ -871,7 +872,7 @@ struct constexpr_ctx {
static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
bool, bool, bool *, bool *, tree *);
bool, bool *, bool *, tree *);
/* Compute a hash value for a constexpr call representation. */
@ -982,7 +983,7 @@ lookup_parameter_binding (const constexpr_call *call, tree t)
static tree
cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
const int nargs = call_expr_nargs (t);
@ -992,10 +993,10 @@ cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t,
for (i = 0; i < nargs; ++i)
{
args[i] = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, i),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
NULL);
if (allow_non_constant && *non_constant_p)
if (ctx->quiet && *non_constant_p)
return t;
}
if (*non_constant_p)
@ -1034,7 +1035,6 @@ adjust_temp_type (tree type, tree temp)
static void
cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
constexpr_call *new_call,
bool allow_non_constant,
bool *non_constant_p, bool *overflow_p)
{
const int nargs = call_expr_nargs (t);
@ -1067,11 +1067,11 @@ cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
type = TREE_TYPE (type);
x = convert_from_reference (x);
}
arg = cxx_eval_constant_expression (ctx, x, allow_non_constant,
arg = cxx_eval_constant_expression (ctx, x,
TREE_CODE (type) == REFERENCE_TYPE,
non_constant_p, overflow_p, NULL);
/* Don't VERIFY_CONSTANT here. */
if (*non_constant_p && allow_non_constant)
if (*non_constant_p && ctx->quiet)
return;
/* Just discard ellipsis args after checking their constantitude. */
if (!parms)
@ -1134,7 +1134,7 @@ cx_error_context (void)
static tree
cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
location_t loc = EXPR_LOC_OR_LOC (t, input_location);
@ -1148,7 +1148,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
if (TREE_CODE (fun) != FUNCTION_DECL)
{
/* Might be a constexpr function pointer. */
fun = cxx_eval_constant_expression (ctx, fun, allow_non_constant,
fun = cxx_eval_constant_expression (ctx, fun,
/*addr*/false, non_constant_p,
overflow_p, NULL);
STRIP_NOPS (fun);
@ -1157,7 +1157,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
}
if (TREE_CODE (fun) != FUNCTION_DECL)
{
if (!allow_non_constant && !*non_constant_p)
if (!ctx->quiet && !*non_constant_p)
error_at (loc, "expression %qE does not designate a constexpr "
"function", fun);
*non_constant_p = true;
@ -1166,11 +1166,11 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
if (DECL_CLONED_FUNCTION_P (fun))
fun = DECL_CLONED_FUNCTION (fun);
if (is_builtin_fn (fun))
return cxx_eval_builtin_function_call (ctx, t, allow_non_constant,
return cxx_eval_builtin_function_call (ctx, t,
addr, non_constant_p, overflow_p);
if (!DECL_DECLARED_CONSTEXPR_P (fun))
{
if (!allow_non_constant)
if (!ctx->quiet)
{
error_at (loc, "call to non-constexpr function %qD", fun);
explain_invalid_constexpr_fn (fun);
@ -1185,7 +1185,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
if (call_expr_nargs (t) == 2)
{
tree arg = convert_from_reference (get_nth_callarg (t, 1));
return cxx_eval_constant_expression (ctx, arg, allow_non_constant,
return cxx_eval_constant_expression (ctx, arg,
addr, non_constant_p,
overflow_p, NULL);
}
@ -1202,7 +1202,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
new_call.fundef = retrieve_constexpr_fundef (fun);
if (new_call.fundef == NULL || new_call.fundef->body == NULL)
{
if (!allow_non_constant)
if (!ctx->quiet)
{
if (DECL_INITIAL (fun))
{
@ -1232,7 +1232,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
}
cxx_bind_parameters_in_call (ctx, t, &new_call,
allow_non_constant, non_constant_p, overflow_p);
non_constant_p, overflow_p);
if (*non_constant_p)
return t;
@ -1257,7 +1257,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
so that we can detect circular dependencies. */
else if (entry->result == NULL)
{
if (!allow_non_constant)
if (!ctx->quiet)
error ("call has circular dependency");
*non_constant_p = true;
entry->result = result = error_mark_node;
@ -1265,7 +1265,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
if (!depth_ok)
{
if (!allow_non_constant)
if (!ctx->quiet)
error ("constexpr evaluation depth exceeds maximum of %d (use "
"-fconstexpr-depth= to increase the maximum)",
max_constexpr_depth);
@ -1282,7 +1282,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
new_ctx.call = &new_call;
result = (cxx_eval_constant_expression
(&new_ctx, new_call.fundef->body,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL));
}
else
@ -1324,7 +1324,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
ctx->values->put (res, NULL_TREE);
tree jump_target = NULL_TREE;
cxx_eval_constant_expression (ctx, body, allow_non_constant,
cxx_eval_constant_expression (ctx, body,
addr, non_constant_p, overflow_p,
&jump_target);
@ -1340,7 +1340,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
result = *ctx->values->get (slot ? slot : res);
if (result == NULL_TREE)
{
if (!allow_non_constant)
if (!ctx->quiet)
error ("constexpr call flows off the end "
"of the function");
*non_constant_p = true;
@ -1452,12 +1452,12 @@ verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
static tree
cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
tree r;
tree orig_arg = TREE_OPERAND (t, 0);
tree arg = cxx_eval_constant_expression (ctx, orig_arg, allow_non_constant,
tree arg = cxx_eval_constant_expression (ctx, orig_arg,
addr, non_constant_p, overflow_p,
NULL);
VERIFY_CONSTANT (arg);
@ -1481,7 +1481,7 @@ cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
tree r;
@ -1489,11 +1489,11 @@ cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
tree orig_rhs = TREE_OPERAND (t, 1);
tree lhs, rhs;
lhs = cxx_eval_constant_expression (ctx, orig_lhs,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
VERIFY_CONSTANT (lhs);
rhs = cxx_eval_constant_expression (ctx, orig_rhs,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
VERIFY_CONSTANT (rhs);
@ -1518,23 +1518,23 @@ cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p,
tree *jump_target)
{
tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
NULL);
VERIFY_CONSTANT (val);
/* Don't VERIFY_CONSTANT the other operands. */
if (integer_zerop (val))
return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
jump_target);
return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
jump_target);
}
@ -1544,12 +1544,12 @@ cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
tree oldary = TREE_OPERAND (t, 0);
tree ary = cxx_eval_constant_expression (ctx, oldary,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
tree index, oldidx;
HOST_WIDE_INT i;
@ -1559,7 +1559,7 @@ cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
return t;
oldidx = TREE_OPERAND (t, 1);
index = cxx_eval_constant_expression (ctx, oldidx,
allow_non_constant, false,
false,
non_constant_p, overflow_p, NULL);
VERIFY_CONSTANT (index);
if (addr && ary == oldary && index == oldidx)
@ -1590,19 +1590,19 @@ cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
initializer, it's value-initialized. */
tree val = build_value_init (elem_type, tf_warning_or_error);
return cxx_eval_constant_expression (ctx, val,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
NULL);
}
if (!allow_non_constant)
if (!ctx->quiet)
error ("array subscript out of bound");
*non_constant_p = true;
return t;
}
else if (tree_int_cst_lt (index, integer_zero_node))
{
if (!allow_non_constant)
if (!ctx->quiet)
error ("negative array subscript");
*non_constant_p = true;
return t;
@ -1628,7 +1628,7 @@ cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
unsigned HOST_WIDE_INT i;
@ -1637,7 +1637,7 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
tree part = TREE_OPERAND (t, 1);
tree orig_whole = TREE_OPERAND (t, 0);
tree whole = cxx_eval_constant_expression (ctx, orig_whole,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
if (whole == orig_whole)
return t;
@ -1648,13 +1648,13 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
CONSTRUCTOR. */
if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
{
if (!allow_non_constant)
if (!ctx->quiet)
error ("%qE is not a constant expression", orig_whole);
*non_constant_p = true;
}
if (DECL_MUTABLE_P (part))
{
if (!allow_non_constant)
if (!ctx->quiet)
error ("mutable %qD is not usable in a constant expression", part);
*non_constant_p = true;
}
@ -1675,7 +1675,7 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
&& CONSTRUCTOR_NELTS (whole) > 0)
{
/* DR 1188 says we don't have to deal with this. */
if (!allow_non_constant)
if (!ctx->quiet)
error ("accessing %qD member instead of initialized %qD member in "
"constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
*non_constant_p = true;
@ -1687,7 +1687,7 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
/* 'whole' is part of the aggregate initializer we're currently
building; if there's no initializer for this member yet, that's an
error. */
if (!allow_non_constant)
if (!ctx->quiet)
error ("accessing uninitialized member %qD", part);
*non_constant_p = true;
return t;
@ -1696,7 +1696,7 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
/* If there's no explicit init for this field, it's value-initialized. */
value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
return cxx_eval_constant_expression (ctx, value,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
}
@ -1706,7 +1706,7 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
tree orig_whole = TREE_OPERAND (t, 0);
@ -1714,7 +1714,7 @@ cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
bool fld_seen = false;
HOST_WIDE_INT istart, isize;
tree whole = cxx_eval_constant_expression (ctx, orig_whole,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
tree start, field, value;
unsigned HOST_WIDE_INT i;
@ -1727,7 +1727,7 @@ cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
&& TREE_CODE (whole) != VECTOR_CST
&& TREE_CODE (whole) != CONSTRUCTOR)
{
if (!allow_non_constant)
if (!ctx->quiet)
error ("%qE is not a constant expression", orig_whole);
*non_constant_p = true;
}
@ -1792,19 +1792,19 @@ cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
tree bailout_value, tree continue_value,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
tree r;
tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
VERIFY_CONSTANT (lhs);
if (tree_int_cst_equal (lhs, bailout_value))
return lhs;
gcc_assert (tree_int_cst_equal (lhs, continue_value));
r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
allow_non_constant, addr, non_constant_p,
addr, non_constant_p,
overflow_p, NULL);
VERIFY_CONSTANT (r);
return r;
@ -1926,7 +1926,7 @@ verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
static tree
cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
@ -1947,11 +1947,11 @@ cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
initializers can refer to it. */
CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor);
tree elt = cxx_eval_constant_expression (&new_ctx, value,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
NULL);
/* Don't VERIFY_CONSTANT here. */
if (allow_non_constant && *non_constant_p)
if (ctx->quiet && *non_constant_p)
break;
if (elt != value)
changed = true;
@ -2007,7 +2007,7 @@ cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
bool value_init, bool allow_non_constant, bool addr,
bool value_init, bool addr,
bool *non_constant_p, bool *overflow_p)
{
tree elttype = TREE_TYPE (atype);
@ -2058,7 +2058,7 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
eltinit = cp_build_array_ref (input_location, init, idx,
tf_warning_or_error);
eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p);
}
else if (pre_init)
@ -2066,7 +2066,7 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
/* Initializing an element using value or default initialization
we just pre-built above. */
eltinit = (cxx_eval_constant_expression
(&new_ctx, init, allow_non_constant,
(&new_ctx, init,
addr, non_constant_p, overflow_p, NULL));
}
else
@ -2080,10 +2080,10 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
eltinit = move (eltinit);
eltinit = force_rvalue (eltinit, tf_warning_or_error);
eltinit = (cxx_eval_constant_expression
(&new_ctx, eltinit, allow_non_constant, addr,
(&new_ctx, eltinit, addr,
non_constant_p, overflow_p, NULL));
}
if (*non_constant_p && !allow_non_constant)
if (*non_constant_p && !ctx->quiet)
break;
if (new_ctx.ctor != ctx->ctor)
{
@ -2105,14 +2105,14 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
static tree
cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
tree atype = TREE_TYPE (t);
tree init = VEC_INIT_EXPR_INIT (t);
tree r = cxx_eval_vec_init_1 (ctx, atype, init,
VEC_INIT_EXPR_VALUE_INIT (t),
allow_non_constant, addr, non_constant_p, overflow_p);
addr, non_constant_p, overflow_p);
if (*non_constant_p)
return t;
else
@ -2312,11 +2312,11 @@ cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
static tree
cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
tree orig_op0 = TREE_OPERAND (t, 0);
tree op0 = cxx_eval_constant_expression (ctx, orig_op0, allow_non_constant,
tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
/*addr*/false, non_constant_p,
overflow_p, NULL);
bool empty_base = false;
@ -2330,7 +2330,7 @@ cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
&empty_base);
if (r)
r = cxx_eval_constant_expression (ctx, r, allow_non_constant,
r = cxx_eval_constant_expression (ctx, r,
addr, non_constant_p, overflow_p, NULL);
else
{
@ -2343,7 +2343,7 @@ cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
gcc_assert (!same_type_ignoring_top_level_qualifiers_p
(TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
/* DR 1188 says we don't have to deal with this. */
if (!allow_non_constant)
if (!ctx->quiet)
error ("accessing value of %qE through a %qT glvalue in a "
"constant expression", build_fold_indirect_ref (sub),
TREE_TYPE (t));
@ -2422,7 +2422,7 @@ non_const_var_error (tree r)
static tree
cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
int i;
@ -2432,7 +2432,7 @@ cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
for (i = 0; i < 3; i++)
{
args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
NULL);
VERIFY_CONSTANT (args[i]);
@ -2458,7 +2458,7 @@ var_in_constexpr_fn (tree t)
static tree
cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
constexpr_ctx new_ctx = *ctx;
@ -2466,7 +2466,7 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
/* 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,
true,
non_constant_p, overflow_p, NULL);
if (*non_constant_p)
return t;
@ -2499,7 +2499,7 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
{
/* A constant-expression cannot modify objects from outside the
constant-expression. */
if (!allow_non_constant)
if (!ctx->quiet)
error ("modification of %qD is not a constant-expression", object);
*non_constant_p = true;
return t;
@ -2542,7 +2542,7 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
}
tree init = cxx_eval_constant_expression (&new_ctx, TREE_OPERAND (t, 1),
allow_non_constant, false,
false,
non_constant_p, overflow_p, NULL);
if (target == object)
/* The hash table might have moved since the get earlier. */
@ -2562,7 +2562,7 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p)
{
enum tree_code code = TREE_CODE (t);
@ -2572,12 +2572,12 @@ cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
gcc_assert (TREE_CONSTANT (offset));
/* The operand as an lvalue. */
op = cxx_eval_constant_expression (ctx, op, allow_non_constant, true,
op = cxx_eval_constant_expression (ctx, op, true,
non_constant_p, overflow_p, NULL);
/* The operand as an rvalue. */
tree val = rvalue (op);
val = cxx_eval_constant_expression (ctx, val, allow_non_constant, false,
val = cxx_eval_constant_expression (ctx, val, false,
non_constant_p, overflow_p, NULL);
VERIFY_CONSTANT (val);
@ -2598,7 +2598,7 @@ cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
/* Storing the modified value. */
tree store = build2 (MODIFY_EXPR, type, op, mod);
cxx_eval_constant_expression (ctx, store, allow_non_constant,
cxx_eval_constant_expression (ctx, store,
true, non_constant_p, overflow_p, NULL);
/* And the value of the expression. */
@ -2686,7 +2686,6 @@ label_matches (tree *jump_target, tree_stmt_iterator i,
static tree
cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
bool allow_non_constant,
bool *non_constant_p, bool *overflow_p,
tree *jump_target)
{
@ -2707,7 +2706,7 @@ cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
continue;
}
cxx_eval_constant_expression (ctx, stmt,
allow_non_constant, false,
false,
non_constant_p, overflow_p,
jump_target);
if (*non_constant_p)
@ -2729,14 +2728,13 @@ cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t,
bool allow_non_constant,
bool *non_constant_p, bool *overflow_p,
tree *jump_target)
{
tree body = TREE_OPERAND (t, 0);
while (true)
{
cxx_eval_statement_list (ctx, body, allow_non_constant,
cxx_eval_statement_list (ctx, body,
non_constant_p, overflow_p, jump_target);
if (returns (jump_target) || breaks (jump_target))
break;
@ -2751,18 +2749,17 @@ cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t,
bool allow_non_constant,
bool *non_constant_p, bool *overflow_p,
tree *jump_target)
{
tree cond = TREE_OPERAND (t, 0);
cond = cxx_eval_constant_expression (ctx, cond, allow_non_constant, false,
cond = cxx_eval_constant_expression (ctx, cond, false,
non_constant_p, overflow_p, NULL);
VERIFY_CONSTANT (cond);
*jump_target = cond;
tree body = TREE_OPERAND (t, 1);
cxx_eval_statement_list (ctx, body, allow_non_constant,
cxx_eval_statement_list (ctx, body,
non_constant_p, overflow_p, jump_target);
if (breaks (jump_target) || switches (jump_target))
*jump_target = NULL_TREE;
@ -2776,7 +2773,7 @@ cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t,
static tree
cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
bool allow_non_constant, bool addr,
bool addr,
bool *non_constant_p, bool *overflow_p,
tree *jump_target)
{
@ -2792,7 +2789,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
{
if (TREE_CODE (t) == PTRMEM_CST)
t = cplus_expand_constant (t);
else if (TREE_OVERFLOW (t) && (!flag_permissive || allow_non_constant))
else if (TREE_OVERFLOW (t) && (!flag_permissive || ctx->quiet))
*overflow_p = true;
return t;
}
@ -2824,7 +2821,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
r = *p;
if (DECL_P (r))
{
if (!allow_non_constant)
if (!ctx->quiet)
non_const_var_error (r);
*non_constant_p = true;
}
@ -2849,7 +2846,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
/* Defer in case this is only used for its type. */;
else
{
if (!allow_non_constant)
if (!ctx->quiet)
error ("%qE is not a constant expression", t);
*non_constant_p = true;
}
@ -2857,7 +2854,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case CALL_EXPR:
case AGGR_INIT_EXPR:
r = cxx_eval_call_expression (ctx, t, allow_non_constant, addr,
r = cxx_eval_call_expression (ctx, t, addr,
non_constant_p, overflow_p);
break;
@ -2878,7 +2875,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
if (tree init = DECL_INITIAL (r))
{
init = cxx_eval_constant_expression (ctx, init,
allow_non_constant, false,
false,
non_constant_p, overflow_p,
NULL);
ctx->values->put (r, init);
@ -2893,7 +2890,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case TARGET_EXPR:
if (!literal_type_p (TREE_TYPE (t)))
{
if (!allow_non_constant)
if (!ctx->quiet)
{
error ("temporary of non-literal type %qT in a "
"constant expression", TREE_TYPE (t));
@ -2917,7 +2914,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
/* 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,
false,
non_constant_p, overflow_p, NULL);
if (!*non_constant_p)
/* Adjust the type of the result to the type of the temporary. */
@ -2930,25 +2927,25 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
/* 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,
false,
non_constant_p, overflow_p, NULL);
break;
}
/* else fall through */
case MODIFY_EXPR:
r = cxx_eval_store_expression (ctx, t, allow_non_constant, addr,
r = cxx_eval_store_expression (ctx, t, addr,
non_constant_p, overflow_p);
break;
case SCOPE_REF:
r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
break;
case RETURN_EXPR:
r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p, NULL);
*jump_target = t;
break;
@ -2961,7 +2958,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case EXPR_STMT:
case EH_SPEC_BLOCK:
r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
jump_target);
break;
@ -2970,7 +2967,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
check for a constant operand or result; an address can be
constant without its operand being, and vice versa. */
case INDIRECT_REF:
r = cxx_eval_indirect_ref (ctx, t, allow_non_constant, addr,
r = cxx_eval_indirect_ref (ctx, t, addr,
non_constant_p, overflow_p);
break;
@ -2978,7 +2975,6 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
{
tree oldop = TREE_OPERAND (t, 0);
tree op = cxx_eval_constant_expression (ctx, oldop,
allow_non_constant,
/*addr*/true,
non_constant_p, overflow_p,
NULL);
@ -3002,7 +2998,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case BIT_NOT_EXPR:
case TRUTH_NOT_EXPR:
case FIXED_CONVERT_EXPR:
r = cxx_eval_unary_expression (ctx, t, allow_non_constant, addr,
r = cxx_eval_unary_expression (ctx, t, addr,
non_constant_p, overflow_p);
break;
@ -3031,17 +3027,17 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
STRIP_NOPS (op1);
if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
|| TREE_CODE (op1) == EMPTY_CLASS_EXPR)
r = cxx_eval_constant_expression (ctx, op0, allow_non_constant,
r = cxx_eval_constant_expression (ctx, op0,
addr, non_constant_p, overflow_p,
jump_target);
else
{
/* Check that the LHS is constant and then discard it. */
cxx_eval_constant_expression (ctx, op0, allow_non_constant,
cxx_eval_constant_expression (ctx, op0,
false, non_constant_p, overflow_p,
jump_target);
op1 = TREE_OPERAND (t, 1);
r = cxx_eval_constant_expression (ctx, op1, allow_non_constant,
r = cxx_eval_constant_expression (ctx, op1,
addr, non_constant_p, overflow_p,
jump_target);
}
@ -3087,7 +3083,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case LTGT_EXPR:
case RANGE_EXPR:
case COMPLEX_EXPR:
r = cxx_eval_binary_expression (ctx, t, allow_non_constant, addr,
r = cxx_eval_binary_expression (ctx, t, addr,
non_constant_p, overflow_p);
break;
@ -3097,7 +3093,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case TRUTH_ANDIF_EXPR:
r = cxx_eval_logical_expression (ctx, t, boolean_false_node,
boolean_true_node,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p);
break;
@ -3105,12 +3101,12 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case TRUTH_ORIF_EXPR:
r = cxx_eval_logical_expression (ctx, t, boolean_true_node,
boolean_false_node,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p);
break;
case ARRAY_REF:
r = cxx_eval_array_reference (ctx, t, allow_non_constant, addr,
r = cxx_eval_array_reference (ctx, t, addr,
non_constant_p, overflow_p);
break;
@ -3121,28 +3117,28 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
build_non_dependent_expr, because any expression that
calls or takes the address of the function will have
pulled a FUNCTION_DECL out of the COMPONENT_REF. */
gcc_checking_assert (allow_non_constant || errorcount);
gcc_checking_assert (ctx->quiet || errorcount);
*non_constant_p = true;
return t;
}
r = cxx_eval_component_reference (ctx, t, allow_non_constant, addr,
r = cxx_eval_component_reference (ctx, t, addr,
non_constant_p, overflow_p);
break;
case BIT_FIELD_REF:
r = cxx_eval_bit_field_ref (ctx, t, allow_non_constant, addr,
r = cxx_eval_bit_field_ref (ctx, t, addr,
non_constant_p, overflow_p);
break;
case COND_EXPR:
case VEC_COND_EXPR:
r = cxx_eval_conditional_expression (ctx, t, allow_non_constant, addr,
r = cxx_eval_conditional_expression (ctx, t, addr,
non_constant_p, overflow_p,
jump_target);
break;
case CONSTRUCTOR:
r = cxx_eval_bare_aggregate (ctx, t, allow_non_constant, addr,
r = cxx_eval_bare_aggregate (ctx, t, addr,
non_constant_p, overflow_p);
break;
@ -3152,13 +3148,13 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
be NULL, meaning default-initialization, or it will be an lvalue
or xvalue of the same type, meaning direct-initialization from the
corresponding member. */
r = cxx_eval_vec_init (ctx, t, allow_non_constant, addr,
r = cxx_eval_vec_init (ctx, t, addr,
non_constant_p, overflow_p);
break;
case FMA_EXPR:
case VEC_PERM_EXPR:
r = cxx_eval_trinary_expression (ctx, t, allow_non_constant, addr,
r = cxx_eval_trinary_expression (ctx, t, addr,
non_constant_p, overflow_p);
break;
@ -3168,7 +3164,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
{
tree oldop = TREE_OPERAND (t, 0);
tree op = cxx_eval_constant_expression (ctx, oldop,
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
NULL);
if (*non_constant_p)
@ -3177,7 +3173,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
&& TREE_CODE (op) == INTEGER_CST
&& !integer_zerop (op))
{
if (!allow_non_constant)
if (!ctx->quiet)
error_at (EXPR_LOC_OR_LOC (t, input_location),
"reinterpret_cast from integer to pointer");
*non_constant_p = true;
@ -3204,12 +3200,12 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case STATEMENT_LIST:
new_ctx = *ctx;
new_ctx.ctor = new_ctx.object = NULL_TREE;
return cxx_eval_statement_list (&new_ctx, t, allow_non_constant,
return cxx_eval_statement_list (&new_ctx, t,
non_constant_p, overflow_p, jump_target);
case BIND_EXPR:
return cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (t),
allow_non_constant, addr,
addr,
non_constant_p, overflow_p,
jump_target);
@ -3217,7 +3213,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case POSTINCREMENT_EXPR:
case PREDECREMENT_EXPR:
case POSTDECREMENT_EXPR:
return cxx_eval_increment_expression (ctx, t, allow_non_constant,
return cxx_eval_increment_expression (ctx, t,
addr, non_constant_p, overflow_p);
case LAMBDA_EXPR:
@ -3234,7 +3230,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
case NON_DEPENDENT_EXPR:
case BASELINK:
case OFFSET_REF:
if (!allow_non_constant)
if (!ctx->quiet)
error_at (EXPR_LOC_OR_LOC (t, input_location),
"expression %qE is not a constant-expression", t);
*non_constant_p = true;
@ -3246,7 +3242,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
/* A placeholder without a referent. We can get here when
checking whether NSDMIs are noexcept, or in massage_init_elt;
just say it's non-constant for now. */
gcc_assert (allow_non_constant);
gcc_assert (ctx->quiet);
*non_constant_p = true;
break;
}
@ -3259,7 +3255,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
gcc_assert (same_type_ignoring_top_level_qualifiers_p
(TREE_TYPE (t), TREE_TYPE (ctor)));
return cxx_eval_constant_expression
(ctx, ctor, allow_non_constant, addr,
(ctx, ctor, addr,
non_constant_p, overflow_p, NULL);
}
break;
@ -3270,12 +3266,12 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
break;
case LOOP_EXPR:
cxx_eval_loop_expr (ctx, t, allow_non_constant,
cxx_eval_loop_expr (ctx, t,
non_constant_p, overflow_p, jump_target);
break;
case SWITCH_EXPR:
cxx_eval_switch_expr (ctx, t, allow_non_constant,
cxx_eval_switch_expr (ctx, t,
non_constant_p, overflow_p, jump_target);
break;
@ -3301,7 +3297,7 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
{
bool non_constant_p = false;
bool overflow_p = false;
constexpr_ctx ctx = { NULL, NULL, NULL, NULL };
constexpr_ctx ctx = { NULL, NULL, NULL, NULL, allow_non_constant };
hash_map<tree,tree> map;
ctx.values = &map;
tree type = initialized_type (t);
@ -3336,7 +3332,7 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
r = TARGET_EXPR_INITIAL (r);
}
r = cxx_eval_constant_expression (&ctx, r, allow_non_constant,
r = cxx_eval_constant_expression (&ctx, r,
false, &non_constant_p, &overflow_p, NULL);
verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);
@ -3410,10 +3406,10 @@ is_sub_constant_expr (tree t)
{
bool non_constant_p = false;
bool overflow_p = false;
constexpr_ctx ctx = { NULL, NULL, NULL, NULL };
constexpr_ctx ctx = { NULL, NULL, NULL, NULL, true };
hash_map <tree, tree> map;
ctx.values = &map;
cxx_eval_constant_expression (&ctx, t, true, false, &non_constant_p,
cxx_eval_constant_expression (&ctx, t, false, &non_constant_p,
&overflow_p, NULL);
return !non_constant_p && !overflow_p;
}