From 2b3ab879c7e00d1d9a86357bf13ebb0859ab9c88 Mon Sep 17 00:00:00 2001 From: Jason Merrill Date: Tue, 18 Nov 2014 22:03:28 -0500 Subject: [PATCH] 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 --- gcc/cp/ChangeLog | 4 + gcc/cp/constexpr.c | 244 ++++++++++++++++++++++----------------------- 2 files changed, 124 insertions(+), 124 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 0759a575c9e..fefe4142f67 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,5 +1,9 @@ 2014-11-18 Jason Merrill + * 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. diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c index 517bf23145f..7cdf649c5f0 100644 --- a/gcc/cp/constexpr.c +++ b/gcc/cp/constexpr.c @@ -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 *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_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 *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 map; ctx.values = ↦ 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 map; ctx.values = ↦ - 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; }