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-2018 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"
37 static bool verify_constant (tree
, bool, bool *, bool *);
38 #define VERIFY_CONSTANT(X) \
40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
44 /* Returns true iff FUN is an instantiation of a constexpr function
45 template or a defaulted constexpr function. */
48 is_instantiation_of_constexpr (tree fun
)
50 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
52 || (DECL_DEFAULTED_FN (fun
)
53 && DECL_DECLARED_CONSTEXPR_P (fun
)));
56 /* Return true if T is a literal type. */
59 literal_type_p (tree t
)
64 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
68 t
= complete_type (t
);
69 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
70 return CLASSTYPE_LITERAL_P (t
);
72 if (TREE_CODE (t
) == ARRAY_TYPE
)
73 return literal_type_p (strip_array_types (t
));
77 /* If DECL is a variable declared `constexpr', require its type
78 be literal. Return error_mark_node if we give an error, the
82 ensure_literal_type_for_constexpr_object (tree decl
)
84 tree type
= TREE_TYPE (decl
);
86 && (DECL_DECLARED_CONSTEXPR_P (decl
)
87 || var_in_constexpr_fn (decl
))
88 && !processing_template_decl
)
90 tree stype
= strip_array_types (type
);
91 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
92 /* Don't complain here, we'll complain about incompleteness
93 when we try to initialize the variable. */;
94 else if (type_uses_auto (type
))
95 /* We don't know the actual type yet. */;
96 else if (!literal_type_p (type
))
98 if (DECL_DECLARED_CONSTEXPR_P (decl
))
100 auto_diagnostic_group d
;
101 error ("the type %qT of %<constexpr%> variable %qD "
102 "is not literal", type
, decl
);
103 explain_non_literal_class (type
);
104 decl
= error_mark_node
;
108 if (!is_instantiation_of_constexpr (current_function_decl
))
110 auto_diagnostic_group d
;
111 error ("variable %qD of non-literal type %qT in %<constexpr%> "
112 "function", decl
, type
);
113 explain_non_literal_class (type
);
114 decl
= error_mark_node
;
116 cp_function_chain
->invalid_constexpr
= true;
119 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
120 && variably_modified_type_p (type
, NULL_TREE
))
122 error ("%<constexpr%> variable %qD has variably-modified type %qT",
124 decl
= error_mark_node
;
130 /* Representation of entries in the constexpr function definition table. */
132 struct GTY((for_user
)) constexpr_fundef
{
137 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
139 static hashval_t
hash (constexpr_fundef
*);
140 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
143 /* This table holds all constexpr function definitions seen in
144 the current translation unit. */
146 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
148 /* Utility function used for managing the constexpr function table.
149 Return true if the entries pointed to by P and Q are for the
150 same constexpr function. */
153 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
155 return lhs
->decl
== rhs
->decl
;
158 /* Utility function used for managing the constexpr function table.
159 Return a hash value for the entry pointed to by Q. */
162 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
164 return DECL_UID (fundef
->decl
);
167 /* Return a previously saved definition of function FUN. */
169 static constexpr_fundef
*
170 retrieve_constexpr_fundef (tree fun
)
172 constexpr_fundef fundef
= { NULL
, NULL
};
173 if (constexpr_fundef_table
== NULL
)
177 return constexpr_fundef_table
->find (&fundef
);
180 /* Check whether the parameter and return types of FUN are valid for a
181 constexpr function, and complain if COMPLAIN. */
184 is_valid_constexpr_fn (tree fun
, bool complain
)
188 if (DECL_INHERITED_CTOR (fun
)
189 && TREE_CODE (fun
) == TEMPLATE_DECL
)
193 error ("inherited constructor %qD is not %<constexpr%>",
194 DECL_INHERITED_CTOR (fun
));
198 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
199 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
200 if (!literal_type_p (TREE_TYPE (parm
)))
205 auto_diagnostic_group d
;
206 error ("invalid type for parameter %d of %<constexpr%> "
207 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
208 explain_non_literal_class (TREE_TYPE (parm
));
213 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
217 inform (DECL_SOURCE_LOCATION (fun
),
218 "lambdas are implicitly %<constexpr%> only in C++17 and later");
220 else if (!DECL_CONSTRUCTOR_P (fun
))
222 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
223 if (!literal_type_p (rettype
))
228 auto_diagnostic_group d
;
229 error ("invalid return type %qT of %<constexpr%> function %q+D",
231 explain_non_literal_class (rettype
);
235 /* C++14 DR 1684 removed this restriction. */
236 if (cxx_dialect
< cxx14
237 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
238 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
243 auto_diagnostic_group d
;
244 if (pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
245 "enclosing class of %<constexpr%> non-static"
246 " member function %q+#D is not a literal type",
248 explain_non_literal_class (DECL_CONTEXT (fun
));
252 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
256 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
262 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
263 for a member of an anonymous aggregate, INIT is the initializer for that
264 member, and VEC_OUTER is the vector of constructor elements for the class
265 whose constructor we are processing. Add the initializer to the vector
266 and return true to indicate success. */
269 build_anon_member_initialization (tree member
, tree init
,
270 vec
<constructor_elt
, va_gc
> **vec_outer
)
272 /* MEMBER presents the relevant fields from the inside out, but we need
273 to build up the initializer from the outside in so that we can reuse
274 previously built CONSTRUCTORs if this is, say, the second field in an
275 anonymous struct. So we use a vec as a stack. */
276 auto_vec
<tree
, 2> fields
;
279 fields
.safe_push (TREE_OPERAND (member
, 1));
280 member
= TREE_OPERAND (member
, 0);
282 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
283 && TREE_CODE (member
) == COMPONENT_REF
);
285 /* VEC has the constructor elements vector for the context of FIELD.
286 If FIELD is an anonymous aggregate, we will push inside it. */
287 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
289 while (field
= fields
.pop(),
290 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
293 /* If there is already an outer constructor entry for the anonymous
294 aggregate FIELD, use it; otherwise, insert one. */
295 if (vec_safe_is_empty (*vec
)
296 || (*vec
)->last().index
!= field
)
298 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
299 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
302 ctor
= (*vec
)->last().value
;
303 vec
= &CONSTRUCTOR_ELTS (ctor
);
306 /* Now we're at the innermost field, the one that isn't an anonymous
307 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
308 gcc_assert (fields
.is_empty());
309 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
314 /* Subroutine of build_constexpr_constructor_member_initializers.
315 The expression tree T represents a data member initialization
316 in a (constexpr) constructor definition. Build a pairing of
317 the data member with its initializer, and prepend that pair
318 to the existing initialization pair INITS. */
321 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
324 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
325 t
= TREE_OPERAND (t
, 0);
326 if (TREE_CODE (t
) == EXPR_STMT
)
327 t
= TREE_OPERAND (t
, 0);
328 if (t
== error_mark_node
)
330 if (TREE_CODE (t
) == STATEMENT_LIST
)
332 tree_stmt_iterator i
;
333 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
335 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
340 if (TREE_CODE (t
) == CLEANUP_STMT
)
342 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
343 but we can in a constexpr constructor for a non-literal class. Just
344 ignore it; either all the initialization will be constant, in which
345 case the cleanup can't run, or it can't be constexpr.
346 Still recurse into CLEANUP_BODY. */
347 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
349 if (TREE_CODE (t
) == CONVERT_EXPR
)
350 t
= TREE_OPERAND (t
, 0);
351 if (TREE_CODE (t
) == INIT_EXPR
352 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
353 use what this function builds for cx_check_missing_mem_inits, and
354 assignment in the ctor body doesn't count. */
355 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
357 member
= TREE_OPERAND (t
, 0);
358 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
360 else if (TREE_CODE (t
) == CALL_EXPR
)
362 tree fn
= get_callee_fndecl (t
);
363 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
364 /* We're only interested in calls to subobject constructors. */
366 member
= CALL_EXPR_ARG (t
, 0);
367 /* We don't use build_cplus_new here because it complains about
368 abstract bases. Leaving the call unwrapped means that it has the
369 wrong type, but cxx_eval_constant_expression doesn't care. */
370 init
= break_out_target_exprs (t
);
372 else if (TREE_CODE (t
) == BIND_EXPR
)
373 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
375 /* Don't add anything else to the CONSTRUCTOR. */
377 if (INDIRECT_REF_P (member
))
378 member
= TREE_OPERAND (member
, 0);
379 if (TREE_CODE (member
) == NOP_EXPR
)
383 if (TREE_CODE (op
) == ADDR_EXPR
)
385 gcc_assert (same_type_ignoring_top_level_qualifiers_p
386 (TREE_TYPE (TREE_TYPE (op
)),
387 TREE_TYPE (TREE_TYPE (member
))));
388 /* Initializing a cv-qualified member; we need to look through
392 else if (op
== current_class_ptr
393 && (same_type_ignoring_top_level_qualifiers_p
394 (TREE_TYPE (TREE_TYPE (member
)),
395 current_class_type
)))
396 /* Delegating constructor. */
400 /* This is an initializer for an empty base; keep it for now so
401 we can check it in cxx_eval_bare_aggregate. */
402 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
405 if (TREE_CODE (member
) == ADDR_EXPR
)
406 member
= TREE_OPERAND (member
, 0);
407 if (TREE_CODE (member
) == COMPONENT_REF
)
409 tree aggr
= TREE_OPERAND (member
, 0);
410 if (TREE_CODE (aggr
) == VAR_DECL
)
411 /* Initializing a local variable, don't add anything. */
413 if (TREE_CODE (aggr
) != COMPONENT_REF
)
414 /* Normal member initialization. */
415 member
= TREE_OPERAND (member
, 1);
416 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
417 /* Initializing a member of an anonymous union. */
418 return build_anon_member_initialization (member
, init
, vec
);
420 /* We're initializing a vtable pointer in a base. Leave it as
421 COMPONENT_REF so we remember the path to get to the vfield. */
422 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
425 /* Value-initialization can produce multiple initializers for the
426 same field; use the last one. */
427 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
428 (*vec
)->last().value
= init
;
430 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
434 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
435 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
436 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
439 check_constexpr_bind_expr_vars (tree t
)
441 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
443 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
444 if (TREE_CODE (var
) == TYPE_DECL
445 && DECL_IMPLICIT_TYPEDEF_P (var
)
446 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
451 /* Subroutine of check_constexpr_ctor_body. */
454 check_constexpr_ctor_body_1 (tree last
, tree list
)
456 switch (TREE_CODE (list
))
459 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
460 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
464 case CLEANUP_POINT_EXPR
:
465 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
469 if (!check_constexpr_bind_expr_vars (list
)
470 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
477 case DEBUG_BEGIN_STMT
:
485 /* Make sure that there are no statements after LAST in the constructor
486 body represented by LIST. */
489 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
491 /* C++14 doesn't require a constexpr ctor to have an empty body. */
492 if (cxx_dialect
>= cxx14
)
496 if (TREE_CODE (list
) == STATEMENT_LIST
)
498 tree_stmt_iterator i
= tsi_last (list
);
499 for (; !tsi_end_p (i
); tsi_prev (&i
))
501 tree t
= tsi_stmt (i
);
504 if (!check_constexpr_ctor_body_1 (last
, t
))
511 else if (list
!= last
512 && !check_constexpr_ctor_body_1 (last
, list
))
517 error ("%<constexpr%> constructor does not have empty body");
518 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
523 /* V is a vector of constructor elements built up for the base and member
524 initializers of a constructor for TYPE. They need to be in increasing
525 offset order, which they might not be yet if TYPE has a primary base
526 which is not first in the base-clause or a vptr and at least one base
527 all of which are non-primary. */
529 static vec
<constructor_elt
, va_gc
> *
530 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
532 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
538 field_type
= BINFO_TYPE (pri
);
539 else if (TYPE_CONTAINS_VPTR_P (type
))
540 field_type
= vtbl_ptr_type_node
;
544 /* Find the element for the primary base or vptr and move it to the
545 beginning of the vec. */
546 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
547 if (TREE_TYPE (ce
->index
) == field_type
)
550 if (i
> 0 && i
< vec_safe_length (v
))
552 vec
<constructor_elt
, va_gc
> &vref
= *v
;
553 constructor_elt elt
= vref
[i
];
562 /* Build compile-time evalable representations of member-initializer list
563 for a constexpr constructor. */
566 build_constexpr_constructor_member_initializers (tree type
, tree body
)
568 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
571 switch (TREE_CODE (body
))
573 case MUST_NOT_THROW_EXPR
:
575 body
= TREE_OPERAND (body
, 0);
579 for (tree_stmt_iterator i
= tsi_start (body
);
580 !tsi_end_p (i
); tsi_next (&i
))
583 if (TREE_CODE (body
) == BIND_EXPR
)
589 body
= BIND_EXPR_BODY (body
);
596 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
598 body
= TREE_OPERAND (body
, 0);
599 if (TREE_CODE (body
) == EXPR_STMT
)
600 body
= TREE_OPERAND (body
, 0);
601 if (TREE_CODE (body
) == INIT_EXPR
602 && (same_type_ignoring_top_level_qualifiers_p
603 (TREE_TYPE (TREE_OPERAND (body
, 0)),
604 current_class_type
)))
607 return TREE_OPERAND (body
, 1);
609 ok
= build_data_member_initialization (body
, &vec
);
611 else if (TREE_CODE (body
) == STATEMENT_LIST
)
613 tree_stmt_iterator i
;
614 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
616 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
621 else if (TREE_CODE (body
) == TRY_BLOCK
)
623 error ("body of %<constexpr%> constructor cannot be "
624 "a function-try-block");
625 return error_mark_node
;
627 else if (EXPR_P (body
))
628 ok
= build_data_member_initialization (body
, &vec
);
630 gcc_assert (errorcount
> 0);
633 if (vec_safe_length (vec
) > 0)
635 /* In a delegating constructor, return the target. */
636 constructor_elt
*ce
= &(*vec
)[0];
637 if (ce
->index
== current_class_ptr
)
644 vec
= sort_constexpr_mem_initializers (type
, vec
);
645 return build_constructor (type
, vec
);
648 return error_mark_node
;
651 /* We have an expression tree T that represents a call, either CALL_EXPR
652 or AGGR_INIT_EXPR. If the call is lexically to a named function,
653 retrun the _DECL for that function. */
656 get_function_named_in_call (tree t
)
658 tree fun
= cp_get_callee (t
);
659 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
660 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
661 fun
= TREE_OPERAND (fun
, 0);
665 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
666 declared to be constexpr, or a sub-statement thereof. Returns the
667 return value if suitable, error_mark_node for a statement not allowed in
668 a constexpr function, or NULL_TREE if no return value was found. */
671 constexpr_fn_retval (tree body
)
673 switch (TREE_CODE (body
))
677 tree_stmt_iterator i
;
678 tree expr
= NULL_TREE
;
679 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
681 tree s
= constexpr_fn_retval (tsi_stmt (i
));
682 if (s
== error_mark_node
)
683 return error_mark_node
;
684 else if (s
== NULL_TREE
)
685 /* Keep iterating. */;
687 /* Multiple return statements. */
688 return error_mark_node
;
696 return break_out_target_exprs (TREE_OPERAND (body
, 0));
700 tree decl
= DECL_EXPR_DECL (body
);
701 if (TREE_CODE (decl
) == USING_DECL
702 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
703 || DECL_ARTIFICIAL (decl
))
705 return error_mark_node
;
708 case CLEANUP_POINT_EXPR
:
709 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
712 if (!check_constexpr_bind_expr_vars (body
))
713 return error_mark_node
;
714 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
717 case DEBUG_BEGIN_STMT
:
722 tree fun
= get_function_named_in_call (body
);
724 && fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
))
730 return error_mark_node
;
734 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
735 FUN; do the necessary transformations to turn it into a single expression
736 that we can store in the hash table. */
739 massage_constexpr_body (tree fun
, tree body
)
741 if (DECL_CONSTRUCTOR_P (fun
))
742 body
= build_constexpr_constructor_member_initializers
743 (DECL_CONTEXT (fun
), body
);
744 else if (cxx_dialect
< cxx14
)
746 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
747 body
= EH_SPEC_STMTS (body
);
748 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
749 body
= TREE_OPERAND (body
, 0);
750 body
= constexpr_fn_retval (body
);
755 /* CTYPE is a type constructed from BODY. Return true if some
756 bases/fields are uninitialized, and complain if COMPLAIN. */
759 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
765 if (TREE_CODE (body
) != CONSTRUCTOR
)
767 nelts
= CONSTRUCTOR_NELTS (body
);
769 tree field
= TYPE_FIELDS (ctype
);
771 if (TREE_CODE (ctype
) == UNION_TYPE
)
773 if (nelts
== 0 && next_initializable_field (field
))
776 error ("%<constexpr%> constructor for union %qT must "
777 "initialize exactly one non-static data member", ctype
);
783 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
784 need an explicit initialization. */
786 for (unsigned i
= 0; i
<= nelts
; ++i
)
788 tree index
= NULL_TREE
;
791 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
792 /* Skip base and vtable inits. */
793 if (TREE_CODE (index
) != FIELD_DECL
794 || DECL_ARTIFICIAL (index
))
798 for (; field
!= index
; field
= DECL_CHAIN (field
))
801 if (TREE_CODE (field
) != FIELD_DECL
)
803 if (DECL_UNNAMED_BIT_FIELD (field
))
805 if (DECL_ARTIFICIAL (field
))
807 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
809 /* Recurse to check the anonummous aggregate member. */
810 bad
|= cx_check_missing_mem_inits
811 (TREE_TYPE (field
), NULL_TREE
, complain
);
812 if (bad
&& !complain
)
816 ftype
= strip_array_types (TREE_TYPE (field
));
817 if (type_has_constexpr_default_constructor (ftype
))
819 /* It's OK to skip a member with a trivial constexpr ctor.
820 A constexpr ctor that isn't trivial should have been
822 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
828 auto_diagnostic_group d
;
829 error ("member %qD must be initialized by mem-initializer "
830 "in %<constexpr%> constructor", field
);
831 inform (DECL_SOURCE_LOCATION (field
), "declared here");
834 if (field
== NULL_TREE
)
837 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
839 /* Check the anonymous aggregate initializer is valid. */
840 bad
|= cx_check_missing_mem_inits
841 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
842 if (bad
&& !complain
)
845 field
= DECL_CHAIN (field
);
851 /* We are processing the definition of the constexpr function FUN.
852 Check that its BODY fulfills the propriate requirements and
853 enter it in the constexpr function definition table.
854 For constructor BODY is actually the TREE_LIST of the
855 member-initializer list. */
858 register_constexpr_fundef (tree fun
, tree body
)
860 constexpr_fundef entry
;
861 constexpr_fundef
**slot
;
863 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
866 tree massaged
= massage_constexpr_body (fun
, body
);
867 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
869 if (!DECL_CONSTRUCTOR_P (fun
))
870 error ("body of %<constexpr%> function %qD not a return-statement",
875 if (!potential_rvalue_constant_expression (massaged
))
877 if (!DECL_GENERATED_P (fun
))
878 require_potential_rvalue_constant_expression (massaged
);
882 if (DECL_CONSTRUCTOR_P (fun
)
883 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
884 massaged
, !DECL_GENERATED_P (fun
)))
887 /* Create the constexpr function table if necessary. */
888 if (constexpr_fundef_table
== NULL
)
889 constexpr_fundef_table
890 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
894 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
896 gcc_assert (*slot
== NULL
);
897 *slot
= ggc_alloc
<constexpr_fundef
> ();
903 /* FUN is a non-constexpr function called in a context that requires a
904 constant expression. If it comes from a constexpr template, explain why
905 the instantiation isn't constexpr. */
908 explain_invalid_constexpr_fn (tree fun
)
910 static hash_set
<tree
> *diagnosed
;
913 /* Only diagnose defaulted functions, lambdas, or instantiations. */
914 if (!DECL_DEFAULTED_FN (fun
)
915 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
916 && !is_instantiation_of_constexpr (fun
))
918 if (diagnosed
== NULL
)
919 diagnosed
= new hash_set
<tree
>;
920 if (diagnosed
->add (fun
))
921 /* Already explained. */
924 save_loc
= input_location
;
925 if (!lambda_static_thunk_p (fun
))
927 /* Diagnostics should completely ignore the static thunk, so leave
928 input_location set to our caller's location. */
929 input_location
= DECL_SOURCE_LOCATION (fun
);
930 inform (input_location
,
931 "%qD is not usable as a %<constexpr%> function because:", fun
);
933 /* First check the declaration. */
934 if (is_valid_constexpr_fn (fun
, true))
936 /* Then if it's OK, the body. */
937 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
938 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
939 explain_implicit_non_constexpr (fun
);
942 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
943 require_potential_rvalue_constant_expression (body
);
944 if (DECL_CONSTRUCTOR_P (fun
))
945 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
948 input_location
= save_loc
;
951 /* Objects of this type represent calls to constexpr functions
952 along with the bindings of parameters to their arguments, for
953 the purpose of compile time evaluation. */
955 struct GTY((for_user
)) constexpr_call
{
956 /* Description of the constexpr function definition. */
957 constexpr_fundef
*fundef
;
958 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
959 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
960 Note: This arrangement is made to accommodate the use of
961 iterative_hash_template_arg (see pt.c). If you change this
962 representation, also change the hash calculation in
963 cxx_eval_call_expression. */
965 /* Result of the call.
966 NULL means the call is being evaluated.
967 error_mark_node means that the evaluation was erroneous;
968 otherwise, the actuall value of the call. */
970 /* The hash of this call; we remember it here to avoid having to
971 recalculate it when expanding the hash table. */
975 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
977 static hashval_t
hash (constexpr_call
*);
978 static bool equal (constexpr_call
*, constexpr_call
*);
981 enum constexpr_switch_state
{
982 /* Used when processing a switch for the first time by cxx_eval_switch_expr
983 and default: label for that switch has not been seen yet. */
984 css_default_not_seen
,
985 /* Used when processing a switch for the first time by cxx_eval_switch_expr
986 and default: label for that switch has been seen already. */
988 /* Used when processing a switch for the second time by
989 cxx_eval_switch_expr, where default: label should match. */
990 css_default_processing
993 /* The constexpr expansion context. CALL is the current function
994 expansion, CTOR is the current aggregate initializer, OBJECT is the
995 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
996 is a map of values of variables initialized within the expression. */
998 struct constexpr_ctx
{
999 /* The innermost call we're evaluating. */
1000 constexpr_call
*call
;
1001 /* Values for any temporaries or local variables within the
1002 constant-expression. */
1003 hash_map
<tree
,tree
> *values
;
1004 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
1005 aren't inside a loop. */
1006 hash_set
<tree
> *save_exprs
;
1007 /* The CONSTRUCTOR we're currently building up for an aggregate
1010 /* The object we're building the CONSTRUCTOR for. */
1012 /* If inside SWITCH_EXPR. */
1013 constexpr_switch_state
*css_state
;
1014 /* Whether we should error on a non-constant expression or fail quietly. */
1016 /* Whether we are strictly conforming to constant expression rules or
1017 trying harder to get a constant value. */
1019 /* Whether __builtin_is_constant_evaluated () should be true. */
1020 bool pretend_const_required
;
1023 /* A table of all constexpr calls that have been evaluated by the
1024 compiler in this translation unit. */
1026 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1028 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1029 bool, bool *, bool *, tree
* = NULL
);
1031 /* Compute a hash value for a constexpr call representation. */
1034 constexpr_call_hasher::hash (constexpr_call
*info
)
1039 /* Return true if the objects pointed to by P and Q represent calls
1040 to the same constexpr function with the same arguments.
1041 Otherwise, return false. */
1044 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1050 if (lhs
->hash
!= rhs
->hash
)
1052 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1054 lhs_bindings
= lhs
->bindings
;
1055 rhs_bindings
= rhs
->bindings
;
1056 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1058 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1059 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1060 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1061 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1063 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1064 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1066 return lhs_bindings
== rhs_bindings
;
1069 /* Initialize the constexpr call table, if needed. */
1072 maybe_initialize_constexpr_call_table (void)
1074 if (constexpr_call_table
== NULL
)
1075 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1078 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1079 a function happens to get called recursively, we unshare the callee
1080 function's body and evaluate this unshared copy instead of evaluating the
1083 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1084 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1085 that's keyed off of the original FUNCTION_DECL and whose value is a
1086 TREE_LIST of this function's unused copies awaiting reuse.
1088 This is not GC-deletable to avoid GC affecting UID generation. */
1090 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1092 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1095 maybe_initialize_fundef_copies_table ()
1097 if (fundef_copies_table
== NULL
)
1098 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1101 /* Reuse a copy or create a new unshared copy of the function FUN.
1102 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1103 is parms, TYPE is result. */
1106 get_fundef_copy (tree fun
)
1108 maybe_initialize_fundef_copies_table ();
1112 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1116 /* There is no cached function available, or in use. We can use
1117 the function directly. That the slot is now created records
1118 that this function is now in use. */
1119 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1120 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1122 else if (*slot
== NULL_TREE
)
1124 /* We've already used the function itself, so make a copy. */
1125 copy
= build_tree_list (NULL
, NULL
);
1126 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1130 /* We have a cached function available. */
1132 *slot
= TREE_CHAIN (copy
);
1138 /* Save the copy COPY of function FUN for later reuse by
1139 get_fundef_copy(). By construction, there will always be an entry
1143 save_fundef_copy (tree fun
, tree copy
)
1145 tree
*slot
= fundef_copies_table
->get (fun
);
1146 TREE_CHAIN (copy
) = *slot
;
1150 /* We have an expression tree T that represents a call, either CALL_EXPR
1151 or AGGR_INIT_EXPR. Return the Nth argument. */
1154 get_nth_callarg (tree t
, int n
)
1156 switch (TREE_CODE (t
))
1159 return CALL_EXPR_ARG (t
, n
);
1161 case AGGR_INIT_EXPR
:
1162 return AGGR_INIT_EXPR_ARG (t
, n
);
1170 /* Attempt to evaluate T which represents a call to a builtin function.
1171 We assume here that all builtin functions evaluate to scalar types
1172 represented by _CST nodes. */
1175 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1177 bool *non_constant_p
, bool *overflow_p
)
1179 const int nargs
= call_expr_nargs (t
);
1180 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1184 /* Don't fold __builtin_constant_p within a constexpr function. */
1185 bool bi_const_p
= DECL_IS_BUILTIN_CONSTANT_P (fun
);
1187 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1188 in a constexpr function until we have values for the parameters. */
1191 && current_function_decl
1192 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1194 *non_constant_p
= true;
1198 /* For __builtin_is_constant_evaluated, defer it if not
1199 ctx->pretend_const_required, otherwise fold it to true. */
1200 if (fndecl_built_in_p (fun
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
1203 if (!ctx
->pretend_const_required
)
1205 *non_constant_p
= true;
1208 return boolean_true_node
;
1211 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1212 return constant false for a non-constant argument. */
1213 constexpr_ctx new_ctx
= *ctx
;
1214 new_ctx
.quiet
= true;
1215 bool dummy1
= false, dummy2
= false;
1216 for (i
= 0; i
< nargs
; ++i
)
1218 args
[i
] = CALL_EXPR_ARG (t
, i
);
1219 /* If builtin_valid_in_constant_expr_p is true,
1220 potential_constant_expression_1 has not recursed into the arguments
1221 of the builtin, verify it here. */
1222 if (!builtin_valid_in_constant_expr_p (fun
)
1223 || potential_constant_expression (args
[i
]))
1224 args
[i
] = cxx_eval_constant_expression (&new_ctx
, args
[i
], false,
1227 /* For __built_in_constant_p, fold all expressions with constant values
1228 even if they aren't C++ constant-expressions. */
1229 args
[i
] = cp_fully_fold (args
[i
]);
1232 bool save_ffbcp
= force_folding_builtin_constant_p
;
1233 force_folding_builtin_constant_p
= true;
1234 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1235 CALL_EXPR_FN (t
), nargs
, args
);
1236 force_folding_builtin_constant_p
= save_ffbcp
;
1237 if (new_call
== NULL
)
1239 if (!*non_constant_p
&& !ctx
->quiet
)
1241 /* Do not allow__builtin_unreachable in constexpr function.
1242 The __builtin_unreachable call with BUILTINS_LOCATION
1243 comes from cp_maybe_instrument_return. */
1244 if (fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
)
1245 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1246 error ("%<constexpr%> call flows off the end of the function");
1249 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1250 CALL_EXPR_FN (t
), nargs
, args
);
1251 error ("%q+E is not a constant expression", new_call
);
1254 *non_constant_p
= true;
1258 if (!is_constant_expression (new_call
))
1260 if (!*non_constant_p
&& !ctx
->quiet
)
1261 error ("%q+E is not a constant expression", new_call
);
1262 *non_constant_p
= true;
1266 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1267 non_constant_p
, overflow_p
);
1270 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1271 the type of the value to match. */
1274 adjust_temp_type (tree type
, tree temp
)
1276 if (TREE_TYPE (temp
) == type
)
1278 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1279 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1280 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1281 gcc_assert (scalarish_type_p (type
));
1282 return cp_fold_convert (type
, temp
);
1285 /* Callback for walk_tree used by unshare_constructor. */
1288 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1292 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1297 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1298 subexpression, return an unshared copy of T. Otherwise return T. */
1301 unshare_constructor (tree t
)
1303 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1304 if (ctor
!= NULL_TREE
)
1305 return unshare_expr (t
);
1309 /* Subroutine of cxx_eval_call_expression.
1310 We are processing a call expression (either CALL_EXPR or
1311 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1312 all arguments and bind their values to correspondings
1313 parameters, making up the NEW_CALL context. */
1316 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1317 constexpr_call
*new_call
,
1318 bool *non_constant_p
, bool *overflow_p
,
1319 bool *non_constant_args
)
1321 const int nargs
= call_expr_nargs (t
);
1322 tree fun
= new_call
->fundef
->decl
;
1323 tree parms
= DECL_ARGUMENTS (fun
);
1325 tree
*p
= &new_call
->bindings
;
1326 for (i
= 0; i
< nargs
; ++i
)
1329 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1330 x
= get_nth_callarg (t
, i
);
1331 /* For member function, the first argument is a pointer to the implied
1332 object. For a constructor, it might still be a dummy object, in
1333 which case we get the real argument from ctx. */
1334 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1335 && is_dummy_object (x
))
1338 x
= build_address (x
);
1340 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1341 non_constant_p
, overflow_p
);
1342 /* Don't VERIFY_CONSTANT here. */
1343 if (*non_constant_p
&& ctx
->quiet
)
1345 /* Just discard ellipsis args after checking their constantitude. */
1349 if (!*non_constant_p
)
1351 /* Don't share a CONSTRUCTOR that might be changed. */
1352 arg
= unshare_constructor (arg
);
1353 /* Make sure the binding has the same type as the parm. But
1354 only for constant args. */
1355 if (!TYPE_REF_P (type
))
1356 arg
= adjust_temp_type (type
, arg
);
1357 if (!TREE_CONSTANT (arg
))
1358 *non_constant_args
= true;
1359 *p
= build_tree_list (parms
, arg
);
1360 p
= &TREE_CHAIN (*p
);
1362 parms
= TREE_CHAIN (parms
);
1366 /* Variables and functions to manage constexpr call expansion context.
1367 These do not need to be marked for PCH or GC. */
1369 /* FIXME remember and print actual constant arguments. */
1370 static vec
<tree
> call_stack
;
1371 static int call_stack_tick
;
1372 static int last_cx_error_tick
;
1375 push_cx_call_context (tree call
)
1378 if (!EXPR_HAS_LOCATION (call
))
1379 SET_EXPR_LOCATION (call
, input_location
);
1380 call_stack
.safe_push (call
);
1381 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1387 pop_cx_call_context (void)
1394 cx_error_context (void)
1396 vec
<tree
> r
= vNULL
;
1397 if (call_stack_tick
!= last_cx_error_tick
1398 && !call_stack
.is_empty ())
1400 last_cx_error_tick
= call_stack_tick
;
1404 /* Evaluate a call T to a GCC internal function when possible and return
1405 the evaluated result or, under the control of CTX, give an error, set
1406 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1409 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1411 bool *non_constant_p
, bool *overflow_p
)
1413 enum tree_code opcode
= ERROR_MARK
;
1415 switch (CALL_EXPR_IFN (t
))
1417 case IFN_UBSAN_NULL
:
1418 case IFN_UBSAN_BOUNDS
:
1419 case IFN_UBSAN_VPTR
:
1420 case IFN_FALLTHROUGH
:
1423 case IFN_ADD_OVERFLOW
:
1426 case IFN_SUB_OVERFLOW
:
1427 opcode
= MINUS_EXPR
;
1429 case IFN_MUL_OVERFLOW
:
1434 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1435 false, non_constant_p
, overflow_p
);
1439 error_at (cp_expr_loc_or_loc (t
, input_location
),
1440 "call to internal function %qE", t
);
1441 *non_constant_p
= true;
1445 /* Evaluate constant arguments using OPCODE and return a complex
1446 number containing the result and the overflow bit. */
1447 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1448 non_constant_p
, overflow_p
);
1449 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1450 non_constant_p
, overflow_p
);
1452 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1454 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1455 tree type
= TREE_TYPE (TREE_TYPE (t
));
1456 tree result
= fold_binary_loc (loc
, opcode
, type
,
1457 fold_convert_loc (loc
, type
, arg0
),
1458 fold_convert_loc (loc
, type
, arg1
));
1460 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1461 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1462 if (TREE_OVERFLOW (result
))
1463 TREE_OVERFLOW (result
) = 0;
1465 return build_complex (TREE_TYPE (t
), result
, ovf
);
1468 *non_constant_p
= true;
1472 /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */
1475 clear_no_implicit_zero (tree ctor
)
1477 if (CONSTRUCTOR_NO_CLEARING (ctor
))
1479 CONSTRUCTOR_NO_CLEARING (ctor
) = false;
1480 tree elt
; unsigned HOST_WIDE_INT idx
;
1481 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1482 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1483 clear_no_implicit_zero (elt
);
1487 /* Subroutine of cxx_eval_constant_expression.
1488 Evaluate the call expression tree T in the context of OLD_CALL expression
1492 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1494 bool *non_constant_p
, bool *overflow_p
)
1496 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1497 tree fun
= get_function_named_in_call (t
);
1498 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1501 if (fun
== NULL_TREE
)
1502 return cxx_eval_internal_function (ctx
, t
, lval
,
1503 non_constant_p
, overflow_p
);
1505 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1507 /* Might be a constexpr function pointer. */
1508 fun
= cxx_eval_constant_expression (ctx
, fun
,
1509 /*lval*/false, non_constant_p
,
1512 if (TREE_CODE (fun
) == ADDR_EXPR
)
1513 fun
= TREE_OPERAND (fun
, 0);
1515 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1517 if (!ctx
->quiet
&& !*non_constant_p
)
1518 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1520 *non_constant_p
= true;
1523 if (DECL_CLONED_FUNCTION_P (fun
))
1524 fun
= DECL_CLONED_FUNCTION (fun
);
1526 if (is_ubsan_builtin_p (fun
))
1529 if (fndecl_built_in_p (fun
))
1530 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1531 lval
, non_constant_p
, overflow_p
);
1532 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1536 if (!lambda_static_thunk_p (fun
))
1537 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1538 explain_invalid_constexpr_fn (fun
);
1540 *non_constant_p
= true;
1544 constexpr_ctx new_ctx
= *ctx
;
1545 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1546 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1548 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1549 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1550 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1551 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1552 CONSTRUCTOR_NO_CLEARING (ctor
) = true;
1553 ctx
->values
->put (new_ctx
.object
, ctor
);
1557 /* Shortcut trivial constructor/op=. */
1558 if (trivial_fn_p (fun
))
1560 tree init
= NULL_TREE
;
1561 if (call_expr_nargs (t
) == 2)
1562 init
= convert_from_reference (get_nth_callarg (t
, 1));
1563 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1564 && AGGR_INIT_ZERO_FIRST (t
))
1565 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1568 tree op
= get_nth_callarg (t
, 0);
1569 if (is_dummy_object (op
))
1572 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1573 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1574 new_ctx
.call
= &new_call
;
1575 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1576 non_constant_p
, overflow_p
);
1580 /* We can't defer instantiating the function any longer. */
1581 if (!DECL_INITIAL (fun
)
1582 && DECL_TEMPLOID_INSTANTIATION (fun
))
1584 location_t save_loc
= input_location
;
1585 input_location
= loc
;
1587 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1589 input_location
= save_loc
;
1592 /* If in direct recursive call, optimize definition search. */
1593 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1594 new_call
.fundef
= ctx
->call
->fundef
;
1597 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1598 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1599 || fun
== current_function_decl
)
1603 /* We need to check for current_function_decl here in case we're
1604 being called during cp_fold_function, because at that point
1605 DECL_INITIAL is set properly and we have a fundef but we
1606 haven't lowered invisirefs yet (c++/70344). */
1607 if (DECL_INITIAL (fun
) == error_mark_node
1608 || fun
== current_function_decl
)
1609 error_at (loc
, "%qD called in a constant expression before its "
1610 "definition is complete", fun
);
1611 else if (DECL_INITIAL (fun
))
1613 /* The definition of fun was somehow unsuitable. But pretend
1614 that lambda static thunks don't exist. */
1615 if (!lambda_static_thunk_p (fun
))
1616 error_at (loc
, "%qD called in a constant expression", fun
);
1617 explain_invalid_constexpr_fn (fun
);
1620 error_at (loc
, "%qD used before its definition", fun
);
1622 *non_constant_p
= true;
1627 bool non_constant_args
= false;
1628 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1629 non_constant_p
, overflow_p
, &non_constant_args
);
1630 if (*non_constant_p
)
1633 depth_ok
= push_cx_call_context (t
);
1635 tree result
= NULL_TREE
;
1637 constexpr_call
*entry
= NULL
;
1638 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1640 new_call
.hash
= iterative_hash_template_arg
1641 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1643 /* If we have seen this call before, we are done. */
1644 maybe_initialize_constexpr_call_table ();
1645 constexpr_call
**slot
1646 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1650 /* We need to keep a pointer to the entry, not just the slot, as the
1651 slot can move in the call to cxx_eval_builtin_function_call. */
1652 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1655 /* Calls that are in progress have their result set to NULL,
1656 so that we can detect circular dependencies. */
1657 else if (entry
->result
== NULL
)
1660 error ("call has circular dependency");
1661 *non_constant_p
= true;
1662 entry
->result
= result
= error_mark_node
;
1665 result
= entry
->result
;
1671 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1672 "-fconstexpr-depth= to increase the maximum)",
1673 max_constexpr_depth
);
1674 *non_constant_p
= true;
1675 result
= error_mark_node
;
1679 if (result
&& result
!= error_mark_node
)
1681 else if (!DECL_SAVED_TREE (fun
))
1683 /* When at_eof >= 2, cgraph has started throwing away
1684 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1685 late code generation for VEC_INIT_EXPR, which needs to be
1686 completely reconsidered. */
1687 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1688 *non_constant_p
= true;
1692 tree body
, parms
, res
;
1694 /* Reuse or create a new unshared copy of this function's body. */
1695 tree copy
= get_fundef_copy (fun
);
1696 body
= TREE_PURPOSE (copy
);
1697 parms
= TREE_VALUE (copy
);
1698 res
= TREE_TYPE (copy
);
1700 /* Associate the bindings with the remapped parms. */
1701 tree bound
= new_call
.bindings
;
1702 tree remapped
= parms
;
1705 tree oparm
= TREE_PURPOSE (bound
);
1706 tree arg
= TREE_VALUE (bound
);
1707 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1708 /* Don't share a CONSTRUCTOR that might be changed. */
1709 arg
= unshare_constructor (arg
);
1710 ctx
->values
->put (remapped
, arg
);
1711 bound
= TREE_CHAIN (bound
);
1712 remapped
= DECL_CHAIN (remapped
);
1714 /* Add the RESULT_DECL to the values map, too. */
1715 tree slot
= NULL_TREE
;
1716 if (DECL_BY_REFERENCE (res
))
1718 slot
= AGGR_INIT_EXPR_SLOT (t
);
1719 tree addr
= build_address (slot
);
1720 addr
= build_nop (TREE_TYPE (res
), addr
);
1721 ctx
->values
->put (res
, addr
);
1722 ctx
->values
->put (slot
, NULL_TREE
);
1725 ctx
->values
->put (res
, NULL_TREE
);
1727 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1728 their values after the call. */
1729 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1730 hash_set
<tree
> save_exprs
;
1731 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1732 ctx_with_save_exprs
.call
= &new_call
;
1734 tree jump_target
= NULL_TREE
;
1735 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1736 lval
, non_constant_p
, overflow_p
,
1739 if (DECL_CONSTRUCTOR_P (fun
))
1740 /* This can be null for a subobject constructor call, in
1741 which case what we care about is the initialization
1742 side-effects rather than the value. We could get at the
1743 value by evaluating *this, but we don't bother; there's
1744 no need to put such a call in the hash table. */
1745 result
= lval
? ctx
->object
: ctx
->ctor
;
1746 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1750 result
= *ctx
->values
->get (slot
? slot
: res
);
1751 if (result
== NULL_TREE
&& !*non_constant_p
)
1754 error ("%<constexpr%> call flows off the end "
1756 *non_constant_p
= true;
1760 /* Forget the saved values of the callee's SAVE_EXPRs. */
1761 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1762 iter
!= save_exprs
.end(); ++iter
)
1763 ctx_with_save_exprs
.values
->remove (*iter
);
1765 /* Remove the parms/result from the values map. Is it worth
1766 bothering to do this when the map itself is only live for
1767 one constexpr evaluation? If so, maybe also clear out
1768 other vars from call, maybe in BIND_EXPR handling? */
1769 ctx
->values
->remove (res
);
1771 ctx
->values
->remove (slot
);
1772 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1773 ctx
->values
->remove (parm
);
1775 /* Make the unshared function copy we used available for re-use. */
1776 save_fundef_copy (fun
, copy
);
1779 if (result
== error_mark_node
)
1780 *non_constant_p
= true;
1781 if (*non_constant_p
|| *overflow_p
)
1782 result
= error_mark_node
;
1786 entry
->result
= result
;
1789 /* The result of a constexpr function must be completely initialized. */
1790 if (TREE_CODE (result
) == CONSTRUCTOR
)
1791 clear_no_implicit_zero (result
);
1793 pop_cx_call_context ();
1794 return unshare_constructor (result
);
1797 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1800 reduced_constant_expression_p (tree t
)
1805 switch (TREE_CODE (t
))
1808 /* Even if we can't lower this yet, it's constant. */
1812 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1813 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1814 if (CONSTRUCTOR_NO_CLEARING (t
))
1816 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1817 /* An initialized vector would have a VECTOR_CST. */
1820 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1824 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1826 /* If VAL is null, we're in the middle of initializing this
1828 if (!reduced_constant_expression_p (val
))
1834 field
= next_initializable_field (DECL_CHAIN (field
));
1839 else if (CONSTRUCTOR_NO_CLEARING (t
))
1840 /* All the fields are initialized. */
1841 CONSTRUCTOR_NO_CLEARING (t
) = false;
1845 /* FIXME are we calling this too much? */
1846 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1850 /* Some expressions may have constant operands but are not constant
1851 themselves, such as 1/0. Call this function to check for that
1854 We only call this in places that require an arithmetic constant, not in
1855 places where we might have a non-constant expression that can be a
1856 component of a constant expression, such as the address of a constexpr
1857 variable that might be dereferenced later. */
1860 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1863 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1865 if (!allow_non_constant
)
1866 error ("%q+E is not a constant expression", t
);
1867 *non_constant_p
= true;
1869 if (TREE_OVERFLOW_P (t
))
1871 if (!allow_non_constant
)
1873 permerror (input_location
, "overflow in constant expression");
1874 /* If we're being permissive (and are in an enforcing
1875 context), ignore the overflow. */
1876 if (flag_permissive
)
1877 return *non_constant_p
;
1881 return *non_constant_p
;
1884 /* Check whether the shift operation with code CODE and type TYPE on LHS
1885 and RHS is undefined. If it is, give an error with an explanation,
1886 and return true; return false otherwise. */
1889 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1890 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1892 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1893 || TREE_CODE (lhs
) != INTEGER_CST
1894 || TREE_CODE (rhs
) != INTEGER_CST
)
1897 tree lhstype
= TREE_TYPE (lhs
);
1898 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1900 /* [expr.shift] The behavior is undefined if the right operand
1901 is negative, or greater than or equal to the length in bits
1902 of the promoted left operand. */
1903 if (tree_int_cst_sgn (rhs
) == -1)
1906 permerror (loc
, "right operand of shift expression %q+E is negative",
1907 build2_loc (loc
, code
, type
, lhs
, rhs
));
1908 return (!flag_permissive
|| ctx
->quiet
);
1910 if (compare_tree_int (rhs
, uprec
) >= 0)
1913 permerror (loc
, "right operand of shift expression %q+E is >= than "
1914 "the precision of the left operand",
1915 build2_loc (loc
, code
, type
, lhs
, rhs
));
1916 return (!flag_permissive
|| ctx
->quiet
);
1919 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1920 if E1 has a signed type and non-negative value, and E1x2^E2 is
1921 representable in the corresponding unsigned type of the result type,
1922 then that value, converted to the result type, is the resulting value;
1923 otherwise, the behavior is undefined. */
1924 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1925 && (cxx_dialect
>= cxx11
))
1927 if (tree_int_cst_sgn (lhs
) == -1)
1931 "left operand of shift expression %q+E is negative",
1932 build2_loc (loc
, code
, type
, lhs
, rhs
));
1933 return (!flag_permissive
|| ctx
->quiet
);
1935 /* For signed x << y the following:
1936 (unsigned) x >> ((prec (lhs) - 1) - y)
1937 if > 1, is undefined. The right-hand side of this formula
1938 is the highest bit of the LHS that can be set (starting from 0),
1939 so that the shift doesn't overflow. We then right-shift the LHS
1940 to see whether any other bit is set making the original shift
1941 undefined -- the result is not representable in the corresponding
1943 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1944 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1945 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1946 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1947 if (tree_int_cst_lt (integer_one_node
, t
))
1950 permerror (loc
, "shift expression %q+E overflows",
1951 build2_loc (loc
, code
, type
, lhs
, rhs
));
1952 return (!flag_permissive
|| ctx
->quiet
);
1958 /* Subroutine of cxx_eval_constant_expression.
1959 Attempt to reduce the unary expression tree T to a compile time value.
1960 If successful, return the value. Otherwise issue a diagnostic
1961 and return error_mark_node. */
1964 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1966 bool *non_constant_p
, bool *overflow_p
)
1969 tree orig_arg
= TREE_OPERAND (t
, 0);
1970 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1971 non_constant_p
, overflow_p
);
1972 VERIFY_CONSTANT (arg
);
1973 location_t loc
= EXPR_LOCATION (t
);
1974 enum tree_code code
= TREE_CODE (t
);
1975 tree type
= TREE_TYPE (t
);
1976 r
= fold_unary_loc (loc
, code
, type
, arg
);
1979 if (arg
== orig_arg
)
1982 r
= build1_loc (loc
, code
, type
, arg
);
1984 VERIFY_CONSTANT (r
);
1988 /* Helper function for cxx_eval_binary_expression. Try to optimize
1989 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1990 generic folding should be used. */
1993 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1994 tree lhs
, tree rhs
, bool *non_constant_p
,
1998 if (TREE_CODE (lhs
) != ADDR_EXPR
)
2001 lhs
= TREE_OPERAND (lhs
, 0);
2003 /* &A[i] p+ j => &A[i + j] */
2004 if (TREE_CODE (lhs
) == ARRAY_REF
2005 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
2006 && TREE_CODE (rhs
) == INTEGER_CST
2007 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
2008 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
2010 tree orig_type
= TREE_TYPE (t
);
2011 location_t loc
= EXPR_LOCATION (t
);
2012 tree type
= TREE_TYPE (lhs
);
2014 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
2015 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
2016 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2018 if (*non_constant_p
)
2020 /* Don't fold an out-of-bound access. */
2021 if (!tree_int_cst_le (t
, nelts
))
2023 rhs
= cp_fold_convert (ssizetype
, rhs
);
2024 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
2025 constexpr int A[1]; ... (char *)&A[0] + 1 */
2026 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
2027 rhs
, TYPE_SIZE_UNIT (type
))))
2029 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2031 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
2032 TYPE_SIZE_UNIT (type
));
2033 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
2034 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
2035 t
, NULL_TREE
, NULL_TREE
);
2036 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2037 t
= cp_fold_convert (orig_type
, t
);
2038 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2039 non_constant_p
, overflow_p
);
2045 /* Subroutine of cxx_eval_constant_expression.
2046 Like cxx_eval_unary_expression, except for binary expressions. */
2049 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2051 bool *non_constant_p
, bool *overflow_p
)
2054 tree orig_lhs
= TREE_OPERAND (t
, 0);
2055 tree orig_rhs
= TREE_OPERAND (t
, 1);
2057 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2058 non_constant_p
, overflow_p
);
2059 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2061 if (*non_constant_p
)
2063 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2064 non_constant_p
, overflow_p
);
2065 if (*non_constant_p
)
2068 location_t loc
= EXPR_LOCATION (t
);
2069 enum tree_code code
= TREE_CODE (t
);
2070 tree type
= TREE_TYPE (t
);
2072 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2074 bool is_code_eq
= (code
== EQ_EXPR
);
2076 if (TREE_CODE (lhs
) == PTRMEM_CST
2077 && TREE_CODE (rhs
) == PTRMEM_CST
)
2079 tree lmem
= PTRMEM_CST_MEMBER (lhs
);
2080 tree rmem
= PTRMEM_CST_MEMBER (rhs
);
2082 if (TREE_CODE (lmem
) == TREE_CODE (rmem
)
2083 && TREE_CODE (lmem
) == FIELD_DECL
2084 && TREE_CODE (DECL_CONTEXT (lmem
)) == UNION_TYPE
2085 && same_type_p (DECL_CONTEXT (lmem
),
2086 DECL_CONTEXT (rmem
)))
2087 /* If both refer to (possibly different) members of the same union
2088 (12.3), they compare equal. */
2091 eq
= cp_tree_equal (lhs
, rhs
);
2092 r
= constant_boolean_node (eq
== is_code_eq
, type
);
2094 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2095 || TREE_CODE (rhs
) == PTRMEM_CST
)
2096 && (null_member_pointer_value_p (lhs
)
2097 || null_member_pointer_value_p (rhs
)))
2098 r
= constant_boolean_node (!is_code_eq
, type
);
2099 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2100 lhs
= cplus_expand_constant (lhs
);
2101 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2102 rhs
= cplus_expand_constant (rhs
);
2104 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2105 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2108 error ("arithmetic involving a null pointer in %qE", lhs
);
2109 *non_constant_p
= true;
2112 else if (code
== POINTER_PLUS_EXPR
)
2113 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2117 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2121 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2124 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2126 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2127 *non_constant_p
= true;
2128 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2129 a local array in a constexpr function. */
2130 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (lhs
));
2132 VERIFY_CONSTANT (r
);
2136 /* Subroutine of cxx_eval_constant_expression.
2137 Attempt to evaluate condition expressions. Dead branches are not
2141 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2143 bool *non_constant_p
, bool *overflow_p
,
2146 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2148 non_constant_p
, overflow_p
);
2149 VERIFY_CONSTANT (val
);
2150 /* Don't VERIFY_CONSTANT the other operands. */
2151 if (integer_zerop (val
))
2152 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2154 non_constant_p
, overflow_p
,
2156 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2158 non_constant_p
, overflow_p
,
2162 /* Subroutine of cxx_eval_constant_expression.
2163 Attempt to evaluate vector condition expressions. Unlike
2164 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2165 ternary arithmetics operation, where all 3 arguments have to be
2166 evaluated as constants and then folding computes the result from
2170 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2171 bool *non_constant_p
, bool *overflow_p
)
2173 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2175 non_constant_p
, overflow_p
);
2176 VERIFY_CONSTANT (arg1
);
2177 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2179 non_constant_p
, overflow_p
);
2180 VERIFY_CONSTANT (arg2
);
2181 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2183 non_constant_p
, overflow_p
);
2184 VERIFY_CONSTANT (arg3
);
2185 location_t loc
= EXPR_LOCATION (t
);
2186 tree type
= TREE_TYPE (t
);
2187 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2190 if (arg1
== TREE_OPERAND (t
, 0)
2191 && arg2
== TREE_OPERAND (t
, 1)
2192 && arg3
== TREE_OPERAND (t
, 2))
2195 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2197 VERIFY_CONSTANT (r
);
2201 /* Returns less than, equal to, or greater than zero if KEY is found to be
2202 less than, to match, or to be greater than the constructor_elt's INDEX. */
2205 array_index_cmp (tree key
, tree index
)
2207 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2209 switch (TREE_CODE (index
))
2212 return tree_int_cst_compare (key
, index
);
2215 tree lo
= TREE_OPERAND (index
, 0);
2216 tree hi
= TREE_OPERAND (index
, 1);
2217 if (tree_int_cst_lt (key
, lo
))
2219 else if (tree_int_cst_lt (hi
, key
))
2229 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2230 if none. If INSERT is true, insert a matching element rather than fail. */
2232 static HOST_WIDE_INT
2233 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2235 if (tree_int_cst_sgn (dindex
) < 0)
2238 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2239 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2240 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2242 unsigned HOST_WIDE_INT end
= len
;
2243 unsigned HOST_WIDE_INT begin
= 0;
2245 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2246 that the same is true of the other elements and index directly. */
2249 tree cindex
= (*elts
)[end
- 1].index
;
2250 if (TREE_CODE (cindex
) == INTEGER_CST
2251 && compare_tree_int (cindex
, end
- 1) == 0)
2260 /* Otherwise, find a matching index by means of a binary search. */
2261 while (begin
!= end
)
2263 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2264 constructor_elt
&elt
= (*elts
)[middle
];
2265 tree idx
= elt
.index
;
2267 int cmp
= array_index_cmp (dindex
, idx
);
2274 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2276 /* We need to split the range. */
2278 tree lo
= TREE_OPERAND (idx
, 0);
2279 tree hi
= TREE_OPERAND (idx
, 1);
2280 tree value
= elt
.value
;
2281 dindex
= fold_convert (sizetype
, dindex
);
2282 if (tree_int_cst_lt (lo
, dindex
))
2284 /* There are still some lower elts; shorten the range. */
2285 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2287 if (tree_int_cst_equal (lo
, new_hi
))
2288 /* Only one element left, no longer a range. */
2291 TREE_OPERAND (idx
, 1) = new_hi
;
2292 /* Append the element we want to insert. */
2295 e
.value
= unshare_constructor (value
);
2296 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2299 /* No lower elts, the range elt is now ours. */
2302 if (tree_int_cst_lt (dindex
, hi
))
2304 /* There are still some higher elts; append a range. */
2305 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2307 if (tree_int_cst_equal (new_lo
, hi
))
2310 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2311 e
.value
= unshare_constructor (value
);
2312 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2321 constructor_elt e
= { dindex
, NULL_TREE
};
2322 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2329 /* Under the control of CTX, issue a detailed diagnostic for
2330 an out-of-bounds subscript INDEX into the expression ARRAY. */
2333 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2337 tree arraytype
= TREE_TYPE (array
);
2339 /* Convert the unsigned array subscript to a signed integer to avoid
2340 printing huge numbers for small negative values. */
2341 tree sidx
= fold_convert (ssizetype
, index
);
2344 if (TYPE_DOMAIN (arraytype
))
2345 error ("array subscript value %qE is outside the bounds "
2346 "of array %qD of type %qT", sidx
, array
, arraytype
);
2348 error ("non-zero array subscript %qE is used with array %qD of "
2349 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2350 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2352 else if (TYPE_DOMAIN (arraytype
))
2353 error ("array subscript value %qE is outside the bounds "
2354 "of array type %qT", sidx
, arraytype
);
2356 error ("non-zero array subscript %qE is used with array of type %qT "
2357 "with unknown bounds", sidx
, arraytype
);
2361 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2365 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2366 bool *non_constant_p
, bool *overflow_p
)
2369 if (TREE_CODE (type
) == ARRAY_TYPE
)
2371 if (TYPE_DOMAIN (type
))
2372 nelts
= array_type_nelts_top (type
);
2374 nelts
= size_zero_node
;
2376 else if (VECTOR_TYPE_P (type
))
2377 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2381 /* For VLAs, the number of elements won't be an integer constant. */
2382 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2383 non_constant_p
, overflow_p
);
2387 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2388 STRING_CST STRING. */
2391 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2393 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2396 if (chars_per_elt
== 1)
2397 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2400 const unsigned char *ptr
2401 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2402 + index
* chars_per_elt
);
2403 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2408 /* Subroutine of cxx_eval_constant_expression.
2409 Attempt to reduce a reference to an array slot. */
2412 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2414 bool *non_constant_p
, bool *overflow_p
)
2416 tree oldary
= TREE_OPERAND (t
, 0);
2417 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2419 non_constant_p
, overflow_p
);
2421 HOST_WIDE_INT i
= 0;
2422 tree elem_type
= NULL_TREE
;
2423 unsigned len
= 0, elem_nchars
= 1;
2424 if (*non_constant_p
)
2426 oldidx
= TREE_OPERAND (t
, 1);
2427 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2429 non_constant_p
, overflow_p
);
2430 VERIFY_CONSTANT (index
);
2433 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2434 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2435 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2436 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2437 ary
= TREE_OPERAND (ary
, 0);
2438 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2439 len
= CONSTRUCTOR_NELTS (ary
);
2440 else if (TREE_CODE (ary
) == STRING_CST
)
2442 elem_nchars
= (TYPE_PRECISION (elem_type
)
2443 / TYPE_PRECISION (char_type_node
));
2444 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2446 else if (TREE_CODE (ary
) == VECTOR_CST
)
2447 /* We don't create variable-length VECTOR_CSTs. */
2448 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2451 /* We can't do anything with other tree codes, so use
2452 VERIFY_CONSTANT to complain and fail. */
2453 VERIFY_CONSTANT (ary
);
2457 if (!tree_fits_shwi_p (index
)
2458 || (i
= tree_to_shwi (index
)) < 0)
2460 diag_array_subscript (ctx
, ary
, index
);
2461 *non_constant_p
= true;
2466 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2468 VERIFY_CONSTANT (nelts
);
2470 ? !tree_int_cst_le (index
, nelts
)
2471 : !tree_int_cst_lt (index
, nelts
))
2472 || tree_int_cst_sgn (index
) < 0)
2474 diag_array_subscript (ctx
, ary
, index
);
2475 *non_constant_p
= true;
2479 if (lval
&& ary
== oldary
&& index
== oldidx
)
2482 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2485 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2487 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2498 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2499 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2500 else if (TREE_CODE (ary
) == VECTOR_CST
)
2501 r
= VECTOR_CST_ELT (ary
, i
);
2503 r
= extract_string_elt (ary
, elem_nchars
, i
);
2506 /* Don't VERIFY_CONSTANT here. */
2509 /* Otherwise the element doesn't have a value yet. */
2514 if (TREE_CODE (ary
) == CONSTRUCTOR
2515 && CONSTRUCTOR_NO_CLEARING (ary
))
2517 /* 'ary' is part of the aggregate initializer we're currently
2518 building; if there's no initializer for this element yet,
2521 error ("accessing uninitialized array element");
2522 *non_constant_p
= true;
2526 /* If it's within the array bounds but doesn't have an explicit
2527 initializer, it's value-initialized. */
2528 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2529 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2533 /* Subroutine of cxx_eval_constant_expression.
2534 Attempt to reduce a field access of a value of class type. */
2537 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2539 bool *non_constant_p
, bool *overflow_p
)
2541 unsigned HOST_WIDE_INT i
;
2544 tree part
= TREE_OPERAND (t
, 1);
2545 tree orig_whole
= TREE_OPERAND (t
, 0);
2546 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2548 non_constant_p
, overflow_p
);
2549 if (INDIRECT_REF_P (whole
)
2550 && integer_zerop (TREE_OPERAND (whole
, 0)))
2553 error ("dereferencing a null pointer in %qE", orig_whole
);
2554 *non_constant_p
= true;
2558 if (TREE_CODE (whole
) == PTRMEM_CST
)
2559 whole
= cplus_expand_constant (whole
);
2560 if (whole
== orig_whole
)
2563 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2564 whole
, part
, NULL_TREE
);
2565 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2567 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2570 error ("%qE is not a constant expression", orig_whole
);
2571 *non_constant_p
= true;
2573 if (DECL_MUTABLE_P (part
))
2576 error ("mutable %qD is not usable in a constant expression", part
);
2577 *non_constant_p
= true;
2579 if (*non_constant_p
)
2581 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2582 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2584 /* Use name match for PMF fields, as a variant will have a
2585 different FIELD_DECL with a different type. */
2586 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2592 /* We're in the middle of initializing it. */
2596 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2597 && CONSTRUCTOR_NELTS (whole
) > 0)
2599 /* DR 1188 says we don't have to deal with this. */
2601 error ("accessing %qD member instead of initialized %qD member in "
2602 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2603 *non_constant_p
= true;
2607 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2608 classes never get represented; throw together a value now. */
2609 if (is_really_empty_class (TREE_TYPE (t
)))
2610 return build_constructor (TREE_TYPE (t
), NULL
);
2612 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2614 if (CONSTRUCTOR_NO_CLEARING (whole
))
2616 /* 'whole' is part of the aggregate initializer we're currently
2617 building; if there's no initializer for this member yet, that's an
2620 error ("accessing uninitialized member %qD", part
);
2621 *non_constant_p
= true;
2625 /* If there's no explicit init for this field, it's value-initialized. */
2626 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2627 return cxx_eval_constant_expression (ctx
, value
,
2629 non_constant_p
, overflow_p
);
2632 /* Subroutine of cxx_eval_constant_expression.
2633 Attempt to reduce a field access of a value of class type that is
2634 expressed as a BIT_FIELD_REF. */
2637 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2639 bool *non_constant_p
, bool *overflow_p
)
2641 tree orig_whole
= TREE_OPERAND (t
, 0);
2642 tree retval
, fldval
, utype
, mask
;
2643 bool fld_seen
= false;
2644 HOST_WIDE_INT istart
, isize
;
2645 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2647 non_constant_p
, overflow_p
);
2648 tree start
, field
, value
;
2649 unsigned HOST_WIDE_INT i
;
2651 if (whole
== orig_whole
)
2653 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2655 if (!*non_constant_p
2656 && TREE_CODE (whole
) != VECTOR_CST
2657 && TREE_CODE (whole
) != CONSTRUCTOR
)
2660 error ("%qE is not a constant expression", orig_whole
);
2661 *non_constant_p
= true;
2663 if (*non_constant_p
)
2666 if (TREE_CODE (whole
) == VECTOR_CST
)
2667 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2668 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2670 start
= TREE_OPERAND (t
, 2);
2671 istart
= tree_to_shwi (start
);
2672 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2673 utype
= TREE_TYPE (t
);
2674 if (!TYPE_UNSIGNED (utype
))
2675 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2676 retval
= build_int_cst (utype
, 0);
2677 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2679 tree bitpos
= bit_position (field
);
2680 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2682 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2683 && TREE_CODE (value
) == INTEGER_CST
2684 && tree_fits_shwi_p (bitpos
)
2685 && tree_fits_shwi_p (DECL_SIZE (field
)))
2687 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2688 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2689 HOST_WIDE_INT shift
;
2690 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2692 fldval
= fold_convert (utype
, value
);
2693 mask
= build_int_cst_type (utype
, -1);
2694 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2695 size_int (TYPE_PRECISION (utype
) - sz
));
2696 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2697 size_int (TYPE_PRECISION (utype
) - sz
));
2698 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2699 shift
= bit
- istart
;
2700 if (BYTES_BIG_ENDIAN
)
2701 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2702 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2704 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2710 return fold_convert (TREE_TYPE (t
), retval
);
2712 return error_mark_node
;
2715 /* Subroutine of cxx_eval_constant_expression.
2716 Evaluate a short-circuited logical expression T in the context
2717 of a given constexpr CALL. BAILOUT_VALUE is the value for
2718 early return. CONTINUE_VALUE is used here purely for
2719 sanity check purposes. */
2722 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2723 tree bailout_value
, tree continue_value
,
2725 bool *non_constant_p
, bool *overflow_p
)
2728 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2730 non_constant_p
, overflow_p
);
2731 VERIFY_CONSTANT (lhs
);
2732 if (tree_int_cst_equal (lhs
, bailout_value
))
2734 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2735 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2736 lval
, non_constant_p
,
2738 VERIFY_CONSTANT (r
);
2742 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2743 CONSTRUCTOR elements to initialize (part of) an object containing that
2744 field. Return a pointer to the constructor_elt corresponding to the
2745 initialization of the field. */
2747 static constructor_elt
*
2748 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2750 tree aggr
= TREE_OPERAND (ref
, 0);
2751 tree field
= TREE_OPERAND (ref
, 1);
2753 constructor_elt
*ce
;
2755 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2757 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2759 constructor_elt
*base_ce
2760 = base_field_constructor_elt (v
, aggr
);
2761 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2764 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2765 if (ce
->index
== field
)
2772 /* Some of the expressions fed to the constexpr mechanism are calls to
2773 constructors, which have type void. In that case, return the type being
2774 initialized by the constructor. */
2777 initialized_type (tree t
)
2781 tree type
= cv_unqualified (TREE_TYPE (t
));
2782 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2784 /* A constructor call has void type, so we need to look deeper. */
2785 tree fn
= get_function_named_in_call (t
);
2786 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2787 && DECL_CXX_CONSTRUCTOR_P (fn
))
2788 type
= DECL_CONTEXT (fn
);
2793 /* We're about to initialize element INDEX of an array or class from VALUE.
2794 Set up NEW_CTX appropriately by adjusting .object to refer to the
2795 subobject and creating a new CONSTRUCTOR if the element is itself
2796 a class or array. */
2799 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2800 tree index
, tree
&value
)
2804 if (index
&& TREE_CODE (index
) != INTEGER_CST
2805 && TREE_CODE (index
) != FIELD_DECL
)
2806 /* This won't have an element in the new CONSTRUCTOR. */
2809 tree type
= initialized_type (value
);
2810 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2811 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2814 /* The sub-aggregate initializer might contain a placeholder;
2815 update object to refer to the subobject and ctor to refer to
2816 the (newly created) sub-initializer. */
2818 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2819 tree elt
= build_constructor (type
, NULL
);
2820 CONSTRUCTOR_NO_CLEARING (elt
) = true;
2823 if (TREE_CODE (value
) == TARGET_EXPR
)
2824 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2825 value
= TARGET_EXPR_INITIAL (value
);
2828 /* We're about to process an initializer for a class or array TYPE. Make
2829 sure that CTX is set up appropriately. */
2832 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2834 /* We don't bother building a ctor for an empty base subobject. */
2835 if (is_empty_class (type
))
2838 /* We're in the middle of an initializer that might involve placeholders;
2839 our caller should have created a CONSTRUCTOR for us to put the
2840 initializer into. We will either return that constructor or T. */
2841 gcc_assert (ctx
->ctor
);
2842 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2843 (type
, TREE_TYPE (ctx
->ctor
)));
2844 /* We used to check that ctx->ctor was empty, but that isn't the case when
2845 the object is zero-initialized before calling the constructor. */
2848 tree otype
= TREE_TYPE (ctx
->object
);
2849 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2850 /* Handle flexible array members. */
2851 || (TREE_CODE (otype
) == ARRAY_TYPE
2852 && TYPE_DOMAIN (otype
) == NULL_TREE
2853 && TREE_CODE (type
) == ARRAY_TYPE
2854 && (same_type_ignoring_top_level_qualifiers_p
2855 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2857 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2858 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2861 /* Subroutine of cxx_eval_constant_expression.
2862 The expression tree T denotes a C-style array or a C-style
2863 aggregate. Reduce it to a constant expression. */
2866 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2868 bool *non_constant_p
, bool *overflow_p
)
2870 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2871 bool changed
= false;
2872 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2873 tree type
= TREE_TYPE (t
);
2875 constexpr_ctx new_ctx
;
2876 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2878 /* We don't really need the ctx->ctor business for a PMF or
2879 vector, but it's simpler to use the same code. */
2881 new_ctx
.ctor
= build_constructor (type
, NULL
);
2882 new_ctx
.object
= NULL_TREE
;
2885 verify_ctor_sanity (ctx
, type
);
2886 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2887 vec_alloc (*p
, vec_safe_length (v
));
2891 bool constant_p
= true;
2892 bool side_effects_p
= false;
2893 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2895 tree orig_value
= value
;
2896 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2897 if (new_ctx
.ctor
!= ctx
->ctor
)
2898 /* If we built a new CONSTRUCTOR, attach it now so that other
2899 initializers can refer to it. */
2900 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2901 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2903 non_constant_p
, overflow_p
);
2904 /* Don't VERIFY_CONSTANT here. */
2905 if (ctx
->quiet
&& *non_constant_p
)
2907 if (elt
!= orig_value
)
2910 if (!TREE_CONSTANT (elt
))
2912 if (TREE_SIDE_EFFECTS (elt
))
2913 side_effects_p
= true;
2914 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2916 /* This is an initialization of a vfield inside a base
2917 subaggregate that we already initialized; push this
2918 initialization into the previous initialization. */
2919 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2924 && (TREE_CODE (index
) == NOP_EXPR
2925 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2927 /* This is an initializer for an empty base; now that we've
2928 checked that it's constant, we can ignore it. */
2929 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2934 if (new_ctx
.ctor
!= ctx
->ctor
)
2936 /* We appended this element above; update the value. */
2937 gcc_assert ((*p
)->last().index
== index
);
2938 (*p
)->last().value
= elt
;
2941 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2942 /* Adding or replacing an element might change the ctor's flags. */
2943 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
2944 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
2947 if (*non_constant_p
|| !changed
)
2950 /* We're done building this CONSTRUCTOR, so now we can interpret an
2951 element without an explicit initializer as value-initialized. */
2952 CONSTRUCTOR_NO_CLEARING (t
) = false;
2953 TREE_CONSTANT (t
) = constant_p
;
2954 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2955 if (VECTOR_TYPE_P (type
))
2960 /* Subroutine of cxx_eval_constant_expression.
2961 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2962 initialization of a non-static data member of array type. Reduce it to a
2965 Note that apart from value-initialization (when VALUE_INIT is true),
2966 this is only intended to support value-initialization and the
2967 initializations done by defaulted constructors for classes with
2968 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2969 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2970 for the copy/move constructor. */
2973 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2974 bool value_init
, bool lval
,
2975 bool *non_constant_p
, bool *overflow_p
)
2977 tree elttype
= TREE_TYPE (atype
);
2978 verify_ctor_sanity (ctx
, atype
);
2979 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2980 bool pre_init
= false;
2981 unsigned HOST_WIDE_INT i
;
2982 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
2984 /* For the default constructor, build up a call to the default
2985 constructor of the element type. We only need to handle class types
2986 here, as for a constructor to be constexpr, all members must be
2987 initialized, which for a defaulted default constructor means they must
2988 be of a class type with a constexpr default constructor. */
2989 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2990 /* We only do this at the lowest level. */;
2991 else if (value_init
)
2993 init
= build_value_init (elttype
, complain
);
2998 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2999 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
3000 &argvec
, elttype
, LOOKUP_NORMAL
,
3002 release_tree_vector (argvec
);
3003 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
3007 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
3009 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
3010 for (i
= 0; i
< max
; ++i
)
3012 tree idx
= build_int_cst (size_type_node
, i
);
3015 constexpr_ctx new_ctx
;
3016 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
3017 if (new_ctx
.ctor
!= ctx
->ctor
)
3018 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
3019 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3021 /* A multidimensional array; recurse. */
3022 if (value_init
|| init
== NULL_TREE
)
3024 eltinit
= NULL_TREE
;
3028 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3029 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
3031 non_constant_p
, overflow_p
);
3035 /* Initializing an element using value or default initialization
3036 we just pre-built above. */
3037 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
3038 non_constant_p
, overflow_p
);
3043 /* Copying an element. */
3044 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3045 (atype
, TREE_TYPE (init
)));
3046 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3047 if (!lvalue_p (init
))
3048 eltinit
= move (eltinit
);
3049 eltinit
= force_rvalue (eltinit
, complain
);
3050 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
3051 non_constant_p
, overflow_p
);
3053 if (*non_constant_p
&& !ctx
->quiet
)
3055 if (new_ctx
.ctor
!= ctx
->ctor
)
3057 /* We appended this element above; update the value. */
3058 gcc_assert ((*p
)->last().index
== idx
);
3059 (*p
)->last().value
= eltinit
;
3062 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3063 /* Reuse the result of cxx_eval_constant_expression call
3064 from the first iteration to all others if it is a constant
3065 initializer that doesn't require relocations. */
3068 && (eltinit
== NULL_TREE
3069 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3070 == null_pointer_node
)))
3072 if (new_ctx
.ctor
!= ctx
->ctor
)
3073 eltinit
= new_ctx
.ctor
;
3074 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3075 build_int_cst (size_type_node
, 1),
3076 build_int_cst (size_type_node
, max
- 1));
3077 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3081 vec_safe_reserve (*p
, max
);
3084 if (!*non_constant_p
)
3087 CONSTRUCTOR_NO_CLEARING (init
) = false;
3093 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3095 bool *non_constant_p
, bool *overflow_p
)
3097 tree atype
= TREE_TYPE (t
);
3098 tree init
= VEC_INIT_EXPR_INIT (t
);
3099 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3100 VEC_INIT_EXPR_VALUE_INIT (t
),
3101 lval
, non_constant_p
, overflow_p
);
3102 if (*non_constant_p
)
3108 /* Like same_type_ignoring_top_level_qualifiers_p, but also handle the case
3109 where the desired type is an array of unknown bounds because the variable
3110 has had its bounds deduced since the wrapping expression was created. */
3113 same_type_ignoring_tlq_and_bounds_p (tree type1
, tree type2
)
3115 while (TREE_CODE (type1
) == ARRAY_TYPE
3116 && TREE_CODE (type2
) == ARRAY_TYPE
3117 && (!TYPE_DOMAIN (type1
) || !TYPE_DOMAIN (type2
)))
3119 type1
= TREE_TYPE (type1
);
3120 type2
= TREE_TYPE (type2
);
3122 return same_type_ignoring_top_level_qualifiers_p (type1
, type2
);
3125 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3126 match. We want to be less strict for simple *& folding; if we have a
3127 non-const temporary that we access through a const pointer, that should
3128 work. We handle this here rather than change fold_indirect_ref_1
3129 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3130 don't really make sense outside of constant expression evaluation. Also
3131 we want to allow folding to COMPONENT_REF, which could cause trouble
3132 with TBAA in fold_indirect_ref_1.
3134 Try to keep this function synced with fold_indirect_ref_1. */
3137 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3141 poly_uint64 const_op01
;
3144 subtype
= TREE_TYPE (sub
);
3145 if (!INDIRECT_TYPE_P (subtype
))
3148 if (TREE_CODE (sub
) == ADDR_EXPR
)
3150 tree op
= TREE_OPERAND (sub
, 0);
3151 tree optype
= TREE_TYPE (op
);
3153 /* *&CONST_DECL -> to the value of the const decl. */
3154 if (TREE_CODE (op
) == CONST_DECL
)
3155 return DECL_INITIAL (op
);
3156 /* *&p => p; make sure to handle *&"str"[cst] here. */
3157 if (same_type_ignoring_tlq_and_bounds_p (optype
, type
))
3159 tree fop
= fold_read_from_constant_string (op
);
3165 /* *(foo *)&fooarray => fooarray[0] */
3166 else if (TREE_CODE (optype
) == ARRAY_TYPE
3167 && (same_type_ignoring_top_level_qualifiers_p
3168 (type
, TREE_TYPE (optype
))))
3170 tree type_domain
= TYPE_DOMAIN (optype
);
3171 tree min_val
= size_zero_node
;
3172 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3173 min_val
= TYPE_MIN_VALUE (type_domain
);
3174 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3175 NULL_TREE
, NULL_TREE
);
3177 /* *(foo *)&complexfoo => __real__ complexfoo */
3178 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3179 && (same_type_ignoring_top_level_qualifiers_p
3180 (type
, TREE_TYPE (optype
))))
3181 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3182 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3183 else if (VECTOR_TYPE_P (optype
)
3184 && (same_type_ignoring_top_level_qualifiers_p
3185 (type
, TREE_TYPE (optype
))))
3187 tree part_width
= TYPE_SIZE (type
);
3188 tree index
= bitsize_int (0);
3189 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3192 /* Also handle conversion to an empty base class, which
3193 is represented with a NOP_EXPR. */
3194 else if (is_empty_class (type
)
3195 && CLASS_TYPE_P (optype
)
3196 && DERIVED_FROM_P (type
, optype
))
3201 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3202 else if (RECORD_OR_UNION_TYPE_P (optype
))
3204 tree field
= TYPE_FIELDS (optype
);
3205 for (; field
; field
= DECL_CHAIN (field
))
3206 if (TREE_CODE (field
) == FIELD_DECL
3207 && TREE_TYPE (field
) != error_mark_node
3208 && integer_zerop (byte_position (field
))
3209 && (same_type_ignoring_top_level_qualifiers_p
3210 (TREE_TYPE (field
), type
)))
3211 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3214 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3215 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3217 tree op00
= TREE_OPERAND (sub
, 0);
3218 tree op01
= TREE_OPERAND (sub
, 1);
3221 if (TREE_CODE (op00
) == ADDR_EXPR
)
3224 op00
= TREE_OPERAND (op00
, 0);
3225 op00type
= TREE_TYPE (op00
);
3227 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3228 if (VECTOR_TYPE_P (op00type
)
3229 && same_type_ignoring_top_level_qualifiers_p
3230 (type
, TREE_TYPE (op00type
))
3231 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3232 but we want to treat offsets with MSB set as negative.
3233 For the code below negative offsets are invalid and
3234 TYPE_SIZE of the element is something unsigned, so
3235 check whether op01 fits into poly_int64, which implies
3236 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3237 then just use poly_uint64 because we want to treat the
3238 value as unsigned. */
3239 && tree_fits_poly_int64_p (op01
))
3241 tree part_width
= TYPE_SIZE (type
);
3242 poly_uint64 max_offset
3243 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3244 * TYPE_VECTOR_SUBPARTS (op00type
));
3245 if (known_lt (const_op01
, max_offset
))
3247 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3248 return fold_build3_loc (loc
,
3249 BIT_FIELD_REF
, type
, op00
,
3253 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3254 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3255 && (same_type_ignoring_top_level_qualifiers_p
3256 (type
, TREE_TYPE (op00type
))))
3258 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3260 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3262 /* ((foo *)&fooarray)[1] => fooarray[1] */
3263 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3264 && (same_type_ignoring_top_level_qualifiers_p
3265 (type
, TREE_TYPE (op00type
))))
3267 tree type_domain
= TYPE_DOMAIN (op00type
);
3268 tree min_val
= size_zero_node
;
3269 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3270 min_val
= TYPE_MIN_VALUE (type_domain
);
3271 offset_int off
= wi::to_offset (op01
);
3272 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3273 offset_int remainder
;
3274 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3275 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3277 off
= off
+ wi::to_offset (min_val
);
3278 op01
= wide_int_to_tree (sizetype
, off
);
3279 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3280 NULL_TREE
, NULL_TREE
);
3283 /* Also handle conversion to an empty base class, which
3284 is represented with a NOP_EXPR. */
3285 else if (is_empty_class (type
)
3286 && CLASS_TYPE_P (op00type
)
3287 && DERIVED_FROM_P (type
, op00type
))
3292 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3293 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3295 tree field
= TYPE_FIELDS (op00type
);
3296 for (; field
; field
= DECL_CHAIN (field
))
3297 if (TREE_CODE (field
) == FIELD_DECL
3298 && TREE_TYPE (field
) != error_mark_node
3299 && tree_int_cst_equal (byte_position (field
), op01
)
3300 && (same_type_ignoring_top_level_qualifiers_p
3301 (TREE_TYPE (field
), type
)))
3302 return fold_build3 (COMPONENT_REF
, type
, op00
,
3307 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3308 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3309 && (same_type_ignoring_top_level_qualifiers_p
3310 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3313 tree min_val
= size_zero_node
;
3315 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3319 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3320 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3321 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3322 min_val
= TYPE_MIN_VALUE (type_domain
);
3323 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3331 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3333 bool *non_constant_p
, bool *overflow_p
)
3335 tree orig_op0
= TREE_OPERAND (t
, 0);
3336 bool empty_base
= false;
3338 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3339 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3341 if (TREE_CODE (t
) == MEM_REF
3342 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3344 gcc_assert (ctx
->quiet
);
3345 *non_constant_p
= true;
3349 /* First try to simplify it directly. */
3350 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3354 /* If that didn't work, evaluate the operand first. */
3355 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3356 /*lval*/false, non_constant_p
,
3358 /* Don't VERIFY_CONSTANT here. */
3359 if (*non_constant_p
)
3362 if (!lval
&& integer_zerop (op0
))
3365 error ("dereferencing a null pointer");
3366 *non_constant_p
= true;
3370 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3374 /* We couldn't fold to a constant value. Make sure it's not
3375 something we should have been able to fold. */
3378 if (TREE_CODE (sub
) == ADDR_EXPR
)
3380 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3381 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3382 /* DR 1188 says we don't have to deal with this. */
3384 error ("accessing value of %qE through a %qT glvalue in a "
3385 "constant expression", build_fold_indirect_ref (sub
),
3387 *non_constant_p
= true;
3391 if (lval
&& op0
!= orig_op0
)
3392 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3394 VERIFY_CONSTANT (t
);
3399 r
= cxx_eval_constant_expression (ctx
, r
,
3400 lval
, non_constant_p
, overflow_p
);
3401 if (*non_constant_p
)
3404 /* If we're pulling out the value of an empty base, just return an empty
3406 if (empty_base
&& !lval
)
3408 r
= build_constructor (TREE_TYPE (t
), NULL
);
3409 TREE_CONSTANT (r
) = true;
3415 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3416 Shared between potential_constant_expression and
3417 cxx_eval_constant_expression. */
3420 non_const_var_error (tree r
)
3422 tree type
= TREE_TYPE (r
);
3423 error ("the value of %qD is not usable in a constant "
3425 /* Avoid error cascade. */
3426 if (DECL_INITIAL (r
) == error_mark_node
)
3428 if (DECL_DECLARED_CONSTEXPR_P (r
))
3429 inform (DECL_SOURCE_LOCATION (r
),
3430 "%qD used in its own initializer", r
);
3431 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3433 if (!CP_TYPE_CONST_P (type
))
3434 inform (DECL_SOURCE_LOCATION (r
),
3435 "%q#D is not const", r
);
3436 else if (CP_TYPE_VOLATILE_P (type
))
3437 inform (DECL_SOURCE_LOCATION (r
),
3438 "%q#D is volatile", r
);
3439 else if (!DECL_INITIAL (r
)
3440 || !TREE_CONSTANT (DECL_INITIAL (r
))
3441 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3442 inform (DECL_SOURCE_LOCATION (r
),
3443 "%qD was not initialized with a constant "
3448 else if (TYPE_REF_P (type
))
3449 inform (DECL_SOURCE_LOCATION (r
),
3450 "%qD was not initialized with a constant "
3454 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3455 inform (DECL_SOURCE_LOCATION (r
),
3456 "%qD was not declared %<constexpr%>", r
);
3458 inform (DECL_SOURCE_LOCATION (r
),
3459 "%qD does not have integral or enumeration type",
3464 /* Subroutine of cxx_eval_constant_expression.
3465 Like cxx_eval_unary_expression, except for trinary expressions. */
3468 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3470 bool *non_constant_p
, bool *overflow_p
)
3476 for (i
= 0; i
< 3; i
++)
3478 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3480 non_constant_p
, overflow_p
);
3481 VERIFY_CONSTANT (args
[i
]);
3484 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3485 args
[0], args
[1], args
[2]);
3486 if (val
== NULL_TREE
)
3488 VERIFY_CONSTANT (val
);
3492 /* True if T was declared in a function declared to be constexpr, and
3493 therefore potentially constant in C++14. */
3496 var_in_constexpr_fn (tree t
)
3498 tree ctx
= DECL_CONTEXT (t
);
3499 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3500 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3503 /* True if T was declared in a function that might be constexpr: either a
3504 function that was declared constexpr, or a C++17 lambda op(). */
3507 var_in_maybe_constexpr_fn (tree t
)
3509 if (cxx_dialect
>= cxx17
3510 && DECL_FUNCTION_SCOPE_P (t
)
3511 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3513 return var_in_constexpr_fn (t
);
3516 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3517 build_over_call we implement trivial copy of a class with tail padding using
3518 assignment of character arrays, which is valid in normal code, but not in
3519 constexpr evaluation. We don't need to worry about clobbering tail padding
3520 in constexpr evaluation, so strip the type punning. */
3523 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3525 if (TREE_CODE (target
) == MEM_REF
3526 && TREE_CODE (init
) == MEM_REF
3527 && TREE_TYPE (target
) == TREE_TYPE (init
)
3528 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3529 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3531 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3532 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3536 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3539 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3541 bool *non_constant_p
, bool *overflow_p
)
3543 constexpr_ctx new_ctx
= *ctx
;
3545 tree init
= TREE_OPERAND (t
, 1);
3546 if (TREE_CLOBBER_P (init
))
3547 /* Just ignore clobbers. */
3550 /* First we figure out where we're storing to. */
3551 tree target
= TREE_OPERAND (t
, 0);
3553 maybe_simplify_trivial_copy (target
, init
);
3555 tree type
= TREE_TYPE (target
);
3556 target
= cxx_eval_constant_expression (ctx
, target
,
3558 non_constant_p
, overflow_p
);
3559 if (*non_constant_p
)
3562 /* cxx_eval_array_reference for lval = true allows references one past
3563 end of array, because it does not know if it is just taking address
3564 (which is valid), or actual dereference. Here we know it is
3565 a dereference, so diagnose it here. */
3566 for (tree probe
= target
; probe
; )
3568 switch (TREE_CODE (probe
))
3572 ary
= TREE_OPERAND (probe
, 0);
3573 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3574 non_constant_p
, overflow_p
);
3575 VERIFY_CONSTANT (nelts
);
3576 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3577 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3578 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3580 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3581 *non_constant_p
= true;
3588 probe
= TREE_OPERAND (probe
, 0);
3597 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3599 /* For initialization of an empty base, the original target will be
3600 *(base*)this, which the above evaluation resolves to the object
3601 argument, which has the derived type rather than the base type. In
3602 this situation, just evaluate the initializer and return, since
3603 there's no actual data to store. */
3604 gcc_assert (is_empty_class (type
));
3605 return cxx_eval_constant_expression (ctx
, init
, false,
3606 non_constant_p
, overflow_p
);
3609 /* And then find the underlying variable. */
3610 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3611 tree object
= NULL_TREE
;
3612 for (tree probe
= target
; object
== NULL_TREE
; )
3614 switch (TREE_CODE (probe
))
3619 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3620 vec_safe_push (refs
, TREE_TYPE (probe
));
3621 probe
= TREE_OPERAND (probe
, 0);
3629 /* And then find/build up our initializer for the path to the subobject
3630 we're initializing. */
3632 if (object
== ctx
->object
&& VAR_P (object
)
3633 && DECL_NAME (object
) && ctx
->call
== NULL
)
3634 /* The variable we're building up an aggregate initializer for is outside
3635 the constant-expression, so don't evaluate the store. We check
3636 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3638 else if (DECL_P (object
))
3639 valp
= ctx
->values
->get (object
);
3644 /* A constant-expression cannot modify objects from outside the
3645 constant-expression. */
3647 error ("modification of %qE is not a constant expression", object
);
3648 *non_constant_p
= true;
3651 type
= TREE_TYPE (object
);
3652 bool no_zero_init
= true;
3654 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3655 while (!refs
->is_empty())
3657 if (*valp
== NULL_TREE
)
3659 *valp
= build_constructor (type
, NULL
);
3660 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3662 else if (TREE_CODE (*valp
) == STRING_CST
)
3664 /* An array was initialized with a string constant, and now
3665 we're writing into one of its elements. Explode the
3666 single initialization into a set of element
3668 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3670 tree string
= *valp
;
3671 tree elt_type
= TREE_TYPE (type
);
3672 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3673 / TYPE_PRECISION (char_type_node
));
3674 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3675 tree ary_ctor
= build_constructor (type
, NULL
);
3677 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3678 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3680 constructor_elt elt
=
3682 build_int_cst (size_type_node
, ix
),
3683 extract_string_elt (string
, chars_per_elt
, ix
)
3685 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3691 /* If the value of object is already zero-initialized, any new ctors for
3692 subobjects will also be zero-initialized. */
3693 no_zero_init
= CONSTRUCTOR_NO_CLEARING (*valp
);
3695 vec_safe_push (ctors
, *valp
);
3697 enum tree_code code
= TREE_CODE (type
);
3699 tree index
= refs
->pop();
3701 constructor_elt
*cep
= NULL
;
3702 if (code
== ARRAY_TYPE
)
3705 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3706 gcc_assert (i
>= 0);
3707 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3708 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3712 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3714 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3715 Usually we meet initializers in that order, but it is
3716 possible for base types to be placed not in program
3718 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3719 unsigned HOST_WIDE_INT idx
;
3721 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3722 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3723 /* Changing active member. */
3724 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3727 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3728 idx
++, fields
= DECL_CHAIN (fields
))
3730 if (index
== cep
->index
)
3733 /* The field we're initializing must be on the field
3734 list. Look to see if it is present before the
3735 field the current ELT initializes. */
3736 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3737 if (index
== fields
)
3741 /* We fell off the end of the CONSTRUCTOR, so insert a new
3742 entry at the end. */
3745 constructor_elt ce
= { index
, NULL_TREE
};
3747 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3748 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3754 release_tree_vector (refs
);
3756 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3758 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3759 wants to modify it. */
3760 if (*valp
== NULL_TREE
)
3762 *valp
= build_constructor (type
, NULL
);
3763 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3765 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3766 *valp
= cplus_expand_constant (*valp
);
3767 new_ctx
.ctor
= *valp
;
3768 new_ctx
.object
= target
;
3771 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3772 non_constant_p
, overflow_p
);
3773 /* Don't share a CONSTRUCTOR that might be changed later. */
3774 init
= unshare_constructor (init
);
3775 if (target
== object
)
3776 /* The hash table might have moved since the get earlier. */
3777 valp
= ctx
->values
->get (object
);
3779 if (TREE_CODE (init
) == CONSTRUCTOR
)
3781 /* An outer ctx->ctor might be pointing to *valp, so replace
3783 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3784 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3785 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3786 CONSTRUCTOR_NO_CLEARING (*valp
)
3787 = CONSTRUCTOR_NO_CLEARING (init
);
3792 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3793 CONSTRUCTORs, if any. */
3796 bool c
= TREE_CONSTANT (init
);
3797 bool s
= TREE_SIDE_EFFECTS (init
);
3799 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3802 TREE_CONSTANT (elt
) = false;
3804 TREE_SIDE_EFFECTS (elt
) = true;
3806 release_tree_vector (ctors
);
3808 if (*non_constant_p
)
3816 /* Evaluate a ++ or -- expression. */
3819 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3821 bool *non_constant_p
, bool *overflow_p
)
3823 enum tree_code code
= TREE_CODE (t
);
3824 tree type
= TREE_TYPE (t
);
3825 tree op
= TREE_OPERAND (t
, 0);
3826 tree offset
= TREE_OPERAND (t
, 1);
3827 gcc_assert (TREE_CONSTANT (offset
));
3829 /* The operand as an lvalue. */
3830 op
= cxx_eval_constant_expression (ctx
, op
, true,
3831 non_constant_p
, overflow_p
);
3833 /* The operand as an rvalue. */
3835 = cxx_eval_constant_expression (ctx
, op
, false,
3836 non_constant_p
, overflow_p
);
3837 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3838 a local array in a constexpr function. */
3839 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (val
));
3841 VERIFY_CONSTANT (val
);
3843 /* The modified value. */
3844 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3846 if (INDIRECT_TYPE_P (type
))
3848 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3849 offset
= convert_to_ptrofftype (offset
);
3851 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3852 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3855 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3857 VERIFY_CONSTANT (mod
);
3859 /* Storing the modified value. */
3860 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3861 cxx_eval_constant_expression (ctx
, store
,
3862 true, non_constant_p
, overflow_p
);
3864 /* And the value of the expression. */
3865 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3867 /* Prefix ops are lvalues. */
3871 /* But we optimize when the caller wants an rvalue. */
3875 /* Postfix ops are rvalues. */
3879 /* Predicates for the meaning of *jump_target. */
3882 returns (tree
*jump_target
)
3885 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3886 || (TREE_CODE (*jump_target
) == LABEL_DECL
3887 && LABEL_DECL_CDTOR (*jump_target
)));
3891 breaks (tree
*jump_target
)
3894 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3895 && LABEL_DECL_BREAK (*jump_target
))
3896 || TREE_CODE (*jump_target
) == BREAK_STMT
3897 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3901 continues (tree
*jump_target
)
3904 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3905 && LABEL_DECL_CONTINUE (*jump_target
))
3906 || TREE_CODE (*jump_target
) == CONTINUE_STMT
);
3911 switches (tree
*jump_target
)
3914 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3917 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3918 STMT matches *jump_target. If we're looking for a case label and we see
3919 the default label, note it in ctx->css_state. */
3922 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3924 switch (TREE_CODE (*jump_target
))
3927 if (TREE_CODE (stmt
) == LABEL_EXPR
3928 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3933 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3935 gcc_assert (ctx
->css_state
!= NULL
);
3936 if (!CASE_LOW (stmt
))
3938 /* default: should appear just once in a SWITCH_EXPR
3939 body (excluding nested SWITCH_EXPR). */
3940 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3941 /* When evaluating SWITCH_EXPR body for the second time,
3942 return true for the default: label. */
3943 if (*ctx
->css_state
== css_default_processing
)
3945 *ctx
->css_state
= css_default_seen
;
3947 else if (CASE_HIGH (stmt
))
3949 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3950 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3953 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3964 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3965 semantics, for switch, break, continue, and return. */
3968 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3969 bool *non_constant_p
, bool *overflow_p
,
3972 tree_stmt_iterator i
;
3974 /* In a statement-expression we want to return the last value.
3975 For empty statement expression return void_node. */
3979 local_target
= NULL_TREE
;
3980 jump_target
= &local_target
;
3982 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3984 tree stmt
= tsi_stmt (i
);
3985 /* We've found a continue, so skip everything until we reach
3986 the label its jumping to. */
3987 if (continues (jump_target
))
3989 if (label_matches (ctx
, jump_target
, stmt
))
3991 *jump_target
= NULL_TREE
;
3995 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
3997 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3998 non_constant_p
, overflow_p
,
4000 if (*non_constant_p
)
4002 if (returns (jump_target
) || breaks (jump_target
))
4008 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
4009 semantics; continue semantics are covered by cxx_eval_statement_list. */
4012 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
4013 bool *non_constant_p
, bool *overflow_p
,
4016 constexpr_ctx new_ctx
= *ctx
;
4018 tree body
= TREE_OPERAND (t
, 0);
4022 hash_set
<tree
> save_exprs
;
4023 new_ctx
.save_exprs
= &save_exprs
;
4025 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
4026 non_constant_p
, overflow_p
, jump_target
);
4028 /* Forget saved values of SAVE_EXPRs. */
4029 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
4030 iter
!= save_exprs
.end(); ++iter
)
4031 new_ctx
.values
->remove (*iter
);
4032 if (++count
>= constexpr_loop_limit
)
4035 error_at (cp_expr_loc_or_loc (t
, input_location
),
4036 "%<constexpr%> loop iteration count exceeds limit of %d "
4037 "(use -fconstexpr-loop-limit= to increase the limit)",
4038 constexpr_loop_limit
);
4039 *non_constant_p
= true;
4043 while (!returns (jump_target
)
4044 && !breaks (jump_target
)
4045 && !switches (jump_target
)
4046 && !*non_constant_p
);
4048 if (breaks (jump_target
))
4049 *jump_target
= NULL_TREE
;
4054 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
4058 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
4059 bool *non_constant_p
, bool *overflow_p
,
4062 tree cond
= TREE_OPERAND (t
, 0);
4063 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
4064 non_constant_p
, overflow_p
);
4065 VERIFY_CONSTANT (cond
);
4066 *jump_target
= cond
;
4068 tree body
= TREE_OPERAND (t
, 1);
4069 constexpr_ctx new_ctx
= *ctx
;
4070 constexpr_switch_state css
= css_default_not_seen
;
4071 new_ctx
.css_state
= &css
;
4072 cxx_eval_constant_expression (&new_ctx
, body
, false,
4073 non_constant_p
, overflow_p
, jump_target
);
4074 if (switches (jump_target
) && css
== css_default_seen
)
4076 /* If the SWITCH_EXPR body has default: label, process it once again,
4077 this time instructing label_matches to return true for default:
4078 label on switches (jump_target). */
4079 css
= css_default_processing
;
4080 cxx_eval_constant_expression (&new_ctx
, body
, false,
4081 non_constant_p
, overflow_p
, jump_target
);
4083 if (breaks (jump_target
) || switches (jump_target
))
4084 *jump_target
= NULL_TREE
;
4088 /* Find the object of TYPE under initialization in CTX. */
4091 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4096 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4097 can is a minor optimization. */
4098 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4104 /* Since an object cannot have a field of its own type, we can search outward
4105 from ctx->object to find the unique containing object of TYPE. */
4106 tree ob
= ctx
->object
;
4109 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4111 if (handled_component_p (ob
))
4112 ob
= TREE_OPERAND (ob
, 0);
4120 /* Attempt to reduce the expression T to a constant value.
4121 On failure, issue diagnostic and return error_mark_node. */
4122 /* FIXME unify with c_fully_fold */
4123 /* FIXME overflow_p is too global */
4126 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4128 bool *non_constant_p
, bool *overflow_p
,
4129 tree
*jump_target
/* = NULL */)
4131 constexpr_ctx new_ctx
;
4134 if (jump_target
&& *jump_target
)
4136 /* If we are jumping, ignore all statements/expressions except those
4137 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4138 switch (TREE_CODE (t
))
4141 case STATEMENT_LIST
:
4146 case CASE_LABEL_EXPR
:
4147 if (label_matches (ctx
, jump_target
, t
))
4149 *jump_target
= NULL_TREE
;
4155 if (error_operand_p (t
))
4157 *non_constant_p
= true;
4160 if (CONSTANT_CLASS_P (t
))
4162 if (TREE_OVERFLOW (t
))
4165 permerror (input_location
, "overflow in constant expression");
4166 if (!flag_permissive
|| ctx
->quiet
)
4170 if (TREE_CODE (t
) == INTEGER_CST
4171 && TYPE_PTR_P (TREE_TYPE (t
))
4172 && !integer_zerop (t
))
4175 error ("value %qE of type %qT is not a constant expression",
4177 *non_constant_p
= true;
4183 tree_code tcode
= TREE_CODE (t
);
4189 /* We ask for an rvalue for the RESULT_DECL when indirecting
4190 through an invisible reference, or in named return value
4192 if (tree
*p
= ctx
->values
->get (t
))
4197 error ("%qE is not a constant expression", t
);
4198 *non_constant_p
= true;
4203 if (DECL_HAS_VALUE_EXPR_P (t
))
4204 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4205 lval
, non_constant_p
, overflow_p
);
4208 /* We used to not check lval for CONST_DECL, but darwin.c uses
4209 CONST_DECL for aggregate constants. */
4212 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4213 && is_really_empty_class (TREE_TYPE (t
)))
4215 /* If the class is empty, we aren't actually loading anything. */
4216 r
= build_constructor (TREE_TYPE (t
), NULL
);
4217 TREE_CONSTANT (r
) = true;
4219 else if (ctx
->strict
)
4220 r
= decl_really_constant_value (t
);
4222 r
= decl_constant_value (t
);
4223 if (TREE_CODE (r
) == TARGET_EXPR
4224 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4225 r
= TARGET_EXPR_INITIAL (r
);
4227 if (tree
*p
= ctx
->values
->get (r
))
4228 if (*p
!= NULL_TREE
)
4233 non_const_var_error (r
);
4234 *non_constant_p
= true;
4238 case DEBUG_BEGIN_STMT
:
4239 /* ??? It might be nice to retain this information somehow, so
4240 as to be able to step into a constexpr function call. */
4247 case CASE_LABEL_EXPR
:
4252 if (lval
&& !TYPE_REF_P (TREE_TYPE (t
)))
4254 else if (tree
*p
= ctx
->values
->get (r
))
4257 /* Defer in case this is only used for its type. */;
4258 else if (TYPE_REF_P (TREE_TYPE (t
)))
4259 /* Defer, there's no lvalue->rvalue conversion. */;
4260 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4261 && is_really_empty_class (TREE_TYPE (t
)))
4263 /* If the class is empty, we aren't actually loading anything. */
4264 r
= build_constructor (TREE_TYPE (t
), NULL
);
4265 TREE_CONSTANT (r
) = true;
4270 error ("%qE is not a constant expression", t
);
4271 *non_constant_p
= true;
4276 case AGGR_INIT_EXPR
:
4277 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4278 non_constant_p
, overflow_p
);
4283 r
= DECL_EXPR_DECL (t
);
4284 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4285 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4289 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4290 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4291 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4295 if (tree init
= DECL_INITIAL (r
))
4297 init
= cxx_eval_constant_expression (ctx
, init
,
4299 non_constant_p
, overflow_p
);
4300 /* Don't share a CONSTRUCTOR that might be changed. */
4301 init
= unshare_constructor (init
);
4302 ctx
->values
->put (r
, init
);
4304 else if (ctx
== &new_ctx
)
4305 /* We gave it a CONSTRUCTOR above. */;
4307 ctx
->values
->put (r
, NULL_TREE
);
4312 if (!literal_type_p (TREE_TYPE (t
)))
4316 auto_diagnostic_group d
;
4317 error ("temporary of non-literal type %qT in a "
4318 "constant expression", TREE_TYPE (t
));
4319 explain_non_literal_class (TREE_TYPE (t
));
4321 *non_constant_p
= true;
4324 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4326 /* We're being expanded without an explicit target, so start
4327 initializing a new object; expansion with an explicit target
4328 strips the TARGET_EXPR before we get here. */
4330 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4331 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4332 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4333 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4336 /* Pass false for 'lval' because this indicates
4337 initialization of a temporary. */
4338 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4340 non_constant_p
, overflow_p
);
4341 if (!*non_constant_p
)
4342 /* Adjust the type of the result to the type of the temporary. */
4343 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4346 tree slot
= TARGET_EXPR_SLOT (t
);
4347 r
= unshare_constructor (r
);
4348 ctx
->values
->put (slot
, r
);
4355 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4356 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4357 non_constant_p
, overflow_p
);
4361 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4363 non_constant_p
, overflow_p
);
4367 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4368 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4370 non_constant_p
, overflow_p
);
4375 /* Can happen with ({ return true; }) && false; passed to
4376 maybe_constant_value. There is nothing to jump over in this
4377 case, and the bug will be diagnosed later. */
4378 gcc_assert (ctx
->quiet
);
4379 *non_constant_p
= true;
4384 /* Avoid evaluating a SAVE_EXPR more than once. */
4385 if (tree
*p
= ctx
->values
->get (t
))
4389 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4390 non_constant_p
, overflow_p
);
4391 ctx
->values
->put (t
, r
);
4392 if (ctx
->save_exprs
)
4393 ctx
->save_exprs
->add (t
);
4397 case NON_LVALUE_EXPR
:
4398 case TRY_CATCH_EXPR
:
4400 case CLEANUP_POINT_EXPR
:
4401 case MUST_NOT_THROW_EXPR
:
4404 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4406 non_constant_p
, overflow_p
,
4410 case TRY_FINALLY_EXPR
:
4411 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4412 non_constant_p
, overflow_p
,
4414 if (!*non_constant_p
)
4415 /* Also evaluate the cleanup. */
4416 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4417 non_constant_p
, overflow_p
,
4421 /* These differ from cxx_eval_unary_expression in that this doesn't
4422 check for a constant operand or result; an address can be
4423 constant without its operand being, and vice versa. */
4426 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4427 non_constant_p
, overflow_p
);
4432 tree oldop
= TREE_OPERAND (t
, 0);
4433 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4435 non_constant_p
, overflow_p
);
4436 /* Don't VERIFY_CONSTANT here. */
4437 if (*non_constant_p
)
4439 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4440 /* This function does more aggressive folding than fold itself. */
4441 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4442 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4451 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4452 non_constant_p
, overflow_p
);
4453 if (r
== error_mark_node
)
4455 else if (r
== TREE_OPERAND (t
, 0))
4458 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4463 case FIX_TRUNC_EXPR
:
4469 case TRUTH_NOT_EXPR
:
4470 case FIXED_CONVERT_EXPR
:
4471 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4472 non_constant_p
, overflow_p
);
4476 r
= fold_sizeof_expr (t
);
4477 VERIFY_CONSTANT (r
);
4482 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4483 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4484 introduced by build_call_a. */
4485 tree op0
= TREE_OPERAND (t
, 0);
4486 tree op1
= TREE_OPERAND (t
, 1);
4488 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4489 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4490 r
= cxx_eval_constant_expression (ctx
, op0
,
4491 lval
, non_constant_p
, overflow_p
,
4495 /* Check that the LHS is constant and then discard it. */
4496 cxx_eval_constant_expression (ctx
, op0
,
4497 true, non_constant_p
, overflow_p
,
4499 if (*non_constant_p
)
4501 op1
= TREE_OPERAND (t
, 1);
4502 r
= cxx_eval_constant_expression (ctx
, op1
,
4503 lval
, non_constant_p
, overflow_p
,
4509 case POINTER_PLUS_EXPR
:
4510 case POINTER_DIFF_EXPR
:
4514 case TRUNC_DIV_EXPR
:
4516 case FLOOR_DIV_EXPR
:
4517 case ROUND_DIV_EXPR
:
4518 case TRUNC_MOD_EXPR
:
4520 case ROUND_MOD_EXPR
:
4522 case EXACT_DIV_EXPR
:
4532 case TRUTH_XOR_EXPR
:
4539 case UNORDERED_EXPR
:
4549 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4550 non_constant_p
, overflow_p
);
4553 /* fold can introduce non-IF versions of these; still treat them as
4554 short-circuiting. */
4555 case TRUTH_AND_EXPR
:
4556 case TRUTH_ANDIF_EXPR
:
4557 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4560 non_constant_p
, overflow_p
);
4564 case TRUTH_ORIF_EXPR
:
4565 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4568 non_constant_p
, overflow_p
);
4572 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4573 non_constant_p
, overflow_p
);
4577 if (is_overloaded_fn (t
))
4579 /* We can only get here in checking mode via
4580 build_non_dependent_expr, because any expression that
4581 calls or takes the address of the function will have
4582 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4583 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4584 *non_constant_p
= true;
4587 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4588 non_constant_p
, overflow_p
);
4592 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4593 non_constant_p
, overflow_p
);
4597 if (jump_target
&& *jump_target
)
4599 /* When jumping to a label, the label might be either in the
4600 then or else blocks, so process then block first in skipping
4601 mode first, and if we are still in the skipping mode at its end,
4602 process the else block too. */
4603 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4604 lval
, non_constant_p
, overflow_p
,
4607 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4608 lval
, non_constant_p
, overflow_p
,
4612 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4613 non_constant_p
, overflow_p
,
4617 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4622 if (TREE_CONSTANT (t
))
4624 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4625 VECTOR_CST if applicable. */
4626 verify_constructor_flags (t
);
4627 if (TREE_CONSTANT (t
))
4630 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4631 non_constant_p
, overflow_p
);
4635 /* We can get this in a defaulted constructor for a class with a
4636 non-static data member of array type. Either the initializer will
4637 be NULL, meaning default-initialization, or it will be an lvalue
4638 or xvalue of the same type, meaning direct-initialization from the
4639 corresponding member. */
4640 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4641 non_constant_p
, overflow_p
);
4645 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4646 non_constant_p
, overflow_p
);
4650 if (REINTERPRET_CAST_P (t
))
4653 error_at (cp_expr_loc_or_loc (t
, input_location
),
4654 "a reinterpret_cast is not a constant expression");
4655 *non_constant_p
= true;
4660 case VIEW_CONVERT_EXPR
:
4661 case UNARY_PLUS_EXPR
:
4663 tree oldop
= TREE_OPERAND (t
, 0);
4665 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4667 non_constant_p
, overflow_p
);
4668 if (*non_constant_p
)
4670 tree type
= TREE_TYPE (t
);
4671 if (TREE_CODE (op
) == PTRMEM_CST
4672 && !TYPE_PTRMEM_P (type
))
4673 op
= cplus_expand_constant (op
);
4675 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4677 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (op
))
4678 && !can_convert_qual (type
, op
))
4679 op
= cplus_expand_constant (op
);
4680 return cp_fold_convert (type
, op
);
4683 if (INDIRECT_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4685 if (integer_zerop (op
))
4687 if (TYPE_REF_P (type
))
4690 error_at (cp_expr_loc_or_loc (t
, input_location
),
4691 "dereferencing a null pointer");
4692 *non_constant_p
= true;
4695 else if (TYPE_PTR_P (TREE_TYPE (op
)))
4697 tree from
= TREE_TYPE (op
);
4699 if (!can_convert (type
, from
, tf_none
))
4702 error_at (cp_expr_loc_or_loc (t
, input_location
),
4703 "conversion of %qT null pointer to %qT "
4704 "is not a constant expression",
4706 *non_constant_p
= true;
4713 /* This detects for example:
4714 reinterpret_cast<void*>(sizeof 0)
4717 error_at (cp_expr_loc_or_loc (t
, input_location
),
4718 "%<reinterpret_cast<%T>(%E)%> is not "
4719 "a constant expression",
4721 *non_constant_p
= true;
4726 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4727 /* We didn't fold at the top so we could check for ptr-int
4731 /* Handle an array's bounds having been deduced after we built
4732 the wrapping expression. */
4733 if (same_type_ignoring_tlq_and_bounds_p (type
, TREE_TYPE (op
)))
4735 else if (tcode
== UNARY_PLUS_EXPR
)
4736 r
= fold_convert (TREE_TYPE (t
), op
);
4738 r
= fold_build1 (tcode
, type
, op
);
4740 /* Conversion of an out-of-range value has implementation-defined
4741 behavior; the language considers it different from arithmetic
4742 overflow, which is undefined. */
4743 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4744 TREE_OVERFLOW (r
) = false;
4748 case EMPTY_CLASS_EXPR
:
4749 /* This is good enough for a function argument that might not get
4750 used, and they can't do anything with it, so just return it. */
4753 case STATEMENT_LIST
:
4755 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4756 return cxx_eval_statement_list (&new_ctx
, t
,
4757 non_constant_p
, overflow_p
, jump_target
);
4760 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4762 non_constant_p
, overflow_p
,
4765 case PREINCREMENT_EXPR
:
4766 case POSTINCREMENT_EXPR
:
4767 case PREDECREMENT_EXPR
:
4768 case POSTDECREMENT_EXPR
:
4769 return cxx_eval_increment_expression (ctx
, t
,
4770 lval
, non_constant_p
, overflow_p
);
4776 case VEC_DELETE_EXPR
:
4779 /* GCC internal stuff. */
4782 case NON_DEPENDENT_EXPR
:
4786 error_at (cp_expr_loc_or_loc (t
, input_location
),
4787 "expression %qE is not a constant expression", t
);
4788 *non_constant_p
= true;
4791 case PLACEHOLDER_EXPR
:
4792 /* Use of the value or address of the current object. */
4793 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4794 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4795 non_constant_p
, overflow_p
);
4796 /* A placeholder without a referent. We can get here when
4797 checking whether NSDMIs are noexcept, or in massage_init_elt;
4798 just say it's non-constant for now. */
4799 gcc_assert (ctx
->quiet
);
4800 *non_constant_p
= true;
4805 tree cond
= TREE_OPERAND (t
, 0);
4806 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4807 non_constant_p
, overflow_p
);
4808 VERIFY_CONSTANT (cond
);
4809 if (integer_nonzerop (cond
))
4815 *jump_target
= TREE_OPERAND (t
, 0);
4816 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4817 /* Allow for jumping to a cdtor_label. */
4818 || returns (jump_target
));
4822 cxx_eval_loop_expr (ctx
, t
,
4823 non_constant_p
, overflow_p
, jump_target
);
4827 cxx_eval_switch_expr (ctx
, t
,
4828 non_constant_p
, overflow_p
, jump_target
);
4832 /* It's possible to get a requires-expression in a constant
4833 expression. For example:
4835 template<typename T> concept bool C() {
4836 return requires (T t) { t; };
4839 template<typename T> requires !C<T>() void f(T);
4841 Normalization leaves f with the associated constraint
4842 '!requires (T t) { ... }' which is not transformed into
4844 if (!processing_template_decl
)
4845 return evaluate_constraint_expression (t
, NULL_TREE
);
4847 *non_constant_p
= true;
4851 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4853 non_constant_p
, overflow_p
,
4862 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4864 /* This function doesn't know how to deal with pre-genericize
4865 statements; this can only happen with statement-expressions,
4866 so for now just fail. */
4868 error_at (EXPR_LOCATION (t
),
4869 "statement is not a constant expression");
4872 internal_error ("unexpected expression %qE of kind %s", t
,
4873 get_tree_code_name (TREE_CODE (t
)));
4874 *non_constant_p
= true;
4878 if (r
== error_mark_node
)
4879 *non_constant_p
= true;
4881 if (*non_constant_p
)
4887 /* P0859: A function is needed for constant evaluation if it is a constexpr
4888 function that is named by an expression ([basic.def.odr]) that is
4889 potentially constant evaluated.
4891 So we need to instantiate any constexpr functions mentioned by the
4892 expression even if the definition isn't needed for evaluating the
4896 instantiate_cx_fn_r (tree
*tp
, int *walk_subtrees
, void */
*data*/
)
4898 if (TREE_CODE (*tp
) == FUNCTION_DECL
4899 && DECL_DECLARED_CONSTEXPR_P (*tp
)
4900 && !DECL_INITIAL (*tp
)
4901 && !trivial_fn_p (*tp
)
4902 && DECL_TEMPLOID_INSTANTIATION (*tp
))
4905 instantiate_decl (*tp
, /*defer_ok*/false, /*expl_inst*/false);
4908 else if (TREE_CODE (*tp
) == CALL_EXPR
4909 || TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
4911 if (EXPR_HAS_LOCATION (*tp
))
4912 input_location
= EXPR_LOCATION (*tp
);
4921 instantiate_constexpr_fns (tree t
)
4923 location_t loc
= input_location
;
4924 cp_walk_tree_without_duplicates (&t
, instantiate_cx_fn_r
, NULL
);
4925 input_location
= loc
;
4928 /* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
4929 PRETEND_CONST_REQUIRED is true if T is required to be const-evaluated as
4930 per P0595 even when ALLOW_NON_CONSTANT is true. */
4933 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4935 bool pretend_const_required
= false,
4936 tree object
= NULL_TREE
)
4938 auto_timevar
time (TV_CONSTEXPR
);
4940 bool non_constant_p
= false;
4941 bool overflow_p
= false;
4942 hash_map
<tree
,tree
> map
;
4944 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4945 allow_non_constant
, strict
,
4946 pretend_const_required
|| !allow_non_constant
};
4948 tree type
= initialized_type (t
);
4950 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4952 /* In C++14 an NSDMI can participate in aggregate initialization,
4953 and can refer to the address of the object being initialized, so
4954 we need to pass in the relevant VAR_DECL if we want to do the
4955 evaluation in a single pass. The evaluation will dynamically
4956 update ctx.values for the VAR_DECL. We use the same strategy
4957 for C++11 constexpr constructors that refer to the object being
4959 ctx
.ctor
= build_constructor (type
, NULL
);
4960 CONSTRUCTOR_NO_CLEARING (ctx
.ctor
) = true;
4963 if (TREE_CODE (t
) == TARGET_EXPR
)
4964 object
= TARGET_EXPR_SLOT (t
);
4965 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4966 object
= AGGR_INIT_EXPR_SLOT (t
);
4968 ctx
.object
= object
;
4970 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4971 (type
, TREE_TYPE (object
)));
4972 if (object
&& DECL_P (object
))
4973 map
.put (object
, ctx
.ctor
);
4974 if (TREE_CODE (r
) == TARGET_EXPR
)
4975 /* Avoid creating another CONSTRUCTOR when we expand the
4977 r
= TARGET_EXPR_INITIAL (r
);
4980 instantiate_constexpr_fns (r
);
4981 r
= cxx_eval_constant_expression (&ctx
, r
,
4982 false, &non_constant_p
, &overflow_p
);
4984 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4986 /* Mutable logic is a bit tricky: we want to allow initialization of
4987 constexpr variables with mutable members, but we can't copy those
4988 members to another constexpr variable. */
4989 if (TREE_CODE (r
) == CONSTRUCTOR
4990 && CONSTRUCTOR_MUTABLE_POISON (r
))
4992 if (!allow_non_constant
)
4993 error ("%qE is not a constant expression because it refers to "
4994 "mutable subobjects of %qT", t
, type
);
4995 non_constant_p
= true;
4998 if (TREE_CODE (r
) == CONSTRUCTOR
4999 && CONSTRUCTOR_NO_CLEARING (r
))
5001 if (!allow_non_constant
)
5002 error ("%qE is not a constant expression because it refers to "
5003 "an incompletely initialized variable", t
);
5004 TREE_CONSTANT (r
) = false;
5005 non_constant_p
= true;
5008 /* Technically we should check this for all subexpressions, but that
5009 runs into problems with our internal representation of pointer
5010 subtraction and the 5.19 rules are still in flux. */
5011 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
5012 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
5013 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
5015 if (!allow_non_constant
)
5016 error ("conversion from pointer type %qT "
5017 "to arithmetic type %qT in a constant expression",
5018 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
5019 non_constant_p
= true;
5022 if (!non_constant_p
&& overflow_p
)
5023 non_constant_p
= true;
5025 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
5027 bool should_unshare
= true;
5028 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
5029 should_unshare
= false;
5031 if (non_constant_p
&& !allow_non_constant
)
5032 return error_mark_node
;
5033 else if (non_constant_p
&& TREE_CONSTANT (r
))
5035 /* If __builtin_is_constant_evaluated () was evaluated to true
5036 and the result is not a valid constant expression, we need to
5038 if (pretend_const_required
)
5039 return cxx_eval_outermost_constant_expr (t
, true, strict
,
5041 /* This isn't actually constant, so unset TREE_CONSTANT.
5042 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
5043 it to be set if it is invariant address, even when it is not
5044 a valid C++ constant expression. Wrap it with a NOP_EXPR
5046 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
5048 else if (TREE_CODE (r
) == CONSTRUCTOR
)
5049 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
5051 r
= build_nop (TREE_TYPE (r
), r
);
5052 TREE_CONSTANT (r
) = false;
5054 else if (non_constant_p
|| r
== t
)
5058 r
= unshare_expr (r
);
5060 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
5062 if (TREE_CODE (t
) == TARGET_EXPR
5063 && TARGET_EXPR_INITIAL (t
) == r
)
5067 r
= get_target_expr (r
);
5068 TREE_CONSTANT (r
) = true;
5076 /* Returns true if T is a valid subexpression of a constant expression,
5077 even if it isn't itself a constant expression. */
5080 is_sub_constant_expr (tree t
)
5082 bool non_constant_p
= false;
5083 bool overflow_p
= false;
5084 hash_map
<tree
, tree
> map
;
5087 = { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true, false };
5089 instantiate_constexpr_fns (t
);
5090 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
5092 return !non_constant_p
&& !overflow_p
;
5095 /* If T represents a constant expression returns its reduced value.
5096 Otherwise return error_mark_node. If T is dependent, then
5100 cxx_constant_value (tree t
, tree decl
)
5102 return cxx_eval_outermost_constant_expr (t
, false, true, true, decl
);
5105 /* Helper routine for fold_simple function. Either return simplified
5106 expression T, otherwise NULL_TREE.
5107 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
5108 even if we are within template-declaration. So be careful on call, as in
5109 such case types can be undefined. */
5112 fold_simple_1 (tree t
)
5115 enum tree_code code
= TREE_CODE (t
);
5127 return fold_sizeof_expr (t
);
5136 case TRUTH_NOT_EXPR
:
5138 case VIEW_CONVERT_EXPR
:
5141 case FIX_TRUNC_EXPR
:
5142 case FIXED_CONVERT_EXPR
:
5143 case ADDR_SPACE_CONVERT_EXPR
:
5145 op1
= TREE_OPERAND (t
, 0);
5147 t
= const_unop (code
, TREE_TYPE (t
), op1
);
5151 if (CONVERT_EXPR_CODE_P (code
)
5152 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
5153 TREE_OVERFLOW (t
) = false;
5161 /* If T is a simple constant expression, returns its simplified value.
5162 Otherwise returns T. In contrast to maybe_constant_value we
5163 simplify only few operations on constant-expressions, and we don't
5164 try to simplify constexpressions. */
5167 fold_simple (tree t
)
5169 if (processing_template_decl
)
5172 tree r
= fold_simple_1 (t
);
5179 /* If T is a constant expression, returns its reduced value.
5180 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5181 Otherwise, returns a version of T without TREE_CONSTANT. */
5183 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5186 maybe_constant_value (tree t
, tree decl
)
5190 if (!is_nondependent_constant_expression (t
))
5192 if (TREE_OVERFLOW_P (t
))
5194 t
= build_nop (TREE_TYPE (t
), t
);
5195 TREE_CONSTANT (t
) = false;
5199 else if (CONSTANT_CLASS_P (t
))
5200 /* No caching or evaluation needed. */
5203 if (cv_cache
== NULL
)
5204 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5205 if (tree
*cached
= cv_cache
->get (t
))
5208 r
= cxx_eval_outermost_constant_expr (t
, true, true, false, decl
);
5209 gcc_checking_assert (r
== t
5210 || CONVERT_EXPR_P (t
)
5211 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5212 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5213 || !cp_tree_equal (r
, t
));
5214 cv_cache
->put (t
, r
);
5218 /* Dispose of the whole CV_CACHE. */
5221 clear_cv_cache (void)
5223 if (cv_cache
!= NULL
)
5227 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5230 clear_cv_and_fold_caches (void)
5233 clear_fold_cache ();
5236 /* Like maybe_constant_value but first fully instantiate the argument.
5238 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5239 (t, complain) followed by maybe_constant_value but is more efficient,
5240 because it calls instantiation_dependent_expression_p and
5241 potential_constant_expression at most once.
5243 Callers should generally pass their active complain, or if they are in a
5244 non-template, diagnosing context, they can use the default of
5245 tf_warning_or_error. Callers that might be within a template context, don't
5246 have a complain parameter, and aren't going to remember the result for long
5247 (e.g. null_ptr_cst_p), can pass tf_none and deal with error_mark_node
5251 fold_non_dependent_expr (tree t
,
5252 tsubst_flags_t complain
/* = tf_warning_or_error */)
5257 /* If we're in a template, but T isn't value dependent, simplify
5258 it. We're supposed to treat:
5260 template <typename T> void f(T[1 + 1]);
5261 template <typename T> void f(T[2]);
5263 as two declarations of the same function, for example. */
5264 if (processing_template_decl
)
5266 if (is_nondependent_constant_expression (t
))
5268 processing_template_decl_sentinel s
;
5269 t
= instantiate_non_dependent_expr_internal (t
, complain
);
5271 if (type_unknown_p (t
)
5272 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5274 if (TREE_OVERFLOW_P (t
))
5276 t
= build_nop (TREE_TYPE (t
), t
);
5277 TREE_CONSTANT (t
) = false;
5282 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, false,
5284 /* cp_tree_equal looks through NOPs, so allow them. */
5285 gcc_checking_assert (r
== t
5286 || CONVERT_EXPR_P (t
)
5287 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5288 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5289 || !cp_tree_equal (r
, t
));
5292 else if (TREE_OVERFLOW_P (t
))
5294 t
= build_nop (TREE_TYPE (t
), t
);
5295 TREE_CONSTANT (t
) = false;
5300 return maybe_constant_value (t
);
5303 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5304 than wrapped in a TARGET_EXPR.
5305 ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5306 PRETEND_CONST_REQUIRED is true if T is required to be const-evaluated as
5307 per P0595 even when ALLOW_NON_CONSTANT is true. */
5310 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
,
5311 bool pretend_const_required
)
5315 if (TREE_CODE (t
) == EXPR_STMT
)
5316 t
= TREE_OPERAND (t
, 0);
5317 if (TREE_CODE (t
) == CONVERT_EXPR
5318 && VOID_TYPE_P (TREE_TYPE (t
)))
5319 t
= TREE_OPERAND (t
, 0);
5320 if (TREE_CODE (t
) == INIT_EXPR
)
5321 t
= TREE_OPERAND (t
, 1);
5322 if (TREE_CODE (t
) == TARGET_EXPR
)
5323 t
= TARGET_EXPR_INITIAL (t
);
5324 if (!is_nondependent_static_init_expression (t
))
5325 /* Don't try to evaluate it. */;
5326 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5327 /* No evaluation needed. */;
5329 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
,
5330 !allow_non_constant
,
5331 pretend_const_required
, decl
);
5332 if (TREE_CODE (t
) == TARGET_EXPR
)
5334 tree init
= TARGET_EXPR_INITIAL (t
);
5335 if (TREE_CODE (init
) == CONSTRUCTOR
)
5341 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5344 maybe_constant_init (tree t
, tree decl
, bool pretend_const_required
)
5346 return maybe_constant_init_1 (t
, decl
, true, pretend_const_required
);
5349 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5352 cxx_constant_init (tree t
, tree decl
)
5354 return maybe_constant_init_1 (t
, decl
, false, true);
5358 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5359 /* Return true if the object referred to by REF has automatic or thread
5362 enum { ck_ok
, ck_bad
, ck_unknown
};
5364 check_automatic_or_tls (tree ref
)
5367 poly_int64 bitsize
, bitpos
;
5369 int volatilep
= 0, unsignedp
= 0;
5370 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5371 &mode
, &unsignedp
, &volatilep
, false);
5374 /* If there isn't a decl in the middle, we don't know the linkage here,
5375 and this isn't a constant expression anyway. */
5378 dk
= decl_storage_duration (decl
);
5379 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5383 /* Return true if T denotes a potentially constant expression. Issue
5384 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5385 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5386 consider the expression in the current context, independent of constexpr
5389 C++0x [expr.const] used to say
5391 6 An expression is a potential constant expression if it is
5392 a constant expression where all occurrences of function
5393 parameters are replaced by arbitrary constant expressions
5394 of the appropriate type.
5396 2 A conditional expression is a constant expression unless it
5397 involves one of the following as a potentially evaluated
5398 subexpression (3.2), but subexpressions of logical AND (5.14),
5399 logical OR (5.15), and conditional (5.16) operations that are
5400 not evaluated are not considered. */
5403 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5404 tsubst_flags_t flags
, tree
*jump_target
)
5406 #define RECUR(T,RV) \
5407 potential_constant_expression_1 ((T), (RV), strict, now, flags, jump_target)
5409 enum { any
= false, rval
= true };
5413 if (t
== error_mark_node
)
5417 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
5420 /* If we are jumping, ignore everything. This is simpler than the
5421 cxx_eval_constant_expression handling because we only need to be
5422 conservatively correct, and we don't necessarily have a constant value
5423 available, so we don't bother with switch tracking. */
5426 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5428 if (flags
& tf_error
)
5429 error_at (loc
, "expression %qE has side-effects", t
);
5432 if (CONSTANT_CLASS_P (t
))
5434 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5435 && TREE_TYPE (t
) == error_mark_node
)
5438 switch (TREE_CODE (t
))
5444 case TEMPLATE_ID_EXPR
:
5447 case CASE_LABEL_EXPR
:
5453 case TEMPLATE_PARM_INDEX
:
5455 case IDENTIFIER_NODE
:
5456 case USERDEF_LITERAL
:
5457 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5462 case PLACEHOLDER_EXPR
:
5465 case DEBUG_BEGIN_STMT
:
5469 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5481 if (flags
& tf_error
)
5482 error ("%qE is not a constant expression", t
);
5487 case AGGR_INIT_EXPR
:
5489 /* -- an invocation of a function other than a constexpr function
5490 or a constexpr constructor. */
5492 tree fun
= get_function_named_in_call (t
);
5493 const int nargs
= call_expr_nargs (t
);
5496 if (fun
== NULL_TREE
)
5498 /* Reset to allow the function to continue past the end
5499 of the block below. Otherwise return early. */
5502 if (TREE_CODE (t
) == CALL_EXPR
5503 && CALL_EXPR_FN (t
) == NULL_TREE
)
5504 switch (CALL_EXPR_IFN (t
))
5506 /* These should be ignored, they are optimized away from
5507 constexpr functions. */
5508 case IFN_UBSAN_NULL
:
5509 case IFN_UBSAN_BOUNDS
:
5510 case IFN_UBSAN_VPTR
:
5511 case IFN_FALLTHROUGH
:
5514 case IFN_ADD_OVERFLOW
:
5515 case IFN_SUB_OVERFLOW
:
5516 case IFN_MUL_OVERFLOW
:
5526 /* fold_call_expr can't do anything with IFN calls. */
5527 if (flags
& tf_error
)
5528 error_at (loc
, "call to internal function %qE", t
);
5533 if (fun
&& is_overloaded_fn (fun
))
5535 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5537 if (builtin_valid_in_constant_expr_p (fun
))
5539 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5540 /* Allow any built-in function; if the expansion
5541 isn't constant, we'll deal with that then. */
5542 && !fndecl_built_in_p (fun
))
5544 if (flags
& tf_error
)
5546 error_at (loc
, "call to non-%<constexpr%> function %qD",
5548 explain_invalid_constexpr_fn (fun
);
5552 /* A call to a non-static member function takes the address
5553 of the object as the first argument. But in a constant
5554 expression the address will be folded away, so look
5556 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5557 && !DECL_CONSTRUCTOR_P (fun
))
5559 tree x
= get_nth_callarg (t
, 0);
5560 if (is_this_parameter (x
))
5562 /* Don't require an immediately constant value, as
5563 constexpr substitution might not use the value. */
5564 bool sub_now
= false;
5565 if (!potential_constant_expression_1 (x
, rval
, strict
,
5574 if (!RECUR (fun
, true))
5576 fun
= get_first_fn (fun
);
5578 /* Skip initial arguments to base constructors. */
5579 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5580 i
= num_artificial_parms_for (fun
);
5581 fun
= DECL_ORIGIN (fun
);
5585 if (RECUR (fun
, rval
))
5586 /* Might end up being a constant function pointer. */;
5590 for (; i
< nargs
; ++i
)
5592 tree x
= get_nth_callarg (t
, i
);
5593 /* In a template, reference arguments haven't been converted to
5594 REFERENCE_TYPE and we might not even know if the parameter
5595 is a reference, so accept lvalue constants too. */
5596 bool rv
= processing_template_decl
? any
: rval
;
5597 /* Don't require an immediately constant value, as constexpr
5598 substitution might not use the value of the argument. */
5599 bool sub_now
= false;
5600 if (!potential_constant_expression_1 (x
, rv
, strict
,
5601 sub_now
, flags
, jump_target
))
5607 case NON_LVALUE_EXPR
:
5608 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5609 -- an lvalue of integral type that refers to a non-volatile
5610 const variable or static data member initialized with
5611 constant expressions, or
5613 -- an lvalue of literal type that refers to non-volatile
5614 object defined with constexpr, or that refers to a
5615 sub-object of such an object; */
5616 return RECUR (TREE_OPERAND (t
, 0), rval
);
5619 if (DECL_HAS_VALUE_EXPR_P (t
))
5621 if (now
&& is_normal_capture_proxy (t
))
5623 /* -- in a lambda-expression, a reference to this or to a
5624 variable with automatic storage duration defined outside that
5625 lambda-expression, where the reference would be an
5627 if (flags
& tf_error
)
5629 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5630 error ("lambda capture of %qE is not a constant expression",
5632 if (!want_rval
&& decl_constant_var_p (cap
))
5633 inform (input_location
, "because it is used as a glvalue");
5637 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5640 && !var_in_maybe_constexpr_fn (t
)
5641 && !type_dependent_expression_p (t
)
5642 && !decl_maybe_constant_var_p (t
)
5644 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5645 || (DECL_INITIAL (t
)
5646 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5647 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5648 && !is_really_empty_class (TREE_TYPE (t
)))
5650 if (flags
& tf_error
)
5651 non_const_var_error (t
);
5658 case VIEW_CONVERT_EXPR
:
5659 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5660 may change to something more specific to type-punning (DR 1312). */
5662 tree from
= TREE_OPERAND (t
, 0);
5663 if (INDIRECT_TYPE_P (TREE_TYPE (t
))
5664 && TREE_CODE (from
) == INTEGER_CST
5665 && !integer_zerop (from
))
5667 if (flags
& tf_error
)
5668 error_at (loc
, "reinterpret_cast from integer to pointer");
5671 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5674 case ADDRESSOF_EXPR
:
5675 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5676 t
= TREE_OPERAND (t
, 0);
5677 goto handle_addr_expr
;
5680 /* -- a unary operator & that is applied to an lvalue that
5681 designates an object with thread or automatic storage
5683 t
= TREE_OPERAND (t
, 0);
5685 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5686 /* A pointer-to-member constant. */
5691 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5692 any checking here, as we might dereference the pointer later. If
5693 we remove this code, also remove check_automatic_or_tls. */
5694 i
= check_automatic_or_tls (t
);
5699 if (flags
& tf_error
)
5700 error ("address-of an object %qE with thread local or "
5701 "automatic storage is not a constant expression", t
);
5705 return RECUR (t
, any
);
5713 /* -- a class member access unless its postfix-expression is
5714 of literal type or of pointer to literal type. */
5715 /* This test would be redundant, as it follows from the
5716 postfix-expression being a potential constant expression. */
5717 if (type_unknown_p (t
))
5719 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5721 case EXPR_PACK_EXPANSION
:
5722 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5726 tree x
= TREE_OPERAND (t
, 0);
5728 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5730 if (!var_in_maybe_constexpr_fn (x
))
5732 if (flags
& tf_error
)
5733 error_at (loc
, "use of %<this%> in a constant expression");
5738 return RECUR (x
, rval
);
5741 case STATEMENT_LIST
:
5743 tree_stmt_iterator i
;
5744 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5746 if (!RECUR (tsi_stmt (i
), any
))
5754 if (cxx_dialect
< cxx14
)
5756 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5758 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5763 if (cxx_dialect
< cxx14
)
5765 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5767 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5772 if (!RECUR (DO_COND (t
), rval
))
5774 if (!RECUR (DO_BODY (t
), any
))
5776 if (breaks (jump_target
) || continues (jump_target
))
5777 *jump_target
= NULL_TREE
;
5781 if (!RECUR (FOR_INIT_STMT (t
), any
))
5783 if (!RECUR (FOR_COND (t
), rval
))
5785 if (!RECUR (FOR_EXPR (t
), any
))
5787 if (!RECUR (FOR_BODY (t
), any
))
5789 if (breaks (jump_target
) || continues (jump_target
))
5790 *jump_target
= NULL_TREE
;
5793 case RANGE_FOR_STMT
:
5794 if (!RECUR (RANGE_FOR_INIT_STMT (t
), any
))
5796 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5798 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5800 if (breaks (jump_target
) || continues (jump_target
))
5801 *jump_target
= NULL_TREE
;
5805 if (!RECUR (WHILE_COND (t
), rval
))
5807 if (!RECUR (WHILE_BODY (t
), any
))
5809 if (breaks (jump_target
) || continues (jump_target
))
5810 *jump_target
= NULL_TREE
;
5814 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5816 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5817 unreachable labels would be checked. */
5821 return RECUR (STMT_EXPR_STMT (t
), rval
);
5824 if (cxx_dialect
>= cxx17
)
5825 /* In C++17 lambdas can be constexpr, don't give up yet. */
5827 else if (flags
& tf_error
)
5828 error_at (loc
, "lambda-expression is not a constant expression "
5832 case DYNAMIC_CAST_EXPR
:
5833 case PSEUDO_DTOR_EXPR
:
5837 case VEC_DELETE_EXPR
:
5843 case OMP_DISTRIBUTE
:
5846 case OMP_TARGET_DATA
:
5855 case OMP_TARGET_UPDATE
:
5856 case OMP_TARGET_ENTER_DATA
:
5857 case OMP_TARGET_EXIT_DATA
:
5859 case OMP_ATOMIC_READ
:
5860 case OMP_ATOMIC_CAPTURE_OLD
:
5861 case OMP_ATOMIC_CAPTURE_NEW
:
5865 case OACC_HOST_DATA
:
5869 case OACC_ENTER_DATA
:
5870 case OACC_EXIT_DATA
:
5872 /* GCC internal stuff. */
5875 case TRANSACTION_EXPR
:
5877 case AT_ENCODE_EXPR
:
5879 if (flags
& tf_error
)
5880 error_at (loc
, "expression %qE is not a constant expression", t
);
5884 /* -- a typeid expression whose operand is of polymorphic
5887 tree e
= TREE_OPERAND (t
, 0);
5888 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5889 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5891 if (flags
& tf_error
)
5892 error_at (loc
, "typeid-expression is not a constant expression "
5893 "because %qE is of polymorphic type", e
);
5899 case POINTER_DIFF_EXPR
:
5913 case PREINCREMENT_EXPR
:
5914 case POSTINCREMENT_EXPR
:
5915 case PREDECREMENT_EXPR
:
5916 case POSTDECREMENT_EXPR
:
5917 if (cxx_dialect
< cxx14
)
5923 if (TYPE_P (TREE_OPERAND (t
, 0)))
5929 case FIX_TRUNC_EXPR
:
5934 case TRUTH_NOT_EXPR
:
5935 case FIXED_CONVERT_EXPR
:
5936 case UNARY_PLUS_EXPR
:
5937 case UNARY_LEFT_FOLD_EXPR
:
5938 case UNARY_RIGHT_FOLD_EXPR
:
5940 return RECUR (TREE_OPERAND (t
, 0), rval
);
5943 case CONST_CAST_EXPR
:
5944 case STATIC_CAST_EXPR
:
5945 case REINTERPRET_CAST_EXPR
:
5946 case IMPLICIT_CONV_EXPR
:
5947 if (cxx_dialect
< cxx11
5948 && !dependent_type_p (TREE_TYPE (t
))
5949 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5950 /* In C++98, a conversion to non-integral type can't be part of a
5951 constant expression. */
5953 if (flags
& tf_error
)
5955 "cast to non-integral type %qT in a constant expression",
5959 /* This might be a conversion from a class to a (potentially) literal
5960 type. Let's consider it potentially constant since the conversion
5961 might be a constexpr user-defined conversion. */
5962 else if (cxx_dialect
>= cxx11
5963 && (dependent_type_p (TREE_TYPE (t
))
5964 || !COMPLETE_TYPE_P (TREE_TYPE (t
))
5965 || literal_type_p (TREE_TYPE (t
)))
5966 && TREE_OPERAND (t
, 0))
5968 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
5969 /* If this is a dependent type, it could end up being a class
5970 with conversions. */
5971 if (type
== NULL_TREE
|| WILDCARD_TYPE_P (type
))
5973 /* Or a non-dependent class which has conversions. */
5974 else if (CLASS_TYPE_P (type
)
5975 && (TYPE_HAS_CONVERSION (type
) || dependent_scope_p (type
)))
5979 return (RECUR (TREE_OPERAND (t
, 0),
5980 !TYPE_REF_P (TREE_TYPE (t
))));
5983 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5985 case CLEANUP_POINT_EXPR
:
5986 case MUST_NOT_THROW_EXPR
:
5987 case TRY_CATCH_EXPR
:
5992 case NON_DEPENDENT_EXPR
:
5993 /* For convenience. */
5996 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5999 tmp
= DECL_EXPR_DECL (t
);
6000 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
6002 if (TREE_STATIC (tmp
))
6004 if (flags
& tf_error
)
6005 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6006 "%<static%> in %<constexpr%> context", tmp
);
6009 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
6011 if (flags
& tf_error
)
6012 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6013 "%<thread_local%> in %<constexpr%> context", tmp
);
6016 else if (!check_for_uninitialized_const_var
6017 (tmp
, /*constexpr_context_p=*/true, flags
))
6020 return RECUR (tmp
, want_rval
);
6022 case TRY_FINALLY_EXPR
:
6023 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
6024 && RECUR (TREE_OPERAND (t
, 1), any
));
6027 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6030 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
6031 && !literal_type_p (TREE_TYPE (t
)))
6033 if (flags
& tf_error
)
6035 auto_diagnostic_group d
;
6036 error_at (loc
, "temporary of non-literal type %qT in a "
6037 "constant expression", TREE_TYPE (t
));
6038 explain_non_literal_class (TREE_TYPE (t
));
6044 return RECUR (TREE_OPERAND (t
, 1), rval
);
6048 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
6049 constructor_elt
*ce
;
6050 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
6051 if (!RECUR (ce
->value
, want_rval
))
6058 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
6059 || DECL_P (TREE_PURPOSE (t
)));
6060 if (!RECUR (TREE_VALUE (t
), want_rval
))
6062 if (TREE_CHAIN (t
) == NULL_TREE
)
6064 return RECUR (TREE_CHAIN (t
), want_rval
);
6067 case TRUNC_DIV_EXPR
:
6069 case FLOOR_DIV_EXPR
:
6070 case ROUND_DIV_EXPR
:
6071 case TRUNC_MOD_EXPR
:
6073 case ROUND_MOD_EXPR
:
6075 tree denom
= TREE_OPERAND (t
, 1);
6076 if (!RECUR (denom
, rval
))
6078 /* We can't call cxx_eval_outermost_constant_expr on an expression
6079 that hasn't been through instantiate_non_dependent_expr yet. */
6080 if (!processing_template_decl
)
6081 denom
= cxx_eval_outermost_constant_expr (denom
, true);
6082 if (integer_zerop (denom
))
6084 if (flags
& tf_error
)
6085 error ("division by zero is not a constant expression");
6091 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6097 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6098 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6099 introduced by build_call_a. */
6100 tree op0
= TREE_OPERAND (t
, 0);
6101 tree op1
= TREE_OPERAND (t
, 1);
6103 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
6104 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
6105 return RECUR (op0
, want_rval
);
6110 /* If the first operand is the non-short-circuit constant, look at
6111 the second operand; otherwise we only care about the first one for
6113 case TRUTH_AND_EXPR
:
6114 case TRUTH_ANDIF_EXPR
:
6115 tmp
= boolean_true_node
;
6118 case TRUTH_ORIF_EXPR
:
6119 tmp
= boolean_false_node
;
6122 tree op
= TREE_OPERAND (t
, 0);
6123 if (!RECUR (op
, rval
))
6125 if (!processing_template_decl
)
6126 op
= cxx_eval_outermost_constant_expr (op
, true);
6127 if (tree_int_cst_equal (op
, tmp
))
6128 return RECUR (TREE_OPERAND (t
, 1), rval
);
6135 case POINTER_PLUS_EXPR
:
6137 case EXACT_DIV_EXPR
:
6147 case TRUTH_XOR_EXPR
:
6148 case UNORDERED_EXPR
:
6161 case ARRAY_RANGE_REF
:
6165 case BINARY_LEFT_FOLD_EXPR
:
6166 case BINARY_RIGHT_FOLD_EXPR
:
6168 for (i
= 0; i
< 2; ++i
)
6169 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
6174 for (i
= 0; i
< 3; ++i
)
6175 if (!RECUR (TREE_OPERAND (t
, i
), true))
6180 if (COND_EXPR_IS_VEC_DELETE (t
))
6182 if (flags
& tf_error
)
6183 error_at (loc
, "%<delete[]%> is not a constant expression");
6189 /* If the condition is a known constant, we know which of the legs we
6190 care about; otherwise we only require that the condition and
6191 either of the legs be potentially constant. */
6192 tmp
= TREE_OPERAND (t
, 0);
6193 if (!RECUR (tmp
, rval
))
6195 if (!processing_template_decl
)
6196 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6197 if (integer_zerop (tmp
))
6198 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
6199 else if (TREE_CODE (tmp
) == INTEGER_CST
)
6200 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6201 for (i
= 1; i
< 3; ++i
)
6202 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
6203 want_rval
, strict
, now
,
6204 tf_none
, jump_target
))
6206 if (flags
& tf_error
)
6207 error_at (loc
, "expression %qE is not a constant expression", t
);
6211 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
6213 if (flags
& tf_error
)
6215 error_at (loc
, "non-constant array initialization");
6216 diagnose_non_constexpr_vec_init (t
);
6222 /* We can see these in statement-expressions. */
6226 case EMPTY_CLASS_EXPR
:
6232 tree
*target
= &TREE_OPERAND (t
, 0);
6233 /* Gotos representing break and continue are OK. */
6234 if (breaks (target
) || continues (target
))
6236 *jump_target
= *target
;
6239 if (flags
& tf_error
)
6240 error_at (loc
, "%<goto%> is not a constant expression");
6245 return RECUR (TREE_OPERAND (t
, 0), rval
);
6248 if (objc_is_property_ref (t
))
6251 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6259 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
6260 tsubst_flags_t flags
)
6262 tree target
= NULL_TREE
;
6263 return potential_constant_expression_1 (t
, want_rval
, strict
, now
,
6267 /* The main entry point to the above. */
6270 potential_constant_expression (tree t
)
6272 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6275 /* As above, but require a constant rvalue. */
6278 potential_rvalue_constant_expression (tree t
)
6280 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6283 /* Like above, but complain about non-constant expressions. */
6286 require_potential_constant_expression (tree t
)
6288 return potential_constant_expression_1 (t
, false, true, false,
6289 tf_warning_or_error
);
6292 /* Cross product of the above. */
6295 require_potential_rvalue_constant_expression (tree t
)
6297 return potential_constant_expression_1 (t
, true, true, false,
6298 tf_warning_or_error
);
6301 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6304 require_rvalue_constant_expression (tree t
)
6306 return potential_constant_expression_1 (t
, true, true, true,
6307 tf_warning_or_error
);
6310 /* Like potential_constant_expression, but don't consider possible constexpr
6311 substitution of the current function. That is, PARM_DECL qualifies under
6312 potential_constant_expression, but not here.
6314 This is basically what you can check when any actual constant values might
6315 be value-dependent. */
6318 is_constant_expression (tree t
)
6320 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6323 /* Like above, but complain about non-constant expressions. */
6326 require_constant_expression (tree t
)
6328 return potential_constant_expression_1 (t
, false, true, true,
6329 tf_warning_or_error
);
6332 /* Like is_constant_expression, but allow const variables that are not allowed
6333 under constexpr rules. */
6336 is_static_init_expression (tree t
)
6338 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6341 /* Returns true if T is a potential constant expression that is not
6342 instantiation-dependent, and therefore a candidate for constant folding even
6346 is_nondependent_constant_expression (tree t
)
6348 return (!type_unknown_p (t
)
6349 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6350 && is_constant_expression (t
)
6351 && !instantiation_dependent_expression_p (t
));
6354 /* Returns true if T is a potential static initializer expression that is not
6355 instantiation-dependent. */
6358 is_nondependent_static_init_expression (tree t
)
6360 return (!type_unknown_p (t
)
6361 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6362 && is_static_init_expression (t
)
6363 && !instantiation_dependent_expression_p (t
));
6366 /* Finalize constexpr processing after parsing. */
6369 fini_constexpr (void)
6371 /* The contexpr call and fundef copies tables are no longer needed. */
6372 constexpr_call_table
= NULL
;
6373 fundef_copies_table
= NULL
;
6376 #include "gt-cp-constexpr.h"