1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2019 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
34 #include "gimple-fold.h"
36 #include "fold-const-call.h"
38 static bool verify_constant (tree
, bool, bool *, bool *);
39 #define VERIFY_CONSTANT(X) \
41 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
45 static HOST_WIDE_INT
find_array_ctor_elt (tree ary
, tree dindex
,
48 /* Returns true iff FUN is an instantiation of a constexpr function
49 template or a defaulted constexpr function. */
52 is_instantiation_of_constexpr (tree fun
)
54 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
55 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
56 || (DECL_DEFAULTED_FN (fun
)
57 && DECL_DECLARED_CONSTEXPR_P (fun
)));
60 /* Return true if T is a literal type. */
63 literal_type_p (tree t
)
68 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
72 t
= complete_type (t
);
73 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
74 return CLASSTYPE_LITERAL_P (t
);
76 if (TREE_CODE (t
) == ARRAY_TYPE
)
77 return literal_type_p (strip_array_types (t
));
81 /* If DECL is a variable declared `constexpr', require its type
82 be literal. Return error_mark_node if we give an error, the
86 ensure_literal_type_for_constexpr_object (tree decl
)
88 tree type
= TREE_TYPE (decl
);
90 && (DECL_DECLARED_CONSTEXPR_P (decl
)
91 || var_in_constexpr_fn (decl
))
92 && !processing_template_decl
)
94 tree stype
= strip_array_types (type
);
95 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
96 /* Don't complain here, we'll complain about incompleteness
97 when we try to initialize the variable. */;
98 else if (type_uses_auto (type
))
99 /* We don't know the actual type yet. */;
100 else if (!literal_type_p (type
))
102 if (DECL_DECLARED_CONSTEXPR_P (decl
))
104 auto_diagnostic_group d
;
105 error_at (DECL_SOURCE_LOCATION (decl
),
106 "the type %qT of %<constexpr%> variable %qD "
107 "is not literal", type
, decl
);
108 explain_non_literal_class (type
);
109 decl
= error_mark_node
;
113 if (!is_instantiation_of_constexpr (current_function_decl
))
115 auto_diagnostic_group d
;
116 error_at (DECL_SOURCE_LOCATION (decl
),
117 "variable %qD of non-literal type %qT in "
118 "%<constexpr%> function", decl
, type
);
119 explain_non_literal_class (type
);
120 decl
= error_mark_node
;
122 cp_function_chain
->invalid_constexpr
= true;
125 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
126 && variably_modified_type_p (type
, NULL_TREE
))
128 error_at (DECL_SOURCE_LOCATION (decl
),
129 "%<constexpr%> variable %qD has variably-modified "
130 "type %qT", decl
, type
);
131 decl
= error_mark_node
;
137 /* Representation of entries in the constexpr function definition table. */
139 struct GTY((for_user
)) constexpr_fundef
{
144 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
146 static hashval_t
hash (constexpr_fundef
*);
147 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
150 /* This table holds all constexpr function definitions seen in
151 the current translation unit. */
153 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
155 /* Utility function used for managing the constexpr function table.
156 Return true if the entries pointed to by P and Q are for the
157 same constexpr function. */
160 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
162 return lhs
->decl
== rhs
->decl
;
165 /* Utility function used for managing the constexpr function table.
166 Return a hash value for the entry pointed to by Q. */
169 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
171 return DECL_UID (fundef
->decl
);
174 /* Return a previously saved definition of function FUN. */
176 static constexpr_fundef
*
177 retrieve_constexpr_fundef (tree fun
)
179 constexpr_fundef fundef
= { NULL
, NULL
};
180 if (constexpr_fundef_table
== NULL
)
184 return constexpr_fundef_table
->find (&fundef
);
187 /* Check whether the parameter and return types of FUN are valid for a
188 constexpr function, and complain if COMPLAIN. */
191 is_valid_constexpr_fn (tree fun
, bool complain
)
195 if (DECL_INHERITED_CTOR (fun
)
196 && TREE_CODE (fun
) == TEMPLATE_DECL
)
200 error ("inherited constructor %qD is not %<constexpr%>",
201 DECL_INHERITED_CTOR (fun
));
205 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
206 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
207 if (!literal_type_p (TREE_TYPE (parm
)))
212 auto_diagnostic_group d
;
213 error ("invalid type for parameter %d of %<constexpr%> "
214 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
215 explain_non_literal_class (TREE_TYPE (parm
));
220 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
224 inform (DECL_SOURCE_LOCATION (fun
),
225 "lambdas are implicitly %<constexpr%> only in C++17 and later");
227 else if (!DECL_CONSTRUCTOR_P (fun
))
229 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
230 if (!literal_type_p (rettype
))
235 auto_diagnostic_group d
;
236 error ("invalid return type %qT of %<constexpr%> function %q+D",
238 explain_non_literal_class (rettype
);
242 /* C++14 DR 1684 removed this restriction. */
243 if (cxx_dialect
< cxx14
244 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
245 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
250 auto_diagnostic_group d
;
251 if (pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
252 "enclosing class of %<constexpr%> non-static"
253 " member function %q+#D is not a literal type",
255 explain_non_literal_class (DECL_CONTEXT (fun
));
259 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
263 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
269 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
270 for a member of an anonymous aggregate, INIT is the initializer for that
271 member, and VEC_OUTER is the vector of constructor elements for the class
272 whose constructor we are processing. Add the initializer to the vector
273 and return true to indicate success. */
276 build_anon_member_initialization (tree member
, tree init
,
277 vec
<constructor_elt
, va_gc
> **vec_outer
)
279 /* MEMBER presents the relevant fields from the inside out, but we need
280 to build up the initializer from the outside in so that we can reuse
281 previously built CONSTRUCTORs if this is, say, the second field in an
282 anonymous struct. So we use a vec as a stack. */
283 auto_vec
<tree
, 2> fields
;
286 fields
.safe_push (TREE_OPERAND (member
, 1));
287 member
= TREE_OPERAND (member
, 0);
289 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
290 && TREE_CODE (member
) == COMPONENT_REF
);
292 /* VEC has the constructor elements vector for the context of FIELD.
293 If FIELD is an anonymous aggregate, we will push inside it. */
294 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
296 while (field
= fields
.pop(),
297 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
300 /* If there is already an outer constructor entry for the anonymous
301 aggregate FIELD, use it; otherwise, insert one. */
302 if (vec_safe_is_empty (*vec
)
303 || (*vec
)->last().index
!= field
)
305 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
306 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
309 ctor
= (*vec
)->last().value
;
310 vec
= &CONSTRUCTOR_ELTS (ctor
);
313 /* Now we're at the innermost field, the one that isn't an anonymous
314 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
315 gcc_assert (fields
.is_empty());
316 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
321 /* Subroutine of build_constexpr_constructor_member_initializers.
322 The expression tree T represents a data member initialization
323 in a (constexpr) constructor definition. Build a pairing of
324 the data member with its initializer, and prepend that pair
325 to the existing initialization pair INITS. */
328 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
331 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
332 t
= TREE_OPERAND (t
, 0);
333 if (TREE_CODE (t
) == EXPR_STMT
)
334 t
= TREE_OPERAND (t
, 0);
335 if (t
== error_mark_node
)
337 if (TREE_CODE (t
) == STATEMENT_LIST
)
339 tree_stmt_iterator i
;
340 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
342 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
347 if (TREE_CODE (t
) == CLEANUP_STMT
)
349 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
350 but we can in a constexpr constructor for a non-literal class. Just
351 ignore it; either all the initialization will be constant, in which
352 case the cleanup can't run, or it can't be constexpr.
353 Still recurse into CLEANUP_BODY. */
354 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
356 if (TREE_CODE (t
) == CONVERT_EXPR
)
357 t
= TREE_OPERAND (t
, 0);
358 if (TREE_CODE (t
) == INIT_EXPR
359 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
360 use what this function builds for cx_check_missing_mem_inits, and
361 assignment in the ctor body doesn't count. */
362 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
364 member
= TREE_OPERAND (t
, 0);
365 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
367 else if (TREE_CODE (t
) == CALL_EXPR
)
369 tree fn
= get_callee_fndecl (t
);
370 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
371 /* We're only interested in calls to subobject constructors. */
373 member
= CALL_EXPR_ARG (t
, 0);
374 /* We don't use build_cplus_new here because it complains about
375 abstract bases. Leaving the call unwrapped means that it has the
376 wrong type, but cxx_eval_constant_expression doesn't care. */
377 init
= break_out_target_exprs (t
);
379 else if (TREE_CODE (t
) == BIND_EXPR
)
380 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
382 /* Don't add anything else to the CONSTRUCTOR. */
384 if (INDIRECT_REF_P (member
))
385 member
= TREE_OPERAND (member
, 0);
386 if (TREE_CODE (member
) == NOP_EXPR
)
390 if (TREE_CODE (op
) == ADDR_EXPR
)
392 gcc_assert (same_type_ignoring_top_level_qualifiers_p
393 (TREE_TYPE (TREE_TYPE (op
)),
394 TREE_TYPE (TREE_TYPE (member
))));
395 /* Initializing a cv-qualified member; we need to look through
399 else if (op
== current_class_ptr
400 && (same_type_ignoring_top_level_qualifiers_p
401 (TREE_TYPE (TREE_TYPE (member
)),
402 current_class_type
)))
403 /* Delegating constructor. */
407 /* This is an initializer for an empty base; keep it for now so
408 we can check it in cxx_eval_bare_aggregate. */
409 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
412 if (TREE_CODE (member
) == ADDR_EXPR
)
413 member
= TREE_OPERAND (member
, 0);
414 if (TREE_CODE (member
) == COMPONENT_REF
)
416 tree aggr
= TREE_OPERAND (member
, 0);
417 if (TREE_CODE (aggr
) == VAR_DECL
)
418 /* Initializing a local variable, don't add anything. */
420 if (TREE_CODE (aggr
) != COMPONENT_REF
)
421 /* Normal member initialization. */
422 member
= TREE_OPERAND (member
, 1);
423 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
424 /* Initializing a member of an anonymous union. */
425 return build_anon_member_initialization (member
, init
, vec
);
427 /* We're initializing a vtable pointer in a base. Leave it as
428 COMPONENT_REF so we remember the path to get to the vfield. */
429 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
432 /* Value-initialization can produce multiple initializers for the
433 same field; use the last one. */
434 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
435 (*vec
)->last().value
= init
;
437 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
441 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
442 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
443 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
446 check_constexpr_bind_expr_vars (tree t
)
448 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
450 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
451 if (TREE_CODE (var
) == TYPE_DECL
452 && DECL_IMPLICIT_TYPEDEF_P (var
)
453 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
458 /* Subroutine of check_constexpr_ctor_body. */
461 check_constexpr_ctor_body_1 (tree last
, tree list
)
463 switch (TREE_CODE (list
))
466 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
467 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
471 case CLEANUP_POINT_EXPR
:
472 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
476 if (!check_constexpr_bind_expr_vars (list
)
477 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
484 case DEBUG_BEGIN_STMT
:
492 /* Make sure that there are no statements after LAST in the constructor
493 body represented by LIST. */
496 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
498 /* C++14 doesn't require a constexpr ctor to have an empty body. */
499 if (cxx_dialect
>= cxx14
)
503 if (TREE_CODE (list
) == STATEMENT_LIST
)
505 tree_stmt_iterator i
= tsi_last (list
);
506 for (; !tsi_end_p (i
); tsi_prev (&i
))
508 tree t
= tsi_stmt (i
);
511 if (!check_constexpr_ctor_body_1 (last
, t
))
518 else if (list
!= last
519 && !check_constexpr_ctor_body_1 (last
, list
))
524 error ("%<constexpr%> constructor does not have empty body");
525 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
530 /* V is a vector of constructor elements built up for the base and member
531 initializers of a constructor for TYPE. They need to be in increasing
532 offset order, which they might not be yet if TYPE has a primary base
533 which is not first in the base-clause or a vptr and at least one base
534 all of which are non-primary. */
536 static vec
<constructor_elt
, va_gc
> *
537 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
539 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
545 field_type
= BINFO_TYPE (pri
);
546 else if (TYPE_CONTAINS_VPTR_P (type
))
547 field_type
= vtbl_ptr_type_node
;
551 /* Find the element for the primary base or vptr and move it to the
552 beginning of the vec. */
553 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
554 if (TREE_TYPE (ce
->index
) == field_type
)
557 if (i
> 0 && i
< vec_safe_length (v
))
559 vec
<constructor_elt
, va_gc
> &vref
= *v
;
560 constructor_elt elt
= vref
[i
];
569 /* Build compile-time evalable representations of member-initializer list
570 for a constexpr constructor. */
573 build_constexpr_constructor_member_initializers (tree type
, tree body
)
575 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
578 switch (TREE_CODE (body
))
580 case MUST_NOT_THROW_EXPR
:
582 body
= TREE_OPERAND (body
, 0);
586 for (tree_stmt_iterator i
= tsi_start (body
);
587 !tsi_end_p (i
); tsi_next (&i
))
590 if (TREE_CODE (body
) == BIND_EXPR
)
596 body
= BIND_EXPR_BODY (body
);
603 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
605 body
= TREE_OPERAND (body
, 0);
606 if (TREE_CODE (body
) == EXPR_STMT
)
607 body
= TREE_OPERAND (body
, 0);
608 if (TREE_CODE (body
) == INIT_EXPR
609 && (same_type_ignoring_top_level_qualifiers_p
610 (TREE_TYPE (TREE_OPERAND (body
, 0)),
611 current_class_type
)))
614 return TREE_OPERAND (body
, 1);
616 ok
= build_data_member_initialization (body
, &vec
);
618 else if (TREE_CODE (body
) == STATEMENT_LIST
)
620 tree_stmt_iterator i
;
621 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
623 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
628 else if (TREE_CODE (body
) == TRY_BLOCK
)
630 error ("body of %<constexpr%> constructor cannot be "
631 "a function-try-block");
632 return error_mark_node
;
634 else if (EXPR_P (body
))
635 ok
= build_data_member_initialization (body
, &vec
);
637 gcc_assert (errorcount
> 0);
640 if (vec_safe_length (vec
) > 0)
642 /* In a delegating constructor, return the target. */
643 constructor_elt
*ce
= &(*vec
)[0];
644 if (ce
->index
== current_class_ptr
)
651 vec
= sort_constexpr_mem_initializers (type
, vec
);
652 return build_constructor (type
, vec
);
655 return error_mark_node
;
658 /* We have an expression tree T that represents a call, either CALL_EXPR
659 or AGGR_INIT_EXPR. If the call is lexically to a named function,
660 retrun the _DECL for that function. */
663 get_function_named_in_call (tree t
)
665 tree fun
= cp_get_callee (t
);
666 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
667 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
668 fun
= TREE_OPERAND (fun
, 0);
672 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
673 declared to be constexpr, or a sub-statement thereof. Returns the
674 return value if suitable, error_mark_node for a statement not allowed in
675 a constexpr function, or NULL_TREE if no return value was found. */
678 constexpr_fn_retval (tree body
)
680 switch (TREE_CODE (body
))
684 tree_stmt_iterator i
;
685 tree expr
= NULL_TREE
;
686 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
688 tree s
= constexpr_fn_retval (tsi_stmt (i
));
689 if (s
== error_mark_node
)
690 return error_mark_node
;
691 else if (s
== NULL_TREE
)
692 /* Keep iterating. */;
694 /* Multiple return statements. */
695 return error_mark_node
;
703 return break_out_target_exprs (TREE_OPERAND (body
, 0));
707 tree decl
= DECL_EXPR_DECL (body
);
708 if (TREE_CODE (decl
) == USING_DECL
709 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
710 || DECL_ARTIFICIAL (decl
))
712 return error_mark_node
;
715 case CLEANUP_POINT_EXPR
:
716 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
719 if (!check_constexpr_bind_expr_vars (body
))
720 return error_mark_node
;
721 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
724 case DEBUG_BEGIN_STMT
:
729 tree fun
= get_function_named_in_call (body
);
731 && fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
))
737 return error_mark_node
;
741 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
742 FUN; do the necessary transformations to turn it into a single expression
743 that we can store in the hash table. */
746 massage_constexpr_body (tree fun
, tree body
)
748 if (DECL_CONSTRUCTOR_P (fun
))
749 body
= build_constexpr_constructor_member_initializers
750 (DECL_CONTEXT (fun
), body
);
751 else if (cxx_dialect
< cxx14
)
753 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
754 body
= EH_SPEC_STMTS (body
);
755 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
756 body
= TREE_OPERAND (body
, 0);
757 body
= constexpr_fn_retval (body
);
762 /* CTYPE is a type constructed from BODY. Return true if some
763 bases/fields are uninitialized, and complain if COMPLAIN. */
766 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
772 if (TREE_CODE (body
) != CONSTRUCTOR
)
774 nelts
= CONSTRUCTOR_NELTS (body
);
776 tree field
= TYPE_FIELDS (ctype
);
778 if (TREE_CODE (ctype
) == UNION_TYPE
)
780 if (nelts
== 0 && next_initializable_field (field
))
783 error ("%<constexpr%> constructor for union %qT must "
784 "initialize exactly one non-static data member", ctype
);
790 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
791 need an explicit initialization. */
793 for (unsigned i
= 0; i
<= nelts
; ++i
)
795 tree index
= NULL_TREE
;
798 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
799 /* Skip base and vtable inits. */
800 if (TREE_CODE (index
) != FIELD_DECL
801 || DECL_ARTIFICIAL (index
))
805 for (; field
!= index
; field
= DECL_CHAIN (field
))
808 if (TREE_CODE (field
) != FIELD_DECL
)
810 if (DECL_UNNAMED_BIT_FIELD (field
))
812 if (DECL_ARTIFICIAL (field
))
814 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
816 /* Recurse to check the anonummous aggregate member. */
817 bad
|= cx_check_missing_mem_inits
818 (TREE_TYPE (field
), NULL_TREE
, complain
);
819 if (bad
&& !complain
)
823 ftype
= strip_array_types (TREE_TYPE (field
));
824 if (type_has_constexpr_default_constructor (ftype
))
826 /* It's OK to skip a member with a trivial constexpr ctor.
827 A constexpr ctor that isn't trivial should have been
829 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
835 auto_diagnostic_group d
;
836 error ("member %qD must be initialized by mem-initializer "
837 "in %<constexpr%> constructor", field
);
838 inform (DECL_SOURCE_LOCATION (field
), "declared here");
841 if (field
== NULL_TREE
)
844 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
846 /* Check the anonymous aggregate initializer is valid. */
847 bad
|= cx_check_missing_mem_inits
848 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
849 if (bad
&& !complain
)
852 field
= DECL_CHAIN (field
);
858 /* We are processing the definition of the constexpr function FUN.
859 Check that its BODY fulfills the propriate requirements and
860 enter it in the constexpr function definition table.
861 For constructor BODY is actually the TREE_LIST of the
862 member-initializer list. */
865 register_constexpr_fundef (tree fun
, tree body
)
867 constexpr_fundef entry
;
868 constexpr_fundef
**slot
;
870 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
873 tree massaged
= massage_constexpr_body (fun
, body
);
874 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
876 if (!DECL_CONSTRUCTOR_P (fun
))
877 error ("body of %<constexpr%> function %qD not a return-statement",
882 if (!potential_rvalue_constant_expression (massaged
))
884 if (!DECL_GENERATED_P (fun
))
885 require_potential_rvalue_constant_expression (massaged
);
889 if (DECL_CONSTRUCTOR_P (fun
)
890 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
891 massaged
, !DECL_GENERATED_P (fun
)))
894 /* Create the constexpr function table if necessary. */
895 if (constexpr_fundef_table
== NULL
)
896 constexpr_fundef_table
897 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
901 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
903 gcc_assert (*slot
== NULL
);
904 *slot
= ggc_alloc
<constexpr_fundef
> ();
910 /* FUN is a non-constexpr function called in a context that requires a
911 constant expression. If it comes from a constexpr template, explain why
912 the instantiation isn't constexpr. */
915 explain_invalid_constexpr_fn (tree fun
)
917 static hash_set
<tree
> *diagnosed
;
920 /* Only diagnose defaulted functions, lambdas, or instantiations. */
921 if (!DECL_DEFAULTED_FN (fun
)
922 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
923 && !is_instantiation_of_constexpr (fun
))
925 if (diagnosed
== NULL
)
926 diagnosed
= new hash_set
<tree
>;
927 if (diagnosed
->add (fun
))
928 /* Already explained. */
931 save_loc
= input_location
;
932 if (!lambda_static_thunk_p (fun
))
934 /* Diagnostics should completely ignore the static thunk, so leave
935 input_location set to our caller's location. */
936 input_location
= DECL_SOURCE_LOCATION (fun
);
937 inform (input_location
,
938 "%qD is not usable as a %<constexpr%> function because:", fun
);
940 /* First check the declaration. */
941 if (is_valid_constexpr_fn (fun
, true))
943 /* Then if it's OK, the body. */
944 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
945 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
946 explain_implicit_non_constexpr (fun
);
949 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
950 require_potential_rvalue_constant_expression (body
);
951 if (DECL_CONSTRUCTOR_P (fun
))
952 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
955 input_location
= save_loc
;
958 /* Objects of this type represent calls to constexpr functions
959 along with the bindings of parameters to their arguments, for
960 the purpose of compile time evaluation. */
962 struct GTY((for_user
)) constexpr_call
{
963 /* Description of the constexpr function definition. */
964 constexpr_fundef
*fundef
;
965 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
966 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
967 Note: This arrangement is made to accommodate the use of
968 iterative_hash_template_arg (see pt.c). If you change this
969 representation, also change the hash calculation in
970 cxx_eval_call_expression. */
972 /* Result of the call.
973 NULL means the call is being evaluated.
974 error_mark_node means that the evaluation was erroneous;
975 otherwise, the actuall value of the call. */
977 /* The hash of this call; we remember it here to avoid having to
978 recalculate it when expanding the hash table. */
980 /* Whether __builtin_is_constant_evaluated() should evaluate to true. */
981 bool manifestly_const_eval
;
984 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
986 static hashval_t
hash (constexpr_call
*);
987 static bool equal (constexpr_call
*, constexpr_call
*);
990 enum constexpr_switch_state
{
991 /* Used when processing a switch for the first time by cxx_eval_switch_expr
992 and default: label for that switch has not been seen yet. */
993 css_default_not_seen
,
994 /* Used when processing a switch for the first time by cxx_eval_switch_expr
995 and default: label for that switch has been seen already. */
997 /* Used when processing a switch for the second time by
998 cxx_eval_switch_expr, where default: label should match. */
999 css_default_processing
1002 /* The constexpr expansion context. CALL is the current function
1003 expansion, CTOR is the current aggregate initializer, OBJECT is the
1004 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
1005 is a map of values of variables initialized within the expression. */
1007 struct constexpr_ctx
{
1008 /* The innermost call we're evaluating. */
1009 constexpr_call
*call
;
1010 /* Values for any temporaries or local variables within the
1011 constant-expression. */
1012 hash_map
<tree
,tree
> *values
;
1013 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
1014 aren't inside a loop. */
1015 hash_set
<tree
> *save_exprs
;
1016 /* The CONSTRUCTOR we're currently building up for an aggregate
1019 /* The object we're building the CONSTRUCTOR for. */
1021 /* If inside SWITCH_EXPR. */
1022 constexpr_switch_state
*css_state
;
1023 /* Whether we should error on a non-constant expression or fail quietly. */
1025 /* Whether we are strictly conforming to constant expression rules or
1026 trying harder to get a constant value. */
1028 /* Whether __builtin_is_constant_evaluated () should be true. */
1029 bool manifestly_const_eval
;
1032 /* A table of all constexpr calls that have been evaluated by the
1033 compiler in this translation unit. */
1035 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1037 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1038 bool, bool *, bool *, tree
* = NULL
);
1040 /* Compute a hash value for a constexpr call representation. */
1043 constexpr_call_hasher::hash (constexpr_call
*info
)
1048 /* Return true if the objects pointed to by P and Q represent calls
1049 to the same constexpr function with the same arguments.
1050 Otherwise, return false. */
1053 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1059 if (lhs
->hash
!= rhs
->hash
)
1061 if (lhs
->manifestly_const_eval
!= rhs
->manifestly_const_eval
)
1063 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1065 lhs_bindings
= lhs
->bindings
;
1066 rhs_bindings
= rhs
->bindings
;
1067 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1069 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1070 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1071 gcc_assert (same_type_p (TREE_TYPE (lhs_arg
), TREE_TYPE (rhs_arg
)));
1072 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1074 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1075 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1077 return lhs_bindings
== rhs_bindings
;
1080 /* Initialize the constexpr call table, if needed. */
1083 maybe_initialize_constexpr_call_table (void)
1085 if (constexpr_call_table
== NULL
)
1086 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1089 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1090 a function happens to get called recursively, we unshare the callee
1091 function's body and evaluate this unshared copy instead of evaluating the
1094 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1095 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1096 that's keyed off of the original FUNCTION_DECL and whose value is a
1097 TREE_LIST of this function's unused copies awaiting reuse.
1099 This is not GC-deletable to avoid GC affecting UID generation. */
1101 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1103 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1106 maybe_initialize_fundef_copies_table ()
1108 if (fundef_copies_table
== NULL
)
1109 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1112 /* Reuse a copy or create a new unshared copy of the function FUN.
1113 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1114 is parms, TYPE is result. */
1117 get_fundef_copy (tree fun
)
1119 maybe_initialize_fundef_copies_table ();
1123 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1127 /* There is no cached function available, or in use. We can use
1128 the function directly. That the slot is now created records
1129 that this function is now in use. */
1130 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1131 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1133 else if (*slot
== NULL_TREE
)
1135 /* We've already used the function itself, so make a copy. */
1136 copy
= build_tree_list (NULL
, NULL
);
1137 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1141 /* We have a cached function available. */
1143 *slot
= TREE_CHAIN (copy
);
1149 /* Save the copy COPY of function FUN for later reuse by
1150 get_fundef_copy(). By construction, there will always be an entry
1154 save_fundef_copy (tree fun
, tree copy
)
1156 tree
*slot
= fundef_copies_table
->get (fun
);
1157 TREE_CHAIN (copy
) = *slot
;
1161 /* We have an expression tree T that represents a call, either CALL_EXPR
1162 or AGGR_INIT_EXPR. Return the Nth argument. */
1165 get_nth_callarg (tree t
, int n
)
1167 switch (TREE_CODE (t
))
1170 return CALL_EXPR_ARG (t
, n
);
1172 case AGGR_INIT_EXPR
:
1173 return AGGR_INIT_EXPR_ARG (t
, n
);
1181 /* Attempt to evaluate T which represents a call to a builtin function.
1182 We assume here that all builtin functions evaluate to scalar types
1183 represented by _CST nodes. */
1186 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1188 bool *non_constant_p
, bool *overflow_p
)
1190 const int nargs
= call_expr_nargs (t
);
1191 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1195 /* Don't fold __builtin_constant_p within a constexpr function. */
1196 bool bi_const_p
= DECL_IS_BUILTIN_CONSTANT_P (fun
);
1198 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1199 in a constexpr function until we have values for the parameters. */
1201 && !ctx
->manifestly_const_eval
1202 && current_function_decl
1203 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1205 *non_constant_p
= true;
1209 /* For __builtin_is_constant_evaluated, defer it if not
1210 ctx->manifestly_const_eval, otherwise fold it to true. */
1211 if (fndecl_built_in_p (fun
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
1214 if (!ctx
->manifestly_const_eval
)
1216 *non_constant_p
= true;
1219 return boolean_true_node
;
1222 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1223 return constant false for a non-constant argument. */
1224 constexpr_ctx new_ctx
= *ctx
;
1225 new_ctx
.quiet
= true;
1226 for (i
= 0; i
< nargs
; ++i
)
1228 args
[i
] = CALL_EXPR_ARG (t
, i
);
1229 /* If builtin_valid_in_constant_expr_p is true,
1230 potential_constant_expression_1 has not recursed into the arguments
1231 of the builtin, verify it here. */
1232 if (!builtin_valid_in_constant_expr_p (fun
)
1233 || potential_constant_expression (args
[i
]))
1235 bool dummy1
= false, dummy2
= false;
1236 args
[i
] = cxx_eval_constant_expression (&new_ctx
, args
[i
], false,
1241 /* For __builtin_constant_p, fold all expressions with constant values
1242 even if they aren't C++ constant-expressions. */
1243 args
[i
] = cp_fold_rvalue (args
[i
]);
1246 bool save_ffbcp
= force_folding_builtin_constant_p
;
1247 force_folding_builtin_constant_p
= true;
1248 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1249 CALL_EXPR_FN (t
), nargs
, args
);
1250 force_folding_builtin_constant_p
= save_ffbcp
;
1251 if (new_call
== NULL
)
1253 if (!*non_constant_p
&& !ctx
->quiet
)
1255 /* Do not allow__builtin_unreachable in constexpr function.
1256 The __builtin_unreachable call with BUILTINS_LOCATION
1257 comes from cp_maybe_instrument_return. */
1258 if (fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
)
1259 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1260 error ("%<constexpr%> call flows off the end of the function");
1263 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1264 CALL_EXPR_FN (t
), nargs
, args
);
1265 error ("%q+E is not a constant expression", new_call
);
1268 *non_constant_p
= true;
1272 if (!is_constant_expression (new_call
))
1274 if (!*non_constant_p
&& !ctx
->quiet
)
1275 error ("%q+E is not a constant expression", new_call
);
1276 *non_constant_p
= true;
1280 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1281 non_constant_p
, overflow_p
);
1284 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1285 the type of the value to match. */
1288 adjust_temp_type (tree type
, tree temp
)
1290 if (same_type_p (TREE_TYPE (temp
), type
))
1292 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1293 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1295 /* build_constructor wouldn't retain various CONSTRUCTOR flags. */
1296 tree t
= copy_node (temp
);
1297 TREE_TYPE (t
) = type
;
1300 if (TREE_CODE (temp
) == EMPTY_CLASS_EXPR
)
1301 return build0 (EMPTY_CLASS_EXPR
, type
);
1302 gcc_assert (scalarish_type_p (type
));
1303 return cp_fold_convert (type
, temp
);
1306 /* Callback for walk_tree used by unshare_constructor. */
1309 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1313 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1318 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1319 subexpression, return an unshared copy of T. Otherwise return T. */
1322 unshare_constructor (tree t
)
1324 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1325 if (ctor
!= NULL_TREE
)
1326 return unshare_expr (t
);
1330 /* Subroutine of cxx_eval_call_expression.
1331 We are processing a call expression (either CALL_EXPR or
1332 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1333 all arguments and bind their values to correspondings
1334 parameters, making up the NEW_CALL context. */
1337 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1338 constexpr_call
*new_call
,
1339 bool *non_constant_p
, bool *overflow_p
,
1340 bool *non_constant_args
)
1342 const int nargs
= call_expr_nargs (t
);
1343 tree fun
= new_call
->fundef
->decl
;
1344 tree parms
= DECL_ARGUMENTS (fun
);
1346 tree
*p
= &new_call
->bindings
;
1347 for (i
= 0; i
< nargs
; ++i
)
1350 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1351 x
= get_nth_callarg (t
, i
);
1352 /* For member function, the first argument is a pointer to the implied
1353 object. For a constructor, it might still be a dummy object, in
1354 which case we get the real argument from ctx. */
1355 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1356 && is_dummy_object (x
))
1359 x
= build_address (x
);
1361 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1362 non_constant_p
, overflow_p
);
1363 /* Don't VERIFY_CONSTANT here. */
1364 if (*non_constant_p
&& ctx
->quiet
)
1366 /* Just discard ellipsis args after checking their constantitude. */
1370 if (!*non_constant_p
)
1372 /* Don't share a CONSTRUCTOR that might be changed. */
1373 arg
= unshare_constructor (arg
);
1374 /* Make sure the binding has the same type as the parm. But
1375 only for constant args. */
1376 if (!TYPE_REF_P (type
))
1377 arg
= adjust_temp_type (type
, arg
);
1378 if (!TREE_CONSTANT (arg
))
1379 *non_constant_args
= true;
1380 *p
= build_tree_list (parms
, arg
);
1381 p
= &TREE_CHAIN (*p
);
1383 parms
= TREE_CHAIN (parms
);
1387 /* Variables and functions to manage constexpr call expansion context.
1388 These do not need to be marked for PCH or GC. */
1390 /* FIXME remember and print actual constant arguments. */
1391 static vec
<tree
> call_stack
;
1392 static int call_stack_tick
;
1393 static int last_cx_error_tick
;
1396 push_cx_call_context (tree call
)
1399 if (!EXPR_HAS_LOCATION (call
))
1400 SET_EXPR_LOCATION (call
, input_location
);
1401 call_stack
.safe_push (call
);
1402 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1408 pop_cx_call_context (void)
1415 cx_error_context (void)
1417 vec
<tree
> r
= vNULL
;
1418 if (call_stack_tick
!= last_cx_error_tick
1419 && !call_stack
.is_empty ())
1421 last_cx_error_tick
= call_stack_tick
;
1425 /* Evaluate a call T to a GCC internal function when possible and return
1426 the evaluated result or, under the control of CTX, give an error, set
1427 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1430 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1432 bool *non_constant_p
, bool *overflow_p
)
1434 enum tree_code opcode
= ERROR_MARK
;
1436 switch (CALL_EXPR_IFN (t
))
1438 case IFN_UBSAN_NULL
:
1439 case IFN_UBSAN_BOUNDS
:
1440 case IFN_UBSAN_VPTR
:
1441 case IFN_FALLTHROUGH
:
1444 case IFN_ADD_OVERFLOW
:
1447 case IFN_SUB_OVERFLOW
:
1448 opcode
= MINUS_EXPR
;
1450 case IFN_MUL_OVERFLOW
:
1455 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1456 false, non_constant_p
, overflow_p
);
1458 case IFN_VEC_CONVERT
:
1460 tree arg
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1461 false, non_constant_p
,
1463 if (TREE_CODE (arg
) == VECTOR_CST
)
1464 return fold_const_call (CFN_VEC_CONVERT
, TREE_TYPE (t
), arg
);
1467 *non_constant_p
= true;
1474 error_at (cp_expr_loc_or_loc (t
, input_location
),
1475 "call to internal function %qE", t
);
1476 *non_constant_p
= true;
1480 /* Evaluate constant arguments using OPCODE and return a complex
1481 number containing the result and the overflow bit. */
1482 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1483 non_constant_p
, overflow_p
);
1484 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1485 non_constant_p
, overflow_p
);
1487 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1489 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1490 tree type
= TREE_TYPE (TREE_TYPE (t
));
1491 tree result
= fold_binary_loc (loc
, opcode
, type
,
1492 fold_convert_loc (loc
, type
, arg0
),
1493 fold_convert_loc (loc
, type
, arg1
));
1495 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1496 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1497 if (TREE_OVERFLOW (result
))
1498 TREE_OVERFLOW (result
) = 0;
1500 return build_complex (TREE_TYPE (t
), result
, ovf
);
1503 *non_constant_p
= true;
1507 /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */
1510 clear_no_implicit_zero (tree ctor
)
1512 if (CONSTRUCTOR_NO_CLEARING (ctor
))
1514 CONSTRUCTOR_NO_CLEARING (ctor
) = false;
1515 tree elt
; unsigned HOST_WIDE_INT idx
;
1516 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1517 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1518 clear_no_implicit_zero (elt
);
1522 /* Subroutine of cxx_eval_constant_expression.
1523 Evaluate the call expression tree T in the context of OLD_CALL expression
1527 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1529 bool *non_constant_p
, bool *overflow_p
)
1531 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1532 tree fun
= get_function_named_in_call (t
);
1533 constexpr_call new_call
1534 = { NULL
, NULL
, NULL
, 0, ctx
->manifestly_const_eval
};
1537 if (fun
== NULL_TREE
)
1538 return cxx_eval_internal_function (ctx
, t
, lval
,
1539 non_constant_p
, overflow_p
);
1541 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1543 /* Might be a constexpr function pointer. */
1544 fun
= cxx_eval_constant_expression (ctx
, fun
,
1545 /*lval*/false, non_constant_p
,
1548 if (TREE_CODE (fun
) == ADDR_EXPR
)
1549 fun
= TREE_OPERAND (fun
, 0);
1550 /* For TARGET_VTABLE_USES_DESCRIPTORS targets, there is no
1551 indirection, the called expression is a pointer into the
1552 virtual table which should contain FDESC_EXPR. Extract the
1553 FUNCTION_DECL from there. */
1554 else if (TARGET_VTABLE_USES_DESCRIPTORS
1555 && TREE_CODE (fun
) == POINTER_PLUS_EXPR
1556 && TREE_CODE (TREE_OPERAND (fun
, 0)) == ADDR_EXPR
1557 && TREE_CODE (TREE_OPERAND (fun
, 1)) == INTEGER_CST
)
1559 tree d
= TREE_OPERAND (TREE_OPERAND (fun
, 0), 0);
1561 && DECL_VTABLE_OR_VTT_P (d
)
1562 && TREE_CODE (TREE_TYPE (d
)) == ARRAY_TYPE
1563 && TREE_TYPE (TREE_TYPE (d
)) == vtable_entry_type
1565 && TREE_CODE (DECL_INITIAL (d
)) == CONSTRUCTOR
)
1567 tree i
= int_const_binop (TRUNC_DIV_EXPR
, TREE_OPERAND (fun
, 1),
1568 TYPE_SIZE_UNIT (vtable_entry_type
));
1569 HOST_WIDE_INT idx
= find_array_ctor_elt (DECL_INITIAL (d
), i
);
1573 = (*CONSTRUCTOR_ELTS (DECL_INITIAL (d
)))[idx
].value
;
1574 if (TREE_CODE (fdesc
) == FDESC_EXPR
1575 && integer_zerop (TREE_OPERAND (fdesc
, 1)))
1576 fun
= TREE_OPERAND (fdesc
, 0);
1581 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1583 if (!ctx
->quiet
&& !*non_constant_p
)
1584 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1586 *non_constant_p
= true;
1589 if (DECL_CLONED_FUNCTION_P (fun
))
1590 fun
= DECL_CLONED_FUNCTION (fun
);
1592 if (is_ubsan_builtin_p (fun
))
1595 if (fndecl_built_in_p (fun
))
1596 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1597 lval
, non_constant_p
, overflow_p
);
1598 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1602 if (!lambda_static_thunk_p (fun
))
1603 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1604 explain_invalid_constexpr_fn (fun
);
1606 *non_constant_p
= true;
1610 constexpr_ctx new_ctx
= *ctx
;
1611 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1612 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1614 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1615 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1616 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1617 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1618 CONSTRUCTOR_NO_CLEARING (ctor
) = true;
1619 ctx
->values
->put (new_ctx
.object
, ctor
);
1623 /* Shortcut trivial constructor/op=. */
1624 if (trivial_fn_p (fun
))
1626 tree init
= NULL_TREE
;
1627 if (call_expr_nargs (t
) == 2)
1628 init
= convert_from_reference (get_nth_callarg (t
, 1));
1629 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1630 && AGGR_INIT_ZERO_FIRST (t
))
1631 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1634 tree op
= get_nth_callarg (t
, 0);
1635 if (is_dummy_object (op
))
1638 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1639 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1640 new_ctx
.call
= &new_call
;
1641 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1642 non_constant_p
, overflow_p
);
1646 /* We can't defer instantiating the function any longer. */
1647 if (!DECL_INITIAL (fun
)
1648 && DECL_TEMPLOID_INSTANTIATION (fun
))
1650 location_t save_loc
= input_location
;
1651 input_location
= loc
;
1653 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1655 input_location
= save_loc
;
1658 /* If in direct recursive call, optimize definition search. */
1659 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1660 new_call
.fundef
= ctx
->call
->fundef
;
1663 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1664 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1665 || fun
== current_function_decl
)
1669 /* We need to check for current_function_decl here in case we're
1670 being called during cp_fold_function, because at that point
1671 DECL_INITIAL is set properly and we have a fundef but we
1672 haven't lowered invisirefs yet (c++/70344). */
1673 if (DECL_INITIAL (fun
) == error_mark_node
1674 || fun
== current_function_decl
)
1675 error_at (loc
, "%qD called in a constant expression before its "
1676 "definition is complete", fun
);
1677 else if (DECL_INITIAL (fun
))
1679 /* The definition of fun was somehow unsuitable. But pretend
1680 that lambda static thunks don't exist. */
1681 if (!lambda_static_thunk_p (fun
))
1682 error_at (loc
, "%qD called in a constant expression", fun
);
1683 explain_invalid_constexpr_fn (fun
);
1686 error_at (loc
, "%qD used before its definition", fun
);
1688 *non_constant_p
= true;
1693 bool non_constant_args
= false;
1694 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1695 non_constant_p
, overflow_p
, &non_constant_args
);
1696 if (*non_constant_p
)
1699 depth_ok
= push_cx_call_context (t
);
1701 tree result
= NULL_TREE
;
1703 constexpr_call
*entry
= NULL
;
1704 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1706 new_call
.hash
= constexpr_fundef_hasher::hash (new_call
.fundef
);
1708 = iterative_hash_template_arg (new_call
.bindings
, new_call
.hash
);
1710 = iterative_hash_object (ctx
->manifestly_const_eval
, new_call
.hash
);
1712 /* If we have seen this call before, we are done. */
1713 maybe_initialize_constexpr_call_table ();
1714 constexpr_call
**slot
1715 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1719 /* We need to keep a pointer to the entry, not just the slot, as the
1720 slot can move in the call to cxx_eval_builtin_function_call. */
1721 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1724 /* Calls that are in progress have their result set to NULL,
1725 so that we can detect circular dependencies. */
1726 else if (entry
->result
== NULL
)
1729 error ("call has circular dependency");
1730 *non_constant_p
= true;
1731 entry
->result
= result
= error_mark_node
;
1734 result
= entry
->result
;
1740 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1741 "%<-fconstexpr-depth=%> to increase the maximum)",
1742 max_constexpr_depth
);
1743 *non_constant_p
= true;
1744 result
= error_mark_node
;
1748 if (result
&& result
!= error_mark_node
)
1750 else if (!DECL_SAVED_TREE (fun
))
1752 /* When at_eof >= 2, cgraph has started throwing away
1753 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1754 late code generation for VEC_INIT_EXPR, which needs to be
1755 completely reconsidered. */
1756 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1757 *non_constant_p
= true;
1761 tree body
, parms
, res
;
1763 /* Reuse or create a new unshared copy of this function's body. */
1764 tree copy
= get_fundef_copy (fun
);
1765 body
= TREE_PURPOSE (copy
);
1766 parms
= TREE_VALUE (copy
);
1767 res
= TREE_TYPE (copy
);
1769 /* Associate the bindings with the remapped parms. */
1770 tree bound
= new_call
.bindings
;
1771 tree remapped
= parms
;
1774 tree oparm
= TREE_PURPOSE (bound
);
1775 tree arg
= TREE_VALUE (bound
);
1776 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1777 /* Don't share a CONSTRUCTOR that might be changed. */
1778 arg
= unshare_constructor (arg
);
1779 ctx
->values
->put (remapped
, arg
);
1780 bound
= TREE_CHAIN (bound
);
1781 remapped
= DECL_CHAIN (remapped
);
1783 /* Add the RESULT_DECL to the values map, too. */
1784 tree slot
= NULL_TREE
;
1785 if (DECL_BY_REFERENCE (res
))
1787 slot
= AGGR_INIT_EXPR_SLOT (t
);
1788 tree addr
= build_address (slot
);
1789 addr
= build_nop (TREE_TYPE (res
), addr
);
1790 ctx
->values
->put (res
, addr
);
1791 ctx
->values
->put (slot
, NULL_TREE
);
1794 ctx
->values
->put (res
, NULL_TREE
);
1796 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1797 their values after the call. */
1798 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1799 hash_set
<tree
> save_exprs
;
1800 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1801 ctx_with_save_exprs
.call
= &new_call
;
1803 tree jump_target
= NULL_TREE
;
1804 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1805 lval
, non_constant_p
, overflow_p
,
1808 if (DECL_CONSTRUCTOR_P (fun
))
1809 /* This can be null for a subobject constructor call, in
1810 which case what we care about is the initialization
1811 side-effects rather than the value. We could get at the
1812 value by evaluating *this, but we don't bother; there's
1813 no need to put such a call in the hash table. */
1814 result
= lval
? ctx
->object
: ctx
->ctor
;
1815 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1819 result
= *ctx
->values
->get (slot
? slot
: res
);
1820 if (result
== NULL_TREE
&& !*non_constant_p
)
1823 error ("%<constexpr%> call flows off the end "
1825 *non_constant_p
= true;
1829 /* Forget the saved values of the callee's SAVE_EXPRs. */
1830 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1831 iter
!= save_exprs
.end(); ++iter
)
1832 ctx_with_save_exprs
.values
->remove (*iter
);
1834 /* Remove the parms/result from the values map. Is it worth
1835 bothering to do this when the map itself is only live for
1836 one constexpr evaluation? If so, maybe also clear out
1837 other vars from call, maybe in BIND_EXPR handling? */
1838 ctx
->values
->remove (res
);
1840 ctx
->values
->remove (slot
);
1841 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1842 ctx
->values
->remove (parm
);
1844 /* Make the unshared function copy we used available for re-use. */
1845 save_fundef_copy (fun
, copy
);
1848 if (result
== error_mark_node
)
1849 *non_constant_p
= true;
1850 if (*non_constant_p
|| *overflow_p
)
1851 result
= error_mark_node
;
1855 entry
->result
= result
;
1858 /* The result of a constexpr function must be completely initialized. */
1859 if (TREE_CODE (result
) == CONSTRUCTOR
)
1860 clear_no_implicit_zero (result
);
1862 pop_cx_call_context ();
1863 return unshare_constructor (result
);
1866 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1869 reduced_constant_expression_p (tree t
)
1874 switch (TREE_CODE (t
))
1877 /* Even if we can't lower this yet, it's constant. */
1881 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1882 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1883 if (CONSTRUCTOR_NO_CLEARING (t
))
1885 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1886 /* An initialized vector would have a VECTOR_CST. */
1889 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1893 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1895 /* If VAL is null, we're in the middle of initializing this
1897 if (!reduced_constant_expression_p (val
))
1903 field
= next_initializable_field (DECL_CHAIN (field
));
1908 else if (CONSTRUCTOR_NO_CLEARING (t
))
1909 /* All the fields are initialized. */
1910 CONSTRUCTOR_NO_CLEARING (t
) = false;
1914 /* FIXME are we calling this too much? */
1915 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1919 /* Some expressions may have constant operands but are not constant
1920 themselves, such as 1/0. Call this function to check for that
1923 We only call this in places that require an arithmetic constant, not in
1924 places where we might have a non-constant expression that can be a
1925 component of a constant expression, such as the address of a constexpr
1926 variable that might be dereferenced later. */
1929 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1932 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1934 if (!allow_non_constant
)
1935 error ("%q+E is not a constant expression", t
);
1936 *non_constant_p
= true;
1938 if (TREE_OVERFLOW_P (t
))
1940 if (!allow_non_constant
)
1942 permerror (input_location
, "overflow in constant expression");
1943 /* If we're being permissive (and are in an enforcing
1944 context), ignore the overflow. */
1945 if (flag_permissive
)
1946 return *non_constant_p
;
1950 return *non_constant_p
;
1953 /* Check whether the shift operation with code CODE and type TYPE on LHS
1954 and RHS is undefined. If it is, give an error with an explanation,
1955 and return true; return false otherwise. */
1958 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1959 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1961 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1962 || TREE_CODE (lhs
) != INTEGER_CST
1963 || TREE_CODE (rhs
) != INTEGER_CST
)
1966 tree lhstype
= TREE_TYPE (lhs
);
1967 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1969 /* [expr.shift] The behavior is undefined if the right operand
1970 is negative, or greater than or equal to the length in bits
1971 of the promoted left operand. */
1972 if (tree_int_cst_sgn (rhs
) == -1)
1975 permerror (loc
, "right operand of shift expression %q+E is negative",
1976 build2_loc (loc
, code
, type
, lhs
, rhs
));
1977 return (!flag_permissive
|| ctx
->quiet
);
1979 if (compare_tree_int (rhs
, uprec
) >= 0)
1982 permerror (loc
, "right operand of shift expression %q+E is >= than "
1983 "the precision of the left operand",
1984 build2_loc (loc
, code
, type
, lhs
, rhs
));
1985 return (!flag_permissive
|| ctx
->quiet
);
1988 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1989 if E1 has a signed type and non-negative value, and E1x2^E2 is
1990 representable in the corresponding unsigned type of the result type,
1991 then that value, converted to the result type, is the resulting value;
1992 otherwise, the behavior is undefined.
1994 The value of E1 << E2 is the unique value congruent to E1 x 2^E2 modulo
1995 2^N, where N is the range exponent of the type of the result. */
1996 if (code
== LSHIFT_EXPR
1997 && !TYPE_UNSIGNED (lhstype
)
1998 && cxx_dialect
>= cxx11
1999 && cxx_dialect
< cxx2a
)
2001 if (tree_int_cst_sgn (lhs
) == -1)
2005 "left operand of shift expression %q+E is negative",
2006 build2_loc (loc
, code
, type
, lhs
, rhs
));
2007 return (!flag_permissive
|| ctx
->quiet
);
2009 /* For signed x << y the following:
2010 (unsigned) x >> ((prec (lhs) - 1) - y)
2011 if > 1, is undefined. The right-hand side of this formula
2012 is the highest bit of the LHS that can be set (starting from 0),
2013 so that the shift doesn't overflow. We then right-shift the LHS
2014 to see whether any other bit is set making the original shift
2015 undefined -- the result is not representable in the corresponding
2017 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
2018 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
2019 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
2020 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
2021 if (tree_int_cst_lt (integer_one_node
, t
))
2024 permerror (loc
, "shift expression %q+E overflows",
2025 build2_loc (loc
, code
, type
, lhs
, rhs
));
2026 return (!flag_permissive
|| ctx
->quiet
);
2032 /* Subroutine of cxx_eval_constant_expression.
2033 Attempt to reduce the unary expression tree T to a compile time value.
2034 If successful, return the value. Otherwise issue a diagnostic
2035 and return error_mark_node. */
2038 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
2040 bool *non_constant_p
, bool *overflow_p
)
2043 tree orig_arg
= TREE_OPERAND (t
, 0);
2044 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
2045 non_constant_p
, overflow_p
);
2046 VERIFY_CONSTANT (arg
);
2047 location_t loc
= EXPR_LOCATION (t
);
2048 enum tree_code code
= TREE_CODE (t
);
2049 tree type
= TREE_TYPE (t
);
2050 r
= fold_unary_loc (loc
, code
, type
, arg
);
2053 if (arg
== orig_arg
)
2056 r
= build1_loc (loc
, code
, type
, arg
);
2058 VERIFY_CONSTANT (r
);
2062 /* Helper function for cxx_eval_binary_expression. Try to optimize
2063 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
2064 generic folding should be used. */
2067 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
2068 tree lhs
, tree rhs
, bool *non_constant_p
,
2072 if (TREE_CODE (lhs
) != ADDR_EXPR
)
2075 lhs
= TREE_OPERAND (lhs
, 0);
2077 /* &A[i] p+ j => &A[i + j] */
2078 if (TREE_CODE (lhs
) == ARRAY_REF
2079 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
2080 && TREE_CODE (rhs
) == INTEGER_CST
2081 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
2082 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
2084 tree orig_type
= TREE_TYPE (t
);
2085 location_t loc
= EXPR_LOCATION (t
);
2086 tree type
= TREE_TYPE (lhs
);
2088 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
2089 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
2090 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2092 if (*non_constant_p
)
2094 /* Don't fold an out-of-bound access. */
2095 if (!tree_int_cst_le (t
, nelts
))
2097 rhs
= cp_fold_convert (ssizetype
, rhs
);
2098 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
2099 constexpr int A[1]; ... (char *)&A[0] + 1 */
2100 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
2101 rhs
, TYPE_SIZE_UNIT (type
))))
2103 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2105 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
2106 TYPE_SIZE_UNIT (type
));
2107 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
2108 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
2109 t
, NULL_TREE
, NULL_TREE
);
2110 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2111 t
= cp_fold_convert (orig_type
, t
);
2112 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2113 non_constant_p
, overflow_p
);
2119 /* Subroutine of cxx_eval_constant_expression.
2120 Like cxx_eval_unary_expression, except for binary expressions. */
2123 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2125 bool *non_constant_p
, bool *overflow_p
)
2128 tree orig_lhs
= TREE_OPERAND (t
, 0);
2129 tree orig_rhs
= TREE_OPERAND (t
, 1);
2131 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2132 non_constant_p
, overflow_p
);
2133 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2135 if (*non_constant_p
)
2137 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2138 non_constant_p
, overflow_p
);
2139 if (*non_constant_p
)
2142 location_t loc
= EXPR_LOCATION (t
);
2143 enum tree_code code
= TREE_CODE (t
);
2144 tree type
= TREE_TYPE (t
);
2146 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2148 bool is_code_eq
= (code
== EQ_EXPR
);
2150 if (TREE_CODE (lhs
) == PTRMEM_CST
2151 && TREE_CODE (rhs
) == PTRMEM_CST
)
2153 tree lmem
= PTRMEM_CST_MEMBER (lhs
);
2154 tree rmem
= PTRMEM_CST_MEMBER (rhs
);
2156 if (TREE_CODE (lmem
) == TREE_CODE (rmem
)
2157 && TREE_CODE (lmem
) == FIELD_DECL
2158 && TREE_CODE (DECL_CONTEXT (lmem
)) == UNION_TYPE
2159 && same_type_p (DECL_CONTEXT (lmem
),
2160 DECL_CONTEXT (rmem
)))
2161 /* If both refer to (possibly different) members of the same union
2162 (12.3), they compare equal. */
2165 eq
= cp_tree_equal (lhs
, rhs
);
2166 r
= constant_boolean_node (eq
== is_code_eq
, type
);
2168 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2169 || TREE_CODE (rhs
) == PTRMEM_CST
)
2170 && (null_member_pointer_value_p (lhs
)
2171 || null_member_pointer_value_p (rhs
)))
2172 r
= constant_boolean_node (!is_code_eq
, type
);
2173 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2174 lhs
= cplus_expand_constant (lhs
);
2175 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2176 rhs
= cplus_expand_constant (rhs
);
2178 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2179 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2182 error ("arithmetic involving a null pointer in %qE", lhs
);
2183 *non_constant_p
= true;
2186 else if (code
== POINTER_PLUS_EXPR
)
2187 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2191 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2195 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2198 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2200 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2201 *non_constant_p
= true;
2202 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2203 a local array in a constexpr function. */
2204 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (lhs
));
2206 VERIFY_CONSTANT (r
);
2210 /* Subroutine of cxx_eval_constant_expression.
2211 Attempt to evaluate condition expressions. Dead branches are not
2215 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2217 bool *non_constant_p
, bool *overflow_p
,
2220 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2222 non_constant_p
, overflow_p
);
2223 VERIFY_CONSTANT (val
);
2224 /* Don't VERIFY_CONSTANT the other operands. */
2225 if (integer_zerop (val
))
2226 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2228 non_constant_p
, overflow_p
,
2230 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2232 non_constant_p
, overflow_p
,
2236 /* Subroutine of cxx_eval_constant_expression.
2237 Attempt to evaluate vector condition expressions. Unlike
2238 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2239 ternary arithmetics operation, where all 3 arguments have to be
2240 evaluated as constants and then folding computes the result from
2244 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2245 bool *non_constant_p
, bool *overflow_p
)
2247 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2249 non_constant_p
, overflow_p
);
2250 VERIFY_CONSTANT (arg1
);
2251 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2253 non_constant_p
, overflow_p
);
2254 VERIFY_CONSTANT (arg2
);
2255 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2257 non_constant_p
, overflow_p
);
2258 VERIFY_CONSTANT (arg3
);
2259 location_t loc
= EXPR_LOCATION (t
);
2260 tree type
= TREE_TYPE (t
);
2261 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2264 if (arg1
== TREE_OPERAND (t
, 0)
2265 && arg2
== TREE_OPERAND (t
, 1)
2266 && arg3
== TREE_OPERAND (t
, 2))
2269 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2271 VERIFY_CONSTANT (r
);
2275 /* Returns less than, equal to, or greater than zero if KEY is found to be
2276 less than, to match, or to be greater than the constructor_elt's INDEX. */
2279 array_index_cmp (tree key
, tree index
)
2281 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2283 switch (TREE_CODE (index
))
2286 return tree_int_cst_compare (key
, index
);
2289 tree lo
= TREE_OPERAND (index
, 0);
2290 tree hi
= TREE_OPERAND (index
, 1);
2291 if (tree_int_cst_lt (key
, lo
))
2293 else if (tree_int_cst_lt (hi
, key
))
2303 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2304 if none. If INSERT is true, insert a matching element rather than fail. */
2306 static HOST_WIDE_INT
2307 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
)
2309 if (tree_int_cst_sgn (dindex
) < 0)
2312 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2313 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2314 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2316 unsigned HOST_WIDE_INT end
= len
;
2317 unsigned HOST_WIDE_INT begin
= 0;
2319 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2320 that the same is true of the other elements and index directly. */
2323 tree cindex
= (*elts
)[end
- 1].index
;
2324 if (TREE_CODE (cindex
) == INTEGER_CST
2325 && compare_tree_int (cindex
, end
- 1) == 0)
2334 /* Otherwise, find a matching index by means of a binary search. */
2335 while (begin
!= end
)
2337 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2338 constructor_elt
&elt
= (*elts
)[middle
];
2339 tree idx
= elt
.index
;
2341 int cmp
= array_index_cmp (dindex
, idx
);
2348 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2350 /* We need to split the range. */
2352 tree lo
= TREE_OPERAND (idx
, 0);
2353 tree hi
= TREE_OPERAND (idx
, 1);
2354 tree value
= elt
.value
;
2355 dindex
= fold_convert (sizetype
, dindex
);
2356 if (tree_int_cst_lt (lo
, dindex
))
2358 /* There are still some lower elts; shorten the range. */
2359 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2361 if (tree_int_cst_equal (lo
, new_hi
))
2362 /* Only one element left, no longer a range. */
2365 TREE_OPERAND (idx
, 1) = new_hi
;
2366 /* Append the element we want to insert. */
2369 e
.value
= unshare_constructor (value
);
2370 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2373 /* No lower elts, the range elt is now ours. */
2376 if (tree_int_cst_lt (dindex
, hi
))
2378 /* There are still some higher elts; append a range. */
2379 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2381 if (tree_int_cst_equal (new_lo
, hi
))
2384 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2385 e
.value
= unshare_constructor (value
);
2386 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2395 constructor_elt e
= { dindex
, NULL_TREE
};
2396 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2403 /* Under the control of CTX, issue a detailed diagnostic for
2404 an out-of-bounds subscript INDEX into the expression ARRAY. */
2407 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2411 tree arraytype
= TREE_TYPE (array
);
2413 /* Convert the unsigned array subscript to a signed integer to avoid
2414 printing huge numbers for small negative values. */
2415 tree sidx
= fold_convert (ssizetype
, index
);
2418 if (TYPE_DOMAIN (arraytype
))
2419 error ("array subscript value %qE is outside the bounds "
2420 "of array %qD of type %qT", sidx
, array
, arraytype
);
2422 error ("non-zero array subscript %qE is used with array %qD of "
2423 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2424 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2426 else if (TYPE_DOMAIN (arraytype
))
2427 error ("array subscript value %qE is outside the bounds "
2428 "of array type %qT", sidx
, arraytype
);
2430 error ("non-zero array subscript %qE is used with array of type %qT "
2431 "with unknown bounds", sidx
, arraytype
);
2435 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2439 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2440 bool *non_constant_p
, bool *overflow_p
)
2443 if (TREE_CODE (type
) == ARRAY_TYPE
)
2445 if (TYPE_DOMAIN (type
))
2446 nelts
= array_type_nelts_top (type
);
2448 nelts
= size_zero_node
;
2450 else if (VECTOR_TYPE_P (type
))
2451 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2455 /* For VLAs, the number of elements won't be an integer constant. */
2456 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2457 non_constant_p
, overflow_p
);
2461 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2462 STRING_CST STRING. */
2465 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2467 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2470 if (chars_per_elt
== 1)
2471 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2474 const unsigned char *ptr
2475 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2476 + index
* chars_per_elt
);
2477 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2482 /* Subroutine of cxx_eval_constant_expression.
2483 Attempt to reduce a reference to an array slot. */
2486 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2488 bool *non_constant_p
, bool *overflow_p
)
2490 tree oldary
= TREE_OPERAND (t
, 0);
2491 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2493 non_constant_p
, overflow_p
);
2495 HOST_WIDE_INT i
= 0;
2496 tree elem_type
= NULL_TREE
;
2497 unsigned len
= 0, elem_nchars
= 1;
2498 if (*non_constant_p
)
2500 oldidx
= TREE_OPERAND (t
, 1);
2501 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2503 non_constant_p
, overflow_p
);
2504 VERIFY_CONSTANT (index
);
2507 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2508 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2509 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2510 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2511 ary
= TREE_OPERAND (ary
, 0);
2512 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2513 len
= CONSTRUCTOR_NELTS (ary
);
2514 else if (TREE_CODE (ary
) == STRING_CST
)
2516 elem_nchars
= (TYPE_PRECISION (elem_type
)
2517 / TYPE_PRECISION (char_type_node
));
2518 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2520 else if (TREE_CODE (ary
) == VECTOR_CST
)
2521 /* We don't create variable-length VECTOR_CSTs. */
2522 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2525 /* We can't do anything with other tree codes, so use
2526 VERIFY_CONSTANT to complain and fail. */
2527 VERIFY_CONSTANT (ary
);
2531 if (!tree_fits_shwi_p (index
)
2532 || (i
= tree_to_shwi (index
)) < 0)
2534 diag_array_subscript (ctx
, ary
, index
);
2535 *non_constant_p
= true;
2540 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2542 VERIFY_CONSTANT (nelts
);
2544 ? !tree_int_cst_le (index
, nelts
)
2545 : !tree_int_cst_lt (index
, nelts
))
2546 || tree_int_cst_sgn (index
) < 0)
2548 diag_array_subscript (ctx
, ary
, index
);
2549 *non_constant_p
= true;
2553 if (lval
&& ary
== oldary
&& index
== oldidx
)
2556 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2559 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2561 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2572 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2573 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2574 else if (TREE_CODE (ary
) == VECTOR_CST
)
2575 r
= VECTOR_CST_ELT (ary
, i
);
2577 r
= extract_string_elt (ary
, elem_nchars
, i
);
2580 /* Don't VERIFY_CONSTANT here. */
2583 /* Otherwise the element doesn't have a value yet. */
2588 if (TREE_CODE (ary
) == CONSTRUCTOR
2589 && CONSTRUCTOR_NO_CLEARING (ary
))
2591 /* 'ary' is part of the aggregate initializer we're currently
2592 building; if there's no initializer for this element yet,
2595 error ("accessing uninitialized array element");
2596 *non_constant_p
= true;
2600 /* If it's within the array bounds but doesn't have an explicit
2601 initializer, it's value-initialized. */
2602 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2603 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2607 /* Subroutine of cxx_eval_constant_expression.
2608 Attempt to reduce a field access of a value of class type. */
2611 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2613 bool *non_constant_p
, bool *overflow_p
)
2615 unsigned HOST_WIDE_INT i
;
2618 tree part
= TREE_OPERAND (t
, 1);
2619 tree orig_whole
= TREE_OPERAND (t
, 0);
2620 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2622 non_constant_p
, overflow_p
);
2623 if (INDIRECT_REF_P (whole
)
2624 && integer_zerop (TREE_OPERAND (whole
, 0)))
2627 error ("dereferencing a null pointer in %qE", orig_whole
);
2628 *non_constant_p
= true;
2632 if (TREE_CODE (whole
) == PTRMEM_CST
)
2633 whole
= cplus_expand_constant (whole
);
2634 if (whole
== orig_whole
)
2637 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2638 whole
, part
, NULL_TREE
);
2639 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2641 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2644 error ("%qE is not a constant expression", orig_whole
);
2645 *non_constant_p
= true;
2647 if (DECL_MUTABLE_P (part
))
2650 error ("mutable %qD is not usable in a constant expression", part
);
2651 *non_constant_p
= true;
2653 if (*non_constant_p
)
2655 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2656 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2658 /* Use name match for PMF fields, as a variant will have a
2659 different FIELD_DECL with a different type. */
2660 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2666 /* We're in the middle of initializing it. */
2670 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2671 && CONSTRUCTOR_NELTS (whole
) > 0)
2673 /* DR 1188 says we don't have to deal with this. */
2675 error ("accessing %qD member instead of initialized %qD member in "
2676 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2677 *non_constant_p
= true;
2681 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2682 classes never get represented; throw together a value now. */
2683 if (is_really_empty_class (TREE_TYPE (t
)))
2684 return build_constructor (TREE_TYPE (t
), NULL
);
2686 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2688 if (CONSTRUCTOR_NO_CLEARING (whole
))
2690 /* 'whole' is part of the aggregate initializer we're currently
2691 building; if there's no initializer for this member yet, that's an
2694 error ("accessing uninitialized member %qD", part
);
2695 *non_constant_p
= true;
2699 /* If there's no explicit init for this field, it's value-initialized. */
2700 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2701 return cxx_eval_constant_expression (ctx
, value
,
2703 non_constant_p
, overflow_p
);
2706 /* Subroutine of cxx_eval_constant_expression.
2707 Attempt to reduce a field access of a value of class type that is
2708 expressed as a BIT_FIELD_REF. */
2711 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2713 bool *non_constant_p
, bool *overflow_p
)
2715 tree orig_whole
= TREE_OPERAND (t
, 0);
2716 tree retval
, fldval
, utype
, mask
;
2717 bool fld_seen
= false;
2718 HOST_WIDE_INT istart
, isize
;
2719 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2721 non_constant_p
, overflow_p
);
2722 tree start
, field
, value
;
2723 unsigned HOST_WIDE_INT i
;
2725 if (whole
== orig_whole
)
2727 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2729 if (!*non_constant_p
2730 && TREE_CODE (whole
) != VECTOR_CST
2731 && TREE_CODE (whole
) != CONSTRUCTOR
)
2734 error ("%qE is not a constant expression", orig_whole
);
2735 *non_constant_p
= true;
2737 if (*non_constant_p
)
2740 if (TREE_CODE (whole
) == VECTOR_CST
)
2741 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2742 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2744 start
= TREE_OPERAND (t
, 2);
2745 istart
= tree_to_shwi (start
);
2746 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2747 utype
= TREE_TYPE (t
);
2748 if (!TYPE_UNSIGNED (utype
))
2749 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2750 retval
= build_int_cst (utype
, 0);
2751 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2753 tree bitpos
= bit_position (field
);
2754 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2756 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2757 && TREE_CODE (value
) == INTEGER_CST
2758 && tree_fits_shwi_p (bitpos
)
2759 && tree_fits_shwi_p (DECL_SIZE (field
)))
2761 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2762 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2763 HOST_WIDE_INT shift
;
2764 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2766 fldval
= fold_convert (utype
, value
);
2767 mask
= build_int_cst_type (utype
, -1);
2768 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2769 size_int (TYPE_PRECISION (utype
) - sz
));
2770 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2771 size_int (TYPE_PRECISION (utype
) - sz
));
2772 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2773 shift
= bit
- istart
;
2774 if (BYTES_BIG_ENDIAN
)
2775 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2776 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2778 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2784 return fold_convert (TREE_TYPE (t
), retval
);
2786 return error_mark_node
;
2789 /* Subroutine of cxx_eval_constant_expression.
2790 Evaluate a short-circuited logical expression T in the context
2791 of a given constexpr CALL. BAILOUT_VALUE is the value for
2792 early return. CONTINUE_VALUE is used here purely for
2793 sanity check purposes. */
2796 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2797 tree bailout_value
, tree continue_value
,
2799 bool *non_constant_p
, bool *overflow_p
)
2802 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2804 non_constant_p
, overflow_p
);
2805 VERIFY_CONSTANT (lhs
);
2806 if (tree_int_cst_equal (lhs
, bailout_value
))
2808 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2809 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2810 lval
, non_constant_p
,
2812 VERIFY_CONSTANT (r
);
2816 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2817 CONSTRUCTOR elements to initialize (part of) an object containing that
2818 field. Return a pointer to the constructor_elt corresponding to the
2819 initialization of the field. */
2821 static constructor_elt
*
2822 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2824 tree aggr
= TREE_OPERAND (ref
, 0);
2825 tree field
= TREE_OPERAND (ref
, 1);
2827 constructor_elt
*ce
;
2829 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2831 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2833 constructor_elt
*base_ce
2834 = base_field_constructor_elt (v
, aggr
);
2835 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2838 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2839 if (ce
->index
== field
)
2846 /* Some of the expressions fed to the constexpr mechanism are calls to
2847 constructors, which have type void. In that case, return the type being
2848 initialized by the constructor. */
2851 initialized_type (tree t
)
2855 tree type
= TREE_TYPE (t
);
2856 if (TREE_CODE (t
) == CALL_EXPR
)
2858 /* A constructor call has void type, so we need to look deeper. */
2859 tree fn
= get_function_named_in_call (t
);
2860 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2861 && DECL_CXX_CONSTRUCTOR_P (fn
))
2862 type
= DECL_CONTEXT (fn
);
2864 else if (TREE_CODE (t
) == COMPOUND_EXPR
)
2865 return initialized_type (TREE_OPERAND (t
, 1));
2866 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
2867 type
= TREE_TYPE (AGGR_INIT_EXPR_SLOT (t
));
2868 return cv_unqualified (type
);
2871 /* We're about to initialize element INDEX of an array or class from VALUE.
2872 Set up NEW_CTX appropriately by adjusting .object to refer to the
2873 subobject and creating a new CONSTRUCTOR if the element is itself
2874 a class or array. */
2877 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2878 tree index
, tree
&value
)
2882 if (index
&& TREE_CODE (index
) != INTEGER_CST
2883 && TREE_CODE (index
) != FIELD_DECL
)
2884 /* This won't have an element in the new CONSTRUCTOR. */
2887 tree type
= initialized_type (value
);
2888 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2889 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2892 /* The sub-aggregate initializer might contain a placeholder;
2893 update object to refer to the subobject and ctor to refer to
2894 the (newly created) sub-initializer. */
2896 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2897 tree elt
= build_constructor (type
, NULL
);
2898 CONSTRUCTOR_NO_CLEARING (elt
) = true;
2901 if (TREE_CODE (value
) == TARGET_EXPR
)
2902 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2903 value
= TARGET_EXPR_INITIAL (value
);
2906 /* We're about to process an initializer for a class or array TYPE. Make
2907 sure that CTX is set up appropriately. */
2910 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2912 /* We don't bother building a ctor for an empty base subobject. */
2913 if (is_empty_class (type
))
2916 /* We're in the middle of an initializer that might involve placeholders;
2917 our caller should have created a CONSTRUCTOR for us to put the
2918 initializer into. We will either return that constructor or T. */
2919 gcc_assert (ctx
->ctor
);
2920 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2921 (type
, TREE_TYPE (ctx
->ctor
)));
2922 /* We used to check that ctx->ctor was empty, but that isn't the case when
2923 the object is zero-initialized before calling the constructor. */
2926 tree otype
= TREE_TYPE (ctx
->object
);
2927 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2928 /* Handle flexible array members. */
2929 || (TREE_CODE (otype
) == ARRAY_TYPE
2930 && TYPE_DOMAIN (otype
) == NULL_TREE
2931 && TREE_CODE (type
) == ARRAY_TYPE
2932 && (same_type_ignoring_top_level_qualifiers_p
2933 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2935 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2936 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2939 /* Subroutine of cxx_eval_constant_expression.
2940 The expression tree T denotes a C-style array or a C-style
2941 aggregate. Reduce it to a constant expression. */
2944 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2946 bool *non_constant_p
, bool *overflow_p
)
2948 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2949 bool changed
= false;
2950 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2951 tree type
= TREE_TYPE (t
);
2953 constexpr_ctx new_ctx
;
2954 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2956 /* We don't really need the ctx->ctor business for a PMF or
2957 vector, but it's simpler to use the same code. */
2959 new_ctx
.ctor
= build_constructor (type
, NULL
);
2960 new_ctx
.object
= NULL_TREE
;
2963 verify_ctor_sanity (ctx
, type
);
2964 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2965 vec_alloc (*p
, vec_safe_length (v
));
2969 bool constant_p
= true;
2970 bool side_effects_p
= false;
2971 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2973 tree orig_value
= value
;
2974 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2975 if (new_ctx
.ctor
!= ctx
->ctor
)
2976 /* If we built a new CONSTRUCTOR, attach it now so that other
2977 initializers can refer to it. */
2978 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2979 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2981 non_constant_p
, overflow_p
);
2982 /* Don't VERIFY_CONSTANT here. */
2983 if (ctx
->quiet
&& *non_constant_p
)
2985 if (elt
!= orig_value
)
2988 if (!TREE_CONSTANT (elt
))
2990 if (TREE_SIDE_EFFECTS (elt
))
2991 side_effects_p
= true;
2992 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2994 /* This is an initialization of a vfield inside a base
2995 subaggregate that we already initialized; push this
2996 initialization into the previous initialization. */
2997 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
3002 && (TREE_CODE (index
) == NOP_EXPR
3003 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
3005 /* This is an initializer for an empty base; now that we've
3006 checked that it's constant, we can ignore it. */
3007 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
3012 if (new_ctx
.ctor
!= ctx
->ctor
)
3014 /* We appended this element above; update the value. */
3015 gcc_assert ((*p
)->last().index
== index
);
3016 (*p
)->last().value
= elt
;
3019 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
3020 /* Adding or replacing an element might change the ctor's flags. */
3021 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
3022 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
3025 if (*non_constant_p
|| !changed
)
3028 /* We're done building this CONSTRUCTOR, so now we can interpret an
3029 element without an explicit initializer as value-initialized. */
3030 CONSTRUCTOR_NO_CLEARING (t
) = false;
3031 TREE_CONSTANT (t
) = constant_p
;
3032 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
3033 if (VECTOR_TYPE_P (type
))
3038 /* Subroutine of cxx_eval_constant_expression.
3039 The expression tree T is a VEC_INIT_EXPR which denotes the desired
3040 initialization of a non-static data member of array type. Reduce it to a
3043 Note that apart from value-initialization (when VALUE_INIT is true),
3044 this is only intended to support value-initialization and the
3045 initializations done by defaulted constructors for classes with
3046 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
3047 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
3048 for the copy/move constructor. */
3051 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
3052 bool value_init
, bool lval
,
3053 bool *non_constant_p
, bool *overflow_p
)
3055 tree elttype
= TREE_TYPE (atype
);
3056 verify_ctor_sanity (ctx
, atype
);
3057 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
3058 bool pre_init
= false;
3059 unsigned HOST_WIDE_INT i
;
3060 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
3062 /* For the default constructor, build up a call to the default
3063 constructor of the element type. We only need to handle class types
3064 here, as for a constructor to be constexpr, all members must be
3065 initialized, which for a defaulted default constructor means they must
3066 be of a class type with a constexpr default constructor. */
3067 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3068 /* We only do this at the lowest level. */;
3069 else if (value_init
)
3071 init
= build_value_init (elttype
, complain
);
3076 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
3077 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
3078 &argvec
, elttype
, LOOKUP_NORMAL
,
3080 release_tree_vector (argvec
);
3081 init
= build_aggr_init_expr (elttype
, init
);
3085 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
3087 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
3088 for (i
= 0; i
< max
; ++i
)
3090 tree idx
= build_int_cst (size_type_node
, i
);
3093 constexpr_ctx new_ctx
;
3094 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
3095 if (new_ctx
.ctor
!= ctx
->ctor
)
3096 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
3097 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3099 /* A multidimensional array; recurse. */
3100 if (value_init
|| init
== NULL_TREE
)
3102 eltinit
= NULL_TREE
;
3106 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3107 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
3109 non_constant_p
, overflow_p
);
3113 /* Initializing an element using value or default initialization
3114 we just pre-built above. */
3115 if (init
== void_node
)
3116 /* Trivial default-init, don't do anything to the CONSTRUCTOR. */
3118 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
3119 non_constant_p
, overflow_p
);
3124 /* Copying an element. */
3125 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3126 (atype
, TREE_TYPE (init
)));
3127 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3128 if (!lvalue_p (init
))
3129 eltinit
= move (eltinit
);
3130 eltinit
= force_rvalue (eltinit
, complain
);
3131 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
3132 non_constant_p
, overflow_p
);
3134 if (*non_constant_p
&& !ctx
->quiet
)
3136 if (new_ctx
.ctor
!= ctx
->ctor
)
3138 /* We appended this element above; update the value. */
3139 gcc_assert ((*p
)->last().index
== idx
);
3140 (*p
)->last().value
= eltinit
;
3143 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3144 /* Reuse the result of cxx_eval_constant_expression call
3145 from the first iteration to all others if it is a constant
3146 initializer that doesn't require relocations. */
3149 && (eltinit
== NULL_TREE
3150 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3151 == null_pointer_node
)))
3153 if (new_ctx
.ctor
!= ctx
->ctor
)
3154 eltinit
= new_ctx
.ctor
;
3155 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3156 build_int_cst (size_type_node
, 1),
3157 build_int_cst (size_type_node
, max
- 1));
3158 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3162 vec_safe_reserve (*p
, max
);
3165 if (!*non_constant_p
)
3168 CONSTRUCTOR_NO_CLEARING (init
) = false;
3174 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3176 bool *non_constant_p
, bool *overflow_p
)
3178 tree atype
= TREE_TYPE (t
);
3179 tree init
= VEC_INIT_EXPR_INIT (t
);
3180 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3181 VEC_INIT_EXPR_VALUE_INIT (t
),
3182 lval
, non_constant_p
, overflow_p
);
3183 if (*non_constant_p
)
3189 /* Like same_type_ignoring_top_level_qualifiers_p, but also handle the case
3190 where the desired type is an array of unknown bounds because the variable
3191 has had its bounds deduced since the wrapping expression was created. */
3194 same_type_ignoring_tlq_and_bounds_p (tree type1
, tree type2
)
3196 while (TREE_CODE (type1
) == ARRAY_TYPE
3197 && TREE_CODE (type2
) == ARRAY_TYPE
3198 && (!TYPE_DOMAIN (type1
) || !TYPE_DOMAIN (type2
)))
3200 type1
= TREE_TYPE (type1
);
3201 type2
= TREE_TYPE (type2
);
3203 return same_type_ignoring_top_level_qualifiers_p (type1
, type2
);
3206 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3207 match. We want to be less strict for simple *& folding; if we have a
3208 non-const temporary that we access through a const pointer, that should
3209 work. We handle this here rather than change fold_indirect_ref_1
3210 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3211 don't really make sense outside of constant expression evaluation. Also
3212 we want to allow folding to COMPONENT_REF, which could cause trouble
3213 with TBAA in fold_indirect_ref_1.
3215 Try to keep this function synced with fold_indirect_ref_1. */
3218 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3222 poly_uint64 const_op01
;
3225 subtype
= TREE_TYPE (sub
);
3226 if (!INDIRECT_TYPE_P (subtype
))
3229 if (TREE_CODE (sub
) == ADDR_EXPR
)
3231 tree op
= TREE_OPERAND (sub
, 0);
3232 tree optype
= TREE_TYPE (op
);
3234 /* *&CONST_DECL -> to the value of the const decl. */
3235 if (TREE_CODE (op
) == CONST_DECL
)
3236 return DECL_INITIAL (op
);
3237 /* *&p => p; make sure to handle *&"str"[cst] here. */
3238 if (same_type_ignoring_tlq_and_bounds_p (optype
, type
))
3240 tree fop
= fold_read_from_constant_string (op
);
3246 /* *(foo *)&fooarray => fooarray[0] */
3247 else if (TREE_CODE (optype
) == ARRAY_TYPE
3248 && (same_type_ignoring_top_level_qualifiers_p
3249 (type
, TREE_TYPE (optype
))))
3251 tree type_domain
= TYPE_DOMAIN (optype
);
3252 tree min_val
= size_zero_node
;
3253 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3254 min_val
= TYPE_MIN_VALUE (type_domain
);
3255 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3256 NULL_TREE
, NULL_TREE
);
3258 /* *(foo *)&complexfoo => __real__ complexfoo */
3259 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3260 && (same_type_ignoring_top_level_qualifiers_p
3261 (type
, TREE_TYPE (optype
))))
3262 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3263 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3264 else if (VECTOR_TYPE_P (optype
)
3265 && (same_type_ignoring_top_level_qualifiers_p
3266 (type
, TREE_TYPE (optype
))))
3268 tree part_width
= TYPE_SIZE (type
);
3269 tree index
= bitsize_int (0);
3270 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3273 /* Also handle conversion to an empty base class, which
3274 is represented with a NOP_EXPR. */
3275 else if (is_empty_class (type
)
3276 && CLASS_TYPE_P (optype
)
3277 && DERIVED_FROM_P (type
, optype
))
3282 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3283 else if (RECORD_OR_UNION_TYPE_P (optype
))
3285 tree field
= TYPE_FIELDS (optype
);
3286 for (; field
; field
= DECL_CHAIN (field
))
3287 if (TREE_CODE (field
) == FIELD_DECL
3288 && TREE_TYPE (field
) != error_mark_node
3289 && integer_zerop (byte_position (field
))
3290 && (same_type_ignoring_top_level_qualifiers_p
3291 (TREE_TYPE (field
), type
)))
3292 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3295 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3296 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3298 tree op00
= TREE_OPERAND (sub
, 0);
3299 tree op01
= TREE_OPERAND (sub
, 1);
3302 if (TREE_CODE (op00
) == ADDR_EXPR
)
3305 op00
= TREE_OPERAND (op00
, 0);
3306 op00type
= TREE_TYPE (op00
);
3308 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3309 if (VECTOR_TYPE_P (op00type
)
3310 && same_type_ignoring_top_level_qualifiers_p
3311 (type
, TREE_TYPE (op00type
))
3312 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3313 but we want to treat offsets with MSB set as negative.
3314 For the code below negative offsets are invalid and
3315 TYPE_SIZE of the element is something unsigned, so
3316 check whether op01 fits into poly_int64, which implies
3317 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3318 then just use poly_uint64 because we want to treat the
3319 value as unsigned. */
3320 && tree_fits_poly_int64_p (op01
))
3322 tree part_width
= TYPE_SIZE (type
);
3323 poly_uint64 max_offset
3324 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3325 * TYPE_VECTOR_SUBPARTS (op00type
));
3326 if (known_lt (const_op01
, max_offset
))
3328 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3329 return fold_build3_loc (loc
,
3330 BIT_FIELD_REF
, type
, op00
,
3334 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3335 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3336 && (same_type_ignoring_top_level_qualifiers_p
3337 (type
, TREE_TYPE (op00type
))))
3339 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3341 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3343 /* ((foo *)&fooarray)[1] => fooarray[1] */
3344 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3345 && (same_type_ignoring_top_level_qualifiers_p
3346 (type
, TREE_TYPE (op00type
))))
3348 tree type_domain
= TYPE_DOMAIN (op00type
);
3349 tree min_val
= size_zero_node
;
3350 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3351 min_val
= TYPE_MIN_VALUE (type_domain
);
3352 offset_int off
= wi::to_offset (op01
);
3353 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3354 offset_int remainder
;
3355 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3356 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3358 off
= off
+ wi::to_offset (min_val
);
3359 op01
= wide_int_to_tree (sizetype
, off
);
3360 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3361 NULL_TREE
, NULL_TREE
);
3364 /* Also handle conversion to an empty base class, which
3365 is represented with a NOP_EXPR. */
3366 else if (is_empty_class (type
)
3367 && CLASS_TYPE_P (op00type
)
3368 && DERIVED_FROM_P (type
, op00type
))
3373 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3374 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3376 tree field
= TYPE_FIELDS (op00type
);
3377 for (; field
; field
= DECL_CHAIN (field
))
3378 if (TREE_CODE (field
) == FIELD_DECL
3379 && TREE_TYPE (field
) != error_mark_node
3380 && tree_int_cst_equal (byte_position (field
), op01
)
3381 && (same_type_ignoring_top_level_qualifiers_p
3382 (TREE_TYPE (field
), type
)))
3383 return fold_build3 (COMPONENT_REF
, type
, op00
,
3388 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3389 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3390 && (same_type_ignoring_top_level_qualifiers_p
3391 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3394 tree min_val
= size_zero_node
;
3396 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3400 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3401 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3402 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3403 min_val
= TYPE_MIN_VALUE (type_domain
);
3404 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3412 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3414 bool *non_constant_p
, bool *overflow_p
)
3416 tree orig_op0
= TREE_OPERAND (t
, 0);
3417 bool empty_base
= false;
3419 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3420 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3422 if (TREE_CODE (t
) == MEM_REF
3423 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3425 gcc_assert (ctx
->quiet
);
3426 *non_constant_p
= true;
3430 /* First try to simplify it directly. */
3431 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3435 /* If that didn't work, evaluate the operand first. */
3436 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3437 /*lval*/false, non_constant_p
,
3439 /* Don't VERIFY_CONSTANT here. */
3440 if (*non_constant_p
)
3443 if (!lval
&& integer_zerop (op0
))
3446 error ("dereferencing a null pointer");
3447 *non_constant_p
= true;
3451 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3455 /* We couldn't fold to a constant value. Make sure it's not
3456 something we should have been able to fold. */
3459 if (TREE_CODE (sub
) == ADDR_EXPR
)
3461 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3462 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3463 /* DR 1188 says we don't have to deal with this. */
3465 error ("accessing value of %qE through a %qT glvalue in a "
3466 "constant expression", build_fold_indirect_ref (sub
),
3468 *non_constant_p
= true;
3472 if (lval
&& op0
!= orig_op0
)
3473 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3475 VERIFY_CONSTANT (t
);
3480 r
= cxx_eval_constant_expression (ctx
, r
,
3481 lval
, non_constant_p
, overflow_p
);
3482 if (*non_constant_p
)
3485 /* If we're pulling out the value of an empty base, just return an empty
3487 if (empty_base
&& !lval
)
3489 r
= build_constructor (TREE_TYPE (t
), NULL
);
3490 TREE_CONSTANT (r
) = true;
3496 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3497 Shared between potential_constant_expression and
3498 cxx_eval_constant_expression. */
3501 non_const_var_error (tree r
)
3503 tree type
= TREE_TYPE (r
);
3504 error ("the value of %qD is not usable in a constant "
3506 /* Avoid error cascade. */
3507 if (DECL_INITIAL (r
) == error_mark_node
)
3509 if (DECL_DECLARED_CONSTEXPR_P (r
))
3510 inform (DECL_SOURCE_LOCATION (r
),
3511 "%qD used in its own initializer", r
);
3512 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3514 if (!CP_TYPE_CONST_P (type
))
3515 inform (DECL_SOURCE_LOCATION (r
),
3516 "%q#D is not const", r
);
3517 else if (CP_TYPE_VOLATILE_P (type
))
3518 inform (DECL_SOURCE_LOCATION (r
),
3519 "%q#D is volatile", r
);
3520 else if (!DECL_INITIAL (r
)
3521 || !TREE_CONSTANT (DECL_INITIAL (r
))
3522 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3523 inform (DECL_SOURCE_LOCATION (r
),
3524 "%qD was not initialized with a constant "
3529 else if (TYPE_REF_P (type
))
3530 inform (DECL_SOURCE_LOCATION (r
),
3531 "%qD was not initialized with a constant "
3535 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3536 inform (DECL_SOURCE_LOCATION (r
),
3537 "%qD was not declared %<constexpr%>", r
);
3539 inform (DECL_SOURCE_LOCATION (r
),
3540 "%qD does not have integral or enumeration type",
3545 /* Subroutine of cxx_eval_constant_expression.
3546 Like cxx_eval_unary_expression, except for trinary expressions. */
3549 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3551 bool *non_constant_p
, bool *overflow_p
)
3557 for (i
= 0; i
< 3; i
++)
3559 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3561 non_constant_p
, overflow_p
);
3562 VERIFY_CONSTANT (args
[i
]);
3565 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3566 args
[0], args
[1], args
[2]);
3567 if (val
== NULL_TREE
)
3569 VERIFY_CONSTANT (val
);
3573 /* True if T was declared in a function declared to be constexpr, and
3574 therefore potentially constant in C++14. */
3577 var_in_constexpr_fn (tree t
)
3579 tree ctx
= DECL_CONTEXT (t
);
3580 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3581 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3584 /* True if T was declared in a function that might be constexpr: either a
3585 function that was declared constexpr, or a C++17 lambda op(). */
3588 var_in_maybe_constexpr_fn (tree t
)
3590 if (cxx_dialect
>= cxx17
3591 && DECL_FUNCTION_SCOPE_P (t
)
3592 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3594 return var_in_constexpr_fn (t
);
3597 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3598 build_over_call we implement trivial copy of a class with tail padding using
3599 assignment of character arrays, which is valid in normal code, but not in
3600 constexpr evaluation. We don't need to worry about clobbering tail padding
3601 in constexpr evaluation, so strip the type punning. */
3604 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3606 if (TREE_CODE (target
) == MEM_REF
3607 && TREE_CODE (init
) == MEM_REF
3608 && TREE_TYPE (target
) == TREE_TYPE (init
)
3609 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3610 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3612 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3613 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3617 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3620 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3622 bool *non_constant_p
, bool *overflow_p
)
3624 constexpr_ctx new_ctx
= *ctx
;
3626 tree init
= TREE_OPERAND (t
, 1);
3627 if (TREE_CLOBBER_P (init
))
3628 /* Just ignore clobbers. */
3631 /* First we figure out where we're storing to. */
3632 tree target
= TREE_OPERAND (t
, 0);
3634 maybe_simplify_trivial_copy (target
, init
);
3636 tree type
= TREE_TYPE (target
);
3637 bool preeval
= SCALAR_TYPE_P (type
) || TREE_CODE (t
) == MODIFY_EXPR
;
3640 /* Evaluate the value to be stored without knowing what object it will be
3641 stored in, so that any side-effects happen first. */
3642 if (!SCALAR_TYPE_P (type
))
3643 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3644 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3645 non_constant_p
, overflow_p
);
3646 if (*non_constant_p
)
3649 target
= cxx_eval_constant_expression (ctx
, target
,
3651 non_constant_p
, overflow_p
);
3652 if (*non_constant_p
)
3655 /* cxx_eval_array_reference for lval = true allows references one past
3656 end of array, because it does not know if it is just taking address
3657 (which is valid), or actual dereference. Here we know it is
3658 a dereference, so diagnose it here. */
3659 for (tree probe
= target
; probe
; )
3661 switch (TREE_CODE (probe
))
3665 ary
= TREE_OPERAND (probe
, 0);
3666 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3667 non_constant_p
, overflow_p
);
3668 VERIFY_CONSTANT (nelts
);
3669 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3670 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3671 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3673 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3674 *non_constant_p
= true;
3681 probe
= TREE_OPERAND (probe
, 0);
3690 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3692 /* For initialization of an empty base, the original target will be
3693 *(base*)this, which the above evaluation resolves to the object
3694 argument, which has the derived type rather than the base type. In
3695 this situation, just evaluate the initializer and return, since
3696 there's no actual data to store. */
3697 gcc_assert (is_empty_class (type
));
3698 return cxx_eval_constant_expression (ctx
, init
, false,
3699 non_constant_p
, overflow_p
);
3702 /* And then find the underlying variable. */
3703 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3704 tree object
= NULL_TREE
;
3705 for (tree probe
= target
; object
== NULL_TREE
; )
3707 switch (TREE_CODE (probe
))
3712 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3713 vec_safe_push (refs
, TREE_TYPE (probe
));
3714 probe
= TREE_OPERAND (probe
, 0);
3722 /* And then find/build up our initializer for the path to the subobject
3723 we're initializing. */
3725 if (object
== ctx
->object
&& VAR_P (object
)
3726 && DECL_NAME (object
) && ctx
->call
== NULL
)
3727 /* The variable we're building up an aggregate initializer for is outside
3728 the constant-expression, so don't evaluate the store. We check
3729 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3731 else if (DECL_P (object
))
3732 valp
= ctx
->values
->get (object
);
3737 /* A constant-expression cannot modify objects from outside the
3738 constant-expression. */
3740 error ("modification of %qE is not a constant expression", object
);
3741 *non_constant_p
= true;
3744 type
= TREE_TYPE (object
);
3745 bool no_zero_init
= true;
3747 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3748 while (!refs
->is_empty())
3750 if (*valp
== NULL_TREE
)
3752 *valp
= build_constructor (type
, NULL
);
3753 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3755 else if (TREE_CODE (*valp
) == STRING_CST
)
3757 /* An array was initialized with a string constant, and now
3758 we're writing into one of its elements. Explode the
3759 single initialization into a set of element
3761 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3763 tree string
= *valp
;
3764 tree elt_type
= TREE_TYPE (type
);
3765 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3766 / TYPE_PRECISION (char_type_node
));
3767 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3768 tree ary_ctor
= build_constructor (type
, NULL
);
3770 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3771 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3773 constructor_elt elt
=
3775 build_int_cst (size_type_node
, ix
),
3776 extract_string_elt (string
, chars_per_elt
, ix
)
3778 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3784 /* If the value of object is already zero-initialized, any new ctors for
3785 subobjects will also be zero-initialized. */
3786 no_zero_init
= CONSTRUCTOR_NO_CLEARING (*valp
);
3788 vec_safe_push (ctors
, *valp
);
3790 enum tree_code code
= TREE_CODE (type
);
3792 tree index
= refs
->pop();
3794 constructor_elt
*cep
= NULL
;
3795 if (code
== ARRAY_TYPE
)
3798 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3799 gcc_assert (i
>= 0);
3800 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3801 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3805 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3807 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3808 Usually we meet initializers in that order, but it is
3809 possible for base types to be placed not in program
3811 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3812 unsigned HOST_WIDE_INT idx
;
3814 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3815 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3816 /* Changing active member. */
3817 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3820 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3821 idx
++, fields
= DECL_CHAIN (fields
))
3823 if (index
== cep
->index
)
3826 /* The field we're initializing must be on the field
3827 list. Look to see if it is present before the
3828 field the current ELT initializes. */
3829 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3830 if (index
== fields
)
3834 /* We fell off the end of the CONSTRUCTOR, so insert a new
3835 entry at the end. */
3838 constructor_elt ce
= { index
, NULL_TREE
};
3840 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3841 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3847 release_tree_vector (refs
);
3851 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3852 wants to modify it. */
3853 if (*valp
== NULL_TREE
)
3855 *valp
= build_constructor (type
, NULL
);
3856 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3858 new_ctx
.ctor
= *valp
;
3859 new_ctx
.object
= target
;
3860 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3861 non_constant_p
, overflow_p
);
3862 if (target
== object
)
3863 /* The hash table might have moved since the get earlier. */
3864 valp
= ctx
->values
->get (object
);
3867 /* Don't share a CONSTRUCTOR that might be changed later. */
3868 init
= unshare_constructor (init
);
3870 if (*valp
&& TREE_CODE (*valp
) == CONSTRUCTOR
3871 && TREE_CODE (init
) == CONSTRUCTOR
)
3873 /* An outer ctx->ctor might be pointing to *valp, so replace
3875 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3876 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3877 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3878 CONSTRUCTOR_NO_CLEARING (*valp
)
3879 = CONSTRUCTOR_NO_CLEARING (init
);
3884 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3885 CONSTRUCTORs, if any. */
3888 bool c
= TREE_CONSTANT (init
);
3889 bool s
= TREE_SIDE_EFFECTS (init
);
3891 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3894 TREE_CONSTANT (elt
) = false;
3896 TREE_SIDE_EFFECTS (elt
) = true;
3898 release_tree_vector (ctors
);
3900 if (*non_constant_p
)
3908 /* Evaluate a ++ or -- expression. */
3911 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3913 bool *non_constant_p
, bool *overflow_p
)
3915 enum tree_code code
= TREE_CODE (t
);
3916 tree type
= TREE_TYPE (t
);
3917 tree op
= TREE_OPERAND (t
, 0);
3918 tree offset
= TREE_OPERAND (t
, 1);
3919 gcc_assert (TREE_CONSTANT (offset
));
3921 /* The operand as an lvalue. */
3922 op
= cxx_eval_constant_expression (ctx
, op
, true,
3923 non_constant_p
, overflow_p
);
3925 /* The operand as an rvalue. */
3927 = cxx_eval_constant_expression (ctx
, op
, false,
3928 non_constant_p
, overflow_p
);
3929 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3930 a local array in a constexpr function. */
3931 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (val
));
3933 VERIFY_CONSTANT (val
);
3935 /* The modified value. */
3936 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3938 if (INDIRECT_TYPE_P (type
))
3940 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3941 offset
= convert_to_ptrofftype (offset
);
3943 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3944 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3947 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3949 VERIFY_CONSTANT (mod
);
3951 /* Storing the modified value. */
3952 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3953 cxx_eval_constant_expression (ctx
, store
,
3954 true, non_constant_p
, overflow_p
);
3956 /* And the value of the expression. */
3957 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3959 /* Prefix ops are lvalues. */
3963 /* But we optimize when the caller wants an rvalue. */
3967 /* Postfix ops are rvalues. */
3971 /* Predicates for the meaning of *jump_target. */
3974 returns (tree
*jump_target
)
3977 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3978 || (TREE_CODE (*jump_target
) == LABEL_DECL
3979 && LABEL_DECL_CDTOR (*jump_target
)));
3983 breaks (tree
*jump_target
)
3986 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3987 && LABEL_DECL_BREAK (*jump_target
))
3988 || TREE_CODE (*jump_target
) == BREAK_STMT
3989 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3993 continues (tree
*jump_target
)
3996 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3997 && LABEL_DECL_CONTINUE (*jump_target
))
3998 || TREE_CODE (*jump_target
) == CONTINUE_STMT
);
4003 switches (tree
*jump_target
)
4006 && TREE_CODE (*jump_target
) == INTEGER_CST
;
4009 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
4010 STMT matches *jump_target. If we're looking for a case label and we see
4011 the default label, note it in ctx->css_state. */
4014 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
4016 switch (TREE_CODE (*jump_target
))
4019 if (TREE_CODE (stmt
) == LABEL_EXPR
4020 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
4025 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
4027 gcc_assert (ctx
->css_state
!= NULL
);
4028 if (!CASE_LOW (stmt
))
4030 /* default: should appear just once in a SWITCH_EXPR
4031 body (excluding nested SWITCH_EXPR). */
4032 gcc_assert (*ctx
->css_state
!= css_default_seen
);
4033 /* When evaluating SWITCH_EXPR body for the second time,
4034 return true for the default: label. */
4035 if (*ctx
->css_state
== css_default_processing
)
4037 *ctx
->css_state
= css_default_seen
;
4039 else if (CASE_HIGH (stmt
))
4041 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
4042 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
4045 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
4056 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
4057 semantics, for switch, break, continue, and return. */
4060 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
4061 bool *non_constant_p
, bool *overflow_p
,
4064 tree_stmt_iterator i
;
4066 /* In a statement-expression we want to return the last value.
4067 For empty statement expression return void_node. */
4071 local_target
= NULL_TREE
;
4072 jump_target
= &local_target
;
4074 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4076 tree stmt
= tsi_stmt (i
);
4077 /* We've found a continue, so skip everything until we reach
4078 the label its jumping to. */
4079 if (continues (jump_target
))
4081 if (label_matches (ctx
, jump_target
, stmt
))
4083 *jump_target
= NULL_TREE
;
4087 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
4089 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
4090 non_constant_p
, overflow_p
,
4092 if (*non_constant_p
)
4094 if (returns (jump_target
) || breaks (jump_target
))
4100 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
4101 semantics; continue semantics are covered by cxx_eval_statement_list. */
4104 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
4105 bool *non_constant_p
, bool *overflow_p
,
4108 constexpr_ctx new_ctx
= *ctx
;
4110 tree body
= TREE_OPERAND (t
, 0);
4114 hash_set
<tree
> save_exprs
;
4115 new_ctx
.save_exprs
= &save_exprs
;
4117 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
4118 non_constant_p
, overflow_p
, jump_target
);
4120 /* Forget saved values of SAVE_EXPRs. */
4121 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
4122 iter
!= save_exprs
.end(); ++iter
)
4123 new_ctx
.values
->remove (*iter
);
4124 if (++count
>= constexpr_loop_limit
)
4127 error_at (cp_expr_loc_or_loc (t
, input_location
),
4128 "%<constexpr%> loop iteration count exceeds limit of %d "
4129 "(use -fconstexpr-loop-limit= to increase the limit)",
4130 constexpr_loop_limit
);
4131 *non_constant_p
= true;
4135 while (!returns (jump_target
)
4136 && !breaks (jump_target
)
4137 && !switches (jump_target
)
4138 && !*non_constant_p
);
4140 if (breaks (jump_target
))
4141 *jump_target
= NULL_TREE
;
4146 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
4150 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
4151 bool *non_constant_p
, bool *overflow_p
,
4154 tree cond
= SWITCH_COND (t
);
4155 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
4156 non_constant_p
, overflow_p
);
4157 VERIFY_CONSTANT (cond
);
4158 *jump_target
= cond
;
4160 tree body
= SWITCH_BODY (t
);
4161 constexpr_ctx new_ctx
= *ctx
;
4162 constexpr_switch_state css
= css_default_not_seen
;
4163 new_ctx
.css_state
= &css
;
4164 cxx_eval_constant_expression (&new_ctx
, body
, false,
4165 non_constant_p
, overflow_p
, jump_target
);
4166 if (switches (jump_target
) && css
== css_default_seen
)
4168 /* If the SWITCH_EXPR body has default: label, process it once again,
4169 this time instructing label_matches to return true for default:
4170 label on switches (jump_target). */
4171 css
= css_default_processing
;
4172 cxx_eval_constant_expression (&new_ctx
, body
, false,
4173 non_constant_p
, overflow_p
, jump_target
);
4175 if (breaks (jump_target
) || switches (jump_target
))
4176 *jump_target
= NULL_TREE
;
4180 /* Find the object of TYPE under initialization in CTX. */
4183 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4188 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4189 can is a minor optimization. */
4190 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4196 /* Since an object cannot have a field of its own type, we can search outward
4197 from ctx->object to find the unique containing object of TYPE. */
4198 tree ob
= ctx
->object
;
4201 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4203 if (handled_component_p (ob
))
4204 ob
= TREE_OPERAND (ob
, 0);
4212 /* Attempt to reduce the expression T to a constant value.
4213 On failure, issue diagnostic and return error_mark_node. */
4214 /* FIXME unify with c_fully_fold */
4215 /* FIXME overflow_p is too global */
4218 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4220 bool *non_constant_p
, bool *overflow_p
,
4221 tree
*jump_target
/* = NULL */)
4223 constexpr_ctx new_ctx
;
4226 if (jump_target
&& *jump_target
)
4228 /* If we are jumping, ignore all statements/expressions except those
4229 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4230 switch (TREE_CODE (t
))
4233 case STATEMENT_LIST
:
4238 case CASE_LABEL_EXPR
:
4239 if (label_matches (ctx
, jump_target
, t
))
4241 *jump_target
= NULL_TREE
;
4247 if (error_operand_p (t
))
4249 *non_constant_p
= true;
4252 if (CONSTANT_CLASS_P (t
))
4254 if (TREE_OVERFLOW (t
))
4257 permerror (input_location
, "overflow in constant expression");
4258 if (!flag_permissive
|| ctx
->quiet
)
4262 if (TREE_CODE (t
) == INTEGER_CST
4263 && TYPE_PTR_P (TREE_TYPE (t
))
4264 && !integer_zerop (t
))
4267 error ("value %qE of type %qT is not a constant expression",
4269 *non_constant_p
= true;
4275 tree_code tcode
= TREE_CODE (t
);
4281 /* We ask for an rvalue for the RESULT_DECL when indirecting
4282 through an invisible reference, or in named return value
4284 if (tree
*p
= ctx
->values
->get (t
))
4289 error ("%qE is not a constant expression", t
);
4290 *non_constant_p
= true;
4295 if (DECL_HAS_VALUE_EXPR_P (t
))
4296 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4297 lval
, non_constant_p
, overflow_p
);
4300 /* We used to not check lval for CONST_DECL, but darwin.c uses
4301 CONST_DECL for aggregate constants. */
4304 /* is_really_empty_class doesn't take into account _vptr, so initializing
4305 otherwise empty class with { } would overwrite the initializer that
4306 initialize_vtable created for us. */
4307 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4308 && !TYPE_POLYMORPHIC_P (TREE_TYPE (t
))
4309 && is_really_empty_class (TREE_TYPE (t
)))
4311 /* If the class is empty, we aren't actually loading anything. */
4312 r
= build_constructor (TREE_TYPE (t
), NULL
);
4313 TREE_CONSTANT (r
) = true;
4315 else if (ctx
->strict
)
4316 r
= decl_really_constant_value (t
);
4318 r
= decl_constant_value (t
);
4319 if (TREE_CODE (r
) == TARGET_EXPR
4320 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4321 r
= TARGET_EXPR_INITIAL (r
);
4323 if (tree
*p
= ctx
->values
->get (r
))
4324 if (*p
!= NULL_TREE
)
4329 non_const_var_error (r
);
4330 *non_constant_p
= true;
4334 case DEBUG_BEGIN_STMT
:
4335 /* ??? It might be nice to retain this information somehow, so
4336 as to be able to step into a constexpr function call. */
4343 case CASE_LABEL_EXPR
:
4348 if (lval
&& !TYPE_REF_P (TREE_TYPE (t
)))
4350 else if (tree
*p
= ctx
->values
->get (r
))
4353 /* Defer in case this is only used for its type. */;
4354 else if (TYPE_REF_P (TREE_TYPE (t
)))
4355 /* Defer, there's no lvalue->rvalue conversion. */;
4356 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4357 && is_really_empty_class (TREE_TYPE (t
)))
4359 /* If the class is empty, we aren't actually loading anything. */
4360 r
= build_constructor (TREE_TYPE (t
), NULL
);
4361 TREE_CONSTANT (r
) = true;
4366 error ("%qE is not a constant expression", t
);
4367 *non_constant_p
= true;
4372 case AGGR_INIT_EXPR
:
4373 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4374 non_constant_p
, overflow_p
);
4379 r
= DECL_EXPR_DECL (t
);
4380 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4381 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4385 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4386 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4387 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4391 if (tree init
= DECL_INITIAL (r
))
4393 init
= cxx_eval_constant_expression (ctx
, init
,
4395 non_constant_p
, overflow_p
);
4396 /* Don't share a CONSTRUCTOR that might be changed. */
4397 init
= unshare_constructor (init
);
4398 ctx
->values
->put (r
, init
);
4400 else if (ctx
== &new_ctx
)
4401 /* We gave it a CONSTRUCTOR above. */;
4403 ctx
->values
->put (r
, NULL_TREE
);
4408 if (!literal_type_p (TREE_TYPE (t
)))
4412 auto_diagnostic_group d
;
4413 error ("temporary of non-literal type %qT in a "
4414 "constant expression", TREE_TYPE (t
));
4415 explain_non_literal_class (TREE_TYPE (t
));
4417 *non_constant_p
= true;
4420 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4422 /* We're being expanded without an explicit target, so start
4423 initializing a new object; expansion with an explicit target
4424 strips the TARGET_EXPR before we get here. */
4426 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4427 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4428 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4429 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4432 /* Pass false for 'lval' because this indicates
4433 initialization of a temporary. */
4434 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4436 non_constant_p
, overflow_p
);
4437 if (!*non_constant_p
)
4438 /* Adjust the type of the result to the type of the temporary. */
4439 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4442 tree slot
= TARGET_EXPR_SLOT (t
);
4443 r
= unshare_constructor (r
);
4444 ctx
->values
->put (slot
, r
);
4451 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4452 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4453 non_constant_p
, overflow_p
);
4457 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4459 non_constant_p
, overflow_p
);
4463 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4464 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4466 non_constant_p
, overflow_p
);
4471 /* Can happen with ({ return true; }) && false; passed to
4472 maybe_constant_value. There is nothing to jump over in this
4473 case, and the bug will be diagnosed later. */
4474 gcc_assert (ctx
->quiet
);
4475 *non_constant_p
= true;
4480 /* Avoid evaluating a SAVE_EXPR more than once. */
4481 if (tree
*p
= ctx
->values
->get (t
))
4485 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4486 non_constant_p
, overflow_p
);
4487 ctx
->values
->put (t
, r
);
4488 if (ctx
->save_exprs
)
4489 ctx
->save_exprs
->add (t
);
4493 case NON_LVALUE_EXPR
:
4494 case TRY_CATCH_EXPR
:
4496 case CLEANUP_POINT_EXPR
:
4497 case MUST_NOT_THROW_EXPR
:
4500 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4502 non_constant_p
, overflow_p
,
4506 case TRY_FINALLY_EXPR
:
4507 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4508 non_constant_p
, overflow_p
,
4510 if (!*non_constant_p
)
4511 /* Also evaluate the cleanup. */
4512 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4513 non_constant_p
, overflow_p
,
4517 /* These differ from cxx_eval_unary_expression in that this doesn't
4518 check for a constant operand or result; an address can be
4519 constant without its operand being, and vice versa. */
4522 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4523 non_constant_p
, overflow_p
);
4528 tree oldop
= TREE_OPERAND (t
, 0);
4529 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4531 non_constant_p
, overflow_p
);
4532 /* Don't VERIFY_CONSTANT here. */
4533 if (*non_constant_p
)
4535 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4536 /* This function does more aggressive folding than fold itself. */
4537 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4538 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4547 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4548 non_constant_p
, overflow_p
);
4549 if (r
== error_mark_node
)
4551 else if (r
== TREE_OPERAND (t
, 0))
4554 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4559 case FIX_TRUNC_EXPR
:
4565 case TRUTH_NOT_EXPR
:
4566 case FIXED_CONVERT_EXPR
:
4567 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4568 non_constant_p
, overflow_p
);
4572 r
= fold_sizeof_expr (t
);
4573 VERIFY_CONSTANT (r
);
4578 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4579 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4580 introduced by build_call_a. */
4581 tree op0
= TREE_OPERAND (t
, 0);
4582 tree op1
= TREE_OPERAND (t
, 1);
4584 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4585 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4586 r
= cxx_eval_constant_expression (ctx
, op0
,
4587 lval
, non_constant_p
, overflow_p
,
4591 /* Check that the LHS is constant and then discard it. */
4592 cxx_eval_constant_expression (ctx
, op0
,
4593 true, non_constant_p
, overflow_p
,
4595 if (*non_constant_p
)
4597 op1
= TREE_OPERAND (t
, 1);
4598 r
= cxx_eval_constant_expression (ctx
, op1
,
4599 lval
, non_constant_p
, overflow_p
,
4605 case POINTER_PLUS_EXPR
:
4606 case POINTER_DIFF_EXPR
:
4610 case TRUNC_DIV_EXPR
:
4612 case FLOOR_DIV_EXPR
:
4613 case ROUND_DIV_EXPR
:
4614 case TRUNC_MOD_EXPR
:
4616 case ROUND_MOD_EXPR
:
4618 case EXACT_DIV_EXPR
:
4628 case TRUTH_XOR_EXPR
:
4635 case UNORDERED_EXPR
:
4645 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4646 non_constant_p
, overflow_p
);
4649 /* fold can introduce non-IF versions of these; still treat them as
4650 short-circuiting. */
4651 case TRUTH_AND_EXPR
:
4652 case TRUTH_ANDIF_EXPR
:
4653 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4656 non_constant_p
, overflow_p
);
4660 case TRUTH_ORIF_EXPR
:
4661 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4664 non_constant_p
, overflow_p
);
4668 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4669 non_constant_p
, overflow_p
);
4673 if (is_overloaded_fn (t
))
4675 /* We can only get here in checking mode via
4676 build_non_dependent_expr, because any expression that
4677 calls or takes the address of the function will have
4678 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4679 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4680 *non_constant_p
= true;
4683 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4684 non_constant_p
, overflow_p
);
4688 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4689 non_constant_p
, overflow_p
);
4693 if (jump_target
&& *jump_target
)
4695 tree orig_jump
= *jump_target
;
4696 /* When jumping to a label, the label might be either in the
4697 then or else blocks, so process then block first in skipping
4698 mode first, and if we are still in the skipping mode at its end,
4699 process the else block too. */
4700 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4701 lval
, non_constant_p
, overflow_p
,
4703 /* It's possible that we found the label in the then block. But
4704 it could have been followed by another jumping statement, e.g.
4705 say we're looking for case 1:
4708 // skipped statements
4709 case 1:; // clears up *jump_target
4710 return 1; // and sets it to a RETURN_EXPR
4713 in which case we need not go looking to the else block.
4714 (goto is not allowed in a constexpr function.) */
4715 if (*jump_target
== orig_jump
)
4716 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4717 lval
, non_constant_p
, overflow_p
,
4721 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4722 non_constant_p
, overflow_p
,
4726 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4731 if (TREE_CONSTANT (t
) && reduced_constant_expression_p (t
))
4733 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4734 VECTOR_CST if applicable. */
4735 verify_constructor_flags (t
);
4736 if (TREE_CONSTANT (t
))
4739 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4740 non_constant_p
, overflow_p
);
4744 /* We can get this in a defaulted constructor for a class with a
4745 non-static data member of array type. Either the initializer will
4746 be NULL, meaning default-initialization, or it will be an lvalue
4747 or xvalue of the same type, meaning direct-initialization from the
4748 corresponding member. */
4749 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4750 non_constant_p
, overflow_p
);
4754 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4755 non_constant_p
, overflow_p
);
4759 if (REINTERPRET_CAST_P (t
))
4762 error_at (cp_expr_loc_or_loc (t
, input_location
),
4763 "a reinterpret_cast is not a constant expression");
4764 *non_constant_p
= true;
4769 case VIEW_CONVERT_EXPR
:
4770 case UNARY_PLUS_EXPR
:
4772 tree oldop
= TREE_OPERAND (t
, 0);
4774 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4776 non_constant_p
, overflow_p
);
4777 if (*non_constant_p
)
4779 tree type
= TREE_TYPE (t
);
4780 if (TREE_CODE (op
) == PTRMEM_CST
4781 && !TYPE_PTRMEM_P (type
))
4782 op
= cplus_expand_constant (op
);
4784 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4786 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (op
))
4787 && !can_convert_qual (type
, op
))
4788 op
= cplus_expand_constant (op
);
4789 return cp_fold_convert (type
, op
);
4792 if (INDIRECT_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4794 if (integer_zerop (op
))
4796 if (TYPE_REF_P (type
))
4799 error_at (cp_expr_loc_or_loc (t
, input_location
),
4800 "dereferencing a null pointer");
4801 *non_constant_p
= true;
4804 else if (TYPE_PTR_P (TREE_TYPE (op
)))
4806 tree from
= TREE_TYPE (op
);
4808 if (!can_convert (type
, from
, tf_none
))
4811 error_at (cp_expr_loc_or_loc (t
, input_location
),
4812 "conversion of %qT null pointer to %qT "
4813 "is not a constant expression",
4815 *non_constant_p
= true;
4822 /* This detects for example:
4823 reinterpret_cast<void*>(sizeof 0)
4826 error_at (cp_expr_loc_or_loc (t
, input_location
),
4827 "%<reinterpret_cast<%T>(%E)%> is not "
4828 "a constant expression",
4830 *non_constant_p
= true;
4835 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4836 /* We didn't fold at the top so we could check for ptr-int
4840 /* Handle an array's bounds having been deduced after we built
4841 the wrapping expression. */
4842 if (same_type_ignoring_tlq_and_bounds_p (type
, TREE_TYPE (op
)))
4844 else if (tcode
== UNARY_PLUS_EXPR
)
4845 r
= fold_convert (TREE_TYPE (t
), op
);
4847 r
= fold_build1 (tcode
, type
, op
);
4849 /* Conversion of an out-of-range value has implementation-defined
4850 behavior; the language considers it different from arithmetic
4851 overflow, which is undefined. */
4852 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4853 TREE_OVERFLOW (r
) = false;
4857 case EMPTY_CLASS_EXPR
:
4858 /* This is good enough for a function argument that might not get
4859 used, and they can't do anything with it, so just return it. */
4862 case STATEMENT_LIST
:
4864 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4865 return cxx_eval_statement_list (&new_ctx
, t
,
4866 non_constant_p
, overflow_p
, jump_target
);
4869 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4871 non_constant_p
, overflow_p
,
4874 case PREINCREMENT_EXPR
:
4875 case POSTINCREMENT_EXPR
:
4876 case PREDECREMENT_EXPR
:
4877 case POSTDECREMENT_EXPR
:
4878 return cxx_eval_increment_expression (ctx
, t
,
4879 lval
, non_constant_p
, overflow_p
);
4885 case VEC_DELETE_EXPR
:
4888 /* GCC internal stuff. */
4890 case NON_DEPENDENT_EXPR
:
4894 error_at (cp_expr_loc_or_loc (t
, input_location
),
4895 "expression %qE is not a constant expression", t
);
4896 *non_constant_p
= true;
4901 /* Virtual function call. Let the constexpr machinery figure out
4902 the dynamic type. */
4903 int token
= tree_to_shwi (OBJ_TYPE_REF_TOKEN (t
));
4904 tree obj
= OBJ_TYPE_REF_OBJECT (t
);
4905 obj
= cxx_eval_constant_expression (ctx
, obj
, lval
, non_constant_p
,
4907 /* We expect something in the form of &x.D.2103.D.2094; get x. */
4908 if (TREE_CODE (obj
) != ADDR_EXPR
4909 || !DECL_P (get_base_address (TREE_OPERAND (obj
, 0))))
4912 error_at (cp_expr_loc_or_loc (t
, input_location
),
4913 "expression %qE is not a constant expression", t
);
4914 *non_constant_p
= true;
4917 obj
= TREE_OPERAND (obj
, 0);
4918 while (TREE_CODE (obj
) == COMPONENT_REF
4919 && DECL_FIELD_IS_BASE (TREE_OPERAND (obj
, 1)))
4920 obj
= TREE_OPERAND (obj
, 0);
4921 tree objtype
= TREE_TYPE (obj
);
4922 /* Find the function decl in the virtual functions list. TOKEN is
4923 the DECL_VINDEX that says which function we're looking for. */
4924 tree virtuals
= BINFO_VIRTUALS (TYPE_BINFO (objtype
));
4925 if (TARGET_VTABLE_USES_DESCRIPTORS
)
4926 token
/= MAX (TARGET_VTABLE_USES_DESCRIPTORS
, 1);
4927 r
= TREE_VALUE (chain_index (token
, virtuals
));
4931 case PLACEHOLDER_EXPR
:
4932 /* Use of the value or address of the current object. */
4933 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4934 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4935 non_constant_p
, overflow_p
);
4936 /* A placeholder without a referent. We can get here when
4937 checking whether NSDMIs are noexcept, or in massage_init_elt;
4938 just say it's non-constant for now. */
4939 gcc_assert (ctx
->quiet
);
4940 *non_constant_p
= true;
4945 tree cond
= TREE_OPERAND (t
, 0);
4946 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4947 non_constant_p
, overflow_p
);
4948 VERIFY_CONSTANT (cond
);
4949 if (integer_nonzerop (cond
))
4955 *jump_target
= TREE_OPERAND (t
, 0);
4956 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4957 /* Allow for jumping to a cdtor_label. */
4958 || returns (jump_target
));
4962 cxx_eval_loop_expr (ctx
, t
,
4963 non_constant_p
, overflow_p
, jump_target
);
4967 cxx_eval_switch_expr (ctx
, t
,
4968 non_constant_p
, overflow_p
, jump_target
);
4972 /* It's possible to get a requires-expression in a constant
4973 expression. For example:
4975 template<typename T> concept bool C() {
4976 return requires (T t) { t; };
4979 template<typename T> requires !C<T>() void f(T);
4981 Normalization leaves f with the associated constraint
4982 '!requires (T t) { ... }' which is not transformed into
4984 if (!processing_template_decl
)
4985 return evaluate_constraint_expression (t
, NULL_TREE
);
4987 *non_constant_p
= true;
4991 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4993 non_constant_p
, overflow_p
,
5002 if (STATEMENT_CODE_P (TREE_CODE (t
)))
5004 /* This function doesn't know how to deal with pre-genericize
5005 statements; this can only happen with statement-expressions,
5006 so for now just fail. */
5008 error_at (EXPR_LOCATION (t
),
5009 "statement is not a constant expression");
5012 internal_error ("unexpected expression %qE of kind %s", t
,
5013 get_tree_code_name (TREE_CODE (t
)));
5014 *non_constant_p
= true;
5018 if (r
== error_mark_node
)
5019 *non_constant_p
= true;
5021 if (*non_constant_p
)
5027 /* P0859: A function is needed for constant evaluation if it is a constexpr
5028 function that is named by an expression ([basic.def.odr]) that is
5029 potentially constant evaluated.
5031 So we need to instantiate any constexpr functions mentioned by the
5032 expression even if the definition isn't needed for evaluating the
5036 instantiate_cx_fn_r (tree
*tp
, int *walk_subtrees
, void */
*data*/
)
5038 if (TREE_CODE (*tp
) == FUNCTION_DECL
5039 && DECL_DECLARED_CONSTEXPR_P (*tp
)
5040 && !DECL_INITIAL (*tp
)
5041 && !trivial_fn_p (*tp
)
5042 && DECL_TEMPLOID_INSTANTIATION (*tp
))
5045 instantiate_decl (*tp
, /*defer_ok*/false, /*expl_inst*/false);
5048 else if (TREE_CODE (*tp
) == CALL_EXPR
5049 || TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
5051 if (EXPR_HAS_LOCATION (*tp
))
5052 input_location
= EXPR_LOCATION (*tp
);
5061 instantiate_constexpr_fns (tree t
)
5063 location_t loc
= input_location
;
5064 cp_walk_tree_without_duplicates (&t
, instantiate_cx_fn_r
, NULL
);
5065 input_location
= loc
;
5068 /* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5069 STRICT has the same sense as for constant_value_1: true if we only allow
5070 conforming C++ constant expressions, or false if we want a constant value
5071 even if it doesn't conform.
5072 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
5073 per P0595 even when ALLOW_NON_CONSTANT is true. */
5076 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
5078 bool manifestly_const_eval
= false,
5079 tree object
= NULL_TREE
)
5081 auto_timevar
time (TV_CONSTEXPR
);
5083 bool non_constant_p
= false;
5084 bool overflow_p
= false;
5085 hash_map
<tree
,tree
> map
;
5087 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
5088 allow_non_constant
, strict
,
5089 manifestly_const_eval
|| !allow_non_constant
};
5091 tree type
= initialized_type (t
);
5093 if (VOID_TYPE_P (type
))
5095 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5097 /* In C++14 an NSDMI can participate in aggregate initialization,
5098 and can refer to the address of the object being initialized, so
5099 we need to pass in the relevant VAR_DECL if we want to do the
5100 evaluation in a single pass. The evaluation will dynamically
5101 update ctx.values for the VAR_DECL. We use the same strategy
5102 for C++11 constexpr constructors that refer to the object being
5104 ctx
.ctor
= build_constructor (type
, NULL
);
5105 CONSTRUCTOR_NO_CLEARING (ctx
.ctor
) = true;
5108 if (TREE_CODE (t
) == TARGET_EXPR
)
5109 object
= TARGET_EXPR_SLOT (t
);
5110 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5111 object
= AGGR_INIT_EXPR_SLOT (t
);
5113 ctx
.object
= object
;
5115 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5116 (type
, TREE_TYPE (object
)));
5117 if (object
&& DECL_P (object
))
5118 map
.put (object
, ctx
.ctor
);
5119 if (TREE_CODE (r
) == TARGET_EXPR
)
5120 /* Avoid creating another CONSTRUCTOR when we expand the
5122 r
= TARGET_EXPR_INITIAL (r
);
5125 instantiate_constexpr_fns (r
);
5126 r
= cxx_eval_constant_expression (&ctx
, r
,
5127 false, &non_constant_p
, &overflow_p
);
5129 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
5131 /* Mutable logic is a bit tricky: we want to allow initialization of
5132 constexpr variables with mutable members, but we can't copy those
5133 members to another constexpr variable. */
5134 if (TREE_CODE (r
) == CONSTRUCTOR
5135 && CONSTRUCTOR_MUTABLE_POISON (r
))
5137 if (!allow_non_constant
)
5138 error ("%qE is not a constant expression because it refers to "
5139 "mutable subobjects of %qT", t
, type
);
5140 non_constant_p
= true;
5143 if (TREE_CODE (r
) == CONSTRUCTOR
5144 && CONSTRUCTOR_NO_CLEARING (r
))
5146 if (!allow_non_constant
)
5147 error ("%qE is not a constant expression because it refers to "
5148 "an incompletely initialized variable", t
);
5149 TREE_CONSTANT (r
) = false;
5150 non_constant_p
= true;
5153 /* Technically we should check this for all subexpressions, but that
5154 runs into problems with our internal representation of pointer
5155 subtraction and the 5.19 rules are still in flux. */
5156 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
5157 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
5158 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
5160 if (!allow_non_constant
)
5161 error ("conversion from pointer type %qT "
5162 "to arithmetic type %qT in a constant expression",
5163 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
5164 non_constant_p
= true;
5167 if (!non_constant_p
&& overflow_p
)
5168 non_constant_p
= true;
5170 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
5172 bool should_unshare
= true;
5173 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
5174 should_unshare
= false;
5176 if (non_constant_p
&& !allow_non_constant
)
5177 return error_mark_node
;
5178 else if (non_constant_p
&& TREE_CONSTANT (r
))
5180 /* If __builtin_is_constant_evaluated () was evaluated to true
5181 and the result is not a valid constant expression, we need to
5183 if (manifestly_const_eval
)
5184 return cxx_eval_outermost_constant_expr (t
, true, strict
,
5186 /* This isn't actually constant, so unset TREE_CONSTANT.
5187 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
5188 it to be set if it is invariant address, even when it is not
5189 a valid C++ constant expression. Wrap it with a NOP_EXPR
5191 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
5193 else if (TREE_CODE (r
) == CONSTRUCTOR
)
5194 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
5196 r
= build_nop (TREE_TYPE (r
), r
);
5197 TREE_CONSTANT (r
) = false;
5199 else if (non_constant_p
)
5203 r
= unshare_expr (r
);
5205 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
5207 r
= adjust_temp_type (type
, r
);
5208 if (TREE_CODE (t
) == TARGET_EXPR
5209 && TARGET_EXPR_INITIAL (t
) == r
)
5211 else if (TREE_CODE (t
) != CONSTRUCTOR
)
5213 r
= get_target_expr (r
);
5214 TREE_CONSTANT (r
) = true;
5221 /* Returns true if T is a valid subexpression of a constant expression,
5222 even if it isn't itself a constant expression. */
5225 is_sub_constant_expr (tree t
)
5227 bool non_constant_p
= false;
5228 bool overflow_p
= false;
5229 hash_map
<tree
, tree
> map
;
5232 = { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true, false };
5234 instantiate_constexpr_fns (t
);
5235 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
5237 return !non_constant_p
&& !overflow_p
;
5240 /* If T represents a constant expression returns its reduced value.
5241 Otherwise return error_mark_node. If T is dependent, then
5245 cxx_constant_value (tree t
, tree decl
)
5247 return cxx_eval_outermost_constant_expr (t
, false, true, true, decl
);
5250 /* Helper routine for fold_simple function. Either return simplified
5251 expression T, otherwise NULL_TREE.
5252 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
5253 even if we are within template-declaration. So be careful on call, as in
5254 such case types can be undefined. */
5257 fold_simple_1 (tree t
)
5260 enum tree_code code
= TREE_CODE (t
);
5272 return fold_sizeof_expr (t
);
5281 case TRUTH_NOT_EXPR
:
5283 case VIEW_CONVERT_EXPR
:
5286 case FIX_TRUNC_EXPR
:
5287 case FIXED_CONVERT_EXPR
:
5288 case ADDR_SPACE_CONVERT_EXPR
:
5290 op1
= TREE_OPERAND (t
, 0);
5292 t
= const_unop (code
, TREE_TYPE (t
), op1
);
5296 if (CONVERT_EXPR_CODE_P (code
)
5297 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
5298 TREE_OVERFLOW (t
) = false;
5306 /* If T is a simple constant expression, returns its simplified value.
5307 Otherwise returns T. In contrast to maybe_constant_value we
5308 simplify only few operations on constant-expressions, and we don't
5309 try to simplify constexpressions. */
5312 fold_simple (tree t
)
5314 if (processing_template_decl
)
5317 tree r
= fold_simple_1 (t
);
5324 /* If T is a constant expression, returns its reduced value.
5325 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5326 Otherwise, returns a version of T without TREE_CONSTANT.
5327 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated
5330 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5333 maybe_constant_value (tree t
, tree decl
, bool manifestly_const_eval
)
5337 if (!is_nondependent_constant_expression (t
))
5339 if (TREE_OVERFLOW_P (t
))
5341 t
= build_nop (TREE_TYPE (t
), t
);
5342 TREE_CONSTANT (t
) = false;
5346 else if (CONSTANT_CLASS_P (t
))
5347 /* No caching or evaluation needed. */
5350 if (manifestly_const_eval
)
5351 return cxx_eval_outermost_constant_expr (t
, true, true, true, decl
);
5353 if (cv_cache
== NULL
)
5354 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5355 if (tree
*cached
= cv_cache
->get (t
))
5358 r
= cxx_eval_outermost_constant_expr (t
, true, true, false, decl
);
5359 gcc_checking_assert (r
== t
5360 || CONVERT_EXPR_P (t
)
5361 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5362 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5363 || !cp_tree_equal (r
, t
));
5364 cv_cache
->put (t
, r
);
5368 /* Dispose of the whole CV_CACHE. */
5371 clear_cv_cache (void)
5373 if (cv_cache
!= NULL
)
5377 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5380 clear_cv_and_fold_caches (void)
5383 clear_fold_cache ();
5386 /* Like maybe_constant_value but first fully instantiate the argument.
5388 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5389 (t, complain) followed by maybe_constant_value but is more efficient,
5390 because it calls instantiation_dependent_expression_p and
5391 potential_constant_expression at most once.
5392 The manifestly_const_eval argument is passed to maybe_constant_value.
5394 Callers should generally pass their active complain, or if they are in a
5395 non-template, diagnosing context, they can use the default of
5396 tf_warning_or_error. Callers that might be within a template context, don't
5397 have a complain parameter, and aren't going to remember the result for long
5398 (e.g. null_ptr_cst_p), can pass tf_none and deal with error_mark_node
5402 fold_non_dependent_expr (tree t
,
5403 tsubst_flags_t complain
/* = tf_warning_or_error */,
5404 bool manifestly_const_eval
/* = false */)
5409 /* If we're in a template, but T isn't value dependent, simplify
5410 it. We're supposed to treat:
5412 template <typename T> void f(T[1 + 1]);
5413 template <typename T> void f(T[2]);
5415 as two declarations of the same function, for example. */
5416 if (processing_template_decl
)
5418 if (is_nondependent_constant_expression (t
))
5420 processing_template_decl_sentinel s
;
5421 t
= instantiate_non_dependent_expr_internal (t
, complain
);
5423 if (type_unknown_p (t
)
5424 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5426 if (TREE_OVERFLOW_P (t
))
5428 t
= build_nop (TREE_TYPE (t
), t
);
5429 TREE_CONSTANT (t
) = false;
5434 tree r
= cxx_eval_outermost_constant_expr (t
, true, true,
5435 manifestly_const_eval
,
5437 /* cp_tree_equal looks through NOPs, so allow them. */
5438 gcc_checking_assert (r
== t
5439 || CONVERT_EXPR_P (t
)
5440 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5441 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5442 || !cp_tree_equal (r
, t
));
5445 else if (TREE_OVERFLOW_P (t
))
5447 t
= build_nop (TREE_TYPE (t
), t
);
5448 TREE_CONSTANT (t
) = false;
5453 return maybe_constant_value (t
, NULL_TREE
, manifestly_const_eval
);
5456 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5457 than wrapped in a TARGET_EXPR.
5458 ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5459 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
5460 per P0595 even when ALLOW_NON_CONSTANT is true. */
5463 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
,
5464 bool manifestly_const_eval
)
5468 if (TREE_CODE (t
) == EXPR_STMT
)
5469 t
= TREE_OPERAND (t
, 0);
5470 if (TREE_CODE (t
) == CONVERT_EXPR
5471 && VOID_TYPE_P (TREE_TYPE (t
)))
5472 t
= TREE_OPERAND (t
, 0);
5473 if (TREE_CODE (t
) == INIT_EXPR
)
5474 t
= TREE_OPERAND (t
, 1);
5475 if (TREE_CODE (t
) == TARGET_EXPR
)
5476 t
= TARGET_EXPR_INITIAL (t
);
5477 if (!is_nondependent_static_init_expression (t
))
5478 /* Don't try to evaluate it. */;
5479 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5480 /* No evaluation needed. */;
5482 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
,
5484 manifestly_const_eval
, decl
);
5485 if (TREE_CODE (t
) == TARGET_EXPR
)
5487 tree init
= TARGET_EXPR_INITIAL (t
);
5488 if (TREE_CODE (init
) == CONSTRUCTOR
)
5494 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5497 maybe_constant_init (tree t
, tree decl
, bool manifestly_const_eval
)
5499 return maybe_constant_init_1 (t
, decl
, true, manifestly_const_eval
);
5502 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5505 cxx_constant_init (tree t
, tree decl
)
5507 return maybe_constant_init_1 (t
, decl
, false, true);
5511 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5512 /* Return true if the object referred to by REF has automatic or thread
5515 enum { ck_ok
, ck_bad
, ck_unknown
};
5517 check_automatic_or_tls (tree ref
)
5520 poly_int64 bitsize
, bitpos
;
5522 int volatilep
= 0, unsignedp
= 0;
5523 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5524 &mode
, &unsignedp
, &volatilep
, false);
5527 /* If there isn't a decl in the middle, we don't know the linkage here,
5528 and this isn't a constant expression anyway. */
5531 dk
= decl_storage_duration (decl
);
5532 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5536 /* Return true if T denotes a potentially constant expression. Issue
5537 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5538 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5539 consider the expression in the current context, independent of constexpr
5542 C++0x [expr.const] used to say
5544 6 An expression is a potential constant expression if it is
5545 a constant expression where all occurrences of function
5546 parameters are replaced by arbitrary constant expressions
5547 of the appropriate type.
5549 2 A conditional expression is a constant expression unless it
5550 involves one of the following as a potentially evaluated
5551 subexpression (3.2), but subexpressions of logical AND (5.14),
5552 logical OR (5.15), and conditional (5.16) operations that are
5553 not evaluated are not considered. */
5556 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5557 tsubst_flags_t flags
, tree
*jump_target
)
5559 #define RECUR(T,RV) \
5560 potential_constant_expression_1 ((T), (RV), strict, now, flags, jump_target)
5562 enum { any
= false, rval
= true };
5566 if (t
== error_mark_node
)
5570 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
5573 /* If we are jumping, ignore everything. This is simpler than the
5574 cxx_eval_constant_expression handling because we only need to be
5575 conservatively correct, and we don't necessarily have a constant value
5576 available, so we don't bother with switch tracking. */
5579 if (TREE_THIS_VOLATILE (t
) && want_rval
)
5581 if (flags
& tf_error
)
5582 error_at (loc
, "lvalue-to-rvalue conversion of a volatile lvalue "
5583 "%qE with type %qT", t
, TREE_TYPE (t
));
5586 if (CONSTANT_CLASS_P (t
))
5588 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5589 && TREE_TYPE (t
) == error_mark_node
)
5592 switch (TREE_CODE (t
))
5598 case TEMPLATE_ID_EXPR
:
5601 case CASE_LABEL_EXPR
:
5607 case TEMPLATE_PARM_INDEX
:
5609 case IDENTIFIER_NODE
:
5610 case USERDEF_LITERAL
:
5611 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5616 case PLACEHOLDER_EXPR
:
5619 case DEBUG_BEGIN_STMT
:
5623 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5635 if (flags
& tf_error
)
5636 error ("%qE is not a constant expression", t
);
5641 case AGGR_INIT_EXPR
:
5643 /* -- an invocation of a function other than a constexpr function
5644 or a constexpr constructor. */
5646 tree fun
= get_function_named_in_call (t
);
5647 const int nargs
= call_expr_nargs (t
);
5650 if (fun
== NULL_TREE
)
5652 /* Reset to allow the function to continue past the end
5653 of the block below. Otherwise return early. */
5656 if (TREE_CODE (t
) == CALL_EXPR
5657 && CALL_EXPR_FN (t
) == NULL_TREE
)
5658 switch (CALL_EXPR_IFN (t
))
5660 /* These should be ignored, they are optimized away from
5661 constexpr functions. */
5662 case IFN_UBSAN_NULL
:
5663 case IFN_UBSAN_BOUNDS
:
5664 case IFN_UBSAN_VPTR
:
5665 case IFN_FALLTHROUGH
:
5668 case IFN_ADD_OVERFLOW
:
5669 case IFN_SUB_OVERFLOW
:
5670 case IFN_MUL_OVERFLOW
:
5672 case IFN_VEC_CONVERT
:
5682 /* fold_call_expr can't do anything with IFN calls. */
5683 if (flags
& tf_error
)
5684 error_at (loc
, "call to internal function %qE", t
);
5689 if (fun
&& is_overloaded_fn (fun
))
5691 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5693 if (builtin_valid_in_constant_expr_p (fun
))
5695 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5696 /* Allow any built-in function; if the expansion
5697 isn't constant, we'll deal with that then. */
5698 && !fndecl_built_in_p (fun
))
5700 if (flags
& tf_error
)
5702 error_at (loc
, "call to non-%<constexpr%> function %qD",
5704 explain_invalid_constexpr_fn (fun
);
5708 /* A call to a non-static member function takes the address
5709 of the object as the first argument. But in a constant
5710 expression the address will be folded away, so look
5712 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5713 && !DECL_CONSTRUCTOR_P (fun
))
5715 tree x
= get_nth_callarg (t
, 0);
5716 if (is_this_parameter (x
))
5718 /* Don't require an immediately constant value, as
5719 constexpr substitution might not use the value. */
5720 bool sub_now
= false;
5721 if (!potential_constant_expression_1 (x
, rval
, strict
,
5730 if (!RECUR (fun
, true))
5732 fun
= get_first_fn (fun
);
5734 /* Skip initial arguments to base constructors. */
5735 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5736 i
= num_artificial_parms_for (fun
);
5737 fun
= DECL_ORIGIN (fun
);
5741 if (RECUR (fun
, rval
))
5742 /* Might end up being a constant function pointer. */;
5746 for (; i
< nargs
; ++i
)
5748 tree x
= get_nth_callarg (t
, i
);
5749 /* In a template, reference arguments haven't been converted to
5750 REFERENCE_TYPE and we might not even know if the parameter
5751 is a reference, so accept lvalue constants too. */
5752 bool rv
= processing_template_decl
? any
: rval
;
5753 /* Don't require an immediately constant value, as constexpr
5754 substitution might not use the value of the argument. */
5755 bool sub_now
= false;
5756 if (!potential_constant_expression_1 (x
, rv
, strict
,
5757 sub_now
, flags
, jump_target
))
5763 case NON_LVALUE_EXPR
:
5764 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5765 -- an lvalue of integral type that refers to a non-volatile
5766 const variable or static data member initialized with
5767 constant expressions, or
5769 -- an lvalue of literal type that refers to non-volatile
5770 object defined with constexpr, or that refers to a
5771 sub-object of such an object; */
5772 return RECUR (TREE_OPERAND (t
, 0), rval
);
5775 if (DECL_HAS_VALUE_EXPR_P (t
))
5777 if (now
&& is_normal_capture_proxy (t
))
5779 /* -- in a lambda-expression, a reference to this or to a
5780 variable with automatic storage duration defined outside that
5781 lambda-expression, where the reference would be an
5783 if (flags
& tf_error
)
5785 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5786 error ("lambda capture of %qE is not a constant expression",
5788 if (!want_rval
&& decl_constant_var_p (cap
))
5789 inform (input_location
, "because it is used as a glvalue");
5793 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5796 && !var_in_maybe_constexpr_fn (t
)
5797 && !type_dependent_expression_p (t
)
5798 && !decl_maybe_constant_var_p (t
)
5800 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5801 || (DECL_INITIAL (t
)
5802 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5803 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5804 && !is_really_empty_class (TREE_TYPE (t
)))
5806 if (flags
& tf_error
)
5807 non_const_var_error (t
);
5814 case VIEW_CONVERT_EXPR
:
5815 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5816 may change to something more specific to type-punning (DR 1312). */
5818 tree from
= TREE_OPERAND (t
, 0);
5819 if (location_wrapper_p (t
))
5820 return (RECUR (from
, want_rval
));
5821 if (INDIRECT_TYPE_P (TREE_TYPE (t
)))
5823 STRIP_ANY_LOCATION_WRAPPER (from
);
5824 if (TREE_CODE (from
) == INTEGER_CST
5825 && !integer_zerop (from
))
5827 if (flags
& tf_error
)
5828 error_at (loc
, "reinterpret_cast from integer to pointer");
5832 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5835 case ADDRESSOF_EXPR
:
5836 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5837 t
= TREE_OPERAND (t
, 0);
5838 goto handle_addr_expr
;
5841 /* -- a unary operator & that is applied to an lvalue that
5842 designates an object with thread or automatic storage
5844 t
= TREE_OPERAND (t
, 0);
5846 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5847 /* A pointer-to-member constant. */
5852 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5853 any checking here, as we might dereference the pointer later. If
5854 we remove this code, also remove check_automatic_or_tls. */
5855 i
= check_automatic_or_tls (t
);
5860 if (flags
& tf_error
)
5861 error ("address-of an object %qE with thread local or "
5862 "automatic storage is not a constant expression", t
);
5866 return RECUR (t
, any
);
5874 /* -- a class member access unless its postfix-expression is
5875 of literal type or of pointer to literal type. */
5876 /* This test would be redundant, as it follows from the
5877 postfix-expression being a potential constant expression. */
5878 if (type_unknown_p (t
))
5880 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5882 case EXPR_PACK_EXPANSION
:
5883 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5887 tree x
= TREE_OPERAND (t
, 0);
5889 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5891 if (!var_in_maybe_constexpr_fn (x
))
5893 if (flags
& tf_error
)
5894 error_at (loc
, "use of %<this%> in a constant expression");
5899 return RECUR (x
, rval
);
5902 case STATEMENT_LIST
:
5904 tree_stmt_iterator i
;
5905 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5907 if (!RECUR (tsi_stmt (i
), any
))
5915 if (cxx_dialect
< cxx14
)
5917 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5919 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5924 if (cxx_dialect
< cxx14
)
5926 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5928 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5933 if (!RECUR (DO_COND (t
), rval
))
5935 if (!RECUR (DO_BODY (t
), any
))
5937 if (breaks (jump_target
) || continues (jump_target
))
5938 *jump_target
= NULL_TREE
;
5942 if (!RECUR (FOR_INIT_STMT (t
), any
))
5945 if (!RECUR (tmp
, rval
))
5949 if (!processing_template_decl
)
5950 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5951 /* If we couldn't evaluate the condition, it might not ever be
5953 if (!integer_onep (tmp
))
5956 if (!RECUR (FOR_EXPR (t
), any
))
5958 if (!RECUR (FOR_BODY (t
), any
))
5960 if (breaks (jump_target
) || continues (jump_target
))
5961 *jump_target
= NULL_TREE
;
5964 case RANGE_FOR_STMT
:
5965 if (!RECUR (RANGE_FOR_INIT_STMT (t
), any
))
5967 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5969 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5971 if (breaks (jump_target
) || continues (jump_target
))
5972 *jump_target
= NULL_TREE
;
5976 tmp
= WHILE_COND (t
);
5977 if (!RECUR (tmp
, rval
))
5979 if (!processing_template_decl
)
5980 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5981 /* If we couldn't evaluate the condition, it might not ever be true. */
5982 if (!integer_onep (tmp
))
5984 if (!RECUR (WHILE_BODY (t
), any
))
5986 if (breaks (jump_target
) || continues (jump_target
))
5987 *jump_target
= NULL_TREE
;
5991 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5993 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5994 unreachable labels would be checked. */
5998 return RECUR (STMT_EXPR_STMT (t
), rval
);
6001 if (cxx_dialect
>= cxx17
)
6002 /* In C++17 lambdas can be constexpr, don't give up yet. */
6004 else if (flags
& tf_error
)
6005 error_at (loc
, "lambda-expression is not a constant expression "
6009 case DYNAMIC_CAST_EXPR
:
6010 case PSEUDO_DTOR_EXPR
:
6014 case VEC_DELETE_EXPR
:
6020 case OMP_DISTRIBUTE
:
6023 case OMP_TARGET_DATA
:
6032 case OMP_TARGET_UPDATE
:
6033 case OMP_TARGET_ENTER_DATA
:
6034 case OMP_TARGET_EXIT_DATA
:
6036 case OMP_ATOMIC_READ
:
6037 case OMP_ATOMIC_CAPTURE_OLD
:
6038 case OMP_ATOMIC_CAPTURE_NEW
:
6043 case OACC_HOST_DATA
:
6047 case OACC_ENTER_DATA
:
6048 case OACC_EXIT_DATA
:
6050 /* GCC internal stuff. */
6052 case TRANSACTION_EXPR
:
6054 case AT_ENCODE_EXPR
:
6056 if (flags
& tf_error
)
6057 error_at (loc
, "expression %qE is not a constant expression", t
);
6061 if (cxx_dialect
>= cxx2a
)
6062 /* In C++2a virtual calls can be constexpr, don't give up yet. */
6064 else if (flags
& tf_error
)
6065 error_at (loc
, "virtual functions cannot be constexpr before C++2a");
6069 /* -- a typeid expression whose operand is of polymorphic
6072 tree e
= TREE_OPERAND (t
, 0);
6073 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
6074 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
6076 if (flags
& tf_error
)
6077 error_at (loc
, "typeid-expression is not a constant expression "
6078 "because %qE is of polymorphic type", e
);
6084 case POINTER_DIFF_EXPR
:
6098 case PREINCREMENT_EXPR
:
6099 case POSTINCREMENT_EXPR
:
6100 case PREDECREMENT_EXPR
:
6101 case POSTDECREMENT_EXPR
:
6102 if (cxx_dialect
< cxx14
)
6108 if (TYPE_P (TREE_OPERAND (t
, 0)))
6114 case FIX_TRUNC_EXPR
:
6119 case TRUTH_NOT_EXPR
:
6120 case FIXED_CONVERT_EXPR
:
6121 case UNARY_PLUS_EXPR
:
6122 case UNARY_LEFT_FOLD_EXPR
:
6123 case UNARY_RIGHT_FOLD_EXPR
:
6125 return RECUR (TREE_OPERAND (t
, 0), rval
);
6128 case CONST_CAST_EXPR
:
6129 case STATIC_CAST_EXPR
:
6130 case REINTERPRET_CAST_EXPR
:
6131 case IMPLICIT_CONV_EXPR
:
6132 if (cxx_dialect
< cxx11
6133 && !dependent_type_p (TREE_TYPE (t
))
6134 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
6135 /* In C++98, a conversion to non-integral type can't be part of a
6136 constant expression. */
6138 if (flags
& tf_error
)
6140 "cast to non-integral type %qT in a constant expression",
6144 /* This might be a conversion from a class to a (potentially) literal
6145 type. Let's consider it potentially constant since the conversion
6146 might be a constexpr user-defined conversion. */
6147 else if (cxx_dialect
>= cxx11
6148 && (dependent_type_p (TREE_TYPE (t
))
6149 || !COMPLETE_TYPE_P (TREE_TYPE (t
))
6150 || literal_type_p (TREE_TYPE (t
)))
6151 && TREE_OPERAND (t
, 0))
6153 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6154 /* If this is a dependent type, it could end up being a class
6155 with conversions. */
6156 if (type
== NULL_TREE
|| WILDCARD_TYPE_P (type
))
6158 /* Or a non-dependent class which has conversions. */
6159 else if (CLASS_TYPE_P (type
)
6160 && (TYPE_HAS_CONVERSION (type
) || dependent_scope_p (type
)))
6164 return (RECUR (TREE_OPERAND (t
, 0),
6165 !TYPE_REF_P (TREE_TYPE (t
))));
6168 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
6170 case CLEANUP_POINT_EXPR
:
6171 case MUST_NOT_THROW_EXPR
:
6172 case TRY_CATCH_EXPR
:
6177 case NON_DEPENDENT_EXPR
:
6178 /* For convenience. */
6181 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6184 tmp
= DECL_EXPR_DECL (t
);
6185 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
6187 if (TREE_STATIC (tmp
))
6189 if (flags
& tf_error
)
6190 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6191 "%<static%> in %<constexpr%> context", tmp
);
6194 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
6196 if (flags
& tf_error
)
6197 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6198 "%<thread_local%> in %<constexpr%> context", tmp
);
6201 else if (!check_for_uninitialized_const_var
6202 (tmp
, /*constexpr_context_p=*/true, flags
))
6205 return RECUR (tmp
, want_rval
);
6207 case TRY_FINALLY_EXPR
:
6208 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
6209 && RECUR (TREE_OPERAND (t
, 1), any
));
6212 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6215 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
6216 && !literal_type_p (TREE_TYPE (t
)))
6218 if (flags
& tf_error
)
6220 auto_diagnostic_group d
;
6221 error_at (loc
, "temporary of non-literal type %qT in a "
6222 "constant expression", TREE_TYPE (t
));
6223 explain_non_literal_class (TREE_TYPE (t
));
6229 return RECUR (TREE_OPERAND (t
, 1), rval
);
6233 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
6234 constructor_elt
*ce
;
6235 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
6236 if (!RECUR (ce
->value
, want_rval
))
6243 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
6244 || DECL_P (TREE_PURPOSE (t
)));
6245 if (!RECUR (TREE_VALUE (t
), want_rval
))
6247 if (TREE_CHAIN (t
) == NULL_TREE
)
6249 return RECUR (TREE_CHAIN (t
), want_rval
);
6252 case TRUNC_DIV_EXPR
:
6254 case FLOOR_DIV_EXPR
:
6255 case ROUND_DIV_EXPR
:
6256 case TRUNC_MOD_EXPR
:
6258 case ROUND_MOD_EXPR
:
6260 tree denom
= TREE_OPERAND (t
, 1);
6261 if (!RECUR (denom
, rval
))
6263 /* We can't call cxx_eval_outermost_constant_expr on an expression
6264 that hasn't been through instantiate_non_dependent_expr yet. */
6265 if (!processing_template_decl
)
6266 denom
= cxx_eval_outermost_constant_expr (denom
, true);
6267 if (integer_zerop (denom
))
6269 if (flags
& tf_error
)
6270 error ("division by zero is not a constant expression");
6276 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6282 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6283 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6284 introduced by build_call_a. */
6285 tree op0
= TREE_OPERAND (t
, 0);
6286 tree op1
= TREE_OPERAND (t
, 1);
6288 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
6289 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
6290 return RECUR (op0
, want_rval
);
6295 /* If the first operand is the non-short-circuit constant, look at
6296 the second operand; otherwise we only care about the first one for
6298 case TRUTH_AND_EXPR
:
6299 case TRUTH_ANDIF_EXPR
:
6300 tmp
= boolean_true_node
;
6303 case TRUTH_ORIF_EXPR
:
6304 tmp
= boolean_false_node
;
6307 tree op
= TREE_OPERAND (t
, 0);
6308 if (!RECUR (op
, rval
))
6310 if (!processing_template_decl
)
6311 op
= cxx_eval_outermost_constant_expr (op
, true);
6312 if (tree_int_cst_equal (op
, tmp
))
6313 return RECUR (TREE_OPERAND (t
, 1), rval
);
6320 case POINTER_PLUS_EXPR
:
6322 case EXACT_DIV_EXPR
:
6332 case TRUTH_XOR_EXPR
:
6333 case UNORDERED_EXPR
:
6346 case ARRAY_RANGE_REF
:
6350 case BINARY_LEFT_FOLD_EXPR
:
6351 case BINARY_RIGHT_FOLD_EXPR
:
6353 for (i
= 0; i
< 2; ++i
)
6354 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
6359 for (i
= 0; i
< 3; ++i
)
6360 if (!RECUR (TREE_OPERAND (t
, i
), true))
6365 if (COND_EXPR_IS_VEC_DELETE (t
))
6367 if (flags
& tf_error
)
6368 error_at (loc
, "%<delete[]%> is not a constant expression");
6374 /* If the condition is a known constant, we know which of the legs we
6375 care about; otherwise we only require that the condition and
6376 either of the legs be potentially constant. */
6377 tmp
= TREE_OPERAND (t
, 0);
6378 if (!RECUR (tmp
, rval
))
6380 if (!processing_template_decl
)
6381 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6382 if (integer_zerop (tmp
))
6383 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
6384 else if (TREE_CODE (tmp
) == INTEGER_CST
)
6385 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6386 for (i
= 1; i
< 3; ++i
)
6387 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
6388 want_rval
, strict
, now
,
6389 tf_none
, jump_target
))
6391 if (flags
& tf_error
)
6392 error_at (loc
, "expression %qE is not a constant expression", t
);
6396 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
6398 if (flags
& tf_error
)
6400 error_at (loc
, "non-constant array initialization");
6401 diagnose_non_constexpr_vec_init (t
);
6407 /* We can see these in statement-expressions. */
6411 case EMPTY_CLASS_EXPR
:
6417 tree
*target
= &TREE_OPERAND (t
, 0);
6418 /* Gotos representing break and continue are OK. */
6419 if (breaks (target
) || continues (target
))
6421 *jump_target
= *target
;
6424 if (flags
& tf_error
)
6425 error_at (loc
, "%<goto%> is not a constant expression");
6430 return RECUR (TREE_OPERAND (t
, 0), rval
);
6433 if (objc_is_property_ref (t
))
6436 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6444 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
6445 tsubst_flags_t flags
)
6447 tree target
= NULL_TREE
;
6448 return potential_constant_expression_1 (t
, want_rval
, strict
, now
,
6452 /* The main entry point to the above. */
6455 potential_constant_expression (tree t
)
6457 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6460 /* As above, but require a constant rvalue. */
6463 potential_rvalue_constant_expression (tree t
)
6465 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6468 /* Like above, but complain about non-constant expressions. */
6471 require_potential_constant_expression (tree t
)
6473 return potential_constant_expression_1 (t
, false, true, false,
6474 tf_warning_or_error
);
6477 /* Cross product of the above. */
6480 require_potential_rvalue_constant_expression (tree t
)
6482 return potential_constant_expression_1 (t
, true, true, false,
6483 tf_warning_or_error
);
6486 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6489 require_rvalue_constant_expression (tree t
)
6491 return potential_constant_expression_1 (t
, true, true, true,
6492 tf_warning_or_error
);
6495 /* Like potential_constant_expression, but don't consider possible constexpr
6496 substitution of the current function. That is, PARM_DECL qualifies under
6497 potential_constant_expression, but not here.
6499 This is basically what you can check when any actual constant values might
6500 be value-dependent. */
6503 is_constant_expression (tree t
)
6505 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6508 /* Like above, but complain about non-constant expressions. */
6511 require_constant_expression (tree t
)
6513 return potential_constant_expression_1 (t
, false, true, true,
6514 tf_warning_or_error
);
6517 /* Like is_constant_expression, but allow const variables that are not allowed
6518 under constexpr rules. */
6521 is_static_init_expression (tree t
)
6523 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6526 /* Returns true if T is a potential constant expression that is not
6527 instantiation-dependent, and therefore a candidate for constant folding even
6531 is_nondependent_constant_expression (tree t
)
6533 return (!type_unknown_p (t
)
6534 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6535 && is_constant_expression (t
)
6536 && !instantiation_dependent_expression_p (t
));
6539 /* Returns true if T is a potential static initializer expression that is not
6540 instantiation-dependent. */
6543 is_nondependent_static_init_expression (tree t
)
6545 return (!type_unknown_p (t
)
6546 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6547 && is_static_init_expression (t
)
6548 && !instantiation_dependent_expression_p (t
));
6551 /* Finalize constexpr processing after parsing. */
6554 fini_constexpr (void)
6556 /* The contexpr call and fundef copies tables are no longer needed. */
6557 constexpr_call_table
= NULL
;
6558 fundef_copies_table
= NULL
;
6561 #include "gt-cp-constexpr.h"