2018-08-08 Jakub Jelinek <jakub@redhat.com>
+ P0595R1 - is_constant_evaluated
+ * cp-tree.h (enum cp_built_in_function): New.
+ (maybe_constant_init): Add pretend_const_required argument.
+ * typeck2.c (store_init_value): Pass true as new argument to
+ maybe_constant_init.
+ * constexpr.c (constexpr_fn_retval): Check also DECL_BUILT_IN_CLASS
+ for BUILT_IN_UNREACHABLE.
+ (struct constexpr_ctx): Add pretend_const_required field.
+ (cxx_eval_builtin_function_call): Use DECL_IS_BUILTIN_CONSTANT_P
+ macro. Handle CP_BUILT_IN_IS_CONSTANT_EVALUATED. Check also
+ DECL_BUILT_IN_CLASS for BUILT_IN_UNREACHABLE.
+ (cxx_eval_outermost_constant_expr): Add pretend_const_required
+ argument, initialize pretend_const_required field in ctx. If the
+ result is TREE_CONSTANT and non_constant_p, retry with
+ pretend_const_required false if it was true.
+ (is_sub_constant_expr): Initialize pretend_const_required_field in
+ ctx.
+ (cxx_constant_value): Pass true as pretend_const_required to
+ cxx_eval_outermost_constant_expr.
+ (maybe_constant_value): Pass false as pretend_const_required to
+ cxx_eval_outermost_constant_expr.
+ (fold_non_dependent_expr): Likewise.
+ (maybe_constant_init_1): Add pretend_const_required argument, pass it
+ down to cxx_eval_outermost_constant_expr. Pass !allow_non_constant
+ instead of false as strict to cxx_eval_outermost_constant_expr.
+ (maybe_constant_init): Add pretend_const_required argument, pass it
+ down to maybe_constant_init_1.
+ (cxx_constant_init): Pass true as pretend_const_required to
+ maybe_constant_init_1.
+ * cp-gimplify.c (cp_gimplify_expr): Handle CALL_EXPRs to
+ CP_BUILT_IN_IS_CONSTANT_EVALUATED.
+ (cp_fold): Don't fold CP_BUILT_IN_IS_CONSTANT_EVALUATED calls.
+ * decl.c: Include langhooks.h.
+ (cxx_init_decl_processing): Register __builtin_is_constant_evaluated
+ built-in.
+ * tree.c (builtin_valid_in_constant_expr_p): Return true for
+ CP_BUILT_IN_IS_CONSTANT_EVALUATED.
+ * pt.c (declare_integer_pack): Initialize DECL_FUNCTION_CODE.
+
PR c++/86836
* pt.c (tsubst_expr): For structured bindings, call tsubst_decomp_names
before tsubst_init, not after it.
{
tree fun = get_function_named_in_call (body);
if (fun != NULL_TREE
+ && DECL_BUILT_IN_CLASS (fun) == BUILT_IN_NORMAL
&& DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE)
return NULL_TREE;
}
/* Whether we are strictly conforming to constant expression rules or
trying harder to get a constant value. */
bool strict;
+ /* Whether __builtin_is_constant_evaluated () should be true. */
+ bool pretend_const_required;
};
/* A table of all constexpr calls that have been evaluated by the
int i;
/* Don't fold __builtin_constant_p within a constexpr function. */
- bool bi_const_p = (DECL_FUNCTION_CODE (fun) == BUILT_IN_CONSTANT_P);
+ bool bi_const_p = DECL_IS_BUILTIN_CONSTANT_P (fun);
/* If we aren't requiring a constant expression, defer __builtin_constant_p
in a constexpr function until we have values for the parameters. */
return t;
}
+ /* For __builtin_is_constant_evaluated, defer it if not
+ ctx->pretend_const_required, otherwise fold it to true. */
+ if (DECL_BUILT_IN_CLASS (fun) == BUILT_IN_FRONTEND
+ && (int) DECL_FUNCTION_CODE (fun) == CP_BUILT_IN_IS_CONSTANT_EVALUATED)
+ {
+ if (!ctx->pretend_const_required)
+ {
+ *non_constant_p = true;
+ return t;
+ }
+ return boolean_true_node;
+ }
+
/* Be permissive for arguments to built-ins; __builtin_constant_p should
return constant false for a non-constant argument. */
constexpr_ctx new_ctx = *ctx;
/* Do not allow__builtin_unreachable in constexpr function.
The __builtin_unreachable call with BUILTINS_LOCATION
comes from cp_maybe_instrument_return. */
- if (DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE
+ if (DECL_BUILT_IN_CLASS (fun) == BUILT_IN_NORMAL
+ && DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE
&& EXPR_LOCATION (t) == BUILTINS_LOCATION)
error ("%<constexpr%> call flows off the end of the function");
else
input_location = loc;
}
+/* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
+ PRETEND_CONST_REQUIRED is true if T is required to be const-evaluated as
+ per P0595 even when ALLOW_NON_CONSTANT is true. */
+
static tree
cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
- bool strict = true, tree object = NULL_TREE)
+ bool strict = true,
+ bool pretend_const_required = false,
+ tree object = NULL_TREE)
{
auto_timevar time (TV_CONSTEXPR);
hash_map<tree,tree> map;
constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL,
- allow_non_constant, strict };
+ allow_non_constant, strict,
+ pretend_const_required || !allow_non_constant };
tree type = initialized_type (t);
tree r = t;
return error_mark_node;
else if (non_constant_p && TREE_CONSTANT (r))
{
+ /* If __builtin_is_constant_evaluated () was evaluated to true
+ and the result is not a valid constant expression, we need to
+ punt. */
+ if (pretend_const_required)
+ return cxx_eval_outermost_constant_expr (t, true, strict,
+ false, object);
/* This isn't actually constant, so unset TREE_CONSTANT.
Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
it to be set if it is invariant address, even when it is not
bool overflow_p = false;
hash_map <tree, tree> map;
- constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL, true, true };
+ constexpr_ctx ctx
+ = { NULL, &map, NULL, NULL, NULL, NULL, true, true, false };
instantiate_constexpr_fns (t);
cxx_eval_constant_expression (&ctx, t, false, &non_constant_p,
tree
cxx_constant_value (tree t, tree decl)
{
- return cxx_eval_outermost_constant_expr (t, false, true, decl);
+ return cxx_eval_outermost_constant_expr (t, false, true, true, decl);
}
/* Helper routine for fold_simple function. Either return simplified
if (tree *cached = cv_cache->get (t))
return *cached;
- r = cxx_eval_outermost_constant_expr (t, true, true, decl);
+ r = cxx_eval_outermost_constant_expr (t, true, true, false, decl);
gcc_checking_assert (r == t
|| CONVERT_EXPR_P (t)
|| TREE_CODE (t) == VIEW_CONVERT_EXPR
return t;
}
- tree r = cxx_eval_outermost_constant_expr (t, true, true, NULL_TREE);
+ tree r = cxx_eval_outermost_constant_expr (t, true, true, false,
+ NULL_TREE);
/* cp_tree_equal looks through NOPs, so allow them. */
gcc_checking_assert (r == t
|| CONVERT_EXPR_P (t)
}
/* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
- than wrapped in a TARGET_EXPR. */
+ than wrapped in a TARGET_EXPR.
+ ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
+ PRETEND_CONST_REQUIRED is true if T is required to be const-evaluated as
+ per P0595 even when ALLOW_NON_CONSTANT is true. */
static tree
-maybe_constant_init_1 (tree t, tree decl, bool allow_non_constant)
+maybe_constant_init_1 (tree t, tree decl, bool allow_non_constant,
+ bool pretend_const_required)
{
if (!t)
return t;
else if (CONSTANT_CLASS_P (t) && allow_non_constant)
/* No evaluation needed. */;
else
- t = cxx_eval_outermost_constant_expr (t, allow_non_constant, false, decl);
+ t = cxx_eval_outermost_constant_expr (t, allow_non_constant,
+ !allow_non_constant,
+ pretend_const_required, decl);
if (TREE_CODE (t) == TARGET_EXPR)
{
tree init = TARGET_EXPR_INITIAL (t);
/* Wrapper for maybe_constant_init_1 which permits non constants. */
tree
-maybe_constant_init (tree t, tree decl)
+maybe_constant_init (tree t, tree decl, bool pretend_const_required)
{
- return maybe_constant_init_1 (t, decl, true);
+ return maybe_constant_init_1 (t, decl, true, pretend_const_required);
}
/* Wrapper for maybe_constant_init_1 which does not permit non constants. */
tree
cxx_constant_init (tree t, tree decl)
{
- return maybe_constant_init_1 (t, decl, false);
+ return maybe_constant_init_1 (t, decl, false, true);
}
#if 0
ret = GS_ERROR;
}
}
+ if (ret != GS_ERROR)
+ {
+ tree decl = cp_get_callee_fndecl_nofold (*expr_p);
+ if (decl
+ && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_FRONTEND
+ && ((int) DECL_FUNCTION_CODE (decl)
+ == CP_BUILT_IN_IS_CONSTANT_EVALUATED))
+ *expr_p = boolean_false_node;
+ }
break;
case RETURN_EXPR:
&& DECL_DECLARED_CONSTEXPR_P (current_function_decl))
nw = 1;
+ /* Defer folding __builtin_is_constant_evaluated. */
+ if (callee
+ && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_FRONTEND
+ && ((int) DECL_FUNCTION_CODE (callee)
+ == CP_BUILT_IN_IS_CONSTANT_EVALUATED))
+ break;
+
x = copy_node (x);
m = call_expr_nargs (x);
static const unsigned short refcount_infinity = (unsigned short) ~0;
};
+/* BUILT_IN_FRONTEND function codes. */
+enum cp_built_in_function {
+ CP_BUILT_IN_IS_CONSTANT_EVALUATED,
+ CP_BUILT_IN_INTEGER_PACK,
+ CP_BUILT_IN_LAST
+};
+
bool decl_spec_seq_has_spec_p (const cp_decl_specifier_seq *, cp_decl_spec);
/* Return the type of the `this' parameter of FNTYPE. */
extern tree cxx_constant_value (tree, tree = NULL_TREE);
extern tree cxx_constant_init (tree, tree = NULL_TREE);
extern tree maybe_constant_value (tree, tree = NULL_TREE);
-extern tree maybe_constant_init (tree, tree = NULL_TREE);
+extern tree maybe_constant_init (tree, tree = NULL_TREE, bool = false);
extern tree fold_non_dependent_expr (tree, tsubst_flags_t = tf_warning_or_error);
extern tree fold_simple (tree);
extern bool is_sub_constant_expr (tree);
#include "gimplify.h"
#include "asan.h"
#include "gcc-rich-location.h"
+#include "langhooks.h"
/* Possible cases of bad specifiers type used by bad_specifiers. */
enum bad_spec_place {
c_common_nodes_and_builtins ();
+ tree bool_ftype = build_function_type_list (boolean_type_node, NULL_TREE);
+ tree decl
+ = add_builtin_function ("__builtin_is_constant_evaluated",
+ bool_ftype, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
+ BUILT_IN_FRONTEND, NULL, NULL_TREE);
+ set_call_expr_flags (decl, ECF_CONST | ECF_NOTHROW | ECF_LEAF);
+
integer_two_node = build_int_cst (NULL_TREE, 2);
/* Guess at the initial static decls size. */
NULL_TREE, ECF_CONST);
DECL_DECLARED_CONSTEXPR_P (ipfn) = true;
DECL_BUILT_IN_CLASS (ipfn) = BUILT_IN_FRONTEND;
+ DECL_FUNCTION_CODE (ipfn)
+ = (enum built_in_function) (int) CP_BUILT_IN_INTEGER_PACK;
}
/* Set up the hash tables for template instantiations. */
bool
builtin_valid_in_constant_expr_p (const_tree decl)
{
- if (!(TREE_CODE (decl) == FUNCTION_DECL
- && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL))
- /* Not a built-in. */
+ if (TREE_CODE (decl) != FUNCTION_DECL)
+ /* Not a function. */
return false;
+ if (DECL_BUILT_IN_CLASS (decl) != BUILT_IN_NORMAL)
+ {
+ if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_FRONTEND
+ && ((int) DECL_FUNCTION_CODE (decl)
+ == CP_BUILT_IN_IS_CONSTANT_EVALUATED))
+ return true;
+ /* Not a built-in. */
+ return false;
+ }
switch (DECL_FUNCTION_CODE (decl))
{
/* These always have constant results like the corresponding
value = cxx_constant_init (value, decl);
}
else
- value = maybe_constant_init (value, decl);
+ value = maybe_constant_init (value, decl, true);
if (TREE_CODE (value) == CONSTRUCTOR && cp_has_mutable_p (type))
/* Poison this CONSTRUCTOR so it can't be copied to another
constexpr variable. */
2018-08-08 Jakub Jelinek <jakub@redhat.com>
+ P0595R1 - is_constant_evaluated
+ * g++.dg/cpp2a/is-constant-evaluated1.C: New test.
+
PR c++/86836
* g++.dg/cpp1z/decomp46.C: New test.
--- /dev/null
+// P0595R1
+// { dg-do compile { target c++14 } }
+
+template<int N> struct X { int v = N; };
+X<__builtin_is_constant_evaluated ()> x; // type X<true>
+int y = 4;
+int a = __builtin_is_constant_evaluated () ? y : 1; // initializes a to 1
+int b = __builtin_is_constant_evaluated () ? 2 : y; // initializes b to 2
+int c = y + (__builtin_is_constant_evaluated () ? 2 : y); // initializes c to 2*y
+int d = __builtin_is_constant_evaluated (); // initializes d to 1
+int e = d + __builtin_is_constant_evaluated (); // initializes e to 0
+
+struct false_type { static constexpr bool value = false; };
+struct true_type { static constexpr bool value = true; };
+template<class T, class U>
+struct is_same : false_type {};
+template<class T>
+struct is_same<T, T> : true_type {};
+
+constexpr int
+foo (int x)
+{
+ const int n = __builtin_is_constant_evaluated () ? 13 : 17; // n == 13
+ int m = __builtin_is_constant_evaluated () ? 13 : 17; // m might be 13 or 17 (see below)
+ char arr[n] = {}; // char[13]
+ return m + sizeof (arr) + x;
+}
+
+constexpr int
+bar ()
+{
+ const int n = __builtin_is_constant_evaluated() ? 13 : 17;
+ X<n> x1;
+ X<__builtin_is_constant_evaluated() ? 13 : 17> x2;
+ static_assert (is_same<decltype (x1), decltype (x2)>::value, "x1/x2's type");
+ return x1.v + x2.v;
+}
+
+int p = foo (0); // m == 13; initialized to 26
+int q = p + foo (0); // m == 17 for this call; initialized to 56
+static_assert (bar () == 26, "bar");
+
+struct S { int a, b; };
+
+S s = { __builtin_is_constant_evaluated () ? 2 : 3, y };
+S t = { __builtin_is_constant_evaluated () ? 2 : 3, 4 };
+
+static_assert (is_same<decltype (x), X<true> >::value, "x's type");
+
+int
+main ()
+{
+ if (a != 1 || b != 2 || c != 8 || d != 1 || e != 0 || p != 26 || q != 56)
+ __builtin_abort ();
+ if (s.a != 3 || s.b != 4 || t.a != 2 || t.b != 4)
+ __builtin_abort ();
+ if (foo (y) != 34)
+ __builtin_abort ();
+#if __cplusplus >= 201703L
+ if constexpr (foo (0) != 26)
+ __builtin_abort ();
+#endif
+ constexpr int w = foo (0);
+ if (w != 26)
+ __builtin_abort ();
+}
projects / gcc.git / commitdiff