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-2023 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"
35 #include "fold-const-call.h"
36 #include "stor-layout.h"
39 #include "stringpool.h"
41 #include "fold-const.h"
45 static bool verify_constant (tree
, bool, bool *, bool *);
46 #define VERIFY_CONSTANT(X) \
48 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
52 static HOST_WIDE_INT
find_array_ctor_elt (tree ary
, tree dindex
,
54 static int array_index_cmp (tree key
, tree index
);
56 /* Returns true iff FUN is an instantiation of a constexpr function
57 template or a defaulted constexpr function. */
60 is_instantiation_of_constexpr (tree fun
)
62 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
63 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
64 || (DECL_DEFAULTED_FN (fun
)
65 && DECL_DECLARED_CONSTEXPR_P (fun
)));
68 /* Return true if T is a literal type. */
71 literal_type_p (tree t
)
76 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
80 t
= complete_type (t
);
81 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
82 return CLASSTYPE_LITERAL_P (t
);
84 if (TREE_CODE (t
) == ARRAY_TYPE
)
85 return literal_type_p (strip_array_types (t
));
89 /* If DECL is a variable declared `constexpr', require its type
90 be literal. Return error_mark_node if we give an error, the
94 ensure_literal_type_for_constexpr_object (tree decl
)
96 tree type
= TREE_TYPE (decl
);
98 && (DECL_DECLARED_CONSTEXPR_P (decl
)
99 || var_in_constexpr_fn (decl
))
100 && !processing_template_decl
)
102 tree stype
= strip_array_types (type
);
103 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
104 /* Don't complain here, we'll complain about incompleteness
105 when we try to initialize the variable. */;
106 else if (!literal_type_p (type
))
108 if (DECL_DECLARED_CONSTEXPR_P (decl
))
110 auto_diagnostic_group d
;
111 error_at (DECL_SOURCE_LOCATION (decl
),
112 "the type %qT of %<constexpr%> variable %qD "
113 "is not literal", type
, decl
);
114 explain_non_literal_class (type
);
115 decl
= error_mark_node
;
117 else if (cxx_dialect
< cxx23
)
119 if (!is_instantiation_of_constexpr (current_function_decl
))
121 auto_diagnostic_group d
;
122 error_at (DECL_SOURCE_LOCATION (decl
),
123 "variable %qD of non-literal type %qT in "
124 "%<constexpr%> function only available with "
125 "%<-std=c++2b%> or %<-std=gnu++2b%>", decl
, type
);
126 explain_non_literal_class (type
);
127 decl
= error_mark_node
;
129 cp_function_chain
->invalid_constexpr
= true;
132 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
133 && variably_modified_type_p (type
, NULL_TREE
))
135 error_at (DECL_SOURCE_LOCATION (decl
),
136 "%<constexpr%> variable %qD has variably-modified "
137 "type %qT", decl
, type
);
138 decl
= error_mark_node
;
144 /* Issue a diagnostic with text GMSGID for constructs that are invalid in
145 constexpr functions. CONSTEXPR_FUNDEF_P is true if we're checking
146 a constexpr function body; if so, don't report hard errors and issue
147 a pedwarn pre-C++23, or a warning in C++23, if requested by
148 -Winvalid-constexpr. Otherwise, we're not in the context where we are
149 checking if a function can be marked 'constexpr', so give a hard error. */
151 ATTRIBUTE_GCC_DIAG(3,4)
153 constexpr_error (location_t location
, bool constexpr_fundef_p
,
154 const char *gmsgid
, ...)
156 diagnostic_info diagnostic
;
158 rich_location
richloc (line_table
, location
);
159 va_start (ap
, gmsgid
);
161 if (!constexpr_fundef_p
)
163 /* Report an error that cannot be suppressed. */
164 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
, DK_ERROR
);
165 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
167 else if (warn_invalid_constexpr
)
169 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
170 cxx_dialect
< cxx23
? DK_PEDWARN
: DK_WARNING
);
171 diagnostic
.option_index
= OPT_Winvalid_constexpr
;
172 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
180 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
182 static hashval_t
hash (const constexpr_fundef
*);
183 static bool equal (const constexpr_fundef
*, const constexpr_fundef
*);
186 /* This table holds all constexpr function definitions seen in
187 the current translation unit. */
189 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
191 /* Utility function used for managing the constexpr function table.
192 Return true if the entries pointed to by P and Q are for the
193 same constexpr function. */
196 constexpr_fundef_hasher::equal (const constexpr_fundef
*lhs
,
197 const constexpr_fundef
*rhs
)
199 return lhs
->decl
== rhs
->decl
;
202 /* Utility function used for managing the constexpr function table.
203 Return a hash value for the entry pointed to by Q. */
206 constexpr_fundef_hasher::hash (const constexpr_fundef
*fundef
)
208 return DECL_UID (fundef
->decl
);
211 /* Return a previously saved definition of function FUN. */
214 retrieve_constexpr_fundef (tree fun
)
216 if (constexpr_fundef_table
== NULL
)
219 constexpr_fundef fundef
= { fun
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
220 return constexpr_fundef_table
->find (&fundef
);
223 /* Check whether the parameter and return types of FUN are valid for a
224 constexpr function, and complain if COMPLAIN. */
227 is_valid_constexpr_fn (tree fun
, bool complain
)
231 if (DECL_INHERITED_CTOR (fun
)
232 && TREE_CODE (fun
) == TEMPLATE_DECL
)
236 error ("inherited constructor %qD is not %<constexpr%>",
237 DECL_INHERITED_CTOR (fun
));
241 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
242 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
243 if (!literal_type_p (TREE_TYPE (parm
)))
248 auto_diagnostic_group d
;
249 if (constexpr_error (input_location
, /*constexpr_fundef_p*/true,
250 "invalid type for parameter %d of "
251 "%<constexpr%> function %q+#D",
252 DECL_PARM_INDEX (parm
), fun
))
253 explain_non_literal_class (TREE_TYPE (parm
));
258 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
262 inform (DECL_SOURCE_LOCATION (fun
),
263 "lambdas are implicitly %<constexpr%> only in C++17 and later");
265 else if (DECL_DESTRUCTOR_P (fun
))
267 if (cxx_dialect
< cxx20
)
271 error_at (DECL_SOURCE_LOCATION (fun
),
272 "%<constexpr%> destructors only available"
273 " with %<-std=c++20%> or %<-std=gnu++20%>");
276 else if (!DECL_CONSTRUCTOR_P (fun
))
278 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
279 if (!literal_type_p (rettype
))
284 auto_diagnostic_group d
;
285 if (constexpr_error (input_location
, /*constexpr_fundef_p*/true,
286 "invalid return type %qT of %<constexpr%> "
287 "function %q+D", rettype
, fun
))
288 explain_non_literal_class (rettype
);
292 /* C++14 DR 1684 removed this restriction. */
293 if (cxx_dialect
< cxx14
294 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
295 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
300 auto_diagnostic_group d
;
301 if (pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
302 "enclosing class of %<constexpr%> non-static"
303 " member function %q+#D is not a literal type",
305 explain_non_literal_class (DECL_CONTEXT (fun
));
309 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
313 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
319 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
320 for a member of an anonymous aggregate, INIT is the initializer for that
321 member, and VEC_OUTER is the vector of constructor elements for the class
322 whose constructor we are processing. Add the initializer to the vector
323 and return true to indicate success. */
326 build_anon_member_initialization (tree member
, tree init
,
327 vec
<constructor_elt
, va_gc
> **vec_outer
)
329 /* MEMBER presents the relevant fields from the inside out, but we need
330 to build up the initializer from the outside in so that we can reuse
331 previously built CONSTRUCTORs if this is, say, the second field in an
332 anonymous struct. So we use a vec as a stack. */
333 auto_vec
<tree
, 2> fields
;
336 fields
.safe_push (TREE_OPERAND (member
, 1));
337 member
= TREE_OPERAND (member
, 0);
339 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
340 && TREE_CODE (member
) == COMPONENT_REF
);
342 /* VEC has the constructor elements vector for the context of FIELD.
343 If FIELD is an anonymous aggregate, we will push inside it. */
344 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
346 while (field
= fields
.pop(),
347 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
350 /* If there is already an outer constructor entry for the anonymous
351 aggregate FIELD, use it; otherwise, insert one. */
352 if (vec_safe_is_empty (*vec
)
353 || (*vec
)->last().index
!= field
)
355 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
356 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
359 ctor
= (*vec
)->last().value
;
360 vec
= &CONSTRUCTOR_ELTS (ctor
);
363 /* Now we're at the innermost field, the one that isn't an anonymous
364 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
365 gcc_assert (fields
.is_empty());
366 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
371 /* Subroutine of build_constexpr_constructor_member_initializers.
372 The expression tree T represents a data member initialization
373 in a (constexpr) constructor definition. Build a pairing of
374 the data member with its initializer, and prepend that pair
375 to the existing initialization pair INITS. */
378 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
381 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
382 t
= TREE_OPERAND (t
, 0);
383 if (TREE_CODE (t
) == EXPR_STMT
)
384 t
= TREE_OPERAND (t
, 0);
385 if (t
== error_mark_node
)
387 if (TREE_CODE (t
) == STATEMENT_LIST
)
389 for (tree stmt
: tsi_range (t
))
390 if (! build_data_member_initialization (stmt
, vec
))
394 if (TREE_CODE (t
) == CLEANUP_STMT
)
396 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
397 but we can in a constexpr constructor for a non-literal class. Just
398 ignore it; either all the initialization will be constant, in which
399 case the cleanup can't run, or it can't be constexpr.
400 Still recurse into CLEANUP_BODY. */
401 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
403 if (TREE_CODE (t
) == CONVERT_EXPR
)
404 t
= TREE_OPERAND (t
, 0);
405 if (TREE_CODE (t
) == INIT_EXPR
406 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
407 use what this function builds for cx_check_missing_mem_inits, and
408 assignment in the ctor body doesn't count. */
409 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
411 member
= TREE_OPERAND (t
, 0);
412 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
414 else if (TREE_CODE (t
) == CALL_EXPR
)
416 tree fn
= get_callee_fndecl (t
);
417 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
418 /* We're only interested in calls to subobject constructors. */
420 member
= CALL_EXPR_ARG (t
, 0);
421 /* We don't use build_cplus_new here because it complains about
422 abstract bases. Leaving the call unwrapped means that it has the
423 wrong type, but cxx_eval_constant_expression doesn't care. */
424 init
= break_out_target_exprs (t
);
426 else if (TREE_CODE (t
) == BIND_EXPR
)
427 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
429 /* Don't add anything else to the CONSTRUCTOR. */
431 if (INDIRECT_REF_P (member
))
432 member
= TREE_OPERAND (member
, 0);
433 if (TREE_CODE (member
) == NOP_EXPR
)
437 if (TREE_CODE (op
) == ADDR_EXPR
)
439 gcc_assert (same_type_ignoring_top_level_qualifiers_p
440 (TREE_TYPE (TREE_TYPE (op
)),
441 TREE_TYPE (TREE_TYPE (member
))));
442 /* Initializing a cv-qualified member; we need to look through
446 else if (op
== current_class_ptr
447 && (same_type_ignoring_top_level_qualifiers_p
448 (TREE_TYPE (TREE_TYPE (member
)),
449 current_class_type
)))
450 /* Delegating constructor. */
454 /* This is an initializer for an empty base; keep it for now so
455 we can check it in cxx_eval_bare_aggregate. */
456 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
459 if (TREE_CODE (member
) == ADDR_EXPR
)
460 member
= TREE_OPERAND (member
, 0);
461 if (TREE_CODE (member
) == COMPONENT_REF
)
463 tree aggr
= TREE_OPERAND (member
, 0);
464 if (TREE_CODE (aggr
) == VAR_DECL
)
465 /* Initializing a local variable, don't add anything. */
467 if (TREE_CODE (aggr
) != COMPONENT_REF
)
468 /* Normal member initialization. */
469 member
= TREE_OPERAND (member
, 1);
470 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
471 /* Initializing a member of an anonymous union. */
472 return build_anon_member_initialization (member
, init
, vec
);
474 /* We're initializing a vtable pointer in a base. Leave it as
475 COMPONENT_REF so we remember the path to get to the vfield. */
476 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
479 /* Value-initialization can produce multiple initializers for the
480 same field; use the last one. */
481 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
482 (*vec
)->last().value
= init
;
484 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
488 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
489 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
490 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
493 check_constexpr_bind_expr_vars (tree t
)
495 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
497 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
498 if (TREE_CODE (var
) == TYPE_DECL
499 && DECL_IMPLICIT_TYPEDEF_P (var
)
500 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
505 /* Subroutine of check_constexpr_ctor_body. */
508 check_constexpr_ctor_body_1 (tree last
, tree list
)
510 switch (TREE_CODE (list
))
513 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
514 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
518 case CLEANUP_POINT_EXPR
:
519 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
523 if (!check_constexpr_bind_expr_vars (list
)
524 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
531 case DEBUG_BEGIN_STMT
:
539 /* Make sure that there are no statements after LAST in the constructor
540 body represented by LIST. */
543 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
545 /* C++14 doesn't require a constexpr ctor to have an empty body. */
546 if (cxx_dialect
>= cxx14
)
550 if (TREE_CODE (list
) == STATEMENT_LIST
)
552 tree_stmt_iterator i
= tsi_last (list
);
553 for (; !tsi_end_p (i
); tsi_prev (&i
))
555 tree t
= tsi_stmt (i
);
558 if (!check_constexpr_ctor_body_1 (last
, t
))
565 else if (list
!= last
566 && !check_constexpr_ctor_body_1 (last
, list
))
571 error ("%<constexpr%> constructor does not have empty body");
572 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
577 /* V is a vector of constructor elements built up for the base and member
578 initializers of a constructor for TYPE. They need to be in increasing
579 offset order, which they might not be yet if TYPE has a primary base
580 which is not first in the base-clause or a vptr and at least one base
581 all of which are non-primary. */
583 static vec
<constructor_elt
, va_gc
> *
584 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
586 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
592 field_type
= BINFO_TYPE (pri
);
593 else if (TYPE_CONTAINS_VPTR_P (type
))
594 field_type
= vtbl_ptr_type_node
;
598 /* Find the element for the primary base or vptr and move it to the
599 beginning of the vec. */
600 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
601 if (TREE_TYPE (ce
->index
) == field_type
)
604 if (i
> 0 && i
< vec_safe_length (v
))
606 vec
<constructor_elt
, va_gc
> &vref
= *v
;
607 constructor_elt elt
= vref
[i
];
616 /* Build compile-time evalable representations of member-initializer list
617 for a constexpr constructor. */
620 build_constexpr_constructor_member_initializers (tree type
, tree body
)
622 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
625 switch (TREE_CODE (body
))
627 case MUST_NOT_THROW_EXPR
:
629 body
= TREE_OPERAND (body
, 0);
633 for (tree stmt
: tsi_range (body
))
636 if (TREE_CODE (body
) == BIND_EXPR
)
642 body
= BIND_EXPR_BODY (body
);
649 if (TREE_CODE (body
) == TRY_BLOCK
)
651 body
= TREE_OPERAND (body
, 0);
652 if (TREE_CODE (body
) == BIND_EXPR
)
653 body
= BIND_EXPR_BODY (body
);
655 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
657 body
= TREE_OPERAND (body
, 0);
658 if (TREE_CODE (body
) == EXPR_STMT
)
659 body
= TREE_OPERAND (body
, 0);
660 if (TREE_CODE (body
) == INIT_EXPR
661 && (same_type_ignoring_top_level_qualifiers_p
662 (TREE_TYPE (TREE_OPERAND (body
, 0)),
663 current_class_type
)))
666 return TREE_OPERAND (body
, 1);
668 ok
= build_data_member_initialization (body
, &vec
);
670 else if (TREE_CODE (body
) == STATEMENT_LIST
)
672 for (tree stmt
: tsi_range (body
))
674 ok
= build_data_member_initialization (stmt
, &vec
);
679 else if (EXPR_P (body
))
680 ok
= build_data_member_initialization (body
, &vec
);
682 gcc_assert (errorcount
> 0);
685 if (vec_safe_length (vec
) > 0)
687 /* In a delegating constructor, return the target. */
688 constructor_elt
*ce
= &(*vec
)[0];
689 if (ce
->index
== current_class_ptr
)
696 vec
= sort_constexpr_mem_initializers (type
, vec
);
697 return build_constructor (type
, vec
);
700 return error_mark_node
;
703 /* We have an expression tree T that represents a call, either CALL_EXPR
704 or AGGR_INIT_EXPR. If the call is lexically to a named function,
705 retrun the _DECL for that function. */
708 get_function_named_in_call (tree t
)
710 tree fun
= cp_get_callee (t
);
711 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
712 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
713 fun
= TREE_OPERAND (fun
, 0);
717 /* Subroutine of check_constexpr_fundef. BODY is the body of a function
718 declared to be constexpr, or a sub-statement thereof. Returns the
719 return value if suitable, error_mark_node for a statement not allowed in
720 a constexpr function, or NULL_TREE if no return value was found. */
723 constexpr_fn_retval (tree body
)
725 switch (TREE_CODE (body
))
729 tree expr
= NULL_TREE
;
730 for (tree stmt
: tsi_range (body
))
732 tree s
= constexpr_fn_retval (stmt
);
733 if (s
== error_mark_node
)
734 return error_mark_node
;
735 else if (s
== NULL_TREE
)
736 /* Keep iterating. */;
738 /* Multiple return statements. */
739 return error_mark_node
;
747 return break_out_target_exprs (TREE_OPERAND (body
, 0));
751 tree decl
= DECL_EXPR_DECL (body
);
752 if (TREE_CODE (decl
) == USING_DECL
753 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
754 || DECL_ARTIFICIAL (decl
))
756 return error_mark_node
;
759 case CLEANUP_POINT_EXPR
:
760 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
763 if (!check_constexpr_bind_expr_vars (body
))
764 return error_mark_node
;
765 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
768 case DEBUG_BEGIN_STMT
:
773 tree fun
= get_function_named_in_call (body
);
775 && fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
))
781 return error_mark_node
;
785 /* Subroutine of check_constexpr_fundef. BODY is the DECL_SAVED_TREE of
786 FUN; do the necessary transformations to turn it into a single expression
787 that we can store in the hash table. */
790 massage_constexpr_body (tree fun
, tree body
)
792 if (DECL_CONSTRUCTOR_P (fun
))
793 body
= build_constexpr_constructor_member_initializers
794 (DECL_CONTEXT (fun
), body
);
795 else if (cxx_dialect
< cxx14
)
797 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
798 body
= EH_SPEC_STMTS (body
);
799 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
800 body
= TREE_OPERAND (body
, 0);
801 body
= constexpr_fn_retval (body
);
806 /* CTYPE is a type constructed from BODY. Return true if some
807 bases/fields are uninitialized, and complain if COMPLAIN. */
810 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
812 /* We allow uninitialized bases/fields in C++20. */
813 if (cxx_dialect
>= cxx20
)
820 if (TREE_CODE (body
) != CONSTRUCTOR
)
822 nelts
= CONSTRUCTOR_NELTS (body
);
824 tree field
= TYPE_FIELDS (ctype
);
826 if (TREE_CODE (ctype
) == UNION_TYPE
)
828 if (nelts
== 0 && next_aggregate_field (field
))
831 error ("%<constexpr%> constructor for union %qT must "
832 "initialize exactly one non-static data member", ctype
);
838 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
839 need an explicit initialization. */
841 for (unsigned i
= 0; i
<= nelts
; ++i
)
843 tree index
= NULL_TREE
;
846 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
847 /* Skip base and vtable inits. */
848 if (TREE_CODE (index
) != FIELD_DECL
849 || DECL_ARTIFICIAL (index
))
853 for (; field
!= index
; field
= DECL_CHAIN (field
))
856 if (TREE_CODE (field
) != FIELD_DECL
)
858 if (DECL_UNNAMED_BIT_FIELD (field
))
860 if (DECL_ARTIFICIAL (field
))
862 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
864 /* Recurse to check the anonymous aggregate member. */
865 bad
|= cx_check_missing_mem_inits
866 (TREE_TYPE (field
), NULL_TREE
, complain
);
867 if (bad
&& !complain
)
871 ftype
= TREE_TYPE (field
);
872 if (!ftype
|| !TYPE_P (ftype
) || !COMPLETE_TYPE_P (ftype
))
873 /* A flexible array can't be intialized here, so don't complain
876 if (is_empty_field (field
))
877 /* An empty field doesn't need an initializer. */
879 ftype
= strip_array_types (ftype
);
880 if (type_has_constexpr_default_constructor (ftype
))
882 /* It's OK to skip a member with a trivial constexpr ctor.
883 A constexpr ctor that isn't trivial should have been
885 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
891 auto_diagnostic_group d
;
892 error ("member %qD must be initialized by mem-initializer "
893 "in %<constexpr%> constructor", field
);
894 inform (DECL_SOURCE_LOCATION (field
), "declared here");
897 if (field
== NULL_TREE
)
900 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
902 /* Check the anonymous aggregate initializer is valid. */
903 bad
|= cx_check_missing_mem_inits
904 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
905 if (bad
&& !complain
)
908 field
= DECL_CHAIN (field
);
914 /* We are processing the definition of the constexpr function FUN.
915 Check that its body fulfills the apropriate requirements and
916 enter it in the constexpr function definition table. */
919 maybe_save_constexpr_fundef (tree fun
)
921 if (processing_template_decl
922 || cp_function_chain
->invalid_constexpr
923 || (DECL_CLONED_FUNCTION_P (fun
) && !DECL_DELETING_DESTRUCTOR_P (fun
)))
926 /* With -fimplicit-constexpr, try to make inlines constexpr. We'll
927 actually set DECL_DECLARED_CONSTEXPR_P below if the checks pass. */
928 bool implicit
= false;
929 if (flag_implicit_constexpr
)
931 if (DECL_DELETING_DESTRUCTOR_P (fun
)
932 && decl_implicit_constexpr_p (DECL_CLONED_FUNCTION (fun
)))
933 /* Don't inherit implicit constexpr from the non-deleting
935 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
937 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
938 && DECL_DECLARED_INLINE_P (fun
)
939 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fun
)))
943 if (!DECL_DECLARED_CONSTEXPR_P (fun
) && !implicit
)
946 bool complain
= !DECL_GENERATED_P (fun
) && !implicit
;
948 if (!is_valid_constexpr_fn (fun
, complain
))
951 tree massaged
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
952 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
954 if (!DECL_CONSTRUCTOR_P (fun
) && complain
)
955 error ("body of %<constexpr%> function %qD not a return-statement",
960 bool potential
= potential_rvalue_constant_expression (massaged
);
961 if (!potential
&& complain
)
962 require_potential_rvalue_constant_expression_fncheck (massaged
);
964 if (DECL_CONSTRUCTOR_P (fun
) && potential
965 && !DECL_DEFAULTED_FN (fun
))
967 if (cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
970 else if (cxx_dialect
> cxx11
)
972 /* What we got from massage_constexpr_body is pretty much just the
973 ctor-initializer, also check the body. */
974 massaged
= DECL_SAVED_TREE (fun
);
975 potential
= potential_rvalue_constant_expression (massaged
);
976 if (!potential
&& complain
)
977 require_potential_rvalue_constant_expression_fncheck (massaged
);
981 if (!potential
&& complain
982 /* If -Wno-invalid-constexpr was specified, we haven't complained
983 about non-constant expressions yet. Register the function and
984 complain in explain_invalid_constexpr_fn if the function is
986 && warn_invalid_constexpr
!= 0)
993 DECL_DECLARED_CONSTEXPR_P (fun
) = true;
994 DECL_LANG_SPECIFIC (fun
)->u
.fn
.implicit_constexpr
= true;
995 if (DECL_CONSTRUCTOR_P (fun
))
996 TYPE_HAS_CONSTEXPR_CTOR (DECL_CONTEXT (fun
)) = true;
999 /* Don't bother keeping the pre-generic body of unsuitable functions
1000 not explicitly declared constexpr. */
1004 constexpr_fundef entry
= {fun
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
1005 bool clear_ctx
= false;
1006 if (DECL_RESULT (fun
) && DECL_CONTEXT (DECL_RESULT (fun
)) == NULL_TREE
)
1009 DECL_CONTEXT (DECL_RESULT (fun
)) = fun
;
1011 tree saved_fn
= current_function_decl
;
1012 current_function_decl
= fun
;
1013 entry
.body
= copy_fn (entry
.decl
, entry
.parms
, entry
.result
);
1014 current_function_decl
= saved_fn
;
1016 DECL_CONTEXT (DECL_RESULT (entry
.decl
)) = NULL_TREE
;
1018 /* For a template instantiation, we want to remember the pre-generic body
1019 for explain_invalid_constexpr_fn, but do tell cxx_eval_call_expression
1020 that it doesn't need to bother trying to expand the function. */
1021 entry
.result
= error_mark_node
;
1023 register_constexpr_fundef (entry
);
1026 /* BODY is a validated and massaged definition of a constexpr
1027 function. Register it in the hash table. */
1030 register_constexpr_fundef (const constexpr_fundef
&value
)
1032 /* Create the constexpr function table if necessary. */
1033 if (constexpr_fundef_table
== NULL
)
1034 constexpr_fundef_table
1035 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
1037 constexpr_fundef
**slot
= constexpr_fundef_table
->find_slot
1038 (const_cast<constexpr_fundef
*> (&value
), INSERT
);
1040 gcc_assert (*slot
== NULL
);
1041 *slot
= ggc_alloc
<constexpr_fundef
> ();
1045 /* FUN is a non-constexpr (or, with -Wno-invalid-constexpr, a constexpr
1046 function called in a context that requires a constant expression).
1047 If it comes from a constexpr template, explain why the instantiation
1048 isn't constexpr. Otherwise, explain why the function cannot be used
1049 in a constexpr context. */
1052 explain_invalid_constexpr_fn (tree fun
)
1054 static hash_set
<tree
> *diagnosed
;
1056 /* In C++23, a function marked 'constexpr' may not actually be a constant
1057 expression. We haven't diagnosed the problem yet: -Winvalid-constexpr
1058 wasn't enabled. The function was called, so diagnose why it cannot be
1059 used in a constant expression. */
1060 if (warn_invalid_constexpr
== 0 && DECL_DECLARED_CONSTEXPR_P (fun
))
1062 /* Only diagnose defaulted functions, lambdas, or instantiations. */
1063 else if (!DECL_DEFAULTED_FN (fun
)
1064 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
1065 && !is_instantiation_of_constexpr (fun
))
1067 inform (DECL_SOURCE_LOCATION (fun
), "%qD declared here", fun
);
1070 if (diagnosed
== NULL
)
1071 diagnosed
= new hash_set
<tree
>;
1072 if (diagnosed
->add (fun
))
1073 /* Already explained. */
1076 iloc_sentinel ils
= input_location
;
1077 if (!lambda_static_thunk_p (fun
))
1079 /* Diagnostics should completely ignore the static thunk, so leave
1080 input_location set to our caller's location. */
1081 input_location
= DECL_SOURCE_LOCATION (fun
);
1082 inform (input_location
,
1083 "%qD is not usable as a %<constexpr%> function because:", fun
);
1085 /* First check the declaration. */
1086 if (is_valid_constexpr_fn (fun
, true))
1088 /* Then if it's OK, the body. */
1089 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
1090 && DECL_DEFAULTED_FN (fun
))
1091 explain_implicit_non_constexpr (fun
);
1094 if (constexpr_fundef
*fd
= retrieve_constexpr_fundef (fun
))
1097 body
= DECL_SAVED_TREE (fun
);
1098 body
= massage_constexpr_body (fun
, body
);
1099 require_potential_rvalue_constant_expression (body
);
1100 if (DECL_CONSTRUCTOR_P (fun
))
1101 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
1106 /* Objects of this type represent calls to constexpr functions
1107 along with the bindings of parameters to their arguments, for
1108 the purpose of compile time evaluation. */
1110 struct GTY((for_user
)) constexpr_call
{
1111 /* Description of the constexpr function definition. */
1112 constexpr_fundef
*fundef
;
1113 /* Parameter bindings environment. A TREE_VEC of arguments. */
1115 /* Result of the call.
1116 NULL means the call is being evaluated.
1117 error_mark_node means that the evaluation was erroneous;
1118 otherwise, the actuall value of the call. */
1120 /* The hash of this call; we remember it here to avoid having to
1121 recalculate it when expanding the hash table. */
1123 /* The value of constexpr_ctx::manifestly_const_eval. */
1124 enum mce_value manifestly_const_eval
;
1127 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
1129 static hashval_t
hash (constexpr_call
*);
1130 static bool equal (constexpr_call
*, constexpr_call
*);
1133 enum constexpr_switch_state
{
1134 /* Used when processing a switch for the first time by cxx_eval_switch_expr
1135 and default: label for that switch has not been seen yet. */
1136 css_default_not_seen
,
1137 /* Used when processing a switch for the first time by cxx_eval_switch_expr
1138 and default: label for that switch has been seen already. */
1140 /* Used when processing a switch for the second time by
1141 cxx_eval_switch_expr, where default: label should match. */
1142 css_default_processing
1145 /* The constexpr expansion context part which needs one instance per
1146 cxx_eval_outermost_constant_expr invocation. VALUES is a map of values of
1147 variables initialized within the expression. */
1149 class constexpr_global_ctx
{
1150 /* Values for any temporaries or local variables within the
1151 constant-expression. */
1152 hash_map
<tree
,tree
> values
;
1154 /* Number of cxx_eval_constant_expression calls (except skipped ones,
1155 on simple constants or location wrappers) encountered during current
1156 cxx_eval_outermost_constant_expr call. */
1157 HOST_WIDE_INT constexpr_ops_count
;
1158 /* Heap VAR_DECLs created during the evaluation of the outermost constant
1160 auto_vec
<tree
, 16> heap_vars
;
1161 /* Cleanups that need to be evaluated at the end of CLEANUP_POINT_EXPR. */
1162 vec
<tree
> *cleanups
;
1163 /* If non-null, only allow modification of existing values of the variables
1164 in this set. Set by modifiable_tracker, below. */
1165 hash_set
<tree
> *modifiable
;
1166 /* Number of heap VAR_DECL deallocations. */
1167 unsigned heap_dealloc_count
;
1169 constexpr_global_ctx ()
1170 : constexpr_ops_count (0), cleanups (NULL
), modifiable (nullptr),
1171 heap_dealloc_count (0) {}
1173 tree
get_value (tree t
)
1175 if (tree
*p
= values
.get (t
))
1179 tree
*get_value_ptr (tree t
)
1181 if (modifiable
&& !modifiable
->contains (t
))
1183 return values
.get (t
);
1185 void put_value (tree t
, tree v
)
1187 bool already_in_map
= values
.put (t
, v
);
1188 if (!already_in_map
&& modifiable
)
1189 modifiable
->add (t
);
1191 void remove_value (tree t
) { values
.remove (t
); }
1194 /* Helper class for constexpr_global_ctx. In some cases we want to avoid
1195 side-effects from evaluation of a particular subexpression of a
1196 constant-expression. In such cases we use modifiable_tracker to prevent
1197 modification of variables created outside of that subexpression.
1199 ??? We could change the hash_set to a hash_map, allow and track external
1200 modifications, and roll them back in the destructor. It's not clear to me
1201 that this would be worthwhile. */
1203 class modifiable_tracker
1206 constexpr_global_ctx
*global
;
1208 modifiable_tracker (constexpr_global_ctx
*g
): global(g
)
1210 global
->modifiable
= &set
;
1212 ~modifiable_tracker ()
1215 global
->remove_value (t
);
1216 global
->modifiable
= nullptr;
1220 /* The constexpr expansion context. CALL is the current function
1221 expansion, CTOR is the current aggregate initializer, OBJECT is the
1222 object being initialized by CTOR, either a VAR_DECL or a _REF. */
1224 struct constexpr_ctx
{
1225 /* The part of the context that needs to be unique to the whole
1226 cxx_eval_outermost_constant_expr invocation. */
1227 constexpr_global_ctx
*global
;
1228 /* The innermost call we're evaluating. */
1229 constexpr_call
*call
;
1230 /* SAVE_EXPRs and TARGET_EXPR_SLOT vars of TARGET_EXPRs that we've seen
1231 within the current LOOP_EXPR. NULL if we aren't inside a loop. */
1232 vec
<tree
> *save_exprs
;
1233 /* The CONSTRUCTOR we're currently building up for an aggregate
1236 /* The object we're building the CONSTRUCTOR for. */
1238 /* If inside SWITCH_EXPR. */
1239 constexpr_switch_state
*css_state
;
1240 /* The aggregate initialization context inside which this one is nested. This
1241 is used by lookup_placeholder to resolve PLACEHOLDER_EXPRs. */
1242 const constexpr_ctx
*parent
;
1244 /* Whether we should error on a non-constant expression or fail quietly.
1245 This flag needs to be here, but some of the others could move to global
1246 if they get larger than a word. */
1248 /* Whether we are strictly conforming to constant expression rules or
1249 trying harder to get a constant value. */
1251 /* Whether __builtin_is_constant_evaluated () should be true. */
1252 mce_value manifestly_const_eval
;
1255 /* This internal flag controls whether we should avoid doing anything during
1256 constexpr evaluation that would cause extra DECL_UID generation, such as
1257 template instantiation and function body copying. */
1259 static bool uid_sensitive_constexpr_evaluation_value
;
1261 /* An internal counter that keeps track of the number of times
1262 uid_sensitive_constexpr_evaluation_p returned true. */
1264 static unsigned uid_sensitive_constexpr_evaluation_true_counter
;
1266 /* The accessor for uid_sensitive_constexpr_evaluation_value which also
1267 increments the corresponding counter. */
1270 uid_sensitive_constexpr_evaluation_p ()
1272 if (uid_sensitive_constexpr_evaluation_value
)
1274 ++uid_sensitive_constexpr_evaluation_true_counter
;
1281 /* The default constructor for uid_sensitive_constexpr_evaluation_sentinel
1282 enables the internal flag for uid_sensitive_constexpr_evaluation_p
1283 during the lifetime of the sentinel object. Upon its destruction, the
1284 previous value of uid_sensitive_constexpr_evaluation_p is restored. */
1286 uid_sensitive_constexpr_evaluation_sentinel
1287 ::uid_sensitive_constexpr_evaluation_sentinel ()
1288 : ovr (uid_sensitive_constexpr_evaluation_value
, true)
1292 /* The default constructor for uid_sensitive_constexpr_evaluation_checker
1293 records the current number of times that uid_sensitive_constexpr_evaluation_p
1294 has been called and returned true. */
1296 uid_sensitive_constexpr_evaluation_checker
1297 ::uid_sensitive_constexpr_evaluation_checker ()
1298 : saved_counter (uid_sensitive_constexpr_evaluation_true_counter
)
1302 /* Returns true iff uid_sensitive_constexpr_evaluation_p is true, and
1303 some constexpr evaluation was restricted due to u_s_c_e_p being called
1304 and returning true during the lifetime of this checker object. */
1307 uid_sensitive_constexpr_evaluation_checker::evaluation_restricted_p () const
1309 return (uid_sensitive_constexpr_evaluation_value
1310 && saved_counter
!= uid_sensitive_constexpr_evaluation_true_counter
);
1314 /* A table of all constexpr calls that have been evaluated by the
1315 compiler in this translation unit. */
1317 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1319 /* Compute a hash value for a constexpr call representation. */
1322 constexpr_call_hasher::hash (constexpr_call
*info
)
1327 /* Return true if the objects pointed to by P and Q represent calls
1328 to the same constexpr function with the same arguments.
1329 Otherwise, return false. */
1332 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1336 if (lhs
->hash
!= rhs
->hash
)
1338 if (lhs
->manifestly_const_eval
!= rhs
->manifestly_const_eval
)
1340 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1342 return cp_tree_equal (lhs
->bindings
, rhs
->bindings
);
1345 /* Initialize the constexpr call table, if needed. */
1348 maybe_initialize_constexpr_call_table (void)
1350 if (constexpr_call_table
== NULL
)
1351 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1354 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1355 a function happens to get called recursively, we unshare the callee
1356 function's body and evaluate this unshared copy instead of evaluating the
1359 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1360 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1361 that's keyed off of the original FUNCTION_DECL and whose value is a
1362 TREE_LIST of this function's unused copies awaiting reuse.
1364 This is not GC-deletable to avoid GC affecting UID generation. */
1366 static GTY(()) decl_tree_map
*fundef_copies_table
;
1368 /* Reuse a copy or create a new unshared copy of the function FUN.
1369 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1370 is parms, TYPE is result. */
1373 get_fundef_copy (constexpr_fundef
*fundef
)
1377 tree
*slot
= &(hash_map_safe_get_or_insert
<hm_ggc
>
1378 (fundef_copies_table
, fundef
->decl
, &existed
, 127));
1382 /* There is no cached function available, or in use. We can use
1383 the function directly. That the slot is now created records
1384 that this function is now in use. */
1385 copy
= build_tree_list (fundef
->body
, fundef
->parms
);
1386 TREE_TYPE (copy
) = fundef
->result
;
1388 else if (*slot
== NULL_TREE
)
1390 if (uid_sensitive_constexpr_evaluation_p ())
1393 /* We've already used the function itself, so make a copy. */
1394 copy
= build_tree_list (NULL
, NULL
);
1395 tree saved_body
= DECL_SAVED_TREE (fundef
->decl
);
1396 tree saved_parms
= DECL_ARGUMENTS (fundef
->decl
);
1397 tree saved_result
= DECL_RESULT (fundef
->decl
);
1398 tree saved_fn
= current_function_decl
;
1399 DECL_SAVED_TREE (fundef
->decl
) = fundef
->body
;
1400 DECL_ARGUMENTS (fundef
->decl
) = fundef
->parms
;
1401 DECL_RESULT (fundef
->decl
) = fundef
->result
;
1402 current_function_decl
= fundef
->decl
;
1403 TREE_PURPOSE (copy
) = copy_fn (fundef
->decl
, TREE_VALUE (copy
),
1405 current_function_decl
= saved_fn
;
1406 DECL_RESULT (fundef
->decl
) = saved_result
;
1407 DECL_ARGUMENTS (fundef
->decl
) = saved_parms
;
1408 DECL_SAVED_TREE (fundef
->decl
) = saved_body
;
1412 /* We have a cached function available. */
1414 *slot
= TREE_CHAIN (copy
);
1420 /* Save the copy COPY of function FUN for later reuse by
1421 get_fundef_copy(). By construction, there will always be an entry
1425 save_fundef_copy (tree fun
, tree copy
)
1427 tree
*slot
= fundef_copies_table
->get (fun
);
1428 TREE_CHAIN (copy
) = *slot
;
1432 /* Whether our evaluation wants a prvalue (e.g. CONSTRUCTOR or _CST),
1433 a glvalue (e.g. VAR_DECL or _REF), or nothing. */
1441 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1442 value_cat
, bool *, bool *, tree
* = NULL
);
1443 static tree
cxx_eval_bare_aggregate (const constexpr_ctx
*, tree
,
1444 value_cat
, bool *, bool *);
1445 static tree
cxx_fold_indirect_ref (const constexpr_ctx
*, location_t
, tree
, tree
,
1447 static tree
find_heap_var_refs (tree
*, int *, void *);
1449 /* Attempt to evaluate T which represents a call to a builtin function.
1450 We assume here that all builtin functions evaluate to scalar types
1451 represented by _CST nodes. */
1454 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1456 bool *non_constant_p
, bool *overflow_p
)
1458 const int nargs
= call_expr_nargs (t
);
1459 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1463 /* Don't fold __builtin_constant_p within a constexpr function. */
1464 bool bi_const_p
= DECL_IS_BUILTIN_CONSTANT_P (fun
);
1466 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1467 in a constexpr function until we have values for the parameters. */
1469 && ctx
->manifestly_const_eval
!= mce_true
1470 && current_function_decl
1471 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1473 *non_constant_p
= true;
1477 /* For __builtin_is_constant_evaluated, defer it if not
1478 ctx->manifestly_const_eval (as sometimes we try to constant evaluate
1479 without manifestly_const_eval even expressions or parts thereof which
1480 will later be manifestly const_eval evaluated), otherwise fold it to
1482 if (fndecl_built_in_p (fun
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
1485 if (ctx
->manifestly_const_eval
== mce_unknown
)
1487 *non_constant_p
= true;
1490 return constant_boolean_node (ctx
->manifestly_const_eval
== mce_true
,
1494 if (fndecl_built_in_p (fun
, CP_BUILT_IN_SOURCE_LOCATION
, BUILT_IN_FRONTEND
))
1496 temp_override
<tree
> ovr (current_function_decl
);
1497 if (ctx
->call
&& ctx
->call
->fundef
)
1498 current_function_decl
= ctx
->call
->fundef
->decl
;
1499 return fold_builtin_source_location (t
);
1504 if (fndecl_built_in_p (fun
, BUILT_IN_NORMAL
))
1505 switch (DECL_FUNCTION_CODE (fun
))
1507 case BUILT_IN_STRLEN
:
1508 case BUILT_IN_STRNLEN
:
1511 case BUILT_IN_MEMCHR
:
1512 case BUILT_IN_STRCHR
:
1513 case BUILT_IN_STRRCHR
:
1517 case BUILT_IN_MEMCMP
:
1518 case BUILT_IN_STRCMP
:
1521 case BUILT_IN_STRSTR
:
1525 case BUILT_IN_ASAN_POINTER_COMPARE
:
1526 case BUILT_IN_ASAN_POINTER_SUBTRACT
:
1527 /* These builtins shall be ignored during constant expression
1530 case BUILT_IN_UNREACHABLE
:
1532 if (!*non_constant_p
&& !ctx
->quiet
)
1534 /* Do not allow__builtin_unreachable in constexpr function.
1535 The __builtin_unreachable call with BUILTINS_LOCATION
1536 comes from cp_maybe_instrument_return. */
1537 if (EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1538 error ("%<constexpr%> call flows off the end of the function");
1540 error ("%q+E is not a constant expression", t
);
1542 *non_constant_p
= true;
1548 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1549 return constant false for a non-constant argument. */
1550 constexpr_ctx new_ctx
= *ctx
;
1551 new_ctx
.quiet
= true;
1552 for (i
= 0; i
< nargs
; ++i
)
1554 tree arg
= CALL_EXPR_ARG (t
, i
);
1557 /* To handle string built-ins we need to pass ADDR_EXPR<STRING_CST> since
1558 expand_builtin doesn't know how to look in the values table. */
1559 bool strop
= i
< strops
;
1563 if (TREE_CODE (arg
) == ADDR_EXPR
)
1564 arg
= TREE_OPERAND (arg
, 0);
1569 /* If builtin_valid_in_constant_expr_p is true,
1570 potential_constant_expression_1 has not recursed into the arguments
1571 of the builtin, verify it here. */
1572 if (!builtin_valid_in_constant_expr_p (fun
)
1573 || potential_constant_expression (arg
))
1575 bool dummy1
= false, dummy2
= false;
1576 arg
= cxx_eval_constant_expression (&new_ctx
, arg
, vc_prvalue
,
1581 /* For __builtin_constant_p, fold all expressions with constant values
1582 even if they aren't C++ constant-expressions. */
1583 arg
= cp_fold_rvalue (arg
);
1586 if (TREE_CODE (arg
) == CONSTRUCTOR
)
1587 arg
= braced_lists_to_strings (TREE_TYPE (arg
), arg
);
1588 if (TREE_CODE (arg
) == STRING_CST
)
1589 arg
= build_address (arg
);
1597 bool save_ffbcp
= force_folding_builtin_constant_p
;
1598 force_folding_builtin_constant_p
|= ctx
->manifestly_const_eval
== mce_true
;
1599 tree save_cur_fn
= current_function_decl
;
1600 /* Return name of ctx->call->fundef->decl for __builtin_FUNCTION (). */
1601 if (fndecl_built_in_p (fun
, BUILT_IN_FUNCTION
)
1603 && ctx
->call
->fundef
)
1604 current_function_decl
= ctx
->call
->fundef
->decl
;
1605 if (fndecl_built_in_p (fun
,
1606 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS
,
1609 location_t loc
= EXPR_LOCATION (t
);
1611 VERIFY_CONSTANT (args
[0]);
1613 = fold_builtin_is_pointer_inverconvertible_with_class (loc
, nargs
,
1616 else if (fndecl_built_in_p (fun
,
1617 CP_BUILT_IN_IS_CORRESPONDING_MEMBER
,
1620 location_t loc
= EXPR_LOCATION (t
);
1623 VERIFY_CONSTANT (args
[0]);
1624 VERIFY_CONSTANT (args
[1]);
1626 new_call
= fold_builtin_is_corresponding_member (loc
, nargs
, args
);
1629 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1630 CALL_EXPR_FN (t
), nargs
, args
);
1631 current_function_decl
= save_cur_fn
;
1632 force_folding_builtin_constant_p
= save_ffbcp
;
1633 if (new_call
== NULL
)
1635 if (!*non_constant_p
&& !ctx
->quiet
)
1637 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1638 CALL_EXPR_FN (t
), nargs
, args
);
1639 error ("%q+E is not a constant expression", new_call
);
1641 *non_constant_p
= true;
1645 if (!potential_constant_expression (new_call
))
1647 if (!*non_constant_p
&& !ctx
->quiet
)
1648 error ("%q+E is not a constant expression", new_call
);
1649 *non_constant_p
= true;
1655 /* memchr returns a pointer into the first argument, but we replaced the
1656 argument above with a STRING_CST; put it back it now. */
1657 tree op
= CALL_EXPR_ARG (t
, strret
-1);
1658 STRIP_NOPS (new_call
);
1659 if (TREE_CODE (new_call
) == POINTER_PLUS_EXPR
)
1660 TREE_OPERAND (new_call
, 0) = op
;
1661 else if (TREE_CODE (new_call
) == ADDR_EXPR
)
1665 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1666 non_constant_p
, overflow_p
);
1669 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1670 the type of the value to match. */
1673 adjust_temp_type (tree type
, tree temp
)
1675 if (same_type_p (TREE_TYPE (temp
), type
))
1677 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1678 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1680 /* build_constructor wouldn't retain various CONSTRUCTOR flags. */
1681 tree t
= copy_node (temp
);
1682 TREE_TYPE (t
) = type
;
1685 if (TREE_CODE (temp
) == EMPTY_CLASS_EXPR
)
1686 return build0 (EMPTY_CLASS_EXPR
, type
);
1687 gcc_assert (scalarish_type_p (type
));
1688 /* Now we know we're dealing with a scalar, and a prvalue of non-class
1689 type is cv-unqualified. */
1690 return cp_fold_convert (cv_unqualified (type
), temp
);
1693 /* If T is a CONSTRUCTOR, return an unshared copy of T and any
1694 sub-CONSTRUCTORs. Otherwise return T.
1696 We use this whenever we initialize an object as a whole, whether it's a
1697 parameter, a local variable, or a subobject, so that subsequent
1698 modifications don't affect other places where it was used. */
1701 unshare_constructor (tree t MEM_STAT_DECL
)
1703 if (!t
|| TREE_CODE (t
) != CONSTRUCTOR
)
1705 auto_vec
<tree
*, 4> ptrs
;
1706 ptrs
.safe_push (&t
);
1707 while (!ptrs
.is_empty ())
1709 tree
*p
= ptrs
.pop ();
1710 tree n
= copy_node (*p PASS_MEM_STAT
);
1711 CONSTRUCTOR_ELTS (n
) = vec_safe_copy (CONSTRUCTOR_ELTS (*p
) PASS_MEM_STAT
);
1713 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (n
);
1714 constructor_elt
*ce
;
1715 for (HOST_WIDE_INT i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
1716 if (ce
->value
&& TREE_CODE (ce
->value
) == CONSTRUCTOR
)
1717 ptrs
.safe_push (&ce
->value
);
1722 /* If T is a CONSTRUCTOR, ggc_free T and any sub-CONSTRUCTORs. */
1725 free_constructor (tree t
)
1727 if (!t
|| TREE_CODE (t
) != CONSTRUCTOR
)
1729 releasing_vec ctors
;
1730 vec_safe_push (ctors
, t
);
1731 while (!ctors
->is_empty ())
1733 tree c
= ctors
->pop ();
1734 if (vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (c
))
1736 constructor_elt
*ce
;
1737 for (HOST_WIDE_INT i
= 0; vec_safe_iterate (elts
, i
, &ce
); ++i
)
1738 if (TREE_CODE (ce
->value
) == CONSTRUCTOR
)
1739 vec_safe_push (ctors
, ce
->value
);
1746 /* Helper function of cxx_bind_parameters_in_call. Return non-NULL
1747 if *TP is address of a static variable (or part of it) currently being
1748 constructed or of a heap artificial variable. */
1751 addr_of_non_const_var (tree
*tp
, int *walk_subtrees
, void *data
)
1753 if (TREE_CODE (*tp
) == ADDR_EXPR
)
1754 if (tree var
= get_base_address (TREE_OPERAND (*tp
, 0)))
1755 if (VAR_P (var
) && TREE_STATIC (var
))
1757 if (DECL_NAME (var
) == heap_uninit_identifier
1758 || DECL_NAME (var
) == heap_identifier
1759 || DECL_NAME (var
) == heap_vec_uninit_identifier
1760 || DECL_NAME (var
) == heap_vec_identifier
)
1763 constexpr_global_ctx
*global
= (constexpr_global_ctx
*) data
;
1764 if (global
->get_value (var
))
1768 *walk_subtrees
= false;
1772 /* Subroutine of cxx_eval_call_expression.
1773 We are processing a call expression (either CALL_EXPR or
1774 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1775 all arguments and bind their values to correspondings
1776 parameters, making up the NEW_CALL context. */
1779 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1780 bool *non_constant_p
, bool *overflow_p
,
1781 bool *non_constant_args
)
1783 const int nargs
= call_expr_nargs (t
);
1784 tree parms
= DECL_ARGUMENTS (fun
);
1786 /* We don't record ellipsis args below. */
1787 int nparms
= list_length (parms
);
1788 int nbinds
= nargs
< nparms
? nargs
: nparms
;
1789 tree binds
= make_tree_vec (nbinds
);
1790 for (i
= 0; i
< nargs
; ++i
)
1793 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1794 if (parms
&& DECL_BY_REFERENCE (parms
))
1795 type
= TREE_TYPE (type
);
1796 x
= get_nth_callarg (t
, i
);
1797 /* For member function, the first argument is a pointer to the implied
1798 object. For a constructor, it might still be a dummy object, in
1799 which case we get the real argument from ctx. */
1800 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1801 && is_dummy_object (x
))
1804 x
= build_address (x
);
1806 if (TREE_ADDRESSABLE (type
))
1807 /* Undo convert_for_arg_passing work here. */
1808 x
= convert_from_reference (x
);
1809 /* Normally we would strip a TARGET_EXPR in an initialization context
1810 such as this, but here we do the elision differently: we keep the
1811 TARGET_EXPR, and use its CONSTRUCTOR as the value of the parm. */
1812 arg
= cxx_eval_constant_expression (ctx
, x
, vc_prvalue
,
1813 non_constant_p
, overflow_p
);
1814 /* Don't VERIFY_CONSTANT here. */
1815 if (*non_constant_p
&& ctx
->quiet
)
1817 /* Just discard ellipsis args after checking their constantitude. */
1821 if (!*non_constant_p
)
1823 /* Make sure the binding has the same type as the parm. But
1824 only for constant args. */
1825 if (!TYPE_REF_P (type
))
1826 arg
= adjust_temp_type (type
, arg
);
1827 if (!TREE_CONSTANT (arg
))
1828 *non_constant_args
= true;
1829 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
1830 /* The destructor needs to see any modifications the callee makes
1832 *non_constant_args
= true;
1833 /* If arg is or contains address of a heap artificial variable or
1834 of a static variable being constructed, avoid caching the
1835 function call, as those variables might be modified by the
1836 function, or might be modified by the callers in between
1837 the cached function and just read by the function. */
1838 else if (!*non_constant_args
1839 && cp_walk_tree (&arg
, addr_of_non_const_var
, ctx
->global
,
1841 *non_constant_args
= true;
1843 /* For virtual calls, adjust the this argument, so that it is
1844 the object on which the method is called, rather than
1845 one of its bases. */
1846 if (i
== 0 && DECL_VIRTUAL_P (fun
))
1850 if (TREE_CODE (addr
) == ADDR_EXPR
)
1852 tree obj
= TREE_OPERAND (addr
, 0);
1853 while (TREE_CODE (obj
) == COMPONENT_REF
1854 && DECL_FIELD_IS_BASE (TREE_OPERAND (obj
, 1))
1855 && !same_type_ignoring_top_level_qualifiers_p
1856 (TREE_TYPE (obj
), DECL_CONTEXT (fun
)))
1857 obj
= TREE_OPERAND (obj
, 0);
1858 if (obj
!= TREE_OPERAND (addr
, 0))
1859 arg
= build_fold_addr_expr_with_type (obj
,
1863 TREE_VEC_ELT (binds
, i
) = arg
;
1865 parms
= TREE_CHAIN (parms
);
1871 /* Variables and functions to manage constexpr call expansion context.
1872 These do not need to be marked for PCH or GC. */
1874 /* FIXME remember and print actual constant arguments. */
1875 static vec
<tree
> call_stack
;
1876 static int call_stack_tick
;
1877 static int last_cx_error_tick
;
1880 push_cx_call_context (tree call
)
1883 if (!EXPR_HAS_LOCATION (call
))
1884 SET_EXPR_LOCATION (call
, input_location
);
1885 call_stack
.safe_push (call
);
1886 int len
= call_stack
.length ();
1887 if (len
> max_constexpr_depth
)
1893 pop_cx_call_context (void)
1900 cx_error_context (void)
1902 vec
<tree
> r
= vNULL
;
1903 if (call_stack_tick
!= last_cx_error_tick
1904 && !call_stack
.is_empty ())
1906 last_cx_error_tick
= call_stack_tick
;
1910 /* E is an operand of a failed assertion, fold it either with or without
1911 constexpr context. */
1914 fold_operand (tree e
, const constexpr_ctx
*ctx
)
1918 bool new_non_constant_p
= false, new_overflow_p
= false;
1919 e
= cxx_eval_constant_expression (ctx
, e
, vc_prvalue
,
1920 &new_non_constant_p
,
1924 e
= fold_non_dependent_expr (e
, tf_none
, /*manifestly_const_eval=*/true);
1928 /* If we have a condition in conjunctive normal form (CNF), find the first
1929 failing clause. In other words, given an expression like
1931 true && true && false && true && false
1933 return the first 'false'. EXPR is the expression. */
1936 find_failing_clause_r (const constexpr_ctx
*ctx
, tree expr
)
1938 if (TREE_CODE (expr
) == TRUTH_ANDIF_EXPR
)
1940 /* First check the left side... */
1941 tree e
= find_failing_clause_r (ctx
, TREE_OPERAND (expr
, 0));
1943 /* ...if we didn't find a false clause, check the right side. */
1944 e
= find_failing_clause_r (ctx
, TREE_OPERAND (expr
, 1));
1947 tree e
= contextual_conv_bool (expr
, tf_none
);
1948 e
= fold_operand (e
, ctx
);
1949 if (integer_zerop (e
))
1950 /* This is the failing clause. */
1955 /* Wrapper for find_failing_clause_r. */
1958 find_failing_clause (const constexpr_ctx
*ctx
, tree expr
)
1960 if (TREE_CODE (expr
) == TRUTH_ANDIF_EXPR
)
1961 if (tree e
= find_failing_clause_r (ctx
, expr
))
1966 /* Emit additional diagnostics for failing condition BAD.
1967 Used by finish_static_assert and IFN_ASSUME constexpr diagnostics.
1968 If SHOW_EXPR_P is true, print the condition (because it was
1969 instantiation-dependent). */
1972 diagnose_failing_condition (tree bad
, location_t cloc
, bool show_expr_p
,
1973 const constexpr_ctx
*ctx
/* = nullptr */)
1975 /* Nobody wants to see the artificial (bool) cast. */
1976 bad
= tree_strip_nop_conversions (bad
);
1977 if (TREE_CODE (bad
) == CLEANUP_POINT_EXPR
)
1978 bad
= TREE_OPERAND (bad
, 0);
1980 /* Actually explain the failure if this is a concept check or a
1981 requires-expression. */
1982 if (concept_check_p (bad
) || TREE_CODE (bad
) == REQUIRES_EXPR
)
1983 diagnose_constraints (cloc
, bad
, NULL_TREE
);
1984 else if (COMPARISON_CLASS_P (bad
)
1985 && ARITHMETIC_TYPE_P (TREE_TYPE (TREE_OPERAND (bad
, 0))))
1987 tree op0
= fold_operand (TREE_OPERAND (bad
, 0), ctx
);
1988 tree op1
= fold_operand (TREE_OPERAND (bad
, 1), ctx
);
1989 tree cond
= build2 (TREE_CODE (bad
), boolean_type_node
, op0
, op1
);
1990 inform (cloc
, "the comparison reduces to %qE", cond
);
1992 else if (show_expr_p
)
1993 inform (cloc
, "%qE evaluates to false", bad
);
1996 /* Process an assert/assume of ORIG_ARG. If it's not supposed to be evaluated,
1997 do it without changing the current evaluation state. If it evaluates to
1998 false, complain and return false; otherwise, return true. */
2001 cxx_eval_assert (const constexpr_ctx
*ctx
, tree arg
, const char *msg
,
2002 location_t loc
, bool evaluated
,
2003 bool *non_constant_p
, bool *overflow_p
)
2005 if (*non_constant_p
)
2011 if (!potential_rvalue_constant_expression (arg
))
2014 constexpr_ctx new_ctx
= *ctx
;
2015 new_ctx
.quiet
= true;
2016 bool new_non_constant_p
= false, new_overflow_p
= false;
2017 /* Avoid modification of existing values. */
2018 modifiable_tracker
ms (new_ctx
.global
);
2019 eval
= cxx_eval_constant_expression (&new_ctx
, arg
, vc_prvalue
,
2020 &new_non_constant_p
,
2024 eval
= cxx_eval_constant_expression (ctx
, arg
, vc_prvalue
,
2027 if (!*non_constant_p
&& integer_zerop (eval
))
2031 /* See if we can find which clause was failing
2032 (for logical AND). */
2033 tree bad
= find_failing_clause (ctx
, arg
);
2034 /* If not, or its location is unusable, fall back to the
2035 previous location. */
2036 location_t cloc
= cp_expr_loc_or_loc (bad
, loc
);
2038 /* Report the error. */
2039 auto_diagnostic_group d
;
2040 error_at (cloc
, msg
);
2041 diagnose_failing_condition (bad
, cloc
, true, ctx
);
2044 *non_constant_p
= true;
2051 /* Evaluate a call T to a GCC internal function when possible and return
2052 the evaluated result or, under the control of CTX, give an error, set
2053 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
2056 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
2058 bool *non_constant_p
, bool *overflow_p
)
2060 enum tree_code opcode
= ERROR_MARK
;
2062 switch (CALL_EXPR_IFN (t
))
2064 case IFN_UBSAN_NULL
:
2065 case IFN_UBSAN_BOUNDS
:
2066 case IFN_UBSAN_VPTR
:
2067 case IFN_FALLTHROUGH
:
2071 if (!cxx_eval_assert (ctx
, CALL_EXPR_ARG (t
, 0),
2072 G_("failed %<assume%> attribute assumption"),
2073 EXPR_LOCATION (t
), /*eval*/false,
2074 non_constant_p
, overflow_p
))
2078 case IFN_ADD_OVERFLOW
:
2081 case IFN_SUB_OVERFLOW
:
2082 opcode
= MINUS_EXPR
;
2084 case IFN_MUL_OVERFLOW
:
2089 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
2090 vc_prvalue
, non_constant_p
,
2093 case IFN_VEC_CONVERT
:
2095 tree arg
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
2096 vc_prvalue
, non_constant_p
,
2098 if (TREE_CODE (arg
) == VECTOR_CST
)
2099 if (tree r
= fold_const_call (CFN_VEC_CONVERT
, TREE_TYPE (t
), arg
))
2106 error_at (cp_expr_loc_or_input_loc (t
),
2107 "call to internal function %qE", t
);
2108 *non_constant_p
= true;
2112 /* Evaluate constant arguments using OPCODE and return a complex
2113 number containing the result and the overflow bit. */
2114 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
2115 non_constant_p
, overflow_p
);
2116 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
2117 non_constant_p
, overflow_p
);
2119 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2121 location_t loc
= cp_expr_loc_or_input_loc (t
);
2122 tree type
= TREE_TYPE (TREE_TYPE (t
));
2123 tree result
= fold_binary_loc (loc
, opcode
, type
,
2124 fold_convert_loc (loc
, type
, arg0
),
2125 fold_convert_loc (loc
, type
, arg1
));
2127 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
2128 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
2129 if (TREE_OVERFLOW (result
))
2130 TREE_OVERFLOW (result
) = 0;
2132 return build_complex (TREE_TYPE (t
), result
, ovf
);
2135 *non_constant_p
= true;
2139 /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */
2142 clear_no_implicit_zero (tree ctor
)
2144 if (CONSTRUCTOR_NO_CLEARING (ctor
))
2146 CONSTRUCTOR_NO_CLEARING (ctor
) = false;
2147 for (auto &e
: CONSTRUCTOR_ELTS (ctor
))
2148 if (TREE_CODE (e
.value
) == CONSTRUCTOR
)
2149 clear_no_implicit_zero (e
.value
);
2153 /* Complain about a const object OBJ being modified in a constant expression.
2154 EXPR is the MODIFY_EXPR expression performing the modification. */
2157 modifying_const_object_error (tree expr
, tree obj
)
2159 location_t loc
= cp_expr_loc_or_input_loc (expr
);
2160 auto_diagnostic_group d
;
2161 error_at (loc
, "modifying a const object %qE is not allowed in "
2162 "a constant expression", TREE_OPERAND (expr
, 0));
2163 inform (location_of (obj
), "originally declared %<const%> here");
2166 /* Return true if FNDECL is a replaceable global allocation function that
2167 should be useable during constant expression evaluation. */
2170 cxx_replaceable_global_alloc_fn (tree fndecl
)
2172 return (cxx_dialect
>= cxx20
2173 && IDENTIFIER_NEWDEL_OP_P (DECL_NAME (fndecl
))
2174 && CP_DECL_CONTEXT (fndecl
) == global_namespace
2175 && (DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl
)
2176 || DECL_IS_OPERATOR_DELETE_P (fndecl
)));
2179 /* Return true if FNDECL is a placement new function that should be
2180 useable during constant expression evaluation of std::construct_at. */
2183 cxx_placement_new_fn (tree fndecl
)
2185 if (cxx_dialect
>= cxx20
2186 && IDENTIFIER_NEW_OP_P (DECL_NAME (fndecl
))
2187 && CP_DECL_CONTEXT (fndecl
) == global_namespace
2188 && !DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl
)
2189 && TREE_CODE (TREE_TYPE (fndecl
)) == FUNCTION_TYPE
)
2191 tree first_arg
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
2192 if (TREE_VALUE (first_arg
) == ptr_type_node
2193 && TREE_CHAIN (first_arg
) == void_list_node
)
2199 /* Return true if FNDECL is std::construct_at. */
2202 is_std_construct_at (tree fndecl
)
2204 if (!decl_in_std_namespace_p (fndecl
))
2207 tree name
= DECL_NAME (fndecl
);
2208 return name
&& id_equal (name
, "construct_at");
2211 /* Overload for the above taking constexpr_call*. */
2214 is_std_construct_at (const constexpr_call
*call
)
2218 && is_std_construct_at (call
->fundef
->decl
));
2221 /* True if CTX is an instance of std::allocator. */
2224 is_std_allocator (tree ctx
)
2226 if (ctx
== NULL_TREE
|| !CLASS_TYPE_P (ctx
) || !TYPE_MAIN_DECL (ctx
))
2229 tree decl
= TYPE_MAIN_DECL (ctx
);
2230 tree name
= DECL_NAME (decl
);
2231 if (name
== NULL_TREE
|| !id_equal (name
, "allocator"))
2234 return decl_in_std_namespace_p (decl
);
2237 /* Return true if FNDECL is std::allocator<T>::{,de}allocate. */
2240 is_std_allocator_allocate (tree fndecl
)
2242 tree name
= DECL_NAME (fndecl
);
2243 if (name
== NULL_TREE
2244 || !(id_equal (name
, "allocate") || id_equal (name
, "deallocate")))
2247 return is_std_allocator (DECL_CONTEXT (fndecl
));
2250 /* Overload for the above taking constexpr_call*. */
2253 is_std_allocator_allocate (const constexpr_call
*call
)
2257 && is_std_allocator_allocate (call
->fundef
->decl
));
2260 /* Return true if FNDECL is __dynamic_cast. */
2263 cxx_dynamic_cast_fn_p (tree fndecl
)
2265 return (cxx_dialect
>= cxx20
2266 && id_equal (DECL_NAME (fndecl
), "__dynamic_cast")
2267 && CP_DECL_CONTEXT (fndecl
) == abi_node
);
2270 /* Often, we have an expression in the form of address + offset, e.g.
2271 "&_ZTV1A + 16". Extract the object from it, i.e. "_ZTV1A". */
2274 extract_obj_from_addr_offset (tree expr
)
2276 if (TREE_CODE (expr
) == POINTER_PLUS_EXPR
)
2277 expr
= TREE_OPERAND (expr
, 0);
2279 if (TREE_CODE (expr
) == ADDR_EXPR
)
2280 expr
= TREE_OPERAND (expr
, 0);
2284 /* Given a PATH like
2286 g.D.2181.D.2154.D.2102.D.2093
2288 find a component with type TYPE. Return NULL_TREE if not found, and
2289 error_mark_node if the component is not accessible. If STOP is non-null,
2290 this function will return NULL_TREE if STOP is found before TYPE. */
2293 get_component_with_type (tree path
, tree type
, tree stop
)
2297 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (path
), type
))
2301 && (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (path
),
2304 else if (TREE_CODE (path
) == COMPONENT_REF
2305 && DECL_FIELD_IS_BASE (TREE_OPERAND (path
, 1)))
2307 /* We need to check that the component we're accessing is in fact
2309 if (TREE_PRIVATE (TREE_OPERAND (path
, 1))
2310 || TREE_PROTECTED (TREE_OPERAND (path
, 1)))
2311 return error_mark_node
;
2312 path
= TREE_OPERAND (path
, 0);
2319 /* Evaluate a call to __dynamic_cast (permitted by P1327R1).
2321 The declaration of __dynamic_cast is:
2323 void* __dynamic_cast (const void* __src_ptr,
2324 const __class_type_info* __src_type,
2325 const __class_type_info* __dst_type,
2326 ptrdiff_t __src2dst);
2328 where src2dst has the following possible values
2330 >-1: src_type is a unique public non-virtual base of dst_type
2331 dst_ptr + src2dst == src_ptr
2332 -1: unspecified relationship
2333 -2: src_type is not a public base of dst_type
2334 -3: src_type is a multiple public non-virtual base of dst_type
2336 Since literal types can't have virtual bases, we only expect hint >=0,
2340 cxx_eval_dynamic_cast_fn (const constexpr_ctx
*ctx
, tree call
,
2341 bool *non_constant_p
, bool *overflow_p
)
2343 /* T will be something like
2344 __dynamic_cast ((B*) b, &_ZTI1B, &_ZTI1D, 8)
2346 gcc_assert (call_expr_nargs (call
) == 4);
2347 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
2348 tree obj
= CALL_EXPR_ARG (call
, 0);
2349 tree type
= CALL_EXPR_ARG (call
, 2);
2350 HOST_WIDE_INT hint
= int_cst_value (CALL_EXPR_ARG (call
, 3));
2351 location_t loc
= cp_expr_loc_or_input_loc (call
);
2353 /* Get the target type of the dynamic_cast. */
2354 gcc_assert (TREE_CODE (type
) == ADDR_EXPR
);
2355 type
= TREE_OPERAND (type
, 0);
2356 type
= TREE_TYPE (DECL_NAME (type
));
2358 /* TYPE can only be either T* or T&. We can't know which of these it
2359 is by looking at TYPE, but OBJ will be "(T*) x" in the first case,
2360 and something like "(T*)(T&)(T*) x" in the second case. */
2361 bool reference_p
= false;
2362 while (CONVERT_EXPR_P (obj
) || TREE_CODE (obj
) == SAVE_EXPR
)
2364 reference_p
|= TYPE_REF_P (TREE_TYPE (obj
));
2365 obj
= TREE_OPERAND (obj
, 0);
2368 /* Evaluate the object so that we know its dynamic type. */
2369 obj
= cxx_eval_constant_expression (ctx
, obj
, vc_prvalue
, non_constant_p
,
2371 if (*non_constant_p
)
2374 /* We expect OBJ to be in form of &d.D.2102 when HINT == 0,
2375 but when HINT is > 0, it can also be something like
2376 &d.D.2102 + 18446744073709551608, which includes the BINFO_OFFSET. */
2377 obj
= extract_obj_from_addr_offset (obj
);
2378 const tree objtype
= TREE_TYPE (obj
);
2379 /* If OBJ doesn't refer to a base field, we're done. */
2380 if (tree t
= (TREE_CODE (obj
) == COMPONENT_REF
2381 ? TREE_OPERAND (obj
, 1) : obj
))
2382 if (TREE_CODE (t
) != FIELD_DECL
|| !DECL_FIELD_IS_BASE (t
))
2388 error_at (loc
, "reference %<dynamic_cast%> failed");
2389 inform (loc
, "dynamic type %qT of its operand does "
2390 "not have a base class of type %qT",
2393 *non_constant_p
= true;
2395 return integer_zero_node
;
2398 /* [class.cdtor] When a dynamic_cast is used in a constructor ...
2399 or in a destructor ... if the operand of the dynamic_cast refers
2400 to the object under construction or destruction, this object is
2401 considered to be a most derived object that has the type of the
2402 constructor or destructor's class. */
2403 tree vtable
= build_vfield_ref (obj
, objtype
);
2404 vtable
= cxx_eval_constant_expression (ctx
, vtable
, vc_prvalue
,
2405 non_constant_p
, overflow_p
);
2406 if (*non_constant_p
)
2408 /* With -fsanitize=vptr, we initialize all vtable pointers to null,
2409 so it's possible that we got a null pointer now. */
2410 if (integer_zerop (vtable
))
2413 error_at (loc
, "virtual table pointer is used uninitialized");
2414 *non_constant_p
= true;
2415 return integer_zero_node
;
2417 /* VTABLE will be &_ZTV1A + 16 or similar, get _ZTV1A. */
2418 vtable
= extract_obj_from_addr_offset (vtable
);
2419 const tree mdtype
= DECL_CONTEXT (vtable
);
2421 /* Given dynamic_cast<T>(v),
2423 [expr.dynamic.cast] If C is the class type to which T points or refers,
2424 the runtime check logically executes as follows:
2426 If, in the most derived object pointed (referred) to by v, v points
2427 (refers) to a public base class subobject of a C object, and if only
2428 one object of type C is derived from the subobject pointed (referred)
2429 to by v the result points (refers) to that C object.
2431 In this case, HINT >= 0 or -3. */
2432 if (hint
>= 0 || hint
== -3)
2434 /* Look for a component with type TYPE. */
2435 tree t
= get_component_with_type (obj
, type
, mdtype
);
2436 /* If not accessible, give an error. */
2437 if (t
== error_mark_node
)
2443 error_at (loc
, "reference %<dynamic_cast%> failed");
2444 inform (loc
, "static type %qT of its operand is a "
2445 "non-public base class of dynamic type %qT",
2449 *non_constant_p
= true;
2451 return integer_zero_node
;
2454 /* The result points to the TYPE object. */
2455 return cp_build_addr_expr (t
, complain
);
2456 /* Else, TYPE was not found, because the HINT turned out to be wrong.
2457 Fall through to the normal processing. */
2460 /* Otherwise, if v points (refers) to a public base class subobject of the
2461 most derived object, and the type of the most derived object has a base
2462 class, of type C, that is unambiguous and public, the result points
2463 (refers) to the C subobject of the most derived object.
2465 But it can also be an invalid case. */
2467 /* Get the most derived object. */
2468 obj
= get_component_with_type (obj
, mdtype
, NULL_TREE
);
2469 if (obj
== error_mark_node
)
2475 error_at (loc
, "reference %<dynamic_cast%> failed");
2476 inform (loc
, "static type %qT of its operand is a non-public"
2477 " base class of dynamic type %qT", objtype
, mdtype
);
2479 *non_constant_p
= true;
2481 return integer_zero_node
;
2486 /* Check that the type of the most derived object has a base class
2487 of type TYPE that is unambiguous and public. */
2489 tree binfo
= lookup_base (mdtype
, type
, ba_check
, &b_kind
, tf_none
);
2490 if (!binfo
|| binfo
== error_mark_node
)
2496 error_at (loc
, "reference %<dynamic_cast%> failed");
2497 if (b_kind
== bk_ambig
)
2498 inform (loc
, "%qT is an ambiguous base class of dynamic "
2499 "type %qT of its operand", type
, mdtype
);
2501 inform (loc
, "dynamic type %qT of its operand does not "
2502 "have an unambiguous public base class %qT",
2505 *non_constant_p
= true;
2507 return integer_zero_node
;
2509 /* If so, return the TYPE subobject of the most derived object. */
2510 obj
= convert_to_base_statically (obj
, binfo
);
2511 return cp_build_addr_expr (obj
, complain
);
2514 /* Data structure used by replace_decl and replace_decl_r. */
2516 struct replace_decl_data
2518 /* The _DECL we want to replace. */
2520 /* The replacement for DECL. */
2522 /* Trees we've visited. */
2523 hash_set
<tree
> *pset
;
2524 /* Whether we've performed any replacements. */
2528 /* Helper function for replace_decl, called through cp_walk_tree. */
2531 replace_decl_r (tree
*tp
, int *walk_subtrees
, void *data
)
2533 replace_decl_data
*d
= (replace_decl_data
*) data
;
2537 *tp
= unshare_expr (d
->replacement
);
2541 else if (TYPE_P (*tp
)
2542 || d
->pset
->add (*tp
))
2548 /* Replace every occurrence of DECL with (an unshared copy of)
2549 REPLACEMENT within the expression *TP. Returns true iff a
2550 replacement was performed. */
2553 replace_decl (tree
*tp
, tree decl
, tree replacement
)
2555 gcc_checking_assert (same_type_ignoring_top_level_qualifiers_p
2556 (TREE_TYPE (decl
), TREE_TYPE (replacement
)));
2557 hash_set
<tree
> pset
;
2558 replace_decl_data data
= { decl
, replacement
, &pset
, false };
2559 cp_walk_tree (tp
, replace_decl_r
, &data
, NULL
);
2560 return data
.changed
;
2563 /* Evaluate the call T to virtual function thunk THUNK_FNDECL. */
2566 cxx_eval_thunk_call (const constexpr_ctx
*ctx
, tree t
, tree thunk_fndecl
,
2568 bool *non_constant_p
, bool *overflow_p
)
2570 tree function
= THUNK_TARGET (thunk_fndecl
);
2572 if (THUNK_VIRTUAL_OFFSET (thunk_fndecl
))
2576 if (!DECL_DECLARED_CONSTEXPR_P (function
))
2578 error ("call to non-%<constexpr%> function %qD", function
);
2579 explain_invalid_constexpr_fn (function
);
2582 /* virtual_offset is only set for virtual bases, which make the
2583 class non-literal, so we don't need to handle it here. */
2584 error ("calling constexpr member function %qD through virtual "
2585 "base subobject", function
);
2587 *non_constant_p
= true;
2591 tree new_call
= copy_node (t
);
2592 CALL_EXPR_FN (new_call
) = function
;
2593 TREE_TYPE (new_call
) = TREE_TYPE (TREE_TYPE (function
));
2595 tree offset
= size_int (THUNK_FIXED_OFFSET (thunk_fndecl
));
2597 if (DECL_THIS_THUNK_P (thunk_fndecl
))
2599 /* 'this'-adjusting thunk. */
2600 tree this_arg
= CALL_EXPR_ARG (t
, 0);
2601 this_arg
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (this_arg
),
2603 CALL_EXPR_ARG (new_call
, 0) = this_arg
;
2606 /* Return-adjusting thunk. */
2607 new_call
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (new_call
),
2610 return cxx_eval_constant_expression (ctx
, new_call
, lval
,
2611 non_constant_p
, overflow_p
);
2614 /* If OBJECT is of const class type, evaluate it to a CONSTRUCTOR and set
2615 its TREE_READONLY flag according to READONLY_P. Used for constexpr
2616 'tors to detect modifying const objects in a constexpr context. */
2619 cxx_set_object_constness (const constexpr_ctx
*ctx
, tree object
,
2620 bool readonly_p
, bool *non_constant_p
,
2623 if (CLASS_TYPE_P (TREE_TYPE (object
))
2624 && CP_TYPE_CONST_P (TREE_TYPE (object
)))
2626 /* Subobjects might not be stored in ctx->global->values but we
2627 can get its CONSTRUCTOR by evaluating *this. */
2628 tree e
= cxx_eval_constant_expression (ctx
, object
, vc_prvalue
,
2629 non_constant_p
, overflow_p
);
2630 if (TREE_CODE (e
) == CONSTRUCTOR
&& !*non_constant_p
)
2631 TREE_READONLY (e
) = readonly_p
;
2635 /* Subroutine of cxx_eval_constant_expression.
2636 Evaluate the call expression tree T in the context of OLD_CALL expression
2640 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
2642 bool *non_constant_p
, bool *overflow_p
)
2644 /* Handle concept checks separately. */
2645 if (concept_check_p (t
))
2646 return evaluate_concept_check (t
);
2648 location_t loc
= cp_expr_loc_or_input_loc (t
);
2649 tree fun
= get_function_named_in_call (t
);
2650 constexpr_call new_call
2651 = { NULL
, NULL
, NULL
, 0, ctx
->manifestly_const_eval
};
2654 if (fun
== NULL_TREE
)
2655 return cxx_eval_internal_function (ctx
, t
, lval
,
2656 non_constant_p
, overflow_p
);
2658 if (TREE_CODE (fun
) != FUNCTION_DECL
)
2660 /* Might be a constexpr function pointer. */
2661 fun
= cxx_eval_constant_expression (ctx
, fun
, vc_prvalue
,
2662 non_constant_p
, overflow_p
);
2664 if (TREE_CODE (fun
) == ADDR_EXPR
)
2665 fun
= TREE_OPERAND (fun
, 0);
2666 /* For TARGET_VTABLE_USES_DESCRIPTORS targets, there is no
2667 indirection, the called expression is a pointer into the
2668 virtual table which should contain FDESC_EXPR. Extract the
2669 FUNCTION_DECL from there. */
2670 else if (TARGET_VTABLE_USES_DESCRIPTORS
2671 && TREE_CODE (fun
) == POINTER_PLUS_EXPR
2672 && TREE_CODE (TREE_OPERAND (fun
, 0)) == ADDR_EXPR
2673 && TREE_CODE (TREE_OPERAND (fun
, 1)) == INTEGER_CST
)
2675 tree d
= TREE_OPERAND (TREE_OPERAND (fun
, 0), 0);
2677 && DECL_VTABLE_OR_VTT_P (d
)
2678 && TREE_CODE (TREE_TYPE (d
)) == ARRAY_TYPE
2679 && TREE_TYPE (TREE_TYPE (d
)) == vtable_entry_type
2681 && TREE_CODE (DECL_INITIAL (d
)) == CONSTRUCTOR
)
2683 tree i
= int_const_binop (TRUNC_DIV_EXPR
, TREE_OPERAND (fun
, 1),
2684 TYPE_SIZE_UNIT (vtable_entry_type
));
2685 HOST_WIDE_INT idx
= find_array_ctor_elt (DECL_INITIAL (d
), i
);
2689 = (*CONSTRUCTOR_ELTS (DECL_INITIAL (d
)))[idx
].value
;
2690 if (TREE_CODE (fdesc
) == FDESC_EXPR
2691 && integer_zerop (TREE_OPERAND (fdesc
, 1)))
2692 fun
= TREE_OPERAND (fdesc
, 0);
2697 if (TREE_CODE (fun
) != FUNCTION_DECL
)
2699 if (!ctx
->quiet
&& !*non_constant_p
)
2700 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
2702 *non_constant_p
= true;
2705 if (DECL_CLONED_FUNCTION_P (fun
) && !DECL_DELETING_DESTRUCTOR_P (fun
))
2706 fun
= DECL_CLONED_FUNCTION (fun
);
2708 if (is_ubsan_builtin_p (fun
))
2711 if (fndecl_built_in_p (fun
))
2712 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
2713 lval
, non_constant_p
, overflow_p
);
2714 if (DECL_THUNK_P (fun
))
2715 return cxx_eval_thunk_call (ctx
, t
, fun
, lval
, non_constant_p
, overflow_p
);
2716 if (!maybe_constexpr_fn (fun
))
2718 if (TREE_CODE (t
) == CALL_EXPR
2719 && cxx_replaceable_global_alloc_fn (fun
)
2720 && (CALL_FROM_NEW_OR_DELETE_P (t
)
2721 || is_std_allocator_allocate (ctx
->call
)))
2723 const int nargs
= call_expr_nargs (t
);
2724 tree arg0
= NULL_TREE
;
2725 for (int i
= 0; i
< nargs
; ++i
)
2727 tree arg
= CALL_EXPR_ARG (t
, i
);
2728 arg
= cxx_eval_constant_expression (ctx
, arg
, vc_prvalue
,
2729 non_constant_p
, overflow_p
);
2730 VERIFY_CONSTANT (arg
);
2735 if (IDENTIFIER_NEW_OP_P (DECL_NAME (fun
)))
2737 tree type
= build_array_type_nelts (char_type_node
,
2738 tree_to_uhwi (arg0
));
2739 tree var
= build_decl (loc
, VAR_DECL
,
2740 (IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun
))
2742 ? heap_vec_uninit_identifier
2743 : heap_uninit_identifier
,
2745 DECL_ARTIFICIAL (var
) = 1;
2746 TREE_STATIC (var
) = 1;
2747 // Temporarily register the artificial var in varpool,
2748 // so that comparisons of its address against NULL are folded
2749 // through nonzero_address even with
2750 // -fno-delete-null-pointer-checks or that comparison of
2751 // addresses of different heap artificial vars is folded too.
2752 // See PR98988 and PR99031.
2753 varpool_node::finalize_decl (var
);
2754 ctx
->global
->heap_vars
.safe_push (var
);
2755 ctx
->global
->put_value (var
, NULL_TREE
);
2756 return fold_convert (ptr_type_node
, build_address (var
));
2761 if (TREE_CODE (arg0
) == ADDR_EXPR
2762 && VAR_P (TREE_OPERAND (arg0
, 0)))
2764 tree var
= TREE_OPERAND (arg0
, 0);
2765 if (DECL_NAME (var
) == heap_uninit_identifier
2766 || DECL_NAME (var
) == heap_identifier
)
2768 if (IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun
))
2773 error_at (loc
, "array deallocation of object "
2774 "allocated with non-array "
2776 inform (DECL_SOURCE_LOCATION (var
),
2777 "allocation performed here");
2779 *non_constant_p
= true;
2782 DECL_NAME (var
) = heap_deleted_identifier
;
2783 ctx
->global
->remove_value (var
);
2784 ctx
->global
->heap_dealloc_count
++;
2787 else if (DECL_NAME (var
) == heap_vec_uninit_identifier
2788 || DECL_NAME (var
) == heap_vec_identifier
)
2790 if ((IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun
))
2791 & OVL_OP_FLAG_VEC
) == 0)
2795 error_at (loc
, "non-array deallocation of "
2796 "object allocated with array "
2798 inform (DECL_SOURCE_LOCATION (var
),
2799 "allocation performed here");
2801 *non_constant_p
= true;
2804 DECL_NAME (var
) = heap_deleted_identifier
;
2805 ctx
->global
->remove_value (var
);
2806 ctx
->global
->heap_dealloc_count
++;
2809 else if (DECL_NAME (var
) == heap_deleted_identifier
)
2812 error_at (loc
, "deallocation of already deallocated "
2814 *non_constant_p
= true;
2819 error_at (loc
, "deallocation of storage that was "
2820 "not previously allocated");
2821 *non_constant_p
= true;
2825 /* Allow placement new in std::construct_at, just return the second
2827 if (TREE_CODE (t
) == CALL_EXPR
2828 && cxx_placement_new_fn (fun
)
2829 && is_std_construct_at (ctx
->call
))
2831 const int nargs
= call_expr_nargs (t
);
2832 tree arg1
= NULL_TREE
;
2833 for (int i
= 0; i
< nargs
; ++i
)
2835 tree arg
= CALL_EXPR_ARG (t
, i
);
2836 arg
= cxx_eval_constant_expression (ctx
, arg
, vc_prvalue
,
2837 non_constant_p
, overflow_p
);
2841 VERIFY_CONSTANT (arg
);
2846 else if (cxx_dynamic_cast_fn_p (fun
))
2847 return cxx_eval_dynamic_cast_fn (ctx
, t
, non_constant_p
, overflow_p
);
2851 if (!lambda_static_thunk_p (fun
))
2852 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
2853 explain_invalid_constexpr_fn (fun
);
2855 *non_constant_p
= true;
2859 constexpr_ctx new_ctx
= *ctx
;
2860 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
2861 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
2863 /* We want to have an initialization target for an AGGR_INIT_EXPR.
2864 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
2865 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
2866 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
2867 CONSTRUCTOR_NO_CLEARING (ctor
) = true;
2868 ctx
->global
->put_value (new_ctx
.object
, ctor
);
2872 /* We used to shortcut trivial constructor/op= here, but nowadays
2873 we can only get a trivial function here with -fno-elide-constructors. */
2874 gcc_checking_assert (!trivial_fn_p (fun
)
2875 || !flag_elide_constructors
2876 /* We don't elide constructors when processing
2877 a noexcept-expression. */
2878 || cp_noexcept_operand
);
2880 bool non_constant_args
= false;
2882 = cxx_bind_parameters_in_call (ctx
, t
, fun
, non_constant_p
,
2883 overflow_p
, &non_constant_args
);
2885 /* We build up the bindings list before we know whether we already have this
2886 call cached. If we don't end up saving these bindings, ggc_free them when
2887 this function exits. */
2892 free_bindings (tree
&b
): bindings (&b
) { }
2893 ~free_bindings () { if (bindings
) ggc_free (*bindings
); }
2894 void preserve () { bindings
= NULL
; }
2895 } fb (new_call
.bindings
);
2897 if (*non_constant_p
)
2900 /* We can't defer instantiating the function any longer. */
2901 if (!DECL_INITIAL (fun
)
2902 && (DECL_TEMPLOID_INSTANTIATION (fun
) || DECL_DEFAULTED_FN (fun
))
2903 && !uid_sensitive_constexpr_evaluation_p ())
2905 location_t save_loc
= input_location
;
2906 input_location
= loc
;
2908 if (ctx
->manifestly_const_eval
== mce_true
)
2909 FNDECL_MANIFESTLY_CONST_EVALUATED (fun
) = true;
2910 if (DECL_TEMPLOID_INSTANTIATION (fun
))
2911 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
2913 synthesize_method (fun
);
2915 input_location
= save_loc
;
2918 /* If in direct recursive call, optimize definition search. */
2919 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
2920 new_call
.fundef
= ctx
->call
->fundef
;
2923 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
2924 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
2925 || new_call
.fundef
->result
== error_mark_node
2926 || fun
== current_function_decl
)
2930 /* We need to check for current_function_decl here in case we're
2931 being called during cp_fold_function, because at that point
2932 DECL_INITIAL is set properly and we have a fundef but we
2933 haven't lowered invisirefs yet (c++/70344). */
2934 if (DECL_INITIAL (fun
) == error_mark_node
2935 || fun
== current_function_decl
)
2936 error_at (loc
, "%qD called in a constant expression before its "
2937 "definition is complete", fun
);
2938 else if (DECL_INITIAL (fun
))
2940 /* The definition of fun was somehow unsuitable. But pretend
2941 that lambda static thunks don't exist. */
2942 if (!lambda_static_thunk_p (fun
))
2943 error_at (loc
, "%qD called in a constant expression", fun
);
2944 explain_invalid_constexpr_fn (fun
);
2947 error_at (loc
, "%qD used before its definition", fun
);
2949 *non_constant_p
= true;
2954 depth_ok
= push_cx_call_context (t
);
2956 /* Remember the object we are constructing or destructing. */
2957 tree new_obj
= NULL_TREE
;
2958 if (DECL_CONSTRUCTOR_P (fun
) || DECL_DESTRUCTOR_P (fun
))
2960 /* In a cdtor, it should be the first `this' argument.
2961 At this point it has already been evaluated in the call
2962 to cxx_bind_parameters_in_call. */
2963 new_obj
= TREE_VEC_ELT (new_call
.bindings
, 0);
2964 new_obj
= cxx_fold_indirect_ref (ctx
, loc
, DECL_CONTEXT (fun
), new_obj
);
2966 if (ctx
->call
&& ctx
->call
->fundef
2967 && DECL_CONSTRUCTOR_P (ctx
->call
->fundef
->decl
))
2969 tree cur_obj
= TREE_VEC_ELT (ctx
->call
->bindings
, 0);
2970 STRIP_NOPS (cur_obj
);
2971 if (TREE_CODE (cur_obj
) == ADDR_EXPR
)
2972 cur_obj
= TREE_OPERAND (cur_obj
, 0);
2973 if (new_obj
== cur_obj
)
2974 /* We're calling the target constructor of a delegating
2975 constructor, or accessing a base subobject through a
2976 NOP_EXPR as part of a call to a base constructor, so
2977 there is no new (sub)object. */
2978 new_obj
= NULL_TREE
;
2982 tree result
= NULL_TREE
;
2984 constexpr_call
*entry
= NULL
;
2985 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
2987 new_call
.hash
= constexpr_fundef_hasher::hash (new_call
.fundef
);
2989 = iterative_hash_template_arg (new_call
.bindings
, new_call
.hash
);
2991 = iterative_hash_object (ctx
->manifestly_const_eval
, new_call
.hash
);
2993 /* If we have seen this call before, we are done. */
2994 maybe_initialize_constexpr_call_table ();
2995 bool insert
= depth_ok
< constexpr_cache_depth
;
2996 constexpr_call
**slot
2997 = constexpr_call_table
->find_slot (&new_call
,
2998 insert
? INSERT
: NO_INSERT
);
2999 entry
= slot
? *slot
: NULL
;
3002 /* Only cache up to constexpr_cache_depth to limit memory use. */
3005 /* We need to keep a pointer to the entry, not just the slot, as
3006 the slot can move during evaluation of the body. */
3007 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
3012 /* Calls that are in progress have their result set to NULL, so that we
3013 can detect circular dependencies. Now that we only cache up to
3014 constexpr_cache_depth this won't catch circular dependencies that
3015 start deeper, but they'll hit the recursion or ops limit. */
3016 else if (entry
->result
== NULL
)
3019 error ("call has circular dependency");
3020 *non_constant_p
= true;
3021 entry
->result
= result
= error_mark_node
;
3024 result
= entry
->result
;
3030 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
3031 "%<-fconstexpr-depth=%> to increase the maximum)",
3032 max_constexpr_depth
);
3033 *non_constant_p
= true;
3034 result
= error_mark_node
;
3038 bool cacheable
= !!entry
;
3039 if (result
&& result
!= error_mark_node
)
3041 else if (!DECL_SAVED_TREE (fun
))
3043 /* When at_eof >= 2, cgraph has started throwing away
3044 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
3045 late code generation for VEC_INIT_EXPR, which needs to be
3046 completely reconsidered. */
3047 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
3048 *non_constant_p
= true;
3050 else if (tree copy
= get_fundef_copy (new_call
.fundef
))
3052 tree body
, parms
, res
;
3053 releasing_vec ctors
;
3055 /* Reuse or create a new unshared copy of this function's body. */
3056 body
= TREE_PURPOSE (copy
);
3057 parms
= TREE_VALUE (copy
);
3058 res
= TREE_TYPE (copy
);
3060 /* Associate the bindings with the remapped parms. */
3061 tree bound
= new_call
.bindings
;
3062 tree remapped
= parms
;
3063 for (int i
= 0; i
< TREE_VEC_LENGTH (bound
); ++i
)
3065 tree arg
= TREE_VEC_ELT (bound
, i
);
3068 /* Unshare args going into the hash table to separate them
3069 from the caller's context, for better GC and to avoid
3070 problems with verify_gimple. */
3071 arg
= unshare_expr_without_location (arg
);
3072 TREE_VEC_ELT (bound
, i
) = arg
;
3074 /* And then unshare again so the callee doesn't change the
3075 argument values in the hash table. XXX Could we unshare
3076 lazily in cxx_eval_store_expression? */
3077 arg
= unshare_constructor (arg
);
3078 if (TREE_CODE (arg
) == CONSTRUCTOR
)
3079 vec_safe_push (ctors
, arg
);
3081 ctx
->global
->put_value (remapped
, arg
);
3082 remapped
= DECL_CHAIN (remapped
);
3084 /* Add the RESULT_DECL to the values map, too. */
3085 gcc_assert (!DECL_BY_REFERENCE (res
));
3086 ctx
->global
->put_value (res
, NULL_TREE
);
3088 /* Track the callee's evaluated SAVE_EXPRs and TARGET_EXPRs so that
3089 we can forget their values after the call. */
3090 constexpr_ctx ctx_with_save_exprs
= *ctx
;
3091 auto_vec
<tree
, 10> save_exprs
;
3092 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
3093 ctx_with_save_exprs
.call
= &new_call
;
3094 unsigned save_heap_alloc_count
= ctx
->global
->heap_vars
.length ();
3095 unsigned save_heap_dealloc_count
= ctx
->global
->heap_dealloc_count
;
3097 /* If this is a constexpr destructor, the object's const and volatile
3098 semantics are no longer in effect; see [class.dtor]p5. */
3099 if (new_obj
&& DECL_DESTRUCTOR_P (fun
))
3100 cxx_set_object_constness (ctx
, new_obj
, /*readonly_p=*/false,
3101 non_constant_p
, overflow_p
);
3103 tree jump_target
= NULL_TREE
;
3104 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
3105 vc_discard
, non_constant_p
, overflow_p
,
3108 if (DECL_CONSTRUCTOR_P (fun
))
3110 /* This can be null for a subobject constructor call, in
3111 which case what we care about is the initialization
3112 side-effects rather than the value. We could get at the
3113 value by evaluating *this, but we don't bother; there's
3114 no need to put such a call in the hash table. */
3115 result
= lval
? ctx
->object
: ctx
->ctor
;
3117 /* If we've just evaluated a subobject constructor call for an
3118 empty union member, it might not have produced a side effect
3119 that actually activated the union member. So produce such a
3120 side effect now to ensure the union appears initialized. */
3121 if (!result
&& new_obj
3122 && TREE_CODE (new_obj
) == COMPONENT_REF
3123 && TREE_CODE (TREE_TYPE
3124 (TREE_OPERAND (new_obj
, 0))) == UNION_TYPE
3125 && is_really_empty_class (TREE_TYPE (new_obj
),
3126 /*ignore_vptr*/false))
3128 tree activate
= build2 (MODIFY_EXPR
, TREE_TYPE (new_obj
),
3130 build_constructor (TREE_TYPE (new_obj
),
3132 cxx_eval_constant_expression (ctx
, activate
, lval
,
3133 non_constant_p
, overflow_p
);
3134 ggc_free (activate
);
3137 else if (VOID_TYPE_P (TREE_TYPE (res
)))
3141 result
= ctx
->global
->get_value (res
);
3142 if (result
== NULL_TREE
&& !*non_constant_p
3143 && !DECL_DESTRUCTOR_P (fun
))
3146 error ("%<constexpr%> call flows off the end "
3148 *non_constant_p
= true;
3152 /* At this point, the object's constructor will have run, so
3153 the object is no longer under construction, and its possible
3154 'const' semantics now apply. Make a note of this fact by
3155 marking the CONSTRUCTOR TREE_READONLY. */
3156 if (new_obj
&& DECL_CONSTRUCTOR_P (fun
))
3157 cxx_set_object_constness (ctx
, new_obj
, /*readonly_p=*/true,
3158 non_constant_p
, overflow_p
);
3160 /* Forget the saved values of the callee's SAVE_EXPRs and
3162 for (tree save_expr
: save_exprs
)
3163 ctx
->global
->remove_value (save_expr
);
3165 /* Remove the parms/result from the values map. Is it worth
3166 bothering to do this when the map itself is only live for
3167 one constexpr evaluation? If so, maybe also clear out
3168 other vars from call, maybe in BIND_EXPR handling? */
3169 ctx
->global
->remove_value (res
);
3170 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
3171 ctx
->global
->remove_value (parm
);
3173 /* Free any parameter CONSTRUCTORs we aren't returning directly. */
3174 while (!ctors
->is_empty ())
3176 tree c
= ctors
->pop ();
3178 free_constructor (c
);
3181 /* Make the unshared function copy we used available for re-use. */
3182 save_fundef_copy (fun
, copy
);
3184 /* If the call allocated some heap object that hasn't been
3185 deallocated during the call, or if it deallocated some heap
3186 object it has not allocated, the call isn't really stateless
3187 for the constexpr evaluation and should not be cached.
3188 It is fine if the call allocates something and deallocates it
3191 && (save_heap_alloc_count
!= ctx
->global
->heap_vars
.length ()
3192 || (save_heap_dealloc_count
3193 != ctx
->global
->heap_dealloc_count
)))
3197 if ((ctx
->global
->heap_vars
.length ()
3198 - ctx
->global
->heap_dealloc_count
)
3199 != save_heap_alloc_count
- save_heap_dealloc_count
)
3202 FOR_EACH_VEC_ELT_FROM (ctx
->global
->heap_vars
, i
, heap_var
,
3203 save_heap_alloc_count
)
3204 if (DECL_NAME (heap_var
) != heap_deleted_identifier
)
3211 /* Rewrite all occurrences of the function's RESULT_DECL with the
3212 current object under construction. */
3213 if (!*non_constant_p
&& ctx
->object
3214 && CLASS_TYPE_P (TREE_TYPE (res
))
3215 && !is_empty_class (TREE_TYPE (res
)))
3216 if (replace_decl (&result
, res
, ctx
->object
))
3219 /* Only cache a permitted result of a constant expression. */
3220 if (cacheable
&& !reduced_constant_expression_p (result
))
3224 /* Couldn't get a function copy to evaluate. */
3225 *non_constant_p
= true;
3227 if (result
== error_mark_node
)
3228 *non_constant_p
= true;
3229 if (*non_constant_p
|| *overflow_p
)
3230 result
= error_mark_node
;
3234 entry
->result
= cacheable
? result
: error_mark_node
;
3237 /* The result of a constexpr function must be completely initialized.
3239 However, in C++20, a constexpr constructor doesn't necessarily have
3240 to initialize all the fields, so we don't clear CONSTRUCTOR_NO_CLEARING
3241 in order to detect reading an unitialized object in constexpr instead
3242 of value-initializing it. (reduced_constant_expression_p is expected to
3243 take care of clearing the flag.) */
3244 if (TREE_CODE (result
) == CONSTRUCTOR
3245 && (cxx_dialect
< cxx20
3246 || !DECL_CONSTRUCTOR_P (fun
)))
3247 clear_no_implicit_zero (result
);
3249 pop_cx_call_context ();
3253 /* Return true if T is a valid constant initializer. If a CONSTRUCTOR
3254 initializes all the members, the CONSTRUCTOR_NO_CLEARING flag will be
3256 FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
3259 reduced_constant_expression_p (tree t
)
3264 switch (TREE_CODE (t
))
3267 /* Even if we can't lower this yet, it's constant. */
3271 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
3273 if (!AGGREGATE_TYPE_P (TREE_TYPE (t
)))
3274 /* A constant vector would be folded to VECTOR_CST.
3275 A CONSTRUCTOR of scalar type means uninitialized. */
3277 if (CONSTRUCTOR_NO_CLEARING (t
))
3279 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
3281 /* There must be a valid constant initializer at every array
3283 tree min
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (t
)));
3284 tree max
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (t
)));
3286 for (auto &e
: CONSTRUCTOR_ELTS (t
))
3288 if (!reduced_constant_expression_p (e
.value
))
3290 if (array_index_cmp (cursor
, e
.index
) != 0)
3292 if (TREE_CODE (e
.index
) == RANGE_EXPR
)
3293 cursor
= TREE_OPERAND (e
.index
, 1);
3294 cursor
= int_const_binop (PLUS_EXPR
, cursor
, size_one_node
);
3296 if (find_array_ctor_elt (t
, max
) == -1)
3300 else if (cxx_dialect
>= cxx20
3301 && TREE_CODE (TREE_TYPE (t
)) == UNION_TYPE
)
3303 if (CONSTRUCTOR_NELTS (t
) == 0)
3304 /* An initialized union has a constructor element. */
3306 /* And it only initializes one member. */
3310 field
= next_subobject_field (TYPE_FIELDS (TREE_TYPE (t
)));
3314 for (auto &e
: CONSTRUCTOR_ELTS (t
))
3316 /* If VAL is null, we're in the middle of initializing this
3318 if (!reduced_constant_expression_p (e
.value
))
3320 /* We want to remove initializers for empty fields in a struct to
3321 avoid confusing output_constructor. */
3322 if (is_empty_field (e
.index
)
3323 && TREE_CODE (TREE_TYPE (t
)) == RECORD_TYPE
)
3325 /* Check for non-empty fields between initialized fields when
3326 CONSTRUCTOR_NO_CLEARING. */
3327 for (; field
&& e
.index
!= field
;
3328 field
= next_subobject_field (DECL_CHAIN (field
)))
3329 if (!is_really_empty_class (TREE_TYPE (field
),
3330 /*ignore_vptr*/false))
3333 field
= next_subobject_field (DECL_CHAIN (field
));
3335 /* There could be a non-empty field at the end. */
3336 for (; field
; field
= next_subobject_field (DECL_CHAIN (field
)))
3337 if (!is_really_empty_class (TREE_TYPE (field
), /*ignore_vptr*/false))
3340 if (CONSTRUCTOR_NO_CLEARING (t
))
3341 /* All the fields are initialized. */
3342 CONSTRUCTOR_NO_CLEARING (t
) = false;
3346 /* FIXME are we calling this too much? */
3347 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
3351 /* Some expressions may have constant operands but are not constant
3352 themselves, such as 1/0. Call this function to check for that
3355 We only call this in places that require an arithmetic constant, not in
3356 places where we might have a non-constant expression that can be a
3357 component of a constant expression, such as the address of a constexpr
3358 variable that might be dereferenced later. */
3361 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
3364 if (!*non_constant_p
&& !reduced_constant_expression_p (t
)
3367 if (!allow_non_constant
)
3368 error ("%q+E is not a constant expression", t
);
3369 *non_constant_p
= true;
3371 if (TREE_OVERFLOW_P (t
))
3373 if (!allow_non_constant
)
3375 permerror (input_location
, "overflow in constant expression");
3376 /* If we're being permissive (and are in an enforcing
3377 context), ignore the overflow. */
3378 if (flag_permissive
)
3379 return *non_constant_p
;
3383 return *non_constant_p
;
3386 /* Check whether the shift operation with code CODE and type TYPE on LHS
3387 and RHS is undefined. If it is, give an error with an explanation,
3388 and return true; return false otherwise. */
3391 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
3392 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
3394 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
3395 || TREE_CODE (lhs
) != INTEGER_CST
3396 || TREE_CODE (rhs
) != INTEGER_CST
)
3399 tree lhstype
= TREE_TYPE (lhs
);
3400 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
3402 /* [expr.shift] The behavior is undefined if the right operand
3403 is negative, or greater than or equal to the length in bits
3404 of the promoted left operand. */
3405 if (tree_int_cst_sgn (rhs
) == -1)
3408 permerror (loc
, "right operand of shift expression %q+E is negative",
3409 build2_loc (loc
, code
, type
, lhs
, rhs
));
3410 return (!flag_permissive
|| ctx
->quiet
);
3412 if (compare_tree_int (rhs
, uprec
) >= 0)
3415 permerror (loc
, "right operand of shift expression %q+E is greater "
3416 "than or equal to the precision %wu of the left operand",
3417 build2_loc (loc
, code
, type
, lhs
, rhs
), uprec
);
3418 return (!flag_permissive
|| ctx
->quiet
);
3421 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
3422 if E1 has a signed type and non-negative value, and E1x2^E2 is
3423 representable in the corresponding unsigned type of the result type,
3424 then that value, converted to the result type, is the resulting value;
3425 otherwise, the behavior is undefined.
3427 The value of E1 << E2 is the unique value congruent to E1 x 2^E2 modulo
3428 2^N, where N is the range exponent of the type of the result. */
3429 if (code
== LSHIFT_EXPR
3430 && !TYPE_OVERFLOW_WRAPS (lhstype
)
3431 && cxx_dialect
>= cxx11
3432 && cxx_dialect
< cxx20
)
3434 if (tree_int_cst_sgn (lhs
) == -1)
3438 "left operand of shift expression %q+E is negative",
3439 build2_loc (loc
, code
, type
, lhs
, rhs
));
3440 return (!flag_permissive
|| ctx
->quiet
);
3442 /* For signed x << y the following:
3443 (unsigned) x >> ((prec (lhs) - 1) - y)
3444 if > 1, is undefined. The right-hand side of this formula
3445 is the highest bit of the LHS that can be set (starting from 0),
3446 so that the shift doesn't overflow. We then right-shift the LHS
3447 to see whether any other bit is set making the original shift
3448 undefined -- the result is not representable in the corresponding
3450 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
3451 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
3452 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
3453 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
3454 if (tree_int_cst_lt (integer_one_node
, t
))
3457 permerror (loc
, "shift expression %q+E overflows",
3458 build2_loc (loc
, code
, type
, lhs
, rhs
));
3459 return (!flag_permissive
|| ctx
->quiet
);
3465 /* Subroutine of cxx_eval_constant_expression.
3466 Attempt to reduce the unary expression tree T to a compile time value.
3467 If successful, return the value. Otherwise issue a diagnostic
3468 and return error_mark_node. */
3471 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
3473 bool *non_constant_p
, bool *overflow_p
)
3476 tree orig_arg
= TREE_OPERAND (t
, 0);
3477 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, vc_prvalue
,
3478 non_constant_p
, overflow_p
);
3479 VERIFY_CONSTANT (arg
);
3480 location_t loc
= EXPR_LOCATION (t
);
3481 enum tree_code code
= TREE_CODE (t
);
3482 tree type
= TREE_TYPE (t
);
3483 r
= fold_unary_loc (loc
, code
, type
, arg
);
3486 if (arg
== orig_arg
)
3489 r
= build1_loc (loc
, code
, type
, arg
);
3491 VERIFY_CONSTANT (r
);
3495 /* Helper function for cxx_eval_binary_expression. Try to optimize
3496 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
3497 generic folding should be used. */
3500 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
3501 tree lhs
, tree rhs
, bool *non_constant_p
,
3505 if (TREE_CODE (lhs
) != ADDR_EXPR
)
3508 lhs
= TREE_OPERAND (lhs
, 0);
3510 /* &A[i] p+ j => &A[i + j] */
3511 if (TREE_CODE (lhs
) == ARRAY_REF
3512 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
3513 && TREE_CODE (rhs
) == INTEGER_CST
3514 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
3515 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
3517 tree orig_type
= TREE_TYPE (t
);
3518 location_t loc
= EXPR_LOCATION (t
);
3519 tree type
= TREE_TYPE (lhs
);
3521 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
3522 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
3523 nelts
= cxx_eval_constant_expression (ctx
, nelts
, vc_prvalue
,
3524 non_constant_p
, overflow_p
);
3525 if (*non_constant_p
)
3527 /* Don't fold an out-of-bound access. */
3528 if (!tree_int_cst_le (t
, nelts
))
3530 rhs
= cp_fold_convert (ssizetype
, rhs
);
3531 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
3532 constexpr int A[1]; ... (char *)&A[0] + 1 */
3533 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
3534 rhs
, TYPE_SIZE_UNIT (type
))))
3536 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
3538 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
3539 TYPE_SIZE_UNIT (type
));
3540 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
3541 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
3542 t
, NULL_TREE
, NULL_TREE
);
3543 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
3544 t
= cp_fold_convert (orig_type
, t
);
3545 return cxx_eval_constant_expression (ctx
, t
, vc_prvalue
,
3546 non_constant_p
, overflow_p
);
3552 /* Try to fold expressions like
3553 (struct S *) (&a[0].D.2378 + 12)
3555 &MEM <struct T> [(void *)&a + 12B]
3556 This is something normally done by gimple_fold_stmt_to_constant_1
3557 on GIMPLE, but is undesirable on GENERIC if we are e.g. going to
3558 dereference the address because some details are lost.
3559 For pointer comparisons we want such folding though so that
3560 match.pd address_compare optimization works. */
3563 cxx_maybe_fold_addr_pointer_plus (tree t
)
3565 while (CONVERT_EXPR_P (t
)
3566 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 0))))
3567 t
= TREE_OPERAND (t
, 0);
3568 if (TREE_CODE (t
) != POINTER_PLUS_EXPR
)
3570 tree op0
= TREE_OPERAND (t
, 0);
3571 tree op1
= TREE_OPERAND (t
, 1);
3572 if (TREE_CODE (op1
) != INTEGER_CST
)
3574 while (CONVERT_EXPR_P (op0
)
3575 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3576 op0
= TREE_OPERAND (op0
, 0);
3577 if (TREE_CODE (op0
) != ADDR_EXPR
)
3579 op1
= fold_convert (ptr_type_node
, op1
);
3580 tree r
= fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (op0
)), op0
, op1
);
3581 return build1_loc (EXPR_LOCATION (t
), ADDR_EXPR
, TREE_TYPE (op0
), r
);
3584 /* Subroutine of cxx_eval_constant_expression.
3585 Like cxx_eval_unary_expression, except for binary expressions. */
3588 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
3590 bool *non_constant_p
, bool *overflow_p
)
3593 tree orig_lhs
= TREE_OPERAND (t
, 0);
3594 tree orig_rhs
= TREE_OPERAND (t
, 1);
3596 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, vc_prvalue
,
3597 non_constant_p
, overflow_p
);
3598 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
3600 if (*non_constant_p
)
3602 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, vc_prvalue
,
3603 non_constant_p
, overflow_p
);
3604 if (*non_constant_p
)
3607 location_t loc
= EXPR_LOCATION (t
);
3608 enum tree_code code
= TREE_CODE (t
);
3609 tree type
= TREE_TYPE (t
);
3611 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
3613 bool is_code_eq
= (code
== EQ_EXPR
);
3615 if (TREE_CODE (lhs
) == PTRMEM_CST
3616 && TREE_CODE (rhs
) == PTRMEM_CST
)
3618 tree lmem
= PTRMEM_CST_MEMBER (lhs
);
3619 tree rmem
= PTRMEM_CST_MEMBER (rhs
);
3621 if (TREE_CODE (lmem
) == TREE_CODE (rmem
)
3622 && TREE_CODE (lmem
) == FIELD_DECL
3623 && TREE_CODE (DECL_CONTEXT (lmem
)) == UNION_TYPE
3624 && same_type_p (DECL_CONTEXT (lmem
),
3625 DECL_CONTEXT (rmem
)))
3626 /* If both refer to (possibly different) members of the same union
3627 (12.3), they compare equal. */
3630 eq
= cp_tree_equal (lhs
, rhs
);
3631 r
= constant_boolean_node (eq
== is_code_eq
, type
);
3633 else if ((TREE_CODE (lhs
) == PTRMEM_CST
3634 || TREE_CODE (rhs
) == PTRMEM_CST
)
3635 && (null_member_pointer_value_p (lhs
)
3636 || null_member_pointer_value_p (rhs
)))
3637 r
= constant_boolean_node (!is_code_eq
, type
);
3638 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
3639 lhs
= cplus_expand_constant (lhs
);
3640 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
3641 rhs
= cplus_expand_constant (rhs
);
3644 && TREE_CODE_CLASS (code
) == tcc_comparison
3645 && POINTER_TYPE_P (TREE_TYPE (lhs
)))
3647 if (tree lhso
= cxx_maybe_fold_addr_pointer_plus (lhs
))
3648 lhs
= fold_convert (TREE_TYPE (lhs
), lhso
);
3649 if (tree rhso
= cxx_maybe_fold_addr_pointer_plus (rhs
))
3650 rhs
= fold_convert (TREE_TYPE (rhs
), rhso
);
3652 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
3653 && integer_zerop (lhs
) && !integer_zerop (rhs
))
3656 error ("arithmetic involving a null pointer in %qE", lhs
);
3657 *non_constant_p
= true;
3660 else if (code
== POINTER_PLUS_EXPR
)
3661 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
3663 else if (code
== SPACESHIP_EXPR
)
3665 r
= genericize_spaceship (loc
, type
, lhs
, rhs
);
3666 return cxx_eval_constant_expression (ctx
, r
, lval
, non_constant_p
,
3672 if (ctx
->manifestly_const_eval
== mce_true
3673 && (flag_constexpr_fp_except
3674 || TREE_CODE (type
) != REAL_TYPE
))
3676 auto ofcc
= make_temp_override (folding_cxx_constexpr
, true);
3677 r
= fold_binary_initializer_loc (loc
, code
, type
, lhs
, rhs
);
3680 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
3684 && (code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
3685 && TREE_CODE (lhs
) == INTEGER_CST
3686 && TREE_CODE (rhs
) == INTEGER_CST
3687 && wi::neg_p (wi::to_wide (rhs
)))
3689 /* For diagnostics and -fpermissive emulate previous behavior of
3690 handling shifts by negative amount. */
3691 tree nrhs
= const_unop (NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
3693 r
= fold_binary_loc (loc
,
3694 code
== LSHIFT_EXPR
? RSHIFT_EXPR
: LSHIFT_EXPR
,
3700 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
3703 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
3705 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
3706 *non_constant_p
= true;
3707 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3708 a local array in a constexpr function. */
3709 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (lhs
));
3711 VERIFY_CONSTANT (r
);
3715 /* Subroutine of cxx_eval_constant_expression.
3716 Attempt to evaluate condition expressions. Dead branches are not
3720 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
3722 bool *non_constant_p
, bool *overflow_p
,
3725 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3727 non_constant_p
, overflow_p
);
3728 VERIFY_CONSTANT (val
);
3729 if (TREE_CODE (t
) == IF_STMT
&& IF_STMT_CONSTEVAL_P (t
))
3731 /* Evaluate the condition as if it was
3732 if (__builtin_is_constant_evaluated ()), i.e. defer it if not
3733 ctx->manifestly_const_eval (as sometimes we try to constant evaluate
3734 without manifestly_const_eval even expressions or parts thereof which
3735 will later be manifestly const_eval evaluated), otherwise fold it to
3737 if (ctx
->manifestly_const_eval
== mce_unknown
)
3739 *non_constant_p
= true;
3742 val
= constant_boolean_node (ctx
->manifestly_const_eval
== mce_true
,
3745 /* Don't VERIFY_CONSTANT the other operands. */
3746 if (integer_zerop (val
))
3747 val
= TREE_OPERAND (t
, 2);
3749 val
= TREE_OPERAND (t
, 1);
3750 if (TREE_CODE (t
) == IF_STMT
&& !val
)
3752 /* A TARGET_EXPR may be nested inside another TARGET_EXPR, but still
3753 serve as the initializer for the same object as the outer TARGET_EXPR,
3755 A a = true ? A{} : A{};
3756 so strip the inner TARGET_EXPR so we don't materialize a temporary. */
3757 if (TREE_CODE (val
) == TARGET_EXPR
)
3758 val
= TARGET_EXPR_INITIAL (val
);
3759 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
3760 overflow_p
, jump_target
);
3763 /* Subroutine of cxx_eval_constant_expression.
3764 Attempt to evaluate vector condition expressions. Unlike
3765 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
3766 ternary arithmetics operation, where all 3 arguments have to be
3767 evaluated as constants and then folding computes the result from
3771 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
3772 bool *non_constant_p
, bool *overflow_p
)
3774 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3776 non_constant_p
, overflow_p
);
3777 VERIFY_CONSTANT (arg1
);
3778 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3780 non_constant_p
, overflow_p
);
3781 VERIFY_CONSTANT (arg2
);
3782 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
3784 non_constant_p
, overflow_p
);
3785 VERIFY_CONSTANT (arg3
);
3786 location_t loc
= EXPR_LOCATION (t
);
3787 tree type
= TREE_TYPE (t
);
3788 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
3791 if (arg1
== TREE_OPERAND (t
, 0)
3792 && arg2
== TREE_OPERAND (t
, 1)
3793 && arg3
== TREE_OPERAND (t
, 2))
3796 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
3798 VERIFY_CONSTANT (r
);
3802 /* Returns less than, equal to, or greater than zero if KEY is found to be
3803 less than, to match, or to be greater than the constructor_elt's INDEX. */
3806 array_index_cmp (tree key
, tree index
)
3808 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
3810 switch (TREE_CODE (index
))
3813 return tree_int_cst_compare (key
, index
);
3816 tree lo
= TREE_OPERAND (index
, 0);
3817 tree hi
= TREE_OPERAND (index
, 1);
3818 if (tree_int_cst_lt (key
, lo
))
3820 else if (tree_int_cst_lt (hi
, key
))
3830 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
3831 if none. If INSERT is true, insert a matching element rather than fail. */
3833 static HOST_WIDE_INT
3834 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
)
3836 if (tree_int_cst_sgn (dindex
) < 0)
3839 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
3840 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
3841 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
3843 unsigned HOST_WIDE_INT end
= len
;
3844 unsigned HOST_WIDE_INT begin
= 0;
3846 /* If the last element of the CONSTRUCTOR has its own index, we can assume
3847 that the same is true of the other elements and index directly. */
3850 tree cindex
= (*elts
)[end
- 1].index
;
3851 if (cindex
== NULL_TREE
)
3853 /* Verify that if the last index is missing, all indexes
3856 for (unsigned int j
= 0; j
< len
- 1; ++j
)
3857 gcc_assert ((*elts
)[j
].index
== NULL_TREE
);
3864 /* If the element is to be added right at the end,
3865 make sure it is added with cleared index too. */
3868 /* Otherwise, in order not to break the assumption
3869 that CONSTRUCTOR either has all indexes or none,
3870 we need to add indexes to all elements. */
3871 for (unsigned int j
= 0; j
< len
; ++j
)
3872 (*elts
)[j
].index
= build_int_cst (TREE_TYPE (dindex
), j
);
3875 else if (TREE_CODE (cindex
) == INTEGER_CST
3876 && compare_tree_int (cindex
, end
- 1) == 0)
3885 /* Otherwise, find a matching index by means of a binary search. */
3886 while (begin
!= end
)
3888 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
3889 constructor_elt
&elt
= (*elts
)[middle
];
3890 tree idx
= elt
.index
;
3892 int cmp
= array_index_cmp (dindex
, idx
);
3899 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
3901 /* We need to split the range. */
3903 tree lo
= TREE_OPERAND (idx
, 0);
3904 tree hi
= TREE_OPERAND (idx
, 1);
3905 tree value
= elt
.value
;
3906 dindex
= fold_convert (sizetype
, dindex
);
3907 if (tree_int_cst_lt (lo
, dindex
))
3909 /* There are still some lower elts; shorten the range. */
3910 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
3912 if (tree_int_cst_equal (lo
, new_hi
))
3913 /* Only one element left, no longer a range. */
3916 TREE_OPERAND (idx
, 1) = new_hi
;
3917 /* Append the element we want to insert. */
3920 e
.value
= unshare_constructor (value
);
3921 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
3924 /* No lower elts, the range elt is now ours. */
3927 if (tree_int_cst_lt (dindex
, hi
))
3929 /* There are still some higher elts; append a range. */
3930 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
3932 if (tree_int_cst_equal (new_lo
, hi
))
3935 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
3936 e
.value
= unshare_constructor (value
);
3937 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
3946 constructor_elt e
= { dindex
, NULL_TREE
};
3947 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
3954 /* Return a pointer to the constructor_elt of CTOR which matches INDEX. If no
3955 matching constructor_elt exists, then add one to CTOR.
3957 As an optimization, if POS_HINT is non-negative then it is used as a guess
3958 for the (integer) index of the matching constructor_elt within CTOR. */
3960 static constructor_elt
*
3961 get_or_insert_ctor_field (tree ctor
, tree index
, int pos_hint
= -1)
3963 /* Check the hint first. */
3964 if (pos_hint
>= 0 && (unsigned)pos_hint
< CONSTRUCTOR_NELTS (ctor
)
3965 && CONSTRUCTOR_ELT (ctor
, pos_hint
)->index
== index
)
3966 return CONSTRUCTOR_ELT (ctor
, pos_hint
);
3968 tree type
= TREE_TYPE (ctor
);
3969 if (TREE_CODE (type
) == VECTOR_TYPE
&& index
== NULL_TREE
)
3971 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (ctor
), index
, NULL_TREE
);
3972 return &CONSTRUCTOR_ELTS (ctor
)->last();
3974 else if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
3976 if (TREE_CODE (index
) == RANGE_EXPR
)
3978 /* Support for RANGE_EXPR index lookups is currently limited to
3979 accessing an existing element via POS_HINT, or appending a new
3980 element to the end of CTOR. ??? Support for other access
3981 patterns may also be needed. */
3982 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
3983 if (vec_safe_length (elts
))
3985 tree lo
= TREE_OPERAND (index
, 0);
3986 gcc_assert (array_index_cmp (elts
->last().index
, lo
) < 0);
3988 CONSTRUCTOR_APPEND_ELT (elts
, index
, NULL_TREE
);
3989 return &elts
->last();
3992 HOST_WIDE_INT i
= find_array_ctor_elt (ctor
, index
, /*insert*/true);
3993 gcc_assert (i
>= 0);
3994 constructor_elt
*cep
= CONSTRUCTOR_ELT (ctor
, i
);
3995 gcc_assert (cep
->index
== NULL_TREE
3996 || TREE_CODE (cep
->index
) != RANGE_EXPR
);
4001 gcc_assert (TREE_CODE (index
) == FIELD_DECL
4002 && (same_type_ignoring_top_level_qualifiers_p
4003 (DECL_CONTEXT (index
), TREE_TYPE (ctor
))));
4005 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
4006 Usually we meet initializers in that order, but it is
4007 possible for base types to be placed not in program
4009 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
4010 unsigned HOST_WIDE_INT idx
= 0;
4011 constructor_elt
*cep
= NULL
;
4013 /* Check if we're changing the active member of a union. */
4014 if (TREE_CODE (type
) == UNION_TYPE
&& CONSTRUCTOR_NELTS (ctor
)
4015 && CONSTRUCTOR_ELT (ctor
, 0)->index
!= index
)
4016 vec_safe_truncate (CONSTRUCTOR_ELTS (ctor
), 0);
4017 /* If the bit offset of INDEX is larger than that of the last
4018 constructor_elt, then we can just immediately append a new
4019 constructor_elt to the end of CTOR. */
4020 else if (CONSTRUCTOR_NELTS (ctor
)
4021 && tree_int_cst_compare (bit_position (index
),
4022 bit_position (CONSTRUCTOR_ELTS (ctor
)
4023 ->last().index
)) > 0)
4025 idx
= CONSTRUCTOR_NELTS (ctor
);
4029 /* Otherwise, we need to iterate over CTOR to find or insert INDEX
4032 for (; vec_safe_iterate (CONSTRUCTOR_ELTS (ctor
), idx
, &cep
);
4033 idx
++, fields
= DECL_CHAIN (fields
))
4035 if (index
== cep
->index
)
4038 /* The field we're initializing must be on the field
4039 list. Look to see if it is present before the
4040 field the current ELT initializes. */
4041 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
4042 if (index
== fields
)
4045 /* We fell off the end of the CONSTRUCTOR, so insert a new
4046 entry at the end. */
4050 constructor_elt ce
= { index
, NULL_TREE
};
4052 vec_safe_insert (CONSTRUCTOR_ELTS (ctor
), idx
, ce
);
4053 cep
= CONSTRUCTOR_ELT (ctor
, idx
);
4061 /* Under the control of CTX, issue a detailed diagnostic for
4062 an out-of-bounds subscript INDEX into the expression ARRAY. */
4065 diag_array_subscript (location_t loc
, const constexpr_ctx
*ctx
, tree array
, tree index
)
4069 tree arraytype
= TREE_TYPE (array
);
4071 /* Convert the unsigned array subscript to a signed integer to avoid
4072 printing huge numbers for small negative values. */
4073 tree sidx
= fold_convert (ssizetype
, index
);
4074 STRIP_ANY_LOCATION_WRAPPER (array
);
4077 if (TYPE_DOMAIN (arraytype
))
4078 error_at (loc
, "array subscript value %qE is outside the bounds "
4079 "of array %qD of type %qT", sidx
, array
, arraytype
);
4081 error_at (loc
, "nonzero array subscript %qE is used with array %qD of "
4082 "type %qT with unknown bounds", sidx
, array
, arraytype
);
4083 inform (DECL_SOURCE_LOCATION (array
), "declared here");
4085 else if (TYPE_DOMAIN (arraytype
))
4086 error_at (loc
, "array subscript value %qE is outside the bounds "
4087 "of array type %qT", sidx
, arraytype
);
4089 error_at (loc
, "nonzero array subscript %qE is used with array of type %qT "
4090 "with unknown bounds", sidx
, arraytype
);
4094 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
4098 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
4099 bool *non_constant_p
, bool *overflow_p
)
4102 if (TREE_CODE (type
) == ARRAY_TYPE
)
4104 if (TYPE_DOMAIN (type
))
4105 nelts
= array_type_nelts_top (type
);
4107 nelts
= size_zero_node
;
4109 else if (VECTOR_TYPE_P (type
))
4110 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
4114 /* For VLAs, the number of elements won't be an integer constant. */
4115 nelts
= cxx_eval_constant_expression (ctx
, nelts
, vc_prvalue
,
4116 non_constant_p
, overflow_p
);
4120 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
4121 STRING_CST STRING. */
4124 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
4126 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
4129 if (chars_per_elt
== 1)
4130 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
4133 const unsigned char *ptr
4134 = ((const unsigned char *)TREE_STRING_POINTER (string
)
4135 + index
* chars_per_elt
);
4136 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
4141 /* Subroutine of cxx_eval_array_reference. T is an ARRAY_REF; evaluate the
4142 subscript, diagnose any problems with it, and return the result. */
4145 eval_and_check_array_index (const constexpr_ctx
*ctx
,
4146 tree t
, bool allow_one_past
,
4147 bool *non_constant_p
, bool *overflow_p
)
4149 location_t loc
= cp_expr_loc_or_input_loc (t
);
4150 tree ary
= TREE_OPERAND (t
, 0);
4151 t
= TREE_OPERAND (t
, 1);
4152 tree index
= cxx_eval_constant_expression (ctx
, t
, vc_prvalue
,
4153 non_constant_p
, overflow_p
);
4154 VERIFY_CONSTANT (index
);
4156 if (!tree_fits_shwi_p (index
)
4157 || tree_int_cst_sgn (index
) < 0)
4159 diag_array_subscript (loc
, ctx
, ary
, index
);
4160 *non_constant_p
= true;
4164 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
4166 VERIFY_CONSTANT (nelts
);
4168 ? !tree_int_cst_le (index
, nelts
)
4169 : !tree_int_cst_lt (index
, nelts
))
4171 diag_array_subscript (loc
, ctx
, ary
, index
);
4172 *non_constant_p
= true;
4179 /* Subroutine of cxx_eval_constant_expression.
4180 Attempt to reduce a reference to an array slot. */
4183 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
4185 bool *non_constant_p
, bool *overflow_p
)
4187 tree oldary
= TREE_OPERAND (t
, 0);
4188 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
4190 non_constant_p
, overflow_p
);
4191 if (*non_constant_p
)
4194 && TREE_CODE (ary
) == VIEW_CONVERT_EXPR
4195 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
4196 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
4197 ary
= TREE_OPERAND (ary
, 0);
4199 tree oldidx
= TREE_OPERAND (t
, 1);
4200 tree index
= eval_and_check_array_index (ctx
, t
, lval
,
4201 non_constant_p
, overflow_p
);
4202 if (*non_constant_p
)
4205 if (lval
&& ary
== oldary
&& index
== oldidx
)
4207 else if (lval
== vc_discard
)
4210 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
4212 unsigned len
= 0, elem_nchars
= 1;
4213 tree elem_type
= TREE_TYPE (TREE_TYPE (ary
));
4214 if (TREE_CODE (ary
) == CONSTRUCTOR
)
4215 len
= CONSTRUCTOR_NELTS (ary
);
4216 else if (TREE_CODE (ary
) == STRING_CST
)
4218 elem_nchars
= (TYPE_PRECISION (elem_type
)
4219 / TYPE_PRECISION (char_type_node
));
4220 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
4222 else if (TREE_CODE (ary
) == VECTOR_CST
)
4223 /* We don't create variable-length VECTOR_CSTs. */
4224 len
= VECTOR_CST_NELTS (ary
).to_constant ();
4227 /* We can't do anything with other tree codes, so use
4228 VERIFY_CONSTANT to complain and fail. */
4229 VERIFY_CONSTANT (ary
);
4234 HOST_WIDE_INT i
= 0;
4235 if (TREE_CODE (ary
) == CONSTRUCTOR
)
4237 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
4244 i
= tree_to_shwi (index
);
4251 if (TREE_CODE (ary
) == CONSTRUCTOR
)
4252 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
4253 else if (TREE_CODE (ary
) == VECTOR_CST
)
4254 r
= VECTOR_CST_ELT (ary
, i
);
4256 r
= extract_string_elt (ary
, elem_nchars
, i
);
4259 /* Don't VERIFY_CONSTANT here. */
4262 /* Otherwise the element doesn't have a value yet. */
4267 if (TREE_CODE (ary
) == CONSTRUCTOR
4268 && CONSTRUCTOR_NO_CLEARING (ary
))
4270 /* 'ary' is part of the aggregate initializer we're currently
4271 building; if there's no initializer for this element yet,
4274 error ("accessing uninitialized array element");
4275 *non_constant_p
= true;
4279 /* If it's within the array bounds but doesn't have an explicit
4280 initializer, it's initialized from {}. But use build_value_init
4281 directly for non-aggregates to avoid creating a garbage CONSTRUCTOR. */
4283 constexpr_ctx new_ctx
;
4284 if (is_really_empty_class (elem_type
, /*ignore_vptr*/false))
4285 return build_constructor (elem_type
, NULL
);
4286 else if (CP_AGGREGATE_TYPE_P (elem_type
))
4288 tree empty_ctor
= build_constructor (init_list_type_node
, NULL
);
4289 val
= digest_init (elem_type
, empty_ctor
, tf_warning_or_error
);
4292 val
= build_value_init (elem_type
, tf_warning_or_error
);
4294 if (!SCALAR_TYPE_P (elem_type
))
4297 new_ctx
.ctor
= build_constructor (elem_type
, NULL
);
4300 t
= cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
4302 if (!SCALAR_TYPE_P (elem_type
) && t
!= ctx
->ctor
)
4303 free_constructor (ctx
->ctor
);
4307 /* Subroutine of cxx_eval_constant_expression.
4308 Attempt to reduce a field access of a value of class type. */
4311 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
4313 bool *non_constant_p
, bool *overflow_p
)
4315 unsigned HOST_WIDE_INT i
;
4318 tree part
= TREE_OPERAND (t
, 1);
4319 tree orig_whole
= TREE_OPERAND (t
, 0);
4320 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
4322 non_constant_p
, overflow_p
);
4323 if (*non_constant_p
)
4325 if (INDIRECT_REF_P (whole
)
4326 && integer_zerop (TREE_OPERAND (whole
, 0)))
4329 error ("dereferencing a null pointer in %qE", orig_whole
);
4330 *non_constant_p
= true;
4334 if (TREE_CODE (whole
) == PTRMEM_CST
)
4335 whole
= cplus_expand_constant (whole
);
4336 if (whole
== orig_whole
)
4338 if (lval
== vc_discard
)
4341 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
4342 whole
, part
, NULL_TREE
);
4343 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
4345 if (TREE_CODE (whole
) != CONSTRUCTOR
)
4348 error ("%qE is not a constant expression", orig_whole
);
4349 *non_constant_p
= true;
4352 if ((cxx_dialect
< cxx14
|| CONSTRUCTOR_MUTABLE_POISON (whole
))
4353 && DECL_MUTABLE_P (part
))
4356 error ("mutable %qD is not usable in a constant expression", part
);
4357 *non_constant_p
= true;
4360 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
4361 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
4363 /* Use name match for PMF fields, as a variant will have a
4364 different FIELD_DECL with a different type. */
4365 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
4370 STRIP_ANY_LOCATION_WRAPPER (value
);
4374 /* We're in the middle of initializing it. */
4378 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
4379 && CONSTRUCTOR_NELTS (whole
) > 0)
4381 /* DR 1188 says we don't have to deal with this. */
4384 constructor_elt
*cep
= CONSTRUCTOR_ELT (whole
, 0);
4385 if (cep
->value
== NULL_TREE
)
4386 error ("accessing uninitialized member %qD", part
);
4388 error ("accessing %qD member instead of initialized %qD member in "
4389 "constant expression", part
, cep
->index
);
4391 *non_constant_p
= true;
4395 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
4396 classes never get represented; throw together a value now. */
4397 if (is_really_empty_class (TREE_TYPE (t
), /*ignore_vptr*/false))
4398 return build_constructor (TREE_TYPE (t
), NULL
);
4400 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
4402 if (CONSTRUCTOR_NO_CLEARING (whole
))
4404 /* 'whole' is part of the aggregate initializer we're currently
4405 building; if there's no initializer for this member yet, that's an
4408 error ("accessing uninitialized member %qD", part
);
4409 *non_constant_p
= true;
4413 /* If there's no explicit init for this field, it's value-initialized. */
4414 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
4415 return cxx_eval_constant_expression (ctx
, value
,
4417 non_constant_p
, overflow_p
);
4420 /* Subroutine of cxx_eval_constant_expression.
4421 Attempt to reduce a field access of a value of class type that is
4422 expressed as a BIT_FIELD_REF. */
4425 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
4427 bool *non_constant_p
, bool *overflow_p
)
4429 tree orig_whole
= TREE_OPERAND (t
, 0);
4430 tree retval
, fldval
, utype
, mask
;
4431 bool fld_seen
= false;
4432 HOST_WIDE_INT istart
, isize
;
4433 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
4435 non_constant_p
, overflow_p
);
4436 tree start
, field
, value
;
4437 unsigned HOST_WIDE_INT i
;
4439 if (whole
== orig_whole
)
4441 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
4443 if (!*non_constant_p
4444 && TREE_CODE (whole
) != VECTOR_CST
4445 && TREE_CODE (whole
) != CONSTRUCTOR
)
4448 error ("%qE is not a constant expression", orig_whole
);
4449 *non_constant_p
= true;
4451 if (*non_constant_p
)
4454 if (TREE_CODE (whole
) == VECTOR_CST
|| !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4456 if (tree r
= fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
4457 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2)))
4460 error ("%qE is not a constant expression", orig_whole
);
4461 *non_constant_p
= true;
4465 start
= TREE_OPERAND (t
, 2);
4466 istart
= tree_to_shwi (start
);
4467 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
4468 utype
= TREE_TYPE (t
);
4469 if (!TYPE_UNSIGNED (utype
))
4470 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
4471 retval
= build_int_cst (utype
, 0);
4472 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
4474 tree bitpos
= bit_position (field
);
4475 STRIP_ANY_LOCATION_WRAPPER (value
);
4476 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
4478 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
4479 && TREE_CODE (value
) == INTEGER_CST
4480 && tree_fits_shwi_p (bitpos
)
4481 && tree_fits_shwi_p (DECL_SIZE (field
)))
4483 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
4484 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
4485 HOST_WIDE_INT shift
;
4486 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
4488 fldval
= fold_convert (utype
, value
);
4489 mask
= build_int_cst_type (utype
, -1);
4490 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
4491 size_int (TYPE_PRECISION (utype
) - sz
));
4492 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
4493 size_int (TYPE_PRECISION (utype
) - sz
));
4494 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
4495 shift
= bit
- istart
;
4496 if (BYTES_BIG_ENDIAN
)
4497 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
4498 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
4500 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
4506 return fold_convert (TREE_TYPE (t
), retval
);
4508 return error_mark_node
;
4511 /* Helper for cxx_eval_bit_cast.
4512 Check [bit.cast]/3 rules, bit_cast is constexpr only if the To and From
4513 types and types of all subobjects have is_union_v<T>, is_pointer_v<T>,
4514 is_member_pointer_v<T>, is_volatile_v<T> false and has no non-static
4515 data members of reference type. */
4518 check_bit_cast_type (const constexpr_ctx
*ctx
, location_t loc
, tree type
,
4521 if (TREE_CODE (type
) == UNION_TYPE
)
4525 if (type
== orig_type
)
4526 error_at (loc
, "%qs is not a constant expression because %qT is "
4527 "a union type", "__builtin_bit_cast", type
);
4529 error_at (loc
, "%qs is not a constant expression because %qT "
4530 "contains a union type", "__builtin_bit_cast",
4535 if (TREE_CODE (type
) == POINTER_TYPE
)
4539 if (type
== orig_type
)
4540 error_at (loc
, "%qs is not a constant expression because %qT is "
4541 "a pointer type", "__builtin_bit_cast", type
);
4543 error_at (loc
, "%qs is not a constant expression because %qT "
4544 "contains a pointer type", "__builtin_bit_cast",
4549 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4553 if (type
== orig_type
)
4554 error_at (loc
, "%qs is not a constant expression because %qT is "
4555 "a reference type", "__builtin_bit_cast", type
);
4557 error_at (loc
, "%qs is not a constant expression because %qT "
4558 "contains a reference type", "__builtin_bit_cast",
4563 if (TYPE_PTRMEM_P (type
))
4567 if (type
== orig_type
)
4568 error_at (loc
, "%qs is not a constant expression because %qT is "
4569 "a pointer to member type", "__builtin_bit_cast",
4572 error_at (loc
, "%qs is not a constant expression because %qT "
4573 "contains a pointer to member type",
4574 "__builtin_bit_cast", orig_type
);
4578 if (TYPE_VOLATILE (type
))
4582 if (type
== orig_type
)
4583 error_at (loc
, "%qs is not a constant expression because %qT is "
4584 "volatile", "__builtin_bit_cast", type
);
4586 error_at (loc
, "%qs is not a constant expression because %qT "
4587 "contains a volatile subobject",
4588 "__builtin_bit_cast", orig_type
);
4592 if (TREE_CODE (type
) == RECORD_TYPE
)
4593 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
4594 if (TREE_CODE (field
) == FIELD_DECL
4595 && check_bit_cast_type (ctx
, loc
, TREE_TYPE (field
), orig_type
))
4600 /* Helper function for cxx_eval_bit_cast. For unsigned char or
4601 std::byte members of CONSTRUCTOR (recursively) if they contain
4602 some indeterminate bits (as set in MASK), remove the ctor elts,
4603 mark the CONSTRUCTOR as CONSTRUCTOR_NO_CLEARING and clear the
4607 clear_uchar_or_std_byte_in_mask (location_t loc
, tree t
, unsigned char *mask
)
4609 if (TREE_CODE (t
) != CONSTRUCTOR
)
4614 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
4616 tree type
= TREE_TYPE (value
);
4617 if (TREE_CODE (TREE_TYPE (t
)) != ARRAY_TYPE
4618 && DECL_BIT_FIELD_TYPE (index
) != NULL_TREE
)
4620 if (is_byte_access_type_not_plain_char (DECL_BIT_FIELD_TYPE (index
)))
4622 HOST_WIDE_INT fldsz
= TYPE_PRECISION (TREE_TYPE (index
));
4623 gcc_assert (fldsz
!= 0);
4624 HOST_WIDE_INT pos
= int_byte_position (index
);
4626 = tree_to_uhwi (DECL_FIELD_BIT_OFFSET (index
));
4627 bpos
%= BITS_PER_UNIT
;
4629 = ROUND_UP (bpos
+ fldsz
, BITS_PER_UNIT
) / BITS_PER_UNIT
;
4630 gcc_assert (end
== 1 || end
== 2);
4631 unsigned char *p
= mask
+ pos
;
4632 unsigned char mask_save
[2];
4633 mask_save
[0] = mask
[pos
];
4634 mask_save
[1] = end
== 2 ? mask
[pos
+ 1] : 0;
4635 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
)
4636 sorry_at (loc
, "PDP11 bit-field handling unsupported"
4637 " in %qs", "__builtin_bit_cast");
4638 else if (BYTES_BIG_ENDIAN
)
4641 if (bpos
+ fldsz
<= BITS_PER_UNIT
)
4642 *p
&= ~(((1 << fldsz
) - 1)
4643 << (BITS_PER_UNIT
- bpos
- fldsz
));
4647 *p
&= ~(((1U << BITS_PER_UNIT
) - 1) >> bpos
);
4649 fldsz
-= BITS_PER_UNIT
- bpos
;
4650 gcc_assert (fldsz
&& fldsz
< BITS_PER_UNIT
);
4651 *p
&= ((1U << BITS_PER_UNIT
) - 1) >> fldsz
;
4656 /* Little endian. */
4657 if (bpos
+ fldsz
<= BITS_PER_UNIT
)
4658 *p
&= ~(((1 << fldsz
) - 1) << bpos
);
4662 *p
&= ~(((1 << BITS_PER_UNIT
) - 1) << bpos
);
4664 fldsz
-= BITS_PER_UNIT
- bpos
;
4665 gcc_assert (fldsz
&& fldsz
< BITS_PER_UNIT
);
4666 *p
&= ~((1 << fldsz
) - 1);
4669 if (mask_save
[0] != mask
[pos
]
4670 || (end
== 2 && mask_save
[1] != mask
[pos
+ 1]))
4672 CONSTRUCTOR_NO_CLEARING (t
) = 1;
4677 else if (is_byte_access_type_not_plain_char (type
))
4680 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
4681 pos
= tree_to_shwi (index
);
4683 pos
= int_byte_position (index
);
4686 CONSTRUCTOR_NO_CLEARING (t
) = 1;
4691 if (TREE_CODE (value
) == CONSTRUCTOR
)
4694 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
4695 pos
= tree_to_shwi (index
)
4696 * tree_to_shwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t
))));
4698 pos
= int_byte_position (index
);
4699 clear_uchar_or_std_byte_in_mask (loc
, value
, mask
+ pos
);
4703 CONSTRUCTOR_ELT (t
, j
)->index
= index
;
4704 CONSTRUCTOR_ELT (t
, j
)->value
= value
;
4708 if (CONSTRUCTOR_NELTS (t
) != j
)
4709 vec_safe_truncate (CONSTRUCTOR_ELTS (t
), j
);
4712 /* Subroutine of cxx_eval_constant_expression.
4713 Attempt to evaluate a BIT_CAST_EXPR. */
4716 cxx_eval_bit_cast (const constexpr_ctx
*ctx
, tree t
, bool *non_constant_p
,
4719 if (check_bit_cast_type (ctx
, EXPR_LOCATION (t
), TREE_TYPE (t
),
4721 || check_bit_cast_type (ctx
, cp_expr_loc_or_loc (TREE_OPERAND (t
, 0),
4723 TREE_TYPE (TREE_OPERAND (t
, 0)),
4724 TREE_TYPE (TREE_OPERAND (t
, 0))))
4726 *non_constant_p
= true;
4730 tree op
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), vc_prvalue
,
4731 non_constant_p
, overflow_p
);
4732 if (*non_constant_p
)
4735 location_t loc
= EXPR_LOCATION (t
);
4736 if (BITS_PER_UNIT
!= 8 || CHAR_BIT
!= 8)
4739 sorry_at (loc
, "%qs cannot be constant evaluated on the target",
4740 "__builtin_bit_cast");
4741 *non_constant_p
= true;
4745 if (!tree_fits_shwi_p (TYPE_SIZE_UNIT (TREE_TYPE (t
))))
4748 sorry_at (loc
, "%qs cannot be constant evaluated because the "
4749 "type is too large", "__builtin_bit_cast");
4750 *non_constant_p
= true;
4754 HOST_WIDE_INT len
= tree_to_shwi (TYPE_SIZE_UNIT (TREE_TYPE (t
)));
4755 if (len
< 0 || (int) len
!= len
)
4758 sorry_at (loc
, "%qs cannot be constant evaluated because the "
4759 "type is too large", "__builtin_bit_cast");
4760 *non_constant_p
= true;
4764 unsigned char buf
[64];
4765 unsigned char *ptr
, *mask
;
4766 size_t alen
= (size_t) len
* 2;
4767 if (alen
<= sizeof (buf
))
4770 ptr
= XNEWVEC (unsigned char, alen
);
4771 mask
= ptr
+ (size_t) len
;
4772 /* At the beginning consider everything indeterminate. */
4773 memset (mask
, ~0, (size_t) len
);
4775 if (native_encode_initializer (op
, ptr
, len
, 0, mask
) != len
)
4778 sorry_at (loc
, "%qs cannot be constant evaluated because the "
4779 "argument cannot be encoded", "__builtin_bit_cast");
4780 *non_constant_p
= true;
4787 if (can_native_interpret_type_p (TREE_TYPE (t
)))
4789 r
= native_interpret_expr (TREE_TYPE (t
), ptr
, len
);
4790 if (is_byte_access_type_not_plain_char (TREE_TYPE (t
)))
4792 gcc_assert (len
== 1);
4795 memset (mask
, 0, len
);
4796 r
= build_constructor (TREE_TYPE (r
), NULL
);
4797 CONSTRUCTOR_NO_CLEARING (r
) = 1;
4801 else if (TREE_CODE (TREE_TYPE (t
)) == RECORD_TYPE
)
4803 r
= native_interpret_aggregate (TREE_TYPE (t
), ptr
, 0, len
);
4806 clear_type_padding_in_mask (TREE_TYPE (t
), mask
);
4807 clear_uchar_or_std_byte_in_mask (loc
, r
, mask
);
4810 tree e
= cxx_eval_bare_aggregate (ctx
, r
, vc_prvalue
,
4811 non_constant_p
, overflow_p
);
4812 gcc_checking_assert (e
== r
);
4820 for (int i
= 0; i
< len
; i
++)
4824 error_at (loc
, "%qs accessing uninitialized byte at offset %d",
4825 "__builtin_bit_cast", i
);
4826 *non_constant_p
= true;
4836 sorry_at (loc
, "%qs cannot be constant evaluated because the "
4837 "argument cannot be interpreted", "__builtin_bit_cast");
4838 *non_constant_p
= true;
4844 /* Subroutine of cxx_eval_constant_expression.
4845 Evaluate a short-circuited logical expression T in the context
4846 of a given constexpr CALL. BAILOUT_VALUE is the value for
4847 early return. CONTINUE_VALUE is used here purely for
4848 sanity check purposes. */
4851 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
4852 tree bailout_value
, tree continue_value
,
4853 bool *non_constant_p
, bool *overflow_p
)
4856 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4857 vc_prvalue
, non_constant_p
,
4859 VERIFY_CONSTANT (lhs
);
4860 if (tree_int_cst_equal (lhs
, bailout_value
))
4862 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
4863 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4864 vc_prvalue
, non_constant_p
,
4866 VERIFY_CONSTANT (r
);
4870 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
4871 CONSTRUCTOR elements to initialize (part of) an object containing that
4872 field. Return a pointer to the constructor_elt corresponding to the
4873 initialization of the field. */
4875 static constructor_elt
*
4876 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
4878 tree aggr
= TREE_OPERAND (ref
, 0);
4879 tree field
= TREE_OPERAND (ref
, 1);
4881 constructor_elt
*ce
;
4883 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
4885 if (TREE_CODE (aggr
) == COMPONENT_REF
)
4887 constructor_elt
*base_ce
4888 = base_field_constructor_elt (v
, aggr
);
4889 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
4892 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4893 if (ce
->index
== field
)
4900 /* Some of the expressions fed to the constexpr mechanism are calls to
4901 constructors, which have type void. In that case, return the type being
4902 initialized by the constructor. */
4905 initialized_type (tree t
)
4909 tree type
= TREE_TYPE (t
);
4910 if (TREE_CODE (t
) == CALL_EXPR
)
4912 /* A constructor call has void type, so we need to look deeper. */
4913 tree fn
= get_function_named_in_call (t
);
4914 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
4915 && DECL_CXX_CONSTRUCTOR_P (fn
))
4916 type
= DECL_CONTEXT (fn
);
4918 else if (TREE_CODE (t
) == COMPOUND_EXPR
)
4919 return initialized_type (TREE_OPERAND (t
, 1));
4920 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4921 type
= TREE_TYPE (AGGR_INIT_EXPR_SLOT (t
));
4922 return cv_unqualified (type
);
4925 /* We're about to initialize element INDEX of an array or class from VALUE.
4926 Set up NEW_CTX appropriately by adjusting .object to refer to the
4927 subobject and creating a new CONSTRUCTOR if the element is itself
4928 a class or array. */
4931 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
4932 tree index
, tree
&value
)
4936 if (index
&& TREE_CODE (index
) != INTEGER_CST
4937 && TREE_CODE (index
) != FIELD_DECL
4938 && TREE_CODE (index
) != RANGE_EXPR
)
4939 /* This won't have an element in the new CONSTRUCTOR. */
4942 tree type
= initialized_type (value
);
4943 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
4944 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
4946 if (VECTOR_TYPE_P (type
)
4947 && VECTOR_TYPE_P (TREE_TYPE (ctx
->ctor
))
4948 && index
== NULL_TREE
)
4949 /* A vector inside of a vector CONSTRUCTOR, e.g. when a larger
4950 vector is constructed from smaller vectors, doesn't get its own
4951 CONSTRUCTOR either. */
4954 /* The sub-aggregate initializer might contain a placeholder;
4955 update object to refer to the subobject and ctor to refer to
4956 the (newly created) sub-initializer. */
4959 if (index
== NULL_TREE
|| TREE_CODE (index
) == RANGE_EXPR
)
4960 /* There's no well-defined subobject for this index. */
4961 new_ctx
.object
= NULL_TREE
;
4963 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
4966 if (is_empty_class (type
))
4967 /* Leave ctor null for an empty subobject, they aren't represented in the
4968 result of evaluation. */
4969 new_ctx
.ctor
= NULL_TREE
;
4972 tree elt
= build_constructor (type
, NULL
);
4973 CONSTRUCTOR_NO_CLEARING (elt
) = true;
4977 if (TREE_CODE (value
) == TARGET_EXPR
)
4978 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
4979 value
= TARGET_EXPR_INITIAL (value
);
4982 /* We're about to process an initializer for a class or array TYPE. Make
4983 sure that CTX is set up appropriately. */
4986 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
4988 /* We don't bother building a ctor for an empty base subobject. */
4989 if (is_empty_class (type
))
4992 /* We're in the middle of an initializer that might involve placeholders;
4993 our caller should have created a CONSTRUCTOR for us to put the
4994 initializer into. We will either return that constructor or T. */
4995 gcc_assert (ctx
->ctor
);
4996 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4997 (type
, TREE_TYPE (ctx
->ctor
)));
4998 /* We used to check that ctx->ctor was empty, but that isn't the case when
4999 the object is zero-initialized before calling the constructor. */
5002 tree otype
= TREE_TYPE (ctx
->object
);
5003 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
5004 /* Handle flexible array members. */
5005 || (TREE_CODE (otype
) == ARRAY_TYPE
5006 && TYPE_DOMAIN (otype
) == NULL_TREE
5007 && TREE_CODE (type
) == ARRAY_TYPE
5008 && (same_type_ignoring_top_level_qualifiers_p
5009 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
5011 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
5012 || ctx
->global
->get_value (ctx
->object
) == ctx
->ctor
);
5015 /* Subroutine of cxx_eval_constant_expression.
5016 The expression tree T denotes a C-style array or a C-style
5017 aggregate. Reduce it to a constant expression. */
5020 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
5022 bool *non_constant_p
, bool *overflow_p
)
5024 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5025 bool changed
= false;
5026 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
5027 tree type
= TREE_TYPE (t
);
5029 constexpr_ctx new_ctx
;
5030 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
5032 /* We don't really need the ctx->ctor business for a PMF or
5033 vector, but it's simpler to use the same code. */
5035 new_ctx
.ctor
= build_constructor (type
, NULL
);
5036 new_ctx
.object
= NULL_TREE
;
5039 verify_ctor_sanity (ctx
, type
);
5040 vec
<constructor_elt
, va_gc
> **p
= nullptr;
5043 p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
5044 vec_alloc (*p
, vec_safe_length (v
));
5045 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (t
))
5046 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ctx
->ctor
) = 1;
5051 bool constant_p
= true;
5052 bool side_effects_p
= false;
5053 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
5055 tree orig_value
= value
;
5056 /* Like in cxx_eval_store_expression, omit entries for empty fields. */
5057 bool no_slot
= TREE_CODE (type
) == RECORD_TYPE
&& is_empty_field (index
);
5058 init_subob_ctx (ctx
, new_ctx
, index
, value
);
5060 if (new_ctx
.ctor
!= ctx
->ctor
&& !no_slot
)
5062 /* If we built a new CONSTRUCTOR, attach it now so that other
5063 initializers can refer to it. */
5064 constructor_elt
*cep
= get_or_insert_ctor_field (ctx
->ctor
, index
);
5065 cep
->value
= new_ctx
.ctor
;
5066 pos_hint
= cep
- (*p
)->begin();
5068 else if (TREE_CODE (type
) == UNION_TYPE
)
5069 /* Otherwise if we're constructing a non-aggregate union member, set
5070 the active union member now so that we can later detect and diagnose
5071 if its initializer attempts to activate another member. */
5072 get_or_insert_ctor_field (ctx
->ctor
, index
);
5073 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
5075 non_constant_p
, overflow_p
);
5076 /* Don't VERIFY_CONSTANT here. */
5077 if (ctx
->quiet
&& *non_constant_p
)
5079 if (elt
!= orig_value
)
5082 if (!TREE_CONSTANT (elt
))
5084 if (TREE_SIDE_EFFECTS (elt
))
5085 side_effects_p
= true;
5086 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
5088 /* This is an initialization of a vfield inside a base
5089 subaggregate that we already initialized; push this
5090 initialization into the previous initialization. */
5091 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
5096 /* This is an initializer for an empty field; now that we've
5097 checked that it's constant, we can ignore it. */
5100 && (TREE_CODE (index
) == NOP_EXPR
5101 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
5103 /* Old representation of empty bases. FIXME remove. */
5104 gcc_checking_assert (false);
5105 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
5110 if (TREE_CODE (type
) == UNION_TYPE
5111 && (*p
)->last().index
!= index
)
5112 /* The initializer erroneously changed the active union member that
5113 we're initializing. */
5114 gcc_assert (*non_constant_p
);
5117 /* The initializer might have mutated the underlying CONSTRUCTOR,
5118 so recompute the location of the target constructer_elt. */
5119 constructor_elt
*cep
5120 = get_or_insert_ctor_field (ctx
->ctor
, index
, pos_hint
);
5124 /* Adding or replacing an element might change the ctor's flags. */
5125 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
5126 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
5129 if (*non_constant_p
)
5133 if (VECTOR_TYPE_P (type
))
5139 t
= build_constructor (type
, NULL
);
5140 /* We're done building this CONSTRUCTOR, so now we can interpret an
5141 element without an explicit initializer as value-initialized. */
5142 CONSTRUCTOR_NO_CLEARING (t
) = false;
5143 TREE_CONSTANT (t
) = constant_p
;
5144 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
5145 if (VECTOR_TYPE_P (type
))
5150 /* Subroutine of cxx_eval_constant_expression.
5151 The expression tree T is a VEC_INIT_EXPR which denotes the desired
5152 initialization of a non-static data member of array type. Reduce it to a
5155 Note that apart from value-initialization (when VALUE_INIT is true),
5156 this is only intended to support value-initialization and the
5157 initializations done by defaulted constructors for classes with
5158 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
5159 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
5160 for the copy/move constructor. */
5163 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
5164 bool value_init
, value_cat lval
,
5165 bool *non_constant_p
, bool *overflow_p
)
5167 tree elttype
= TREE_TYPE (atype
);
5168 verify_ctor_sanity (ctx
, atype
);
5169 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
5170 bool pre_init
= false;
5171 unsigned HOST_WIDE_INT i
;
5172 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
5174 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
5175 return cxx_eval_bare_aggregate (ctx
, init
, lval
,
5176 non_constant_p
, overflow_p
);
5178 /* For the default constructor, build up a call to the default
5179 constructor of the element type. We only need to handle class types
5180 here, as for a constructor to be constexpr, all members must be
5181 initialized, which for a defaulted default constructor means they must
5182 be of a class type with a constexpr default constructor. */
5183 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
5184 /* We only do this at the lowest level. */;
5185 else if (value_init
)
5187 init
= build_value_init (elttype
, complain
);
5192 releasing_vec argvec
;
5193 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
5194 &argvec
, elttype
, LOOKUP_NORMAL
,
5196 init
= build_aggr_init_expr (elttype
, init
);
5200 bool zeroed_out
= false;
5201 if (!CONSTRUCTOR_NO_CLEARING (ctx
->ctor
))
5203 /* We're initializing an array object that had been zero-initialized
5204 earlier. Truncate ctx->ctor, and propagate its zeroed state by
5205 clearing CONSTRUCTOR_NO_CLEARING on each of the aggregate element
5206 initializers we append to it. */
5207 gcc_checking_assert (initializer_zerop (ctx
->ctor
));
5209 vec_safe_truncate (*p
, 0);
5212 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
5214 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
5215 for (i
= 0; i
< max
; ++i
)
5217 tree idx
= build_int_cst (size_type_node
, i
);
5220 constexpr_ctx new_ctx
;
5221 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
5222 if (new_ctx
.ctor
!= ctx
->ctor
)
5225 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = false;
5226 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
5228 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
5230 /* A multidimensional array; recurse. */
5231 if (value_init
|| init
== NULL_TREE
)
5233 eltinit
= NULL_TREE
;
5237 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
5238 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
5240 non_constant_p
, overflow_p
);
5244 /* Initializing an element using value or default initialization
5245 we just pre-built above. */
5246 if (init
== void_node
)
5247 /* Trivial default-init, don't do anything to the CONSTRUCTOR. */
5249 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
5250 non_constant_p
, overflow_p
);
5255 /* Copying an element. */
5256 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
5257 if (!lvalue_p (init
))
5258 eltinit
= move (eltinit
);
5259 eltinit
= (perform_implicit_conversion_flags
5260 (elttype
, eltinit
, complain
,
5261 LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
));
5262 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
5263 non_constant_p
, overflow_p
);
5265 if (*non_constant_p
)
5267 if (new_ctx
.ctor
!= ctx
->ctor
)
5269 /* We appended this element above; update the value. */
5270 gcc_assert ((*p
)->last().index
== idx
);
5271 (*p
)->last().value
= eltinit
;
5274 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
5275 /* Reuse the result of cxx_eval_constant_expression call
5276 from the first iteration to all others if it is a constant
5277 initializer that doesn't require relocations. */
5280 && (eltinit
== NULL_TREE
5281 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
5282 == null_pointer_node
)))
5284 if (new_ctx
.ctor
!= ctx
->ctor
)
5285 eltinit
= new_ctx
.ctor
;
5286 tree range
= build2 (RANGE_EXPR
, size_type_node
,
5287 build_int_cst (size_type_node
, 1),
5288 build_int_cst (size_type_node
, max
- 1));
5289 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
5293 vec_safe_reserve (*p
, max
);
5296 if (!*non_constant_p
)
5299 CONSTRUCTOR_NO_CLEARING (init
) = false;
5305 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
5307 bool *non_constant_p
, bool *overflow_p
)
5309 tree atype
= TREE_TYPE (t
);
5310 tree init
= VEC_INIT_EXPR_INIT (t
);
5311 bool value_init
= VEC_INIT_EXPR_VALUE_INIT (t
);
5312 if (!init
|| !BRACE_ENCLOSED_INITIALIZER_P (init
))
5314 else if (CONSTRUCTOR_NELTS (init
) == 0
5315 && !CP_AGGREGATE_TYPE_P (strip_array_types (atype
)))
5317 /* Handle {} as value-init. */
5323 /* This is a more complicated case, like needing to loop over trailing
5324 elements; call build_vec_init and evaluate the result. */
5325 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
5326 constexpr_ctx new_ctx
= *ctx
;
5329 /* We want to have an initialization target for an VEC_INIT_EXPR.
5330 If we don't already have one in CTX, use the VEC_INIT_EXPR_SLOT. */
5331 new_ctx
.object
= VEC_INIT_EXPR_SLOT (t
);
5332 tree ctor
= new_ctx
.ctor
= build_constructor (atype
, NULL
);
5333 CONSTRUCTOR_NO_CLEARING (ctor
) = true;
5334 ctx
->global
->put_value (new_ctx
.object
, ctor
);
5337 init
= expand_vec_init_expr (ctx
->object
, t
, complain
);
5338 return cxx_eval_constant_expression (ctx
, init
, lval
, non_constant_p
,
5341 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
, value_init
,
5342 lval
, non_constant_p
, overflow_p
);
5343 if (*non_constant_p
)
5349 /* Like same_type_ignoring_top_level_qualifiers_p, but also handle the case
5350 where the desired type is an array of unknown bounds because the variable
5351 has had its bounds deduced since the wrapping expression was created. */
5354 same_type_ignoring_tlq_and_bounds_p (tree type1
, tree type2
)
5356 while (TREE_CODE (type1
) == ARRAY_TYPE
5357 && TREE_CODE (type2
) == ARRAY_TYPE
5358 && (!TYPE_DOMAIN (type1
) || !TYPE_DOMAIN (type2
)))
5360 type1
= TREE_TYPE (type1
);
5361 type2
= TREE_TYPE (type2
);
5363 return same_type_ignoring_top_level_qualifiers_p (type1
, type2
);
5366 /* Try to determine the currently active union member for an expression
5367 with UNION_TYPE. If it can be determined, return the FIELD_DECL,
5368 otherwise return NULL_TREE. */
5371 cxx_union_active_member (const constexpr_ctx
*ctx
, tree t
)
5373 constexpr_ctx new_ctx
= *ctx
;
5374 new_ctx
.quiet
= true;
5375 bool non_constant_p
= false, overflow_p
= false;
5376 tree ctor
= cxx_eval_constant_expression (&new_ctx
, t
, vc_prvalue
,
5379 if (TREE_CODE (ctor
) == CONSTRUCTOR
5380 && CONSTRUCTOR_NELTS (ctor
) == 1
5381 && CONSTRUCTOR_ELT (ctor
, 0)->index
5382 && TREE_CODE (CONSTRUCTOR_ELT (ctor
, 0)->index
) == FIELD_DECL
)
5383 return CONSTRUCTOR_ELT (ctor
, 0)->index
;
5387 /* Helper function for cxx_fold_indirect_ref_1, called recursively. */
5390 cxx_fold_indirect_ref_1 (const constexpr_ctx
*ctx
, location_t loc
, tree type
,
5391 tree op
, unsigned HOST_WIDE_INT off
, bool *empty_base
)
5393 tree optype
= TREE_TYPE (op
);
5394 unsigned HOST_WIDE_INT const_nunits
;
5395 if (off
== 0 && similar_type_p (optype
, type
))
5397 else if (TREE_CODE (optype
) == COMPLEX_TYPE
5398 && similar_type_p (type
, TREE_TYPE (optype
)))
5400 /* *(foo *)&complexfoo => __real__ complexfoo */
5402 return build1_loc (loc
, REALPART_EXPR
, type
, op
);
5403 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
5404 else if (tree_to_uhwi (TYPE_SIZE_UNIT (type
)) == off
)
5405 return build1_loc (loc
, IMAGPART_EXPR
, type
, op
);
5407 /* ((foo*)&vectorfoo)[x] => BIT_FIELD_REF<vectorfoo,...> */
5408 else if (VECTOR_TYPE_P (optype
)
5409 && similar_type_p (type
, TREE_TYPE (optype
))
5410 && TYPE_VECTOR_SUBPARTS (optype
).is_constant (&const_nunits
))
5412 unsigned HOST_WIDE_INT part_width
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
5413 unsigned HOST_WIDE_INT max_offset
= part_width
* const_nunits
;
5414 if (off
< max_offset
&& off
% part_width
== 0)
5416 tree index
= bitsize_int (off
* BITS_PER_UNIT
);
5417 return build3_loc (loc
, BIT_FIELD_REF
, type
, op
,
5418 TYPE_SIZE (type
), index
);
5421 /* ((foo *)&fooarray)[x] => fooarray[x] */
5422 else if (TREE_CODE (optype
) == ARRAY_TYPE
5423 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (optype
)))
5424 && !integer_zerop (TYPE_SIZE_UNIT (TREE_TYPE (optype
))))
5426 tree type_domain
= TYPE_DOMAIN (optype
);
5427 tree min_val
= size_zero_node
;
5428 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
5429 min_val
= TYPE_MIN_VALUE (type_domain
);
5430 unsigned HOST_WIDE_INT el_sz
5431 = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (optype
)));
5432 unsigned HOST_WIDE_INT idx
= off
/ el_sz
;
5433 unsigned HOST_WIDE_INT rem
= off
% el_sz
;
5434 if (tree_fits_uhwi_p (min_val
))
5436 tree index
= size_int (idx
+ tree_to_uhwi (min_val
));
5437 op
= build4_loc (loc
, ARRAY_REF
, TREE_TYPE (optype
), op
, index
,
5438 NULL_TREE
, NULL_TREE
);
5439 return cxx_fold_indirect_ref_1 (ctx
, loc
, type
, op
, rem
,
5443 /* ((foo *)&struct_with_foo_field)[x] => COMPONENT_REF */
5444 else if (TREE_CODE (optype
) == RECORD_TYPE
5445 || TREE_CODE (optype
) == UNION_TYPE
)
5447 if (TREE_CODE (optype
) == UNION_TYPE
)
5448 /* For unions prefer the currently active member. */
5449 if (tree field
= cxx_union_active_member (ctx
, op
))
5451 unsigned HOST_WIDE_INT el_sz
5452 = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (field
)));
5455 tree cop
= build3 (COMPONENT_REF
, TREE_TYPE (field
),
5456 op
, field
, NULL_TREE
);
5457 if (tree ret
= cxx_fold_indirect_ref_1 (ctx
, loc
, type
, cop
,
5463 /* Handle conversion to an empty base class, which is represented with a
5464 NOP_EXPR. Do this before spelunking into the non-empty subobjects,
5465 which is likely to be a waste of time (109678). */
5466 if (is_empty_class (type
)
5467 && CLASS_TYPE_P (optype
)
5468 && lookup_base (optype
, type
, ba_any
, NULL
, tf_none
, off
))
5475 for (tree field
= TYPE_FIELDS (optype
);
5476 field
; field
= DECL_CHAIN (field
))
5477 if (TREE_CODE (field
) == FIELD_DECL
5478 && TREE_TYPE (field
) != error_mark_node
5479 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (field
))))
5481 tree pos
= byte_position (field
);
5482 if (!tree_fits_uhwi_p (pos
))
5484 unsigned HOST_WIDE_INT upos
= tree_to_uhwi (pos
);
5485 unsigned HOST_WIDE_INT el_sz
5486 = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (field
)));
5487 if (upos
<= off
&& off
< upos
+ el_sz
)
5489 tree cop
= build3 (COMPONENT_REF
, TREE_TYPE (field
),
5490 op
, field
, NULL_TREE
);
5491 if (tree ret
= cxx_fold_indirect_ref_1 (ctx
, loc
, type
, cop
,
5502 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
5503 match. We want to be less strict for simple *& folding; if we have a
5504 non-const temporary that we access through a const pointer, that should
5505 work. We handle this here rather than change fold_indirect_ref_1
5506 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
5507 don't really make sense outside of constant expression evaluation. Also
5508 we want to allow folding to COMPONENT_REF, which could cause trouble
5509 with TBAA in fold_indirect_ref_1. */
5512 cxx_fold_indirect_ref (const constexpr_ctx
*ctx
, location_t loc
, tree type
,
5513 tree op0
, bool *empty_base
/* = NULL*/)
5517 poly_uint64 const_op01
;
5519 /* STRIP_NOPS, but stop if REINTERPRET_CAST_P. */
5520 while (CONVERT_EXPR_P (sub
) || TREE_CODE (sub
) == NON_LVALUE_EXPR
5521 || TREE_CODE (sub
) == VIEW_CONVERT_EXPR
)
5523 if (TREE_CODE (sub
) == NOP_EXPR
5524 && REINTERPRET_CAST_P (sub
))
5526 sub
= TREE_OPERAND (sub
, 0);
5529 subtype
= TREE_TYPE (sub
);
5530 if (!INDIRECT_TYPE_P (subtype
))
5533 /* Canonicalizes the given OBJ/OFF pair by iteratively absorbing
5534 the innermost component into the offset until it would make the
5535 offset positive, so that cxx_fold_indirect_ref_1 can identify
5536 more folding opportunities. */
5537 auto canonicalize_obj_off
= [] (tree
& obj
, tree
& off
) {
5538 while (TREE_CODE (obj
) == COMPONENT_REF
5539 && (tree_int_cst_sign_bit (off
) || integer_zerop (off
)))
5541 tree field
= TREE_OPERAND (obj
, 1);
5542 tree pos
= byte_position (field
);
5543 if (integer_zerop (off
) && integer_nonzerop (pos
))
5544 /* If the offset is already 0, keep going as long as the
5545 component is at position 0. */
5547 off
= int_const_binop (PLUS_EXPR
, off
, pos
);
5548 obj
= TREE_OPERAND (obj
, 0);
5552 if (TREE_CODE (sub
) == ADDR_EXPR
)
5554 tree op
= TREE_OPERAND (sub
, 0);
5555 tree optype
= TREE_TYPE (op
);
5557 /* *&CONST_DECL -> to the value of the const decl. */
5558 if (TREE_CODE (op
) == CONST_DECL
)
5559 return DECL_INITIAL (op
);
5560 /* *&p => p; make sure to handle *&"str"[cst] here. */
5561 if (similar_type_p (optype
, type
))
5563 tree fop
= fold_read_from_constant_string (op
);
5571 tree off
= integer_zero_node
;
5572 canonicalize_obj_off (op
, off
);
5573 gcc_assert (integer_zerop (off
));
5574 return cxx_fold_indirect_ref_1 (ctx
, loc
, type
, op
, 0, empty_base
);
5577 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
5578 && tree_fits_uhwi_p (TREE_OPERAND (sub
, 1)))
5580 tree op00
= TREE_OPERAND (sub
, 0);
5581 tree off
= TREE_OPERAND (sub
, 1);
5584 if (TREE_CODE (op00
) == ADDR_EXPR
)
5586 tree obj
= TREE_OPERAND (op00
, 0);
5587 canonicalize_obj_off (obj
, off
);
5588 return cxx_fold_indirect_ref_1 (ctx
, loc
, type
, obj
,
5589 tree_to_uhwi (off
), empty_base
);
5592 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
5593 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
5594 && similar_type_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
5597 tree min_val
= size_zero_node
;
5599 = cxx_fold_indirect_ref (ctx
, loc
, TREE_TYPE (subtype
), sub
, NULL
);
5603 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
5604 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
5605 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
5606 min_val
= TYPE_MIN_VALUE (type_domain
);
5607 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
5615 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
5617 bool *non_constant_p
, bool *overflow_p
)
5619 tree orig_op0
= TREE_OPERAND (t
, 0);
5620 bool empty_base
= false;
5622 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
5623 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
5625 if (TREE_CODE (t
) == MEM_REF
5626 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
5628 gcc_assert (ctx
->quiet
);
5629 *non_constant_p
= true;
5633 /* First try to simplify it directly. */
5634 tree r
= cxx_fold_indirect_ref (ctx
, EXPR_LOCATION (t
), TREE_TYPE (t
),
5635 orig_op0
, &empty_base
);
5638 /* If that didn't work, evaluate the operand first. */
5639 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
5640 vc_prvalue
, non_constant_p
,
5642 /* Don't VERIFY_CONSTANT here. */
5643 if (*non_constant_p
)
5646 if (!lval
&& integer_zerop (op0
))
5649 error ("dereferencing a null pointer");
5650 *non_constant_p
= true;
5654 r
= cxx_fold_indirect_ref (ctx
, EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
5658 /* We couldn't fold to a constant value. Make sure it's not
5659 something we should have been able to fold. */
5662 if (TREE_CODE (sub
) == ADDR_EXPR
)
5664 gcc_assert (!similar_type_p
5665 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
5666 /* DR 1188 says we don't have to deal with this. */
5668 error_at (cp_expr_loc_or_input_loc (t
),
5669 "accessing value of %qE through a %qT glvalue in a "
5670 "constant expression", build_fold_indirect_ref (sub
),
5672 *non_constant_p
= true;
5676 if (lval
== vc_glvalue
&& op0
!= orig_op0
)
5677 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
5679 VERIFY_CONSTANT (t
);
5684 r
= cxx_eval_constant_expression (ctx
, r
,
5685 lval
, non_constant_p
, overflow_p
);
5686 if (*non_constant_p
)
5689 /* If we're pulling out the value of an empty base, just return an empty
5691 if (empty_base
&& !lval
)
5693 r
= build_constructor (TREE_TYPE (t
), NULL
);
5694 TREE_CONSTANT (r
) = true;
5700 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
5701 FUNDEF_P is true if we're checking a constexpr function body.
5702 Shared between potential_constant_expression and
5703 cxx_eval_constant_expression. */
5706 non_const_var_error (location_t loc
, tree r
, bool fundef_p
)
5708 auto_diagnostic_group d
;
5709 tree type
= TREE_TYPE (r
);
5710 if (DECL_NAME (r
) == heap_uninit_identifier
5711 || DECL_NAME (r
) == heap_identifier
5712 || DECL_NAME (r
) == heap_vec_uninit_identifier
5713 || DECL_NAME (r
) == heap_vec_identifier
)
5715 if (constexpr_error (loc
, fundef_p
, "the content of uninitialized "
5716 "storage is not usable in a constant expression"))
5717 inform (DECL_SOURCE_LOCATION (r
), "allocated here");
5720 if (DECL_NAME (r
) == heap_deleted_identifier
)
5722 if (constexpr_error (loc
, fundef_p
, "use of allocated storage after "
5723 "deallocation in a constant expression"))
5724 inform (DECL_SOURCE_LOCATION (r
), "allocated here");
5727 if (!constexpr_error (loc
, fundef_p
, "the value of %qD is not usable in "
5728 "a constant expression", r
))
5730 /* Avoid error cascade. */
5731 if (DECL_INITIAL (r
) == error_mark_node
)
5733 if (DECL_DECLARED_CONSTEXPR_P (r
))
5734 inform (DECL_SOURCE_LOCATION (r
),
5735 "%qD used in its own initializer", r
);
5736 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5738 if (!CP_TYPE_CONST_P (type
))
5739 inform (DECL_SOURCE_LOCATION (r
),
5740 "%q#D is not const", r
);
5741 else if (CP_TYPE_VOLATILE_P (type
))
5742 inform (DECL_SOURCE_LOCATION (r
),
5743 "%q#D is volatile", r
);
5744 else if (!DECL_INITIAL (r
)
5745 || !TREE_CONSTANT (DECL_INITIAL (r
))
5746 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
5747 inform (DECL_SOURCE_LOCATION (r
),
5748 "%qD was not initialized with a constant "
5753 else if (TYPE_REF_P (type
))
5754 inform (DECL_SOURCE_LOCATION (r
),
5755 "%qD was not initialized with a constant "
5759 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
5760 inform (DECL_SOURCE_LOCATION (r
),
5761 "%qD was not declared %<constexpr%>", r
);
5763 inform (DECL_SOURCE_LOCATION (r
),
5764 "%qD does not have integral or enumeration type",
5769 /* Subroutine of cxx_eval_constant_expression.
5770 Like cxx_eval_unary_expression, except for trinary expressions. */
5773 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
5775 bool *non_constant_p
, bool *overflow_p
)
5781 for (i
= 0; i
< 3; i
++)
5783 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
5785 non_constant_p
, overflow_p
);
5786 VERIFY_CONSTANT (args
[i
]);
5789 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
5790 args
[0], args
[1], args
[2]);
5791 if (val
== NULL_TREE
)
5793 VERIFY_CONSTANT (val
);
5797 /* True if T was declared in a function declared to be constexpr, and
5798 therefore potentially constant in C++14. */
5801 var_in_constexpr_fn (tree t
)
5803 tree ctx
= DECL_CONTEXT (t
);
5804 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
5805 && DECL_DECLARED_CONSTEXPR_P (ctx
));
5808 /* True if a function might be constexpr: either a function that was
5809 declared constexpr, or a C++17 lambda op(). */
5812 maybe_constexpr_fn (tree t
)
5814 return (DECL_DECLARED_CONSTEXPR_P (t
)
5815 || (cxx_dialect
>= cxx17
&& LAMBDA_FUNCTION_P (t
))
5816 || (flag_implicit_constexpr
5817 && DECL_DECLARED_INLINE_P (STRIP_TEMPLATE (t
))));
5820 /* True if T was declared in a function that might be constexpr: either a
5821 function that was declared constexpr, or a C++17 lambda op(). */
5824 var_in_maybe_constexpr_fn (tree t
)
5826 return (DECL_FUNCTION_SCOPE_P (t
)
5827 && maybe_constexpr_fn (DECL_CONTEXT (t
)));
5830 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
5831 build_over_call we implement trivial copy of a class with tail padding using
5832 assignment of character arrays, which is valid in normal code, but not in
5833 constexpr evaluation. We don't need to worry about clobbering tail padding
5834 in constexpr evaluation, so strip the type punning. */
5837 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
5839 if (TREE_CODE (target
) == MEM_REF
5840 && TREE_CODE (init
) == MEM_REF
5841 && TREE_TYPE (target
) == TREE_TYPE (init
)
5842 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
5843 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
5845 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
5846 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
5850 /* Returns true if REF, which is a COMPONENT_REF, has any fields
5851 of constant type. This does not check for 'mutable', so the
5852 caller is expected to be mindful of that. */
5855 cref_has_const_field (tree ref
)
5857 while (TREE_CODE (ref
) == COMPONENT_REF
)
5859 if (CP_TYPE_CONST_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
5861 ref
= TREE_OPERAND (ref
, 0);
5866 /* Return true if we are modifying something that is const during constant
5867 expression evaluation. CODE is the code of the statement, OBJ is the
5868 object in question, MUTABLE_P is true if one of the subobjects were
5869 declared mutable. */
5872 modifying_const_object_p (tree_code code
, tree obj
, bool mutable_p
)
5874 /* If this is initialization, there's no problem. */
5875 if (code
!= MODIFY_EXPR
)
5878 /* [basic.type.qualifier] "A const object is an object of type
5879 const T or a non-mutable subobject of a const object." */
5883 if (TREE_READONLY (obj
))
5886 if (CP_TYPE_CONST_P (TREE_TYPE (obj
)))
5888 /* Although a COMPONENT_REF may have a const type, we should
5889 only consider it modifying a const object when any of the
5890 field components is const. This can happen when using
5891 constructs such as const_cast<const T &>(m), making something
5892 const even though it wasn't declared const. */
5893 if (TREE_CODE (obj
) == COMPONENT_REF
)
5894 return cref_has_const_field (obj
);
5902 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
5905 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
5907 bool *non_constant_p
, bool *overflow_p
)
5909 constexpr_ctx new_ctx
= *ctx
;
5911 tree init
= TREE_OPERAND (t
, 1);
5912 if (TREE_CLOBBER_P (init
))
5913 /* Just ignore clobbers. */
5916 /* First we figure out where we're storing to. */
5917 tree target
= TREE_OPERAND (t
, 0);
5919 maybe_simplify_trivial_copy (target
, init
);
5921 tree type
= TREE_TYPE (target
);
5922 bool preeval
= SCALAR_TYPE_P (type
) || TREE_CODE (t
) == MODIFY_EXPR
;
5925 /* Evaluate the value to be stored without knowing what object it will be
5926 stored in, so that any side-effects happen first. */
5927 if (!SCALAR_TYPE_P (type
))
5928 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
5929 init
= cxx_eval_constant_expression (&new_ctx
, init
, vc_prvalue
,
5930 non_constant_p
, overflow_p
);
5931 if (*non_constant_p
)
5935 bool evaluated
= false;
5936 if (lval
== vc_glvalue
)
5938 /* If we want to return a reference to the target, we need to evaluate it
5939 as a whole; otherwise, only evaluate the innermost piece to avoid
5940 building up unnecessary *_REFs. */
5941 target
= cxx_eval_constant_expression (ctx
, target
, lval
,
5942 non_constant_p
, overflow_p
);
5944 if (*non_constant_p
)
5948 /* Find the underlying variable. */
5950 tree object
= NULL_TREE
;
5951 /* If we're modifying a const object, save it. */
5952 tree const_object_being_modified
= NULL_TREE
;
5953 bool mutable_p
= false;
5954 for (tree probe
= target
; object
== NULL_TREE
; )
5956 switch (TREE_CODE (probe
))
5962 tree ob
= TREE_OPERAND (probe
, 0);
5963 tree elt
= TREE_OPERAND (probe
, 1);
5964 if (TREE_CODE (elt
) == FIELD_DECL
&& DECL_MUTABLE_P (elt
))
5966 if (TREE_CODE (probe
) == ARRAY_REF
)
5968 elt
= eval_and_check_array_index (ctx
, probe
, false,
5969 non_constant_p
, overflow_p
);
5970 if (*non_constant_p
)
5973 /* We don't check modifying_const_object_p for ARRAY_REFs. Given
5974 "int a[10]", an ARRAY_REF "a[2]" can be "const int", even though
5975 the array isn't const. Instead, check "a" in the next iteration;
5976 that will detect modifying "const int a[10]". */
5978 && modifying_const_object_p (TREE_CODE (t
), probe
,
5980 && const_object_being_modified
== NULL_TREE
)
5981 const_object_being_modified
= probe
;
5982 vec_safe_push (refs
, elt
);
5983 vec_safe_push (refs
, TREE_TYPE (probe
));
5989 gcc_assert (probe
== target
);
5990 vec_safe_push (refs
, probe
);
5991 vec_safe_push (refs
, TREE_TYPE (probe
));
5992 probe
= TREE_OPERAND (probe
, 0);
5996 gcc_assert (probe
== target
);
5997 vec_safe_push (refs
, probe
);
5998 vec_safe_push (refs
, TREE_TYPE (probe
));
5999 probe
= TREE_OPERAND (probe
, 0);
6007 probe
= cxx_eval_constant_expression (ctx
, probe
, vc_glvalue
,
6008 non_constant_p
, overflow_p
);
6010 if (*non_constant_p
)
6017 if (modifying_const_object_p (TREE_CODE (t
), object
, mutable_p
)
6018 && const_object_being_modified
== NULL_TREE
)
6019 const_object_being_modified
= object
;
6021 /* And then find/build up our initializer for the path to the subobject
6022 we're initializing. */
6024 if (DECL_P (object
))
6025 valp
= ctx
->global
->get_value_ptr (object
);
6030 /* A constant-expression cannot modify objects from outside the
6031 constant-expression. */
6033 error ("modification of %qE is not a constant expression", object
);
6034 *non_constant_p
= true;
6037 type
= TREE_TYPE (object
);
6038 bool no_zero_init
= true;
6040 auto_vec
<tree
*> ctors
;
6041 releasing_vec indexes
;
6042 auto_vec
<int> index_pos_hints
;
6043 bool activated_union_member_p
= false;
6044 bool empty_base
= false;
6045 while (!refs
->is_empty ())
6047 if (*valp
== NULL_TREE
)
6049 *valp
= build_constructor (type
, NULL
);
6050 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
6052 else if (STRIP_ANY_LOCATION_WRAPPER (*valp
),
6053 TREE_CODE (*valp
) == STRING_CST
)
6055 /* An array was initialized with a string constant, and now
6056 we're writing into one of its elements. Explode the
6057 single initialization into a set of element
6059 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
6061 tree string
= *valp
;
6062 tree elt_type
= TREE_TYPE (type
);
6063 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
6064 / TYPE_PRECISION (char_type_node
));
6065 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
6066 tree ary_ctor
= build_constructor (type
, NULL
);
6068 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
6069 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
6071 constructor_elt elt
=
6073 build_int_cst (size_type_node
, ix
),
6074 extract_string_elt (string
, chars_per_elt
, ix
)
6076 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
6082 enum tree_code code
= TREE_CODE (type
);
6083 tree reftype
= refs
->pop();
6084 tree index
= refs
->pop();
6086 if (code
== COMPLEX_TYPE
)
6088 if (TREE_CODE (*valp
) == COMPLEX_CST
)
6089 *valp
= build2 (COMPLEX_EXPR
, type
, TREE_REALPART (*valp
),
6090 TREE_IMAGPART (*valp
));
6091 else if (TREE_CODE (*valp
) == CONSTRUCTOR
6092 && CONSTRUCTOR_NELTS (*valp
) == 0
6093 && CONSTRUCTOR_NO_CLEARING (*valp
))
6095 tree r
= build_constructor (reftype
, NULL
);
6096 CONSTRUCTOR_NO_CLEARING (r
) = 1;
6097 *valp
= build2 (COMPLEX_EXPR
, type
, r
, r
);
6099 gcc_assert (TREE_CODE (*valp
) == COMPLEX_EXPR
);
6100 ctors
.safe_push (valp
);
6101 vec_safe_push (indexes
, index
);
6102 valp
= &TREE_OPERAND (*valp
, TREE_CODE (index
) == IMAGPART_EXPR
);
6103 gcc_checking_assert (refs
->is_empty ());
6108 /* If the value of object is already zero-initialized, any new ctors for
6109 subobjects will also be zero-initialized. */
6110 no_zero_init
= CONSTRUCTOR_NO_CLEARING (*valp
);
6112 if (code
== RECORD_TYPE
&& is_empty_field (index
))
6113 /* Don't build a sub-CONSTRUCTOR for an empty base or field, as they
6114 have no data and might have an offset lower than previously declared
6115 fields, which confuses the middle-end. The code below will notice
6116 that we don't have a CONSTRUCTOR for our inner target and just
6125 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
6126 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
6128 if (cxx_dialect
< cxx20
)
6131 error_at (cp_expr_loc_or_input_loc (t
),
6132 "change of the active member of a union "
6134 CONSTRUCTOR_ELT (*valp
, 0)->index
,
6136 *non_constant_p
= true;
6138 else if (TREE_CODE (t
) == MODIFY_EXPR
6139 && CONSTRUCTOR_NO_CLEARING (*valp
))
6141 /* Diagnose changing the active union member while the union
6142 is in the process of being initialized. */
6144 error_at (cp_expr_loc_or_input_loc (t
),
6145 "change of the active member of a union "
6146 "from %qD to %qD during initialization",
6147 CONSTRUCTOR_ELT (*valp
, 0)->index
,
6149 *non_constant_p
= true;
6151 no_zero_init
= true;
6154 ctors
.safe_push (valp
);
6155 vec_safe_push (indexes
, index
);
6157 constructor_elt
*cep
6158 = get_or_insert_ctor_field (*valp
, index
);
6159 index_pos_hints
.safe_push (cep
- CONSTRUCTOR_ELTS (*valp
)->begin());
6161 if (code
== UNION_TYPE
)
6162 activated_union_member_p
= true;
6167 /* For initialization of an empty base, the original target will be
6168 *(base*)this, evaluation of which resolves to the object
6169 argument, which has the derived type rather than the base type. */
6170 if (!empty_base
&& !(same_type_ignoring_top_level_qualifiers_p
6171 (initialized_type (init
), type
)))
6173 gcc_assert (is_empty_class (TREE_TYPE (target
)));
6177 /* Detect modifying a constant object in constexpr evaluation.
6178 We have found a const object that is being modified. Figure out
6179 if we need to issue an error. Consider
6183 constexpr A() : n(1) { n = 2; } // #1
6187 constexpr B() { a.n = 3; } // #2
6191 #1 is OK, since we're modifying an object under construction, but
6192 #2 is wrong, since "a" is const and has been fully constructed.
6193 To track it, we use the TREE_READONLY bit in the object's CONSTRUCTOR
6194 which means that the object is read-only. For the example above, the
6195 *ctors stack at the point of #2 will look like:
6197 ctors[0] = {.a={.n=2}} TREE_READONLY = 0
6198 ctors[1] = {.n=2} TREE_READONLY = 1
6200 and we're modifying "b.a", so we search the stack and see if the
6201 constructor for "b.a" has already run. */
6202 if (const_object_being_modified
)
6206 = strip_array_types (TREE_TYPE (const_object_being_modified
));
6207 if (!CLASS_TYPE_P (const_objtype
))
6211 /* [class.ctor]p5 "A constructor can be invoked for a const,
6212 volatile, or const volatile object. const and volatile
6213 semantics are not applied on an object under construction.
6214 They come into effect when the constructor for the most
6215 derived object ends." */
6216 for (tree
*elt
: ctors
)
6217 if (same_type_ignoring_top_level_qualifiers_p
6218 (TREE_TYPE (const_object_being_modified
), TREE_TYPE (*elt
)))
6220 fail
= TREE_READONLY (*elt
);
6227 modifying_const_object_error (t
, const_object_being_modified
);
6228 *non_constant_p
= true;
6235 /* We're handling an INIT_EXPR of class type, so the value of the
6236 initializer can depend on the object it's initializing. */
6238 /* Create a new CONSTRUCTOR in case evaluation of the initializer
6239 wants to modify it. */
6240 if (*valp
== NULL_TREE
)
6242 *valp
= build_constructor (type
, NULL
);
6243 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
6245 new_ctx
.ctor
= empty_base
? NULL_TREE
: *valp
;
6246 new_ctx
.object
= target
;
6247 /* Avoid temporary materialization when initializing from a TARGET_EXPR.
6248 We don't need to mess with AGGR_EXPR_SLOT/VEC_INIT_EXPR_SLOT because
6249 expansion of those trees uses ctx instead. */
6250 if (TREE_CODE (init
) == TARGET_EXPR
)
6251 if (tree tinit
= TARGET_EXPR_INITIAL (init
))
6253 init
= cxx_eval_constant_expression (&new_ctx
, init
, vc_prvalue
,
6254 non_constant_p
, overflow_p
);
6255 /* The hash table might have moved since the get earlier, and the
6256 initializer might have mutated the underlying CONSTRUCTORs, so we must
6258 valp
= ctx
->global
->get_value_ptr (object
);
6259 for (unsigned i
= 0; i
< vec_safe_length (indexes
); i
++)
6262 constructor_elt
*cep
6263 = get_or_insert_ctor_field (*valp
, indexes
[i
], index_pos_hints
[i
]);
6268 if (*non_constant_p
)
6271 /* Don't share a CONSTRUCTOR that might be changed later. */
6272 init
= unshare_constructor (init
);
6274 gcc_checking_assert (!*valp
|| (same_type_ignoring_top_level_qualifiers_p
6275 (TREE_TYPE (*valp
), type
)));
6278 /* Just evaluate the initializer and return, since there's no actual data
6279 to store, and we didn't build a CONSTRUCTOR. */
6282 /* But do make sure we have something in *valp. */
6283 *valp
= build_constructor (type
, nullptr);
6284 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
6287 else if (*valp
&& TREE_CODE (*valp
) == CONSTRUCTOR
6288 && TREE_CODE (init
) == CONSTRUCTOR
)
6290 /* An outer ctx->ctor might be pointing to *valp, so replace
6292 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
6293 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
6294 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
6295 CONSTRUCTOR_NO_CLEARING (*valp
)
6296 = CONSTRUCTOR_NO_CLEARING (init
);
6301 /* After initialization, 'const' semantics apply to the value of the
6302 object. Make a note of this fact by marking the CONSTRUCTOR
6304 if (TREE_CODE (t
) == INIT_EXPR
6305 && TREE_CODE (*valp
) == CONSTRUCTOR
6306 && TYPE_READONLY (type
))
6308 if (INDIRECT_REF_P (target
)
6309 && (is_this_parameter
6310 (tree_strip_nop_conversions (TREE_OPERAND (target
, 0)))))
6311 /* We've just initialized '*this' (perhaps via the target
6312 constructor of a delegating constructor). Leave it up to the
6313 caller that set 'this' to set TREE_READONLY appropriately. */
6314 gcc_checking_assert (same_type_ignoring_top_level_qualifiers_p
6315 (TREE_TYPE (target
), type
) || empty_base
);
6317 TREE_READONLY (*valp
) = true;
6320 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
6321 CONSTRUCTORs, if any. */
6322 bool c
= TREE_CONSTANT (init
);
6323 bool s
= TREE_SIDE_EFFECTS (init
);
6324 if (!indexes
->is_empty ())
6326 tree last
= indexes
->last ();
6327 if (TREE_CODE (last
) == REALPART_EXPR
6328 || TREE_CODE (last
) == IMAGPART_EXPR
)
6330 /* And canonicalize COMPLEX_EXPR into COMPLEX_CST if
6332 tree
*cexpr
= ctors
.last ();
6333 if (tree c
= const_binop (COMPLEX_EXPR
, TREE_TYPE (*cexpr
),
6334 TREE_OPERAND (*cexpr
, 0),
6335 TREE_OPERAND (*cexpr
, 1)))
6339 TREE_CONSTANT (*cexpr
)
6340 = (TREE_CONSTANT (TREE_OPERAND (*cexpr
, 0))
6341 & TREE_CONSTANT (TREE_OPERAND (*cexpr
, 1)));
6342 TREE_SIDE_EFFECTS (*cexpr
)
6343 = (TREE_SIDE_EFFECTS (TREE_OPERAND (*cexpr
, 0))
6344 | TREE_SIDE_EFFECTS (TREE_OPERAND (*cexpr
, 1)));
6346 c
= TREE_CONSTANT (*cexpr
);
6347 s
= TREE_SIDE_EFFECTS (*cexpr
);
6350 if (!c
|| s
|| activated_union_member_p
)
6351 for (tree
*elt
: ctors
)
6353 if (TREE_CODE (*elt
) != CONSTRUCTOR
)
6356 TREE_CONSTANT (*elt
) = false;
6358 TREE_SIDE_EFFECTS (*elt
) = true;
6359 /* Clear CONSTRUCTOR_NO_CLEARING since we've activated a member of
6361 if (TREE_CODE (TREE_TYPE (*elt
)) == UNION_TYPE
)
6362 CONSTRUCTOR_NO_CLEARING (*elt
) = false;
6371 /* Evaluate a ++ or -- expression. */
6374 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
6376 bool *non_constant_p
, bool *overflow_p
)
6378 enum tree_code code
= TREE_CODE (t
);
6379 tree type
= TREE_TYPE (t
);
6380 tree op
= TREE_OPERAND (t
, 0);
6381 tree offset
= TREE_OPERAND (t
, 1);
6382 gcc_assert (TREE_CONSTANT (offset
));
6384 /* OFFSET is constant, but perhaps not constant enough. We need to
6385 e.g. bash FLOAT_EXPRs to REAL_CSTs. */
6386 offset
= fold_simple (offset
);
6388 /* The operand as an lvalue. */
6389 op
= cxx_eval_constant_expression (ctx
, op
, vc_glvalue
,
6390 non_constant_p
, overflow_p
);
6392 /* The operand as an rvalue. */
6394 = cxx_eval_constant_expression (ctx
, op
, vc_prvalue
,
6395 non_constant_p
, overflow_p
);
6396 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
6397 a local array in a constexpr function. */
6398 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (val
));
6400 VERIFY_CONSTANT (val
);
6402 /* The modified value. */
6403 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
6405 if (INDIRECT_TYPE_P (type
))
6407 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
6408 offset
= convert_to_ptrofftype (offset
);
6410 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
6411 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
6413 else if (c_promoting_integer_type_p (type
)
6414 && !TYPE_UNSIGNED (type
)
6415 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
6417 offset
= fold_convert (integer_type_node
, offset
);
6418 mod
= fold_convert (integer_type_node
, val
);
6419 tree t
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, integer_type_node
,
6421 mod
= fold_convert (type
, t
);
6422 if (TREE_OVERFLOW_P (mod
) && !TREE_OVERFLOW_P (t
))
6423 TREE_OVERFLOW (mod
) = false;
6426 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
6428 VERIFY_CONSTANT (mod
);
6430 /* Storing the modified value. */
6431 tree store
= build2_loc (cp_expr_loc_or_loc (t
, input_location
),
6432 MODIFY_EXPR
, type
, op
, mod
);
6433 mod
= cxx_eval_constant_expression (ctx
, store
, lval
,
6434 non_constant_p
, overflow_p
);
6436 if (*non_constant_p
)
6439 /* And the value of the expression. */
6440 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
6441 /* Prefix ops are lvalues, but the caller might want an rvalue;
6442 lval has already been taken into account in the store above. */
6445 /* Postfix ops are rvalues. */
6449 /* Predicates for the meaning of *jump_target. */
6452 returns (tree
*jump_target
)
6455 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
6459 breaks (tree
*jump_target
)
6462 && ((TREE_CODE (*jump_target
) == LABEL_DECL
6463 && LABEL_DECL_BREAK (*jump_target
))
6464 || TREE_CODE (*jump_target
) == BREAK_STMT
6465 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
6469 continues (tree
*jump_target
)
6472 && ((TREE_CODE (*jump_target
) == LABEL_DECL
6473 && LABEL_DECL_CONTINUE (*jump_target
))
6474 || TREE_CODE (*jump_target
) == CONTINUE_STMT
);
6479 switches (tree
*jump_target
)
6482 && TREE_CODE (*jump_target
) == INTEGER_CST
;
6485 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
6486 STMT matches *jump_target. If we're looking for a case label and we see
6487 the default label, note it in ctx->css_state. */
6490 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
6492 switch (TREE_CODE (*jump_target
))
6495 if (TREE_CODE (stmt
) == LABEL_EXPR
6496 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
6501 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
6503 gcc_assert (ctx
->css_state
!= NULL
);
6504 if (!CASE_LOW (stmt
))
6506 /* default: should appear just once in a SWITCH_EXPR
6507 body (excluding nested SWITCH_EXPR). */
6508 gcc_assert (*ctx
->css_state
!= css_default_seen
);
6509 /* When evaluating SWITCH_EXPR body for the second time,
6510 return true for the default: label. */
6511 if (*ctx
->css_state
== css_default_processing
)
6513 *ctx
->css_state
= css_default_seen
;
6515 else if (CASE_HIGH (stmt
))
6517 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
6518 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
6521 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
6528 /* These two are handled directly in cxx_eval_loop_expr by testing
6529 breaks (jump_target) or continues (jump_target). */
6538 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
6539 semantics, for switch, break, continue, and return. */
6542 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
6543 bool *non_constant_p
, bool *overflow_p
,
6547 /* In a statement-expression we want to return the last value.
6548 For empty statement expression return void_node. */
6552 local_target
= NULL_TREE
;
6553 jump_target
= &local_target
;
6555 for (tree_stmt_iterator i
= tsi_start (t
); !tsi_end_p (i
); ++i
)
6559 /* We've found a continue, so skip everything until we reach
6560 the label its jumping to. */
6561 if (continues (jump_target
))
6563 if (label_matches (ctx
, jump_target
, stmt
))
6565 *jump_target
= NULL_TREE
;
6569 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
6572 value_cat lval
= vc_discard
;
6573 /* The result of a statement-expression is not wrapped in EXPR_STMT. */
6574 if (tsi_one_before_end_p (i
) && TREE_CODE (stmt
) != EXPR_STMT
)
6577 r
= cxx_eval_constant_expression (ctx
, stmt
, lval
,
6578 non_constant_p
, overflow_p
,
6580 if (*non_constant_p
)
6582 if (returns (jump_target
) || breaks (jump_target
))
6585 if (*jump_target
&& jump_target
== &local_target
)
6587 /* We aren't communicating the jump to our caller, so give up. We don't
6588 need to support evaluation of jumps out of statement-exprs. */
6590 error_at (cp_expr_loc_or_input_loc (r
),
6591 "statement is not a constant expression");
6592 *non_constant_p
= true;
6597 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
6598 semantics; continue semantics are covered by cxx_eval_statement_list. */
6601 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
6602 bool *non_constant_p
, bool *overflow_p
,
6605 constexpr_ctx new_ctx
= *ctx
;
6609 local_target
= NULL_TREE
;
6610 jump_target
= &local_target
;
6613 tree body
, cond
= NULL_TREE
, expr
= NULL_TREE
;
6615 switch (TREE_CODE (t
))
6618 body
= LOOP_EXPR_BODY (t
);
6625 body
= WHILE_BODY (t
);
6626 cond
= WHILE_COND (t
);
6630 if (FOR_INIT_STMT (t
))
6631 cxx_eval_constant_expression (ctx
, FOR_INIT_STMT (t
), vc_discard
,
6632 non_constant_p
, overflow_p
, jump_target
);
6633 if (*non_constant_p
)
6635 body
= FOR_BODY (t
);
6636 cond
= FOR_COND (t
);
6637 expr
= FOR_EXPR (t
);
6643 auto_vec
<tree
, 10> save_exprs
;
6644 new_ctx
.save_exprs
= &save_exprs
;
6650 cxx_eval_constant_expression (&new_ctx
, body
, vc_discard
,
6651 non_constant_p
, overflow_p
,
6653 if (breaks (jump_target
))
6655 *jump_target
= NULL_TREE
;
6659 if (TREE_CODE (t
) != LOOP_EXPR
&& continues (jump_target
))
6660 *jump_target
= NULL_TREE
;
6663 cxx_eval_constant_expression (&new_ctx
, expr
, vc_prvalue
,
6664 non_constant_p
, overflow_p
,
6671 = cxx_eval_constant_expression (&new_ctx
, cond
, vc_prvalue
,
6672 non_constant_p
, overflow_p
,
6676 if (verify_constant (res
, ctx
->quiet
, non_constant_p
,
6679 if (integer_zerop (res
))
6683 gcc_assert (*jump_target
);
6686 /* Forget saved values of SAVE_EXPRs and TARGET_EXPRs. */
6687 for (tree save_expr
: save_exprs
)
6688 ctx
->global
->remove_value (save_expr
);
6689 save_exprs
.truncate (0);
6691 if (++count
>= constexpr_loop_limit
)
6694 error_at (cp_expr_loc_or_input_loc (t
),
6695 "%<constexpr%> loop iteration count exceeds limit of %d "
6696 "(use %<-fconstexpr-loop-limit=%> to increase the limit)",
6697 constexpr_loop_limit
);
6698 *non_constant_p
= true;
6702 while (!returns (jump_target
)
6703 && !breaks (jump_target
)
6704 && !continues (jump_target
)
6705 && (!switches (jump_target
) || count
== 0)
6706 && !*non_constant_p
);
6708 /* Forget saved values of SAVE_EXPRs and TARGET_EXPRs. */
6709 for (tree save_expr
: save_exprs
)
6710 ctx
->global
->remove_value (save_expr
);
6715 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
6719 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
6720 bool *non_constant_p
, bool *overflow_p
,
6724 = TREE_CODE (t
) == SWITCH_STMT
? SWITCH_STMT_COND (t
) : SWITCH_COND (t
);
6725 cond
= cxx_eval_constant_expression (ctx
, cond
, vc_prvalue
,
6726 non_constant_p
, overflow_p
);
6727 VERIFY_CONSTANT (cond
);
6728 *jump_target
= cond
;
6731 = TREE_CODE (t
) == SWITCH_STMT
? SWITCH_STMT_BODY (t
) : SWITCH_BODY (t
);
6732 constexpr_ctx new_ctx
= *ctx
;
6733 constexpr_switch_state css
= css_default_not_seen
;
6734 new_ctx
.css_state
= &css
;
6735 cxx_eval_constant_expression (&new_ctx
, body
, vc_discard
,
6736 non_constant_p
, overflow_p
, jump_target
);
6737 if (switches (jump_target
) && css
== css_default_seen
)
6739 /* If the SWITCH_EXPR body has default: label, process it once again,
6740 this time instructing label_matches to return true for default:
6741 label on switches (jump_target). */
6742 css
= css_default_processing
;
6743 cxx_eval_constant_expression (&new_ctx
, body
, vc_discard
,
6744 non_constant_p
, overflow_p
, jump_target
);
6746 if (breaks (jump_target
) || switches (jump_target
))
6747 *jump_target
= NULL_TREE
;
6751 /* Find the object of TYPE under initialization in CTX. */
6754 lookup_placeholder (const constexpr_ctx
*ctx
, value_cat lval
, tree type
)
6759 /* Prefer the outermost matching object, but don't cross
6760 CONSTRUCTOR_PLACEHOLDER_BOUNDARY constructors. */
6761 if (ctx
->ctor
&& !CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ctx
->ctor
))
6762 if (tree outer_ob
= lookup_placeholder (ctx
->parent
, lval
, type
))
6765 /* We could use ctx->object unconditionally, but using ctx->ctor when we
6766 can is a minor optimization. */
6767 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
6773 /* Since an object cannot have a field of its own type, we can search outward
6774 from ctx->object to find the unique containing object of TYPE. */
6775 tree ob
= ctx
->object
;
6778 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
6780 if (handled_component_p (ob
))
6781 ob
= TREE_OPERAND (ob
, 0);
6789 /* Complain about an attempt to evaluate inline assembly. If FUNDEF_P is
6790 true, we're checking a constexpr function body. */
6793 inline_asm_in_constexpr_error (location_t loc
, bool fundef_p
)
6795 auto_diagnostic_group d
;
6796 if (constexpr_error (loc
, fundef_p
, "inline assembly is not a "
6797 "constant expression"))
6798 inform (loc
, "only unevaluated inline assembly is allowed in a "
6799 "%<constexpr%> function in C++20");
6802 /* We're getting the constant value of DECL in a manifestly constant-evaluated
6803 context; maybe complain about that. */
6806 maybe_warn_about_constant_value (location_t loc
, tree decl
)
6808 static bool explained
= false;
6809 if (cxx_dialect
>= cxx17
6810 && warn_interference_size
6811 && !OPTION_SET_P (param_destruct_interfere_size
)
6812 && DECL_CONTEXT (decl
) == std_node
6813 && id_equal (DECL_NAME (decl
), "hardware_destructive_interference_size")
6814 && (LOCATION_FILE (input_location
) != main_input_filename
6815 || module_exporting_p ())
6816 && warning_at (loc
, OPT_Winterference_size
, "use of %qD", decl
)
6820 inform (loc
, "its value can vary between compiler versions or "
6821 "with different %<-mtune%> or %<-mcpu%> flags");
6822 inform (loc
, "if this use is part of a public ABI, change it to "
6823 "instead use a constant variable you define");
6824 inform (loc
, "the default value for the current CPU tuning "
6825 "is %d bytes", param_destruct_interfere_size
);
6826 inform (loc
, "you can stabilize this value with %<--param "
6827 "hardware_destructive_interference_size=%d%>, or disable "
6828 "this warning with %<-Wno-interference-size%>",
6829 param_destruct_interfere_size
);
6833 /* For element type ELT_TYPE, return the appropriate type of the heap object
6834 containing such element(s). COOKIE_SIZE is NULL or the size of cookie
6835 in bytes. If COOKIE_SIZE is NULL, return array type
6836 ELT_TYPE[FULL_SIZE / sizeof(ELT_TYPE)], otherwise return
6837 struct { size_t[COOKIE_SIZE/sizeof(size_t)]; ELT_TYPE[N]; }
6838 where N is is computed such that the size of the struct fits into FULL_SIZE.
6839 If ARG_SIZE is non-NULL, it is the first argument to the new operator.
6840 It should be passed if ELT_TYPE is zero sized type in which case FULL_SIZE
6841 will be also 0 and so it is not possible to determine the actual array
6842 size. CTX, NON_CONSTANT_P and OVERFLOW_P are used during constant
6843 expression evaluation of subexpressions of ARG_SIZE. */
6846 build_new_constexpr_heap_type (const constexpr_ctx
*ctx
, tree elt_type
,
6847 tree cookie_size
, tree full_size
, tree arg_size
,
6848 bool *non_constant_p
, bool *overflow_p
)
6850 gcc_assert (cookie_size
== NULL_TREE
|| tree_fits_uhwi_p (cookie_size
));
6851 gcc_assert (tree_fits_uhwi_p (full_size
));
6852 unsigned HOST_WIDE_INT csz
= cookie_size
? tree_to_uhwi (cookie_size
) : 0;
6855 STRIP_NOPS (arg_size
);
6858 if (TREE_CODE (arg_size
) != PLUS_EXPR
)
6859 arg_size
= NULL_TREE
;
6860 else if (TREE_CODE (TREE_OPERAND (arg_size
, 0)) == INTEGER_CST
6861 && tree_int_cst_equal (cookie_size
,
6862 TREE_OPERAND (arg_size
, 0)))
6864 arg_size
= TREE_OPERAND (arg_size
, 1);
6865 STRIP_NOPS (arg_size
);
6867 else if (TREE_CODE (TREE_OPERAND (arg_size
, 1)) == INTEGER_CST
6868 && tree_int_cst_equal (cookie_size
,
6869 TREE_OPERAND (arg_size
, 1)))
6871 arg_size
= TREE_OPERAND (arg_size
, 0);
6872 STRIP_NOPS (arg_size
);
6875 arg_size
= NULL_TREE
;
6877 if (arg_size
&& TREE_CODE (arg_size
) == MULT_EXPR
)
6879 tree op0
= TREE_OPERAND (arg_size
, 0);
6880 tree op1
= TREE_OPERAND (arg_size
, 1);
6881 if (integer_zerop (op0
))
6883 = cxx_eval_constant_expression (ctx
, op1
, vc_prvalue
,
6884 non_constant_p
, overflow_p
);
6885 else if (integer_zerop (op1
))
6887 = cxx_eval_constant_expression (ctx
, op0
, vc_prvalue
,
6888 non_constant_p
, overflow_p
);
6890 arg_size
= NULL_TREE
;
6893 arg_size
= NULL_TREE
;
6896 unsigned HOST_WIDE_INT fsz
= tree_to_uhwi (arg_size
? arg_size
: full_size
);
6899 unsigned HOST_WIDE_INT esz
= int_size_in_bytes (elt_type
);
6900 gcc_assert (fsz
>= csz
);
6905 tree itype2
= build_index_type (size_int (fsz
- 1));
6907 return build_cplus_array_type (elt_type
, itype2
);
6908 return build_new_constexpr_heap_type (elt_type
, cookie_size
, itype2
);
6911 /* Attempt to reduce the expression T to a constant value.
6912 On failure, issue diagnostic and return error_mark_node. */
6913 /* FIXME unify with c_fully_fold */
6914 /* FIXME overflow_p is too global */
6917 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
6919 bool *non_constant_p
, bool *overflow_p
,
6920 tree
*jump_target
/* = NULL */)
6922 if (jump_target
&& *jump_target
)
6924 /* If we are jumping, ignore all statements/expressions except those
6925 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
6926 switch (TREE_CODE (t
))
6929 case STATEMENT_LIST
:
6938 case CASE_LABEL_EXPR
:
6939 if (label_matches (ctx
, jump_target
, t
))
6941 *jump_target
= NULL_TREE
;
6947 if (error_operand_p (t
))
6949 *non_constant_p
= true;
6953 location_t loc
= cp_expr_loc_or_input_loc (t
);
6955 STRIP_ANY_LOCATION_WRAPPER (t
);
6957 if (CONSTANT_CLASS_P (t
))
6959 if (TREE_OVERFLOW (t
))
6962 permerror (input_location
, "overflow in constant expression");
6963 if (!flag_permissive
|| ctx
->quiet
)
6967 if (TREE_CODE (t
) == INTEGER_CST
6968 && TYPE_PTR_P (TREE_TYPE (t
))
6969 /* INTEGER_CST with pointer-to-method type is only used
6970 for a virtual method in a pointer to member function.
6971 Don't reject those. */
6972 && TREE_CODE (TREE_TYPE (TREE_TYPE (t
))) != METHOD_TYPE
6973 && !integer_zerop (t
))
6976 error ("value %qE of type %qT is not a constant expression",
6978 *non_constant_p
= true;
6984 /* Avoid excessively long constexpr evaluations. */
6985 if (++ctx
->global
->constexpr_ops_count
>= constexpr_ops_limit
)
6989 "%<constexpr%> evaluation operation count exceeds limit of "
6990 "%wd (use %<-fconstexpr-ops-limit=%> to increase the limit)",
6991 constexpr_ops_limit
);
6992 ctx
->global
->constexpr_ops_count
= INTTYPE_MINIMUM (HOST_WIDE_INT
);
6993 *non_constant_p
= true;
6997 constexpr_ctx new_ctx
;
7000 tree_code tcode
= TREE_CODE (t
);
7006 /* We ask for an rvalue for the RESULT_DECL when indirecting
7007 through an invisible reference, or in named return value
7009 if (tree v
= ctx
->global
->get_value (t
))
7014 error ("%qE is not a constant expression", t
);
7015 *non_constant_p
= true;
7020 if (DECL_HAS_VALUE_EXPR_P (t
))
7022 if (is_normal_capture_proxy (t
)
7023 && current_function_decl
== DECL_CONTEXT (t
))
7025 /* Function parms aren't constexpr within the function
7026 definition, so don't try to look at the closure. But if the
7027 captured variable is constant, try to evaluate it directly. */
7028 r
= DECL_CAPTURED_VARIABLE (t
);
7029 tree type
= TREE_TYPE (t
);
7030 if (TYPE_REF_P (type
) != TYPE_REF_P (TREE_TYPE (r
)))
7032 /* Adjust r to match the reference-ness of t. */
7033 if (TYPE_REF_P (type
))
7034 r
= build_address (r
);
7036 r
= convert_from_reference (r
);
7040 r
= DECL_VALUE_EXPR (t
);
7041 return cxx_eval_constant_expression (ctx
, r
, lval
, non_constant_p
,
7046 /* We used to not check lval for CONST_DECL, but darwin.cc uses
7047 CONST_DECL for aggregate constants. */
7050 else if (t
== ctx
->object
)
7053 if (tree v
= ctx
->global
->get_value (t
))
7058 if (ctx
->manifestly_const_eval
== mce_true
)
7059 maybe_warn_about_constant_value (loc
, t
);
7060 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
7061 && is_really_empty_class (TREE_TYPE (t
), /*ignore_vptr*/false))
7063 /* If the class is empty, we aren't actually loading anything. */
7064 r
= build_constructor (TREE_TYPE (t
), NULL
);
7065 TREE_CONSTANT (r
) = true;
7067 else if (ctx
->strict
)
7068 r
= decl_really_constant_value (t
, /*unshare_p=*/false);
7070 r
= decl_constant_value (t
, /*unshare_p=*/false);
7071 if (TREE_CODE (r
) == TARGET_EXPR
7072 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
7073 r
= TARGET_EXPR_INITIAL (r
);
7077 non_const_var_error (loc
, r
, /*fundef_p*/false);
7078 *non_constant_p
= true;
7082 case DEBUG_BEGIN_STMT
:
7083 /* ??? It might be nice to retain this information somehow, so
7084 as to be able to step into a constexpr function call. */
7091 case CASE_LABEL_EXPR
:
7096 if (lval
&& !TYPE_REF_P (TREE_TYPE (t
)))
7098 else if (tree v
= ctx
->global
->get_value (t
))
7101 /* Defer in case this is only used for its type. */;
7102 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
7103 && is_really_empty_class (TREE_TYPE (t
), /*ignore_vptr*/false))
7105 /* If the class is empty, we aren't actually loading anything. */
7106 r
= build_constructor (TREE_TYPE (t
), NULL
);
7107 TREE_CONSTANT (r
) = true;
7112 error ("%qE is not a constant expression", t
);
7113 *non_constant_p
= true;
7118 case AGGR_INIT_EXPR
:
7119 r
= cxx_eval_call_expression (ctx
, t
, lval
,
7120 non_constant_p
, overflow_p
);
7125 r
= DECL_EXPR_DECL (t
);
7126 if (TREE_CODE (r
) == USING_DECL
)
7134 || (CP_DECL_THREAD_LOCAL_P (r
) && !DECL_REALLY_EXTERN (r
)))
7135 /* Allow __FUNCTION__ etc. */
7136 && !DECL_ARTIFICIAL (r
)
7137 && !decl_constant_var_p (r
))
7141 if (CP_DECL_THREAD_LOCAL_P (r
))
7142 error_at (loc
, "control passes through definition of %qD "
7143 "with thread storage duration", r
);
7145 error_at (loc
, "control passes through definition of %qD "
7146 "with static storage duration", r
);
7148 *non_constant_p
= true;
7152 /* make_rtl_for_nonlocal_decl could have deferred emission of
7153 a local static var, but if it appears in a statement expression
7154 which is constant expression evaluated to e.g. just the address
7155 of the variable, its DECL_EXPR will never be seen during
7156 gimple lowering's record_vars_into as the statement expression
7157 will not be in the IL at all. */
7160 && !DECL_REALLY_EXTERN (r
)
7161 && DECL_FUNCTION_SCOPE_P (r
)
7162 && !var_in_maybe_constexpr_fn (r
)
7163 && decl_constant_var_p (r
))
7165 varpool_node
*node
= varpool_node::get (r
);
7166 if (node
== NULL
|| !node
->definition
)
7167 rest_of_decl_compilation (r
, 0, at_eof
);
7170 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
7171 || VECTOR_TYPE_P (TREE_TYPE (r
)))
7175 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
7176 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
7177 ctx
->global
->put_value (r
, new_ctx
.ctor
);
7181 if (tree init
= DECL_INITIAL (r
))
7183 init
= cxx_eval_constant_expression (ctx
, init
, vc_prvalue
,
7184 non_constant_p
, overflow_p
);
7185 /* Don't share a CONSTRUCTOR that might be changed. */
7186 init
= unshare_constructor (init
);
7187 /* Remember that a constant object's constructor has already
7189 if (CLASS_TYPE_P (TREE_TYPE (r
))
7190 && CP_TYPE_CONST_P (TREE_TYPE (r
)))
7191 TREE_READONLY (init
) = true;
7192 ctx
->global
->put_value (r
, init
);
7194 else if (ctx
== &new_ctx
)
7195 /* We gave it a CONSTRUCTOR above. */;
7197 ctx
->global
->put_value (r
, NULL_TREE
);
7203 tree type
= TREE_TYPE (t
);
7205 if (!literal_type_p (type
))
7209 auto_diagnostic_group d
;
7210 error ("temporary of non-literal type %qT in a "
7211 "constant expression", type
);
7212 explain_non_literal_class (type
);
7214 *non_constant_p
= true;
7217 gcc_checking_assert (!TARGET_EXPR_DIRECT_INIT_P (t
));
7218 /* Avoid evaluating a TARGET_EXPR more than once. */
7219 tree slot
= TARGET_EXPR_SLOT (t
);
7220 if (tree v
= ctx
->global
->get_value (slot
))
7227 if ((AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
)))
7229 /* We're being expanded without an explicit target, so start
7230 initializing a new object; expansion with an explicit target
7231 strips the TARGET_EXPR before we get here. */
7233 /* Link CTX to NEW_CTX so that lookup_placeholder can resolve
7234 any PLACEHOLDER_EXPR within the initializer that refers to the
7235 former object under construction. */
7236 new_ctx
.parent
= ctx
;
7237 new_ctx
.ctor
= build_constructor (type
, NULL
);
7238 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
7239 new_ctx
.object
= slot
;
7240 ctx
->global
->put_value (new_ctx
.object
, new_ctx
.ctor
);
7243 /* Pass vc_prvalue because this indicates
7244 initialization of a temporary. */
7245 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), vc_prvalue
,
7246 non_constant_p
, overflow_p
);
7247 if (*non_constant_p
)
7249 /* If the initializer is complex, evaluate it to initialize slot. */
7250 bool is_complex
= target_expr_needs_replace (t
);
7253 r
= unshare_constructor (r
);
7254 /* Adjust the type of the result to the type of the temporary. */
7255 r
= adjust_temp_type (type
, r
);
7256 ctx
->global
->put_value (slot
, r
);
7258 if (TARGET_EXPR_CLEANUP (t
) && !CLEANUP_EH_ONLY (t
))
7259 ctx
->global
->cleanups
->safe_push (TARGET_EXPR_CLEANUP (t
));
7260 if (ctx
->save_exprs
)
7261 ctx
->save_exprs
->safe_push (slot
);
7265 r
= ctx
->global
->get_value (slot
);
7271 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
7272 r
= cxx_eval_store_expression (ctx
, t
, lval
,
7273 non_constant_p
, overflow_p
);
7277 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
7279 non_constant_p
, overflow_p
);
7283 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
7284 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
7286 non_constant_p
, overflow_p
);
7294 /* Can happen with ({ return true; }) && false; passed to
7295 maybe_constant_value. There is nothing to jump over in this
7296 case, and the bug will be diagnosed later. */
7297 gcc_assert (ctx
->quiet
);
7298 *non_constant_p
= true;
7303 /* Avoid evaluating a SAVE_EXPR more than once. */
7304 if (tree v
= ctx
->global
->get_value (t
))
7308 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), vc_prvalue
,
7309 non_constant_p
, overflow_p
);
7310 if (*non_constant_p
)
7312 ctx
->global
->put_value (t
, r
);
7313 if (ctx
->save_exprs
)
7314 ctx
->save_exprs
->safe_push (t
);
7318 case TRY_CATCH_EXPR
:
7319 if (TREE_OPERAND (t
, 0) == NULL_TREE
)
7325 case NON_LVALUE_EXPR
:
7327 case MUST_NOT_THROW_EXPR
:
7330 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
7332 non_constant_p
, overflow_p
,
7336 case CLEANUP_POINT_EXPR
:
7338 auto_vec
<tree
, 2> cleanups
;
7339 vec
<tree
> *prev_cleanups
= ctx
->global
->cleanups
;
7340 ctx
->global
->cleanups
= &cleanups
;
7341 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
7343 non_constant_p
, overflow_p
,
7345 ctx
->global
->cleanups
= prev_cleanups
;
7348 /* Evaluate the cleanups. */
7349 FOR_EACH_VEC_ELT_REVERSE (cleanups
, i
, cleanup
)
7350 cxx_eval_constant_expression (ctx
, cleanup
, vc_discard
,
7351 non_constant_p
, overflow_p
);
7355 case TRY_FINALLY_EXPR
:
7356 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
7357 non_constant_p
, overflow_p
,
7359 if (!*non_constant_p
)
7360 /* Also evaluate the cleanup. */
7361 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), vc_discard
,
7362 non_constant_p
, overflow_p
);
7366 r
= cxx_eval_constant_expression (ctx
, CLEANUP_BODY (t
), lval
,
7367 non_constant_p
, overflow_p
,
7369 if (!CLEANUP_EH_ONLY (t
) && !*non_constant_p
)
7371 iloc_sentinel
ils (loc
);
7372 /* Also evaluate the cleanup. */
7373 cxx_eval_constant_expression (ctx
, CLEANUP_EXPR (t
), vc_discard
,
7374 non_constant_p
, overflow_p
);
7378 /* These differ from cxx_eval_unary_expression in that this doesn't
7379 check for a constant operand or result; an address can be
7380 constant without its operand being, and vice versa. */
7383 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
7384 non_constant_p
, overflow_p
);
7389 tree oldop
= TREE_OPERAND (t
, 0);
7390 tree op
= cxx_eval_constant_expression (ctx
, oldop
, vc_glvalue
,
7391 non_constant_p
, overflow_p
);
7392 /* Don't VERIFY_CONSTANT here. */
7393 if (*non_constant_p
)
7395 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
7396 /* This function does more aggressive folding than fold itself. */
7397 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
7398 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
7410 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
7411 non_constant_p
, overflow_p
);
7412 if (r
== error_mark_node
)
7414 else if (r
== TREE_OPERAND (t
, 0) || lval
== vc_discard
)
7417 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
7422 case FIX_TRUNC_EXPR
:
7428 case TRUTH_NOT_EXPR
:
7429 case FIXED_CONVERT_EXPR
:
7430 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
7431 non_constant_p
, overflow_p
);
7435 r
= fold_sizeof_expr (t
);
7436 /* In a template, fold_sizeof_expr may merely create a new SIZEOF_EXPR,
7437 which could lead to an infinite recursion. */
7438 if (TREE_CODE (r
) != SIZEOF_EXPR
)
7439 r
= cxx_eval_constant_expression (ctx
, r
, lval
,
7440 non_constant_p
, overflow_p
,
7444 *non_constant_p
= true;
7445 gcc_assert (ctx
->quiet
);
7452 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7453 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7454 introduced by build_call_a. */
7455 tree op0
= TREE_OPERAND (t
, 0);
7456 tree op1
= TREE_OPERAND (t
, 1);
7458 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7459 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7460 r
= cxx_eval_constant_expression (ctx
, op0
,
7461 lval
, non_constant_p
, overflow_p
,
7465 /* Check that the LHS is constant and then discard it. */
7466 cxx_eval_constant_expression (ctx
, op0
, vc_discard
,
7467 non_constant_p
, overflow_p
,
7469 if (*non_constant_p
)
7471 op1
= TREE_OPERAND (t
, 1);
7472 r
= cxx_eval_constant_expression (ctx
, op1
,
7473 lval
, non_constant_p
, overflow_p
,
7479 case POINTER_PLUS_EXPR
:
7480 case POINTER_DIFF_EXPR
:
7484 case TRUNC_DIV_EXPR
:
7486 case FLOOR_DIV_EXPR
:
7487 case ROUND_DIV_EXPR
:
7488 case TRUNC_MOD_EXPR
:
7490 case ROUND_MOD_EXPR
:
7492 case EXACT_DIV_EXPR
:
7502 case TRUTH_XOR_EXPR
:
7509 case SPACESHIP_EXPR
:
7510 case UNORDERED_EXPR
:
7520 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
7521 non_constant_p
, overflow_p
);
7524 /* fold can introduce non-IF versions of these; still treat them as
7525 short-circuiting. */
7526 case TRUTH_AND_EXPR
:
7527 case TRUTH_ANDIF_EXPR
:
7528 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
7530 non_constant_p
, overflow_p
);
7534 case TRUTH_ORIF_EXPR
:
7535 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
7537 non_constant_p
, overflow_p
);
7541 r
= cxx_eval_array_reference (ctx
, t
, lval
,
7542 non_constant_p
, overflow_p
);
7546 if (is_overloaded_fn (t
))
7548 /* We can only get here in checking mode via
7549 build_non_dependent_expr, because any expression that
7550 calls or takes the address of the function will have
7551 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
7552 gcc_checking_assert (ctx
->quiet
|| errorcount
);
7553 *non_constant_p
= true;
7556 r
= cxx_eval_component_reference (ctx
, t
, lval
,
7557 non_constant_p
, overflow_p
);
7561 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
7562 non_constant_p
, overflow_p
);
7567 if (jump_target
&& *jump_target
)
7569 tree orig_jump
= *jump_target
;
7570 tree arg
= ((TREE_CODE (t
) != IF_STMT
|| TREE_OPERAND (t
, 1))
7571 ? TREE_OPERAND (t
, 1) : void_node
);
7572 /* When jumping to a label, the label might be either in the
7573 then or else blocks, so process then block first in skipping
7574 mode first, and if we are still in the skipping mode at its end,
7575 process the else block too. */
7576 r
= cxx_eval_constant_expression (ctx
, arg
, lval
, non_constant_p
,
7577 overflow_p
, jump_target
);
7578 /* It's possible that we found the label in the then block. But
7579 it could have been followed by another jumping statement, e.g.
7580 say we're looking for case 1:
7583 // skipped statements
7584 case 1:; // clears up *jump_target
7585 return 1; // and sets it to a RETURN_EXPR
7588 in which case we need not go looking to the else block.
7589 (goto is not allowed in a constexpr function.) */
7590 if (*jump_target
== orig_jump
)
7592 arg
= ((TREE_CODE (t
) != IF_STMT
|| TREE_OPERAND (t
, 2))
7593 ? TREE_OPERAND (t
, 2) : void_node
);
7594 r
= cxx_eval_constant_expression (ctx
, arg
, lval
, non_constant_p
,
7595 overflow_p
, jump_target
);
7599 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
7600 non_constant_p
, overflow_p
,
7604 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
7609 if (TREE_CONSTANT (t
) && reduced_constant_expression_p (t
))
7611 /* Don't re-process a constant CONSTRUCTOR. */
7612 verify_constructor_flags (t
);
7613 if (TREE_CONSTANT (t
))
7616 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
7617 non_constant_p
, overflow_p
);
7621 /* We can get this in a defaulted constructor for a class with a
7622 non-static data member of array type. Either the initializer will
7623 be NULL, meaning default-initialization, or it will be an lvalue
7624 or xvalue of the same type, meaning direct-initialization from the
7625 corresponding member. */
7626 r
= cxx_eval_vec_init (ctx
, t
, lval
,
7627 non_constant_p
, overflow_p
);
7631 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
7632 non_constant_p
, overflow_p
);
7636 gcc_assert (!REF_PARENTHESIZED_P (t
));
7637 /* A PAREN_EXPR resulting from __builtin_assoc_barrier has no effect in
7638 constant expressions since it's unaffected by -fassociative-math. */
7639 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
7640 non_constant_p
, overflow_p
);
7644 if (REINTERPRET_CAST_P (t
))
7648 "%<reinterpret_cast%> is not a constant expression");
7649 *non_constant_p
= true;
7654 case VIEW_CONVERT_EXPR
:
7655 case UNARY_PLUS_EXPR
:
7657 tree oldop
= TREE_OPERAND (t
, 0);
7659 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
7661 non_constant_p
, overflow_p
);
7662 if (*non_constant_p
)
7664 tree type
= TREE_TYPE (t
);
7666 if (VOID_TYPE_P (type
))
7669 if (TREE_CODE (t
) == CONVERT_EXPR
7670 && ARITHMETIC_TYPE_P (type
)
7671 && INDIRECT_TYPE_P (TREE_TYPE (op
))
7672 && ctx
->manifestly_const_eval
== mce_true
)
7676 "conversion from pointer type %qT to arithmetic type "
7677 "%qT in a constant expression", TREE_TYPE (op
), type
);
7678 *non_constant_p
= true;
7682 /* [expr.const]: a conversion from type cv void* to a pointer-to-object
7683 type cannot be part of a core constant expression as a resolution to
7685 if (TYPE_PTROB_P (type
)
7686 && TYPE_PTR_P (TREE_TYPE (op
))
7687 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (op
)))
7688 /* Inside a call to std::construct_at or to
7689 std::allocator<T>::{,de}allocate, we permit casting from void*
7690 because that is compiler-generated code. */
7691 && !is_std_construct_at (ctx
->call
)
7692 && !is_std_allocator_allocate (ctx
->call
))
7694 /* Likewise, don't error when casting from void* when OP is
7695 &heap uninit and similar. */
7696 tree sop
= tree_strip_nop_conversions (op
);
7697 if (TREE_CODE (sop
) == ADDR_EXPR
7698 && VAR_P (TREE_OPERAND (sop
, 0))
7699 && DECL_ARTIFICIAL (TREE_OPERAND (sop
, 0)))
7701 /* P2738 (C++26): a conversion from a prvalue P of type "pointer to
7702 cv void" to a pointer-to-object type T unless P points to an
7703 object whose type is similar to T. */
7704 else if (cxx_dialect
> cxx23
7705 && (sop
= cxx_fold_indirect_ref (ctx
, loc
,
7706 TREE_TYPE (type
), sop
)))
7708 r
= build1 (ADDR_EXPR
, type
, sop
);
7714 error_at (loc
, "cast from %qT is not allowed",
7716 *non_constant_p
= true;
7721 if (TREE_CODE (op
) == PTRMEM_CST
&& !TYPE_PTRMEM_P (type
))
7723 op
= cplus_expand_constant (op
);
7724 if (TREE_CODE (op
) == PTRMEM_CST
)
7727 error_at (loc
, "%qE is not a constant expression when the "
7728 "class %qT is still incomplete", op
,
7729 PTRMEM_CST_CLASS (op
));
7730 *non_constant_p
= true;
7735 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
7737 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (op
))
7738 && !can_convert_qual (type
, op
))
7739 op
= cplus_expand_constant (op
);
7740 return cp_fold_convert (type
, op
);
7743 if (INDIRECT_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
7745 if (integer_zerop (op
))
7747 if (TYPE_REF_P (type
))
7750 error_at (loc
, "dereferencing a null pointer");
7751 *non_constant_p
= true;
7757 /* This detects for example:
7758 reinterpret_cast<void*>(sizeof 0)
7761 error_at (loc
, "%<reinterpret_cast<%T>(%E)%> is not "
7762 "a constant expression",
7764 *non_constant_p
= true;
7769 if (INDIRECT_TYPE_P (type
)
7770 && TREE_CODE (op
) == NOP_EXPR
7771 && TREE_TYPE (op
) == ptr_type_node
7772 && TREE_CODE (TREE_OPERAND (op
, 0)) == ADDR_EXPR
7773 && VAR_P (TREE_OPERAND (TREE_OPERAND (op
, 0), 0))
7774 && (DECL_NAME (TREE_OPERAND (TREE_OPERAND (op
, 0),
7775 0)) == heap_uninit_identifier
7776 || DECL_NAME (TREE_OPERAND (TREE_OPERAND (op
, 0),
7777 0)) == heap_vec_uninit_identifier
))
7779 tree var
= TREE_OPERAND (TREE_OPERAND (op
, 0), 0);
7780 tree var_size
= TYPE_SIZE_UNIT (TREE_TYPE (var
));
7781 tree elt_type
= TREE_TYPE (type
);
7782 tree cookie_size
= NULL_TREE
;
7783 tree arg_size
= NULL_TREE
;
7784 if (TREE_CODE (elt_type
) == RECORD_TYPE
7785 && TYPE_NAME (elt_type
) == heap_identifier
)
7787 tree fld1
= TYPE_FIELDS (elt_type
);
7788 tree fld2
= DECL_CHAIN (fld1
);
7789 elt_type
= TREE_TYPE (TREE_TYPE (fld2
));
7790 cookie_size
= TYPE_SIZE_UNIT (TREE_TYPE (fld1
));
7793 = (DECL_NAME (var
) == heap_uninit_identifier
7794 ? heap_identifier
: heap_vec_identifier
);
7795 /* For zero sized elt_type, try to recover how many outer_nelts
7797 if ((cookie_size
? tree_int_cst_equal (var_size
, cookie_size
)
7798 : integer_zerop (var_size
))
7799 && !int_size_in_bytes (elt_type
)
7800 && TREE_CODE (oldop
) == CALL_EXPR
7801 && call_expr_nargs (oldop
) >= 1)
7802 if (tree fun
= get_function_named_in_call (oldop
))
7803 if (cxx_replaceable_global_alloc_fn (fun
)
7804 && IDENTIFIER_NEW_OP_P (DECL_NAME (fun
)))
7805 arg_size
= CALL_EXPR_ARG (oldop
, 0);
7807 = build_new_constexpr_heap_type (ctx
, elt_type
, cookie_size
,
7809 non_constant_p
, overflow_p
);
7810 TREE_TYPE (TREE_OPERAND (op
, 0))
7811 = build_pointer_type (TREE_TYPE (var
));
7814 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
7815 /* We didn't fold at the top so we could check for ptr-int
7821 /* Handle an array's bounds having been deduced after we built
7822 the wrapping expression. */
7823 if (same_type_ignoring_tlq_and_bounds_p (type
, TREE_TYPE (op
)))
7825 else if (sop
= tree_strip_nop_conversions (op
),
7826 sop
!= op
&& (same_type_ignoring_tlq_and_bounds_p
7827 (type
, TREE_TYPE (sop
))))
7829 else if (tcode
== UNARY_PLUS_EXPR
)
7830 r
= fold_convert (TREE_TYPE (t
), op
);
7832 r
= fold_build1 (tcode
, type
, op
);
7834 /* Conversion of an out-of-range value has implementation-defined
7835 behavior; the language considers it different from arithmetic
7836 overflow, which is undefined. */
7837 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
7838 TREE_OVERFLOW (r
) = false;
7842 case EXCESS_PRECISION_EXPR
:
7844 tree oldop
= TREE_OPERAND (t
, 0);
7846 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
7848 non_constant_p
, overflow_p
);
7849 if (*non_constant_p
)
7851 r
= fold_convert (TREE_TYPE (t
), op
);
7855 case EMPTY_CLASS_EXPR
:
7856 /* Handle EMPTY_CLASS_EXPR produced by build_call_a by lowering
7857 it to an appropriate CONSTRUCTOR. */
7858 return build_constructor (TREE_TYPE (t
), NULL
);
7860 case STATEMENT_LIST
:
7862 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
7863 return cxx_eval_statement_list (&new_ctx
, t
,
7864 non_constant_p
, overflow_p
, jump_target
);
7867 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
7869 non_constant_p
, overflow_p
,
7872 case PREINCREMENT_EXPR
:
7873 case POSTINCREMENT_EXPR
:
7874 case PREDECREMENT_EXPR
:
7875 case POSTDECREMENT_EXPR
:
7876 return cxx_eval_increment_expression (ctx
, t
,
7877 lval
, non_constant_p
, overflow_p
);
7883 case VEC_DELETE_EXPR
:
7886 /* GCC internal stuff. */
7888 case NON_DEPENDENT_EXPR
:
7892 error_at (loc
, "expression %qE is not a constant expression", t
);
7893 *non_constant_p
= true;
7897 /* Virtual function lookup. We don't need to do anything fancy. */
7898 return cxx_eval_constant_expression (ctx
, OBJ_TYPE_REF_EXPR (t
),
7899 lval
, non_constant_p
, overflow_p
);
7901 case PLACEHOLDER_EXPR
:
7902 /* Use of the value or address of the current object. */
7903 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
7905 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
7908 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
7909 non_constant_p
, overflow_p
);
7911 /* A placeholder without a referent. We can get here when
7912 checking whether NSDMIs are noexcept, or in massage_init_elt;
7913 just say it's non-constant for now. */
7914 gcc_assert (ctx
->quiet
);
7915 *non_constant_p
= true;
7920 tree cond
= TREE_OPERAND (t
, 0);
7921 cond
= cxx_eval_constant_expression (ctx
, cond
, vc_prvalue
,
7922 non_constant_p
, overflow_p
);
7923 VERIFY_CONSTANT (cond
);
7924 if (integer_nonzerop (cond
))
7930 if (breaks (&TREE_OPERAND (t
, 0))
7931 || continues (&TREE_OPERAND (t
, 0)))
7932 *jump_target
= TREE_OPERAND (t
, 0);
7935 gcc_assert (cxx_dialect
>= cxx23
);
7937 error_at (loc
, "%<goto%> is not a constant expression");
7938 *non_constant_p
= true;
7946 cxx_eval_loop_expr (ctx
, t
,
7947 non_constant_p
, overflow_p
, jump_target
);
7952 cxx_eval_switch_expr (ctx
, t
,
7953 non_constant_p
, overflow_p
, jump_target
);
7957 /* It's possible to get a requires-expression in a constant
7958 expression. For example:
7960 template<typename T> concept bool C() {
7961 return requires (T t) { t; };
7964 template<typename T> requires !C<T>() void f(T);
7966 Normalization leaves f with the associated constraint
7967 '!requires (T t) { ... }' which is not transformed into
7969 if (!processing_template_decl
)
7970 return evaluate_requires_expr (t
);
7972 *non_constant_p
= true;
7976 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
7978 non_constant_p
, overflow_p
,
7986 case ASSERTION_STMT
:
7987 case PRECONDITION_STMT
:
7988 case POSTCONDITION_STMT
:
7990 contract_semantic semantic
= get_contract_semantic (t
);
7991 if (semantic
== CCS_IGNORE
)
7994 if (!cxx_eval_assert (ctx
, CONTRACT_CONDITION (t
),
7995 G_("contract predicate is false in "
7996 "constant expression"),
7997 EXPR_LOCATION (t
), checked_contract_p (semantic
),
7998 non_constant_p
, overflow_p
))
7999 *non_constant_p
= true;
8004 case TEMPLATE_ID_EXPR
:
8006 /* We can evaluate template-id that refers to a concept only if
8007 the template arguments are non-dependent. */
8008 tree id
= unpack_concept_check (t
);
8009 tree tmpl
= TREE_OPERAND (id
, 0);
8010 if (!concept_definition_p (tmpl
))
8011 internal_error ("unexpected template-id %qE", t
);
8013 if (function_concept_p (tmpl
))
8016 error_at (cp_expr_loc_or_input_loc (t
),
8017 "function concept must be called");
8018 r
= error_mark_node
;
8022 if (!value_dependent_expression_p (t
)
8023 && !uid_sensitive_constexpr_evaluation_p ())
8024 r
= evaluate_concept_check (t
);
8026 *non_constant_p
= true;
8033 inline_asm_in_constexpr_error (loc
, /*constexpr_fundef_p*/false);
8034 *non_constant_p
= true;
8041 error_at (EXPR_LOCATION (t
),
8042 "address of a call to %qs is not a constant expression",
8043 "__builtin_bit_cast");
8044 *non_constant_p
= true;
8047 r
= cxx_eval_bit_cast (ctx
, t
, non_constant_p
, overflow_p
);
8054 case OMP_DISTRIBUTE
:
8058 case OMP_TARGET_DATA
:
8070 case OMP_TARGET_UPDATE
:
8071 case OMP_TARGET_ENTER_DATA
:
8072 case OMP_TARGET_EXIT_DATA
:
8074 case OMP_ATOMIC_READ
:
8075 case OMP_ATOMIC_CAPTURE_OLD
:
8076 case OMP_ATOMIC_CAPTURE_NEW
:
8082 case OACC_HOST_DATA
:
8086 case OACC_ENTER_DATA
:
8087 case OACC_EXIT_DATA
:
8090 error_at (EXPR_LOCATION (t
),
8091 "statement is not a constant expression");
8092 *non_constant_p
= true;
8096 if (STATEMENT_CODE_P (TREE_CODE (t
)))
8098 /* This function doesn't know how to deal with pre-genericize
8099 statements; this can only happen with statement-expressions,
8100 so for now just fail. */
8102 error_at (EXPR_LOCATION (t
),
8103 "statement is not a constant expression");
8106 internal_error ("unexpected expression %qE of kind %s", t
,
8107 get_tree_code_name (TREE_CODE (t
)));
8108 *non_constant_p
= true;
8112 if (r
== error_mark_node
)
8113 *non_constant_p
= true;
8115 if (*non_constant_p
)
8121 /* P0859: A function is needed for constant evaluation if it is a constexpr
8122 function that is named by an expression ([basic.def.odr]) that is
8123 potentially constant evaluated.
8125 So we need to instantiate any constexpr functions mentioned by the
8126 expression even if the definition isn't needed for evaluating the
8130 instantiate_cx_fn_r (tree
*tp
, int *walk_subtrees
, void */
*data*/
)
8132 if (TREE_CODE (*tp
) == FUNCTION_DECL
8133 && DECL_DECLARED_CONSTEXPR_P (*tp
)
8134 && !DECL_INITIAL (*tp
)
8135 && !trivial_fn_p (*tp
)
8136 && (DECL_TEMPLOID_INSTANTIATION (*tp
) || DECL_DEFAULTED_FN (*tp
))
8137 && !uid_sensitive_constexpr_evaluation_p ())
8140 if (DECL_TEMPLOID_INSTANTIATION (*tp
))
8141 instantiate_decl (*tp
, /*defer_ok*/false, /*expl_inst*/false);
8143 synthesize_method (*tp
);
8146 else if (TREE_CODE (*tp
) == CALL_EXPR
8147 || TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
8149 if (EXPR_HAS_LOCATION (*tp
))
8150 input_location
= EXPR_LOCATION (*tp
);
8160 instantiate_constexpr_fns (tree t
)
8162 location_t loc
= input_location
;
8163 cp_walk_tree_without_duplicates (&t
, instantiate_cx_fn_r
, NULL
);
8164 input_location
= loc
;
8167 /* Look for heap variables in the expression *TP. */
8170 find_heap_var_refs (tree
*tp
, int *walk_subtrees
, void */
*data*/
)
8173 && (DECL_NAME (*tp
) == heap_uninit_identifier
8174 || DECL_NAME (*tp
) == heap_identifier
8175 || DECL_NAME (*tp
) == heap_vec_uninit_identifier
8176 || DECL_NAME (*tp
) == heap_vec_identifier
8177 || DECL_NAME (*tp
) == heap_deleted_identifier
))
8185 /* Find immediate function decls in *TP if any. */
8188 find_immediate_fndecl (tree
*tp
, int */
*walk_subtrees*/
, void */
*data*/
)
8190 if (TREE_CODE (*tp
) == FUNCTION_DECL
&& DECL_IMMEDIATE_FUNCTION_P (*tp
))
8192 if (TREE_CODE (*tp
) == PTRMEM_CST
8193 && TREE_CODE (PTRMEM_CST_MEMBER (*tp
)) == FUNCTION_DECL
8194 && DECL_IMMEDIATE_FUNCTION_P (PTRMEM_CST_MEMBER (*tp
)))
8195 return PTRMEM_CST_MEMBER (*tp
);
8199 /* T has TREE_CONSTANT set but has been deemed not a valid C++ constant
8200 expression. Return a version of T that has TREE_CONSTANT cleared. */
8203 mark_non_constant (tree t
)
8205 gcc_checking_assert (TREE_CONSTANT (t
));
8207 /* This isn't actually constant, so unset TREE_CONSTANT.
8208 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
8209 it to be set if it is invariant address, even when it is not
8210 a valid C++ constant expression. Wrap it with a NOP_EXPR
8212 if (EXPR_P (t
) && TREE_CODE (t
) != ADDR_EXPR
)
8214 else if (TREE_CODE (t
) == CONSTRUCTOR
)
8215 t
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (t
), t
);
8217 t
= build_nop (TREE_TYPE (t
), t
);
8218 TREE_CONSTANT (t
) = false;
8222 /* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
8223 STRICT has the same sense as for constant_value_1: true if we only allow
8224 conforming C++ constant expressions, or false if we want a constant value
8225 even if it doesn't conform.
8226 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
8227 per P0595 even when ALLOW_NON_CONSTANT is true.
8228 CONSTEXPR_DTOR is true when evaluating the dtor of a constexpr variable.
8229 OBJECT must be non-NULL in that case. */
8232 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
8234 mce_value manifestly_const_eval
= mce_unknown
,
8235 bool constexpr_dtor
= false,
8236 tree object
= NULL_TREE
)
8238 auto_timevar
time (TV_CONSTEXPR
);
8240 bool non_constant_p
= false;
8241 bool overflow_p
= false;
8243 if (BRACE_ENCLOSED_INITIALIZER_P (t
))
8245 gcc_checking_assert (allow_non_constant
);
8249 constexpr_global_ctx global_ctx
;
8250 constexpr_ctx ctx
= { &global_ctx
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8251 allow_non_constant
, strict
,
8252 !allow_non_constant
? mce_true
: manifestly_const_eval
};
8254 /* Turn off -frounding-math for manifestly constant evaluation. */
8255 warning_sentinel
rm (flag_rounding_math
,
8256 ctx
.manifestly_const_eval
== mce_true
);
8257 tree type
= initialized_type (t
);
8259 bool is_consteval
= false;
8260 if (VOID_TYPE_P (type
))
8263 /* Used for destructors of array elements. */
8264 type
= TREE_TYPE (object
);
8267 if (cxx_dialect
< cxx20
)
8269 if (TREE_CODE (t
) != CALL_EXPR
&& TREE_CODE (t
) != AGGR_INIT_EXPR
)
8271 /* Calls to immediate functions returning void need to be
8273 tree fndecl
= cp_get_callee_fndecl_nofold (t
);
8274 if (fndecl
== NULL_TREE
|| !DECL_IMMEDIATE_FUNCTION_P (fndecl
))
8277 is_consteval
= true;
8280 else if (cxx_dialect
>= cxx20
8281 && (TREE_CODE (t
) == CALL_EXPR
8282 || TREE_CODE (t
) == AGGR_INIT_EXPR
8283 || TREE_CODE (t
) == TARGET_EXPR
))
8285 /* For non-concept checks, determine if it is consteval. */
8286 if (!concept_check_p (t
))
8289 if (TREE_CODE (x
) == TARGET_EXPR
)
8290 x
= TARGET_EXPR_INITIAL (x
);
8291 tree fndecl
= cp_get_callee_fndecl_nofold (x
);
8292 if (fndecl
&& DECL_IMMEDIATE_FUNCTION_P (fndecl
))
8293 is_consteval
= true;
8296 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
8298 /* In C++14 an NSDMI can participate in aggregate initialization,
8299 and can refer to the address of the object being initialized, so
8300 we need to pass in the relevant VAR_DECL if we want to do the
8301 evaluation in a single pass. The evaluation will dynamically
8302 update ctx.values for the VAR_DECL. We use the same strategy
8303 for C++11 constexpr constructors that refer to the object being
8307 gcc_assert (object
&& VAR_P (object
));
8308 gcc_assert (DECL_DECLARED_CONSTEXPR_P (object
));
8309 gcc_assert (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (object
));
8310 if (error_operand_p (DECL_INITIAL (object
)))
8312 ctx
.ctor
= unshare_expr (DECL_INITIAL (object
));
8313 TREE_READONLY (ctx
.ctor
) = false;
8314 /* Temporarily force decl_really_constant_value to return false
8315 for it, we want to use ctx.ctor for the current value instead. */
8316 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (object
) = false;
8320 ctx
.ctor
= build_constructor (type
, NULL
);
8321 CONSTRUCTOR_NO_CLEARING (ctx
.ctor
) = true;
8325 if (TREE_CODE (t
) == TARGET_EXPR
)
8326 object
= TARGET_EXPR_SLOT (t
);
8327 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
8328 object
= AGGR_INIT_EXPR_SLOT (t
);
8330 ctx
.object
= object
;
8332 gcc_assert (same_type_ignoring_top_level_qualifiers_p
8333 (type
, TREE_TYPE (object
)));
8334 if (object
&& DECL_P (object
))
8335 global_ctx
.put_value (object
, ctx
.ctor
);
8336 if (TREE_CODE (r
) == TARGET_EXPR
)
8337 /* Avoid creating another CONSTRUCTOR when we expand the
8339 r
= TARGET_EXPR_INITIAL (r
);
8342 auto_vec
<tree
, 16> cleanups
;
8343 global_ctx
.cleanups
= &cleanups
;
8345 if (manifestly_const_eval
== mce_true
)
8346 instantiate_constexpr_fns (r
);
8347 r
= cxx_eval_constant_expression (&ctx
, r
, vc_prvalue
,
8348 &non_constant_p
, &overflow_p
);
8350 if (!constexpr_dtor
)
8351 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
8353 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (object
) = true;
8357 /* Evaluate the cleanups. */
8358 FOR_EACH_VEC_ELT_REVERSE (cleanups
, i
, cleanup
)
8359 cxx_eval_constant_expression (&ctx
, cleanup
, vc_discard
,
8360 &non_constant_p
, &overflow_p
);
8362 /* Mutable logic is a bit tricky: we want to allow initialization of
8363 constexpr variables with mutable members, but we can't copy those
8364 members to another constexpr variable. */
8365 if (TREE_CODE (r
) == CONSTRUCTOR
&& CONSTRUCTOR_MUTABLE_POISON (r
))
8367 if (!allow_non_constant
)
8368 error ("%qE is not a constant expression because it refers to "
8369 "mutable subobjects of %qT", t
, type
);
8370 non_constant_p
= true;
8373 if (TREE_CODE (r
) == CONSTRUCTOR
&& CONSTRUCTOR_NO_CLEARING (r
))
8375 if (!allow_non_constant
)
8376 error ("%qE is not a constant expression because it refers to "
8377 "an incompletely initialized variable", t
);
8378 TREE_CONSTANT (r
) = false;
8379 non_constant_p
= true;
8382 if (!non_constant_p
&& cxx_dialect
>= cxx20
8383 && !global_ctx
.heap_vars
.is_empty ())
8385 tree heap_var
= cp_walk_tree_without_duplicates (&r
, find_heap_var_refs
,
8390 if (!allow_non_constant
&& !non_constant_p
)
8391 error_at (DECL_SOURCE_LOCATION (heap_var
),
8392 "%qE is not a constant expression because it refers to "
8393 "a result of %<operator new%>", t
);
8395 non_constant_p
= true;
8397 FOR_EACH_VEC_ELT (global_ctx
.heap_vars
, i
, heap_var
)
8399 if (DECL_NAME (heap_var
) != heap_deleted_identifier
)
8401 if (!allow_non_constant
&& !non_constant_p
)
8402 error_at (DECL_SOURCE_LOCATION (heap_var
),
8403 "%qE is not a constant expression because allocated "
8404 "storage has not been deallocated", t
);
8406 non_constant_p
= true;
8408 varpool_node::get (heap_var
)->remove ();
8412 /* Check that immediate invocation does not return an expression referencing
8413 any immediate function decls. */
8414 if (!non_constant_p
&& cxx_dialect
>= cxx20
)
8415 if (tree immediate_fndecl
8416 = cp_walk_tree_without_duplicates (&r
, find_immediate_fndecl
,
8419 if (!allow_non_constant
&& !non_constant_p
)
8422 error_at (cp_expr_loc_or_input_loc (t
),
8423 "immediate evaluation returns address of immediate "
8424 "function %qD", immediate_fndecl
);
8426 error_at (cp_expr_loc_or_input_loc (t
),
8427 "constant evaluation returns address of immediate "
8428 "function %qD", immediate_fndecl
);
8431 non_constant_p
= true;
8435 /* If we saw something bad, go back to our argument. The wrapping below is
8436 only for the cases of TREE_CONSTANT argument or overflow. */
8439 if (!non_constant_p
&& overflow_p
)
8440 non_constant_p
= true;
8442 /* Unshare the result. */
8443 bool should_unshare
= true;
8444 if (r
== t
|| (TREE_CODE (t
) == TARGET_EXPR
8445 && TARGET_EXPR_INITIAL (t
) == r
))
8446 should_unshare
= false;
8448 if (non_constant_p
&& !allow_non_constant
)
8449 return error_mark_node
;
8450 else if (constexpr_dtor
)
8452 else if (non_constant_p
&& TREE_CONSTANT (r
))
8453 r
= mark_non_constant (r
);
8454 else if (non_constant_p
)
8458 r
= unshare_expr (r
);
8460 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
8462 r
= adjust_temp_type (type
, r
);
8463 if (TREE_CODE (t
) == TARGET_EXPR
8464 && TARGET_EXPR_INITIAL (t
) == r
)
8466 else if (TREE_CODE (t
) == CONSTRUCTOR
|| TREE_CODE (t
) == CALL_EXPR
)
8467 /* Don't add a TARGET_EXPR if our argument didn't have one. */;
8468 else if (TREE_CODE (t
) == TARGET_EXPR
&& TARGET_EXPR_CLEANUP (t
))
8469 r
= get_target_expr (r
);
8472 r
= get_target_expr (r
, tf_warning_or_error
| tf_no_cleanup
);
8473 TREE_CONSTANT (r
) = true;
8477 if (TREE_CODE (t
) == TARGET_EXPR
8478 && TREE_CODE (r
) == TARGET_EXPR
)
8480 /* Preserve this flag for potential_constant_expression, and the others
8481 for good measure. */
8482 TARGET_EXPR_ELIDING_P (r
) = TARGET_EXPR_ELIDING_P (t
);
8483 TARGET_EXPR_IMPLICIT_P (r
) = TARGET_EXPR_IMPLICIT_P (t
);
8484 TARGET_EXPR_LIST_INIT_P (r
) = TARGET_EXPR_LIST_INIT_P (t
);
8485 TARGET_EXPR_DIRECT_INIT_P (r
) = TARGET_EXPR_DIRECT_INIT_P (t
);
8488 /* Remember the original location if that wouldn't need a wrapper. */
8489 if (location_t loc
= EXPR_LOCATION (t
))
8490 protected_set_expr_location (r
, loc
);
8495 /* If T represents a constant expression returns its reduced value.
8496 Otherwise return error_mark_node. */
8499 cxx_constant_value (tree t
, tree decl
/* = NULL_TREE */,
8500 tsubst_flags_t complain
/* = tf_error */)
8502 bool sfinae
= !(complain
& tf_error
);
8503 tree r
= cxx_eval_outermost_constant_expr (t
, sfinae
, true, mce_true
, false, decl
);
8504 if (sfinae
&& !TREE_CONSTANT (r
))
8505 r
= error_mark_node
;
8509 /* Like cxx_constant_value, but used for evaluation of constexpr destructors
8510 of constexpr variables. The actual initializer of DECL is not modified. */
8513 cxx_constant_dtor (tree t
, tree decl
)
8515 cxx_eval_outermost_constant_expr (t
, false, true, mce_true
, true, decl
);
8518 /* Helper routine for fold_simple function. Either return simplified
8519 expression T, otherwise NULL_TREE.
8520 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
8521 even if we are within template-declaration. So be careful on call, as in
8522 such case types can be undefined. */
8525 fold_simple_1 (tree t
)
8528 enum tree_code code
= TREE_CODE (t
);
8540 return fold_sizeof_expr (t
);
8549 case TRUTH_NOT_EXPR
:
8550 case VIEW_CONVERT_EXPR
:
8553 case FIX_TRUNC_EXPR
:
8554 case FIXED_CONVERT_EXPR
:
8555 case ADDR_SPACE_CONVERT_EXPR
:
8557 op1
= TREE_OPERAND (t
, 0);
8559 t
= const_unop (code
, TREE_TYPE (t
), op1
);
8563 if (CONVERT_EXPR_CODE_P (code
)
8564 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
8565 TREE_OVERFLOW (t
) = false;
8573 /* If T is a simple constant expression, returns its simplified value.
8574 Otherwise returns T. In contrast to maybe_constant_value we
8575 simplify only few operations on constant-expressions, and we don't
8576 try to simplify constexpressions. */
8579 fold_simple (tree t
)
8581 if (processing_template_decl
)
8584 tree r
= fold_simple_1 (t
);
8591 /* Try folding the expression T to a simple constant.
8592 Returns that constant, otherwise returns T. */
8595 fold_to_constant (tree t
)
8598 if (CONSTANT_CLASS_P (r
) && !TREE_OVERFLOW (r
))
8604 /* If T is a constant expression, returns its reduced value.
8605 Otherwise, if T does not have TREE_CONSTANT set, returns T.
8606 Otherwise, returns a version of T without TREE_CONSTANT.
8607 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated
8610 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
8613 maybe_constant_value (tree t
, tree decl
/* = NULL_TREE */,
8614 mce_value manifestly_const_eval
/* = mce_unknown */)
8618 if (!is_nondependent_constant_expression (t
))
8620 if (TREE_OVERFLOW_P (t
)
8621 || (!processing_template_decl
&& TREE_CONSTANT (t
)))
8622 t
= mark_non_constant (t
);
8625 else if (CONSTANT_CLASS_P (t
))
8626 /* No caching or evaluation needed. */
8629 /* Don't constant evaluate an unevaluated non-manifestly-constant operand,
8630 but at least try folding it to a simple constant. */
8631 if (cp_unevaluated_operand
&& manifestly_const_eval
!= mce_true
)
8632 return fold_to_constant (t
);
8634 if (manifestly_const_eval
!= mce_unknown
)
8635 return cxx_eval_outermost_constant_expr (t
, true, true,
8636 manifestly_const_eval
, false, decl
);
8638 if (cv_cache
== NULL
)
8639 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
8640 if (tree
*cached
= cv_cache
->get (t
))
8645 /* Clear processing_template_decl for sake of break_out_target_exprs;
8646 entries in the cv_cache are non-templated. */
8647 processing_template_decl_sentinel ptds
;
8649 r
= break_out_target_exprs (r
, /*clear_loc*/true);
8650 protected_set_expr_location (r
, EXPR_LOCATION (t
));
8655 uid_sensitive_constexpr_evaluation_checker c
;
8656 r
= cxx_eval_outermost_constant_expr (t
, true, true,
8657 manifestly_const_eval
, false, decl
);
8658 gcc_checking_assert (r
== t
8659 || CONVERT_EXPR_P (t
)
8660 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
8661 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
8662 || !cp_tree_equal (r
, t
));
8663 if (!c
.evaluation_restricted_p ())
8664 cv_cache
->put (t
, r
);
8668 /* Dispose of the whole CV_CACHE. */
8671 clear_cv_cache (void)
8673 if (cv_cache
!= NULL
)
8677 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
8680 clear_cv_and_fold_caches ()
8683 clear_fold_cache ();
8686 /* Internal function handling expressions in templates for
8687 fold_non_dependent_expr and fold_non_dependent_init.
8689 If we're in a template, but T isn't value dependent, simplify
8690 it. We're supposed to treat:
8692 template <typename T> void f(T[1 + 1]);
8693 template <typename T> void f(T[2]);
8695 as two declarations of the same function, for example. */
8698 fold_non_dependent_expr_template (tree t
, tsubst_flags_t complain
,
8699 bool manifestly_const_eval
,
8702 gcc_assert (processing_template_decl
);
8704 if (is_nondependent_constant_expression (t
))
8706 processing_template_decl_sentinel s
;
8707 t
= instantiate_non_dependent_expr_internal (t
, complain
);
8709 if (type_unknown_p (t
) || BRACE_ENCLOSED_INITIALIZER_P (t
))
8711 if (TREE_OVERFLOW_P (t
))
8713 t
= build_nop (TREE_TYPE (t
), t
);
8714 TREE_CONSTANT (t
) = false;
8718 else if (CONSTANT_CLASS_P (t
))
8719 /* No evaluation needed. */
8722 /* Don't constant evaluate an unevaluated non-manifestly-constant operand,
8723 but at least try folding it to a simple constant. */
8724 if (cp_unevaluated_operand
&& !manifestly_const_eval
)
8725 return fold_to_constant (t
);
8727 tree r
= cxx_eval_outermost_constant_expr (t
, true, true,
8728 mce_value (manifestly_const_eval
),
8730 /* cp_tree_equal looks through NOPs, so allow them. */
8731 gcc_checking_assert (r
== t
8732 || CONVERT_EXPR_P (t
)
8733 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
8734 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
8735 || !cp_tree_equal (r
, t
));
8738 else if (TREE_OVERFLOW_P (t
))
8740 t
= build_nop (TREE_TYPE (t
), t
);
8741 TREE_CONSTANT (t
) = false;
8747 /* Like maybe_constant_value but first fully instantiate the argument.
8749 Note: this is equivalent to instantiate_non_dependent_expr (t, complain)
8750 followed by maybe_constant_value but is more efficient,
8751 because it calls instantiation_dependent_expression_p and
8752 potential_constant_expression at most once.
8753 The manifestly_const_eval argument is passed to maybe_constant_value.
8755 Callers should generally pass their active complain, or if they are in a
8756 non-template, diagnosing context, they can use the default of
8757 tf_warning_or_error. Callers that might be within a template context, don't
8758 have a complain parameter, and aren't going to remember the result for long
8759 (e.g. null_ptr_cst_p), can pass tf_none and deal with error_mark_node
8763 fold_non_dependent_expr (tree t
,
8764 tsubst_flags_t complain
/* = tf_warning_or_error */,
8765 bool manifestly_const_eval
/* = false */,
8766 tree object
/* = NULL_TREE */)
8771 if (processing_template_decl
)
8772 return fold_non_dependent_expr_template (t
, complain
,
8773 manifestly_const_eval
, object
);
8775 return maybe_constant_value (t
, object
, mce_value (manifestly_const_eval
));
8778 /* Like fold_non_dependent_expr, but if EXPR couldn't be folded to a constant,
8779 return the original expression. */
8782 maybe_fold_non_dependent_expr (tree expr
,
8783 tsubst_flags_t complain
/*=tf_warning_or_error*/)
8785 tree t
= fold_non_dependent_expr (expr
, complain
);
8786 if (t
&& TREE_CONSTANT (t
))
8792 /* Like maybe_constant_init but first fully instantiate the argument. */
8795 fold_non_dependent_init (tree t
,
8796 tsubst_flags_t complain
/*=tf_warning_or_error*/,
8797 bool manifestly_const_eval
/*=false*/,
8798 tree object
/* = NULL_TREE */)
8803 if (processing_template_decl
)
8805 t
= fold_non_dependent_expr_template (t
, complain
,
8806 manifestly_const_eval
, object
);
8807 /* maybe_constant_init does this stripping, so do it here too. */
8808 if (TREE_CODE (t
) == TARGET_EXPR
)
8810 tree init
= TARGET_EXPR_INITIAL (t
);
8811 if (TREE_CODE (init
) == CONSTRUCTOR
)
8817 return maybe_constant_init (t
, object
, manifestly_const_eval
);
8820 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
8821 than wrapped in a TARGET_EXPR.
8822 ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
8823 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
8824 per P0595 even when ALLOW_NON_CONSTANT is true. */
8827 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
,
8828 bool manifestly_const_eval
)
8832 if (TREE_CODE (t
) == EXPR_STMT
)
8833 t
= TREE_OPERAND (t
, 0);
8834 if (TREE_CODE (t
) == CONVERT_EXPR
8835 && VOID_TYPE_P (TREE_TYPE (t
)))
8836 t
= TREE_OPERAND (t
, 0);
8837 if (TREE_CODE (t
) == INIT_EXPR
)
8838 t
= TREE_OPERAND (t
, 1);
8839 if (TREE_CODE (t
) == TARGET_EXPR
)
8840 t
= TARGET_EXPR_INITIAL (t
);
8841 if (!is_nondependent_static_init_expression (t
))
8842 /* Don't try to evaluate it. */;
8843 else if (CONSTANT_CLASS_P (t
) && TREE_CODE (t
) != PTRMEM_CST
)
8844 /* No evaluation needed. PTRMEM_CST needs the immediate fn check. */;
8847 /* [basic.start.static] allows constant-initialization of variables with
8848 static or thread storage duration even if it isn't required, but we
8849 shouldn't bend the rules the same way for automatic variables. */
8850 bool is_static
= (decl
&& DECL_P (decl
)
8851 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)));
8853 manifestly_const_eval
= true;
8855 if (cp_unevaluated_operand
&& !manifestly_const_eval
)
8856 return fold_to_constant (t
);
8858 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
, !is_static
,
8859 mce_value (manifestly_const_eval
),
8862 if (TREE_CODE (t
) == TARGET_EXPR
)
8864 tree init
= TARGET_EXPR_INITIAL (t
);
8865 if (TREE_CODE (init
) == CONSTRUCTOR
)
8871 /* Wrapper for maybe_constant_init_1 which permits non constants. */
8874 maybe_constant_init (tree t
, tree decl
, bool manifestly_const_eval
)
8876 return maybe_constant_init_1 (t
, decl
, true, manifestly_const_eval
);
8879 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
8882 cxx_constant_init (tree t
, tree decl
)
8884 return maybe_constant_init_1 (t
, decl
, false, true);
8888 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
8889 /* Return true if the object referred to by REF has automatic or thread
8892 enum { ck_ok
, ck_bad
, ck_unknown
};
8894 check_automatic_or_tls (tree ref
)
8897 poly_int64 bitsize
, bitpos
;
8899 int volatilep
= 0, unsignedp
= 0;
8900 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
8901 &mode
, &unsignedp
, &volatilep
, false);
8904 /* If there isn't a decl in the middle, we don't know the linkage here,
8905 and this isn't a constant expression anyway. */
8908 dk
= decl_storage_duration (decl
);
8909 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
8913 /* Data structure for passing data from potential_constant_expression_1
8914 to check_for_return_continue via cp_walk_tree. */
8915 struct check_for_return_continue_data
{
8916 hash_set
<tree
> *pset
;
8921 /* Helper function for potential_constant_expression_1 SWITCH_STMT handling,
8922 called through cp_walk_tree. Return the first RETURN_EXPR found, or note
8923 the first CONTINUE_STMT and/or BREAK_STMT if RETURN_EXPR is not found. */
8925 check_for_return_continue (tree
*tp
, int *walk_subtrees
, void *data
)
8928 check_for_return_continue_data
*d
= (check_for_return_continue_data
*) data
;
8929 switch (TREE_CODE (t
))
8935 if (d
->continue_stmt
== NULL_TREE
)
8936 d
->continue_stmt
= t
;
8940 if (d
->break_stmt
== NULL_TREE
)
8945 if (tree r = cp_walk_tree (&x, check_for_return_continue, data, \
8949 /* For loops, walk subtrees manually, so that continue stmts found
8950 inside of the bodies of the loops are ignored. */
8953 RECUR (DO_COND (t
));
8954 s
= d
->continue_stmt
;
8956 RECUR (DO_BODY (t
));
8957 d
->continue_stmt
= s
;
8963 RECUR (WHILE_COND (t
));
8964 s
= d
->continue_stmt
;
8966 RECUR (WHILE_BODY (t
));
8967 d
->continue_stmt
= s
;
8973 RECUR (FOR_INIT_STMT (t
));
8974 RECUR (FOR_COND (t
));
8975 RECUR (FOR_EXPR (t
));
8976 s
= d
->continue_stmt
;
8978 RECUR (FOR_BODY (t
));
8979 d
->continue_stmt
= s
;
8983 case RANGE_FOR_STMT
:
8985 RECUR (RANGE_FOR_EXPR (t
));
8986 s
= d
->continue_stmt
;
8988 RECUR (RANGE_FOR_BODY (t
));
8989 d
->continue_stmt
= s
;
8995 RECUR (SWITCH_STMT_COND (t
));
8997 RECUR (SWITCH_STMT_BODY (t
));
9002 case STATEMENT_LIST
:
9015 /* Return true if T denotes a potentially constant expression. Issue
9016 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
9017 an lvalue-rvalue conversion is implied. If NOW is true, we want to
9018 consider the expression in the current context, independent of constexpr
9019 substitution. If FUNDEF_P is true, we're checking a constexpr function body
9020 and hard errors should not be reported by constexpr_error.
9022 C++0x [expr.const] used to say
9024 6 An expression is a potential constant expression if it is
9025 a constant expression where all occurrences of function
9026 parameters are replaced by arbitrary constant expressions
9027 of the appropriate type.
9029 2 A conditional expression is a constant expression unless it
9030 involves one of the following as a potentially evaluated
9031 subexpression (3.2), but subexpressions of logical AND (5.14),
9032 logical OR (5.15), and conditional (5.16) operations that are
9033 not evaluated are not considered. */
9036 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
9037 bool fundef_p
, tsubst_flags_t flags
,
9040 #define RECUR(T,RV) \
9041 potential_constant_expression_1 ((T), (RV), strict, now, fundef_p, flags, \
9044 enum { any
= false, rval
= true };
9048 if (t
== error_mark_node
)
9052 location_t loc
= cp_expr_loc_or_input_loc (t
);
9055 /* If we are jumping, ignore everything. This is simpler than the
9056 cxx_eval_constant_expression handling because we only need to be
9057 conservatively correct, and we don't necessarily have a constant value
9058 available, so we don't bother with switch tracking. */
9061 if (TREE_THIS_VOLATILE (t
) && want_rval
)
9063 if (flags
& tf_error
)
9064 constexpr_error (loc
, fundef_p
, "lvalue-to-rvalue conversion of "
9065 "a volatile lvalue %qE with type %qT", t
,
9069 if (CONSTANT_CLASS_P (t
))
9071 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
9072 && TREE_TYPE (t
) == error_mark_node
)
9075 switch (TREE_CODE (t
))
9081 case TEMPLATE_ID_EXPR
:
9083 case CASE_LABEL_EXPR
:
9090 case TEMPLATE_PARM_INDEX
:
9092 case IDENTIFIER_NODE
:
9093 case USERDEF_LITERAL
:
9094 /* We can see a FIELD_DECL in a pointer-to-member expression. */
9099 case PLACEHOLDER_EXPR
:
9102 case DEBUG_BEGIN_STMT
:
9106 if (!RECUR (TREE_OPERAND (t
, 0), any
))
9116 if (now
&& want_rval
)
9118 tree type
= TREE_TYPE (t
);
9119 if (dependent_type_p (type
)
9120 || !COMPLETE_TYPE_P (processing_template_decl
9121 ? type
: complete_type (type
))
9122 || is_really_empty_class (type
, /*ignore_vptr*/false))
9123 /* An empty class has no data to read. */
9125 if (flags
& tf_error
)
9126 constexpr_error (input_location
, fundef_p
,
9127 "%qE is not a constant expression", t
);
9132 case AGGR_INIT_EXPR
:
9134 /* -- an invocation of a function other than a constexpr function
9135 or a constexpr constructor. */
9137 tree fun
= get_function_named_in_call (t
);
9138 const int nargs
= call_expr_nargs (t
);
9141 if (fun
== NULL_TREE
)
9143 /* Reset to allow the function to continue past the end
9144 of the block below. Otherwise return early. */
9147 if (TREE_CODE (t
) == CALL_EXPR
9148 && CALL_EXPR_FN (t
) == NULL_TREE
)
9149 switch (CALL_EXPR_IFN (t
))
9151 /* These should be ignored, they are optimized away from
9152 constexpr functions. */
9153 case IFN_UBSAN_NULL
:
9154 case IFN_UBSAN_BOUNDS
:
9155 case IFN_UBSAN_VPTR
:
9156 case IFN_FALLTHROUGH
:
9160 case IFN_ADD_OVERFLOW
:
9161 case IFN_SUB_OVERFLOW
:
9162 case IFN_MUL_OVERFLOW
:
9164 case IFN_VEC_CONVERT
:
9174 /* fold_call_expr can't do anything with IFN calls. */
9175 if (flags
& tf_error
)
9176 constexpr_error (loc
, fundef_p
,
9177 "call to internal function %qE", t
);
9182 if (fun
&& is_overloaded_fn (fun
))
9184 if (!RECUR (fun
, true))
9186 fun
= get_fns (fun
);
9188 if (TREE_CODE (fun
) == FUNCTION_DECL
)
9190 if (builtin_valid_in_constant_expr_p (fun
))
9192 if (!maybe_constexpr_fn (fun
)
9193 /* Allow any built-in function; if the expansion
9194 isn't constant, we'll deal with that then. */
9195 && !fndecl_built_in_p (fun
)
9196 /* In C++20, replaceable global allocation functions
9197 are constant expressions. */
9198 && (!cxx_replaceable_global_alloc_fn (fun
)
9199 || TREE_CODE (t
) != CALL_EXPR
9200 || (!CALL_FROM_NEW_OR_DELETE_P (t
)
9201 && (current_function_decl
== NULL_TREE
9202 || !is_std_allocator_allocate
9203 (current_function_decl
))))
9204 /* Allow placement new in std::construct_at. */
9205 && (!cxx_placement_new_fn (fun
)
9206 || TREE_CODE (t
) != CALL_EXPR
9207 || current_function_decl
== NULL_TREE
9208 || !is_std_construct_at (current_function_decl
))
9209 && !cxx_dynamic_cast_fn_p (fun
))
9211 if ((flags
& tf_error
)
9212 && constexpr_error (loc
, fundef_p
,
9213 "call to non-%<constexpr%> "
9214 "function %qD", fun
))
9215 explain_invalid_constexpr_fn (fun
);
9220 fun
= OVL_FIRST (fun
);
9221 /* Skip initial arguments to base constructors. */
9222 if (DECL_BASE_CONSTRUCTOR_P (fun
))
9223 i
= num_artificial_parms_for (fun
);
9227 if (RECUR (fun
, FUNCTION_POINTER_TYPE_P (fun
) ? rval
: any
))
9228 /* Might end up being a constant function pointer. But it
9229 could also be a function object with constexpr op(), so
9230 we pass 'any' so that the underlying VAR_DECL is deemed
9231 as potentially-constant even though it wasn't declared
9236 for (; i
< nargs
; ++i
)
9238 tree x
= get_nth_callarg (t
, i
);
9239 /* In a template, reference arguments haven't been converted to
9240 REFERENCE_TYPE and we might not even know if the parameter
9241 is a reference, so accept lvalue constants too. */
9242 bool rv
= processing_template_decl
? any
: rval
;
9243 /* Don't require an immediately constant value, as constexpr
9244 substitution might not use the value of the argument. */
9245 bool sub_now
= false;
9246 if (!potential_constant_expression_1 (x
, rv
, strict
,
9247 sub_now
, fundef_p
, flags
,
9254 case NON_LVALUE_EXPR
:
9255 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
9256 -- an lvalue of integral type that refers to a non-volatile
9257 const variable or static data member initialized with
9258 constant expressions, or
9260 -- an lvalue of literal type that refers to non-volatile
9261 object defined with constexpr, or that refers to a
9262 sub-object of such an object; */
9263 return RECUR (TREE_OPERAND (t
, 0), rval
);
9265 case EXCESS_PRECISION_EXPR
:
9266 return RECUR (TREE_OPERAND (t
, 0), rval
);
9269 if (DECL_HAS_VALUE_EXPR_P (t
))
9271 if (now
&& is_normal_capture_proxy (t
))
9273 /* -- in a lambda-expression, a reference to this or to a
9274 variable with automatic storage duration defined outside that
9275 lambda-expression, where the reference would be an
9279 /* Since we're doing an lvalue-rvalue conversion, this might
9280 not be an odr-use, so evaluate the variable directly. */
9281 return RECUR (DECL_CAPTURED_VARIABLE (t
), rval
);
9283 if (flags
& tf_error
)
9285 tree cap
= DECL_CAPTURED_VARIABLE (t
);
9286 if (constexpr_error (input_location
, fundef_p
,
9287 "lambda capture of %qE is not a "
9288 "constant expression", cap
)
9289 && decl_constant_var_p (cap
))
9290 inform (input_location
, "because it is used as a glvalue");
9294 /* Treat __PRETTY_FUNCTION__ inside a template function as
9295 potentially-constant. */
9296 else if (DECL_PRETTY_FUNCTION_P (t
)
9297 && DECL_VALUE_EXPR (t
) == error_mark_node
)
9299 return RECUR (DECL_VALUE_EXPR (t
), rval
);
9302 && !var_in_maybe_constexpr_fn (t
)
9303 && !type_dependent_expression_p (t
)
9304 && !decl_maybe_constant_var_p (t
)
9306 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
9307 || (DECL_INITIAL (t
)
9308 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
9309 && COMPLETE_TYPE_P (TREE_TYPE (t
))
9310 && !is_really_empty_class (TREE_TYPE (t
), /*ignore_vptr*/false))
9312 if (flags
& tf_error
)
9313 non_const_var_error (loc
, t
, fundef_p
);
9319 if (REINTERPRET_CAST_P (t
))
9321 if (flags
& tf_error
)
9322 constexpr_error (loc
, fundef_p
, "%<reinterpret_cast%> is not a "
9323 "constant expression");
9328 case VIEW_CONVERT_EXPR
:
9329 /* -- a reinterpret_cast. FIXME not implemented, and this rule
9330 may change to something more specific to type-punning (DR 1312). */
9332 tree from
= TREE_OPERAND (t
, 0);
9333 if (location_wrapper_p (t
))
9335 iloc_sentinel ils
= loc
;
9336 return (RECUR (from
, want_rval
));
9338 if (INDIRECT_TYPE_P (TREE_TYPE (t
)))
9340 STRIP_ANY_LOCATION_WRAPPER (from
);
9341 if (TREE_CODE (from
) == INTEGER_CST
9342 && !integer_zerop (from
))
9344 if (flags
& tf_error
)
9345 constexpr_error (loc
, fundef_p
,
9346 "%<reinterpret_cast%> from integer to "
9351 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
9354 case ADDRESSOF_EXPR
:
9355 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
9356 t
= TREE_OPERAND (t
, 0);
9357 goto handle_addr_expr
;
9360 /* -- a unary operator & that is applied to an lvalue that
9361 designates an object with thread or automatic storage
9363 t
= TREE_OPERAND (t
, 0);
9365 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
9366 /* A pointer-to-member constant. */
9371 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
9372 any checking here, as we might dereference the pointer later. If
9373 we remove this code, also remove check_automatic_or_tls. */
9374 i
= check_automatic_or_tls (t
);
9379 if (flags
& tf_error
)
9380 error ("address-of an object %qE with thread local or "
9381 "automatic storage is not a constant expression", t
);
9385 return RECUR (t
, any
);
9390 /* -- a class member access unless its postfix-expression is
9391 of literal type or of pointer to literal type. */
9392 /* This test would be redundant, as it follows from the
9393 postfix-expression being a potential constant expression. */
9394 if (type_unknown_p (t
))
9396 if (is_overloaded_fn (t
))
9397 /* In a template, a COMPONENT_REF of a function expresses ob.fn(),
9398 which uses ob as an lvalue. */
9405 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
9407 case EXPR_PACK_EXPANSION
:
9408 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
9412 tree x
= TREE_OPERAND (t
, 0);
9414 if (is_this_parameter (x
) && !is_capture_proxy (x
))
9416 if (!var_in_maybe_constexpr_fn (x
))
9418 if (flags
& tf_error
)
9419 constexpr_error (loc
, fundef_p
, "use of %<this%> in a "
9420 "constant expression");
9425 return RECUR (x
, rval
);
9428 case STATEMENT_LIST
:
9429 for (tree stmt
: tsi_range (t
))
9430 if (!RECUR (stmt
, any
))
9435 if (cxx_dialect
< cxx14
)
9437 if (!RECUR (TREE_OPERAND (t
, 0), any
))
9439 /* Just ignore clobbers. */
9440 if (TREE_CLOBBER_P (TREE_OPERAND (t
, 1)))
9442 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
9447 if (cxx_dialect
< cxx14
)
9449 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
9451 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
9456 if (!RECUR (DO_COND (t
), rval
))
9458 if (!RECUR (DO_BODY (t
), any
))
9460 if (breaks (jump_target
) || continues (jump_target
))
9461 *jump_target
= NULL_TREE
;
9465 if (!RECUR (FOR_INIT_STMT (t
), any
))
9468 if (!RECUR (tmp
, rval
))
9472 if (!processing_template_decl
)
9473 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
9474 /* If we couldn't evaluate the condition, it might not ever be
9476 if (!integer_onep (tmp
))
9478 /* Before returning true, check if the for body can contain
9480 hash_set
<tree
> pset
;
9481 check_for_return_continue_data data
= { &pset
, NULL_TREE
,
9484 = cp_walk_tree (&FOR_BODY (t
), check_for_return_continue
,
9486 *jump_target
= ret_expr
;
9490 if (!RECUR (FOR_EXPR (t
), any
))
9492 if (!RECUR (FOR_BODY (t
), any
))
9494 if (breaks (jump_target
) || continues (jump_target
))
9495 *jump_target
= NULL_TREE
;
9498 case RANGE_FOR_STMT
:
9499 if (!RECUR (RANGE_FOR_INIT_STMT (t
), any
))
9501 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
9503 if (!RECUR (RANGE_FOR_BODY (t
), any
))
9505 if (breaks (jump_target
) || continues (jump_target
))
9506 *jump_target
= NULL_TREE
;
9510 tmp
= WHILE_COND (t
);
9511 if (!RECUR (tmp
, rval
))
9513 if (!processing_template_decl
)
9514 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
9515 /* If we couldn't evaluate the condition, it might not ever be true. */
9516 if (!integer_onep (tmp
))
9518 /* Before returning true, check if the while body can contain
9520 hash_set
<tree
> pset
;
9521 check_for_return_continue_data data
= { &pset
, NULL_TREE
,
9524 = cp_walk_tree (&WHILE_BODY (t
), check_for_return_continue
,
9526 *jump_target
= ret_expr
;
9529 if (!RECUR (WHILE_BODY (t
), any
))
9531 if (breaks (jump_target
) || continues (jump_target
))
9532 *jump_target
= NULL_TREE
;
9536 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
9538 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
9539 unreachable labels would be checked and it is enough if there is
9540 a single switch cond value for which it is a valid constant
9541 expression. We need to check if there are any RETURN_EXPRs
9542 or CONTINUE_STMTs inside of the body though, as in that case
9543 we need to set *jump_target. */
9546 hash_set
<tree
> pset
;
9547 check_for_return_continue_data data
= { &pset
, NULL_TREE
,
9550 = cp_walk_tree (&SWITCH_STMT_BODY (t
), check_for_return_continue
,
9552 /* The switch might return. */
9553 *jump_target
= ret_expr
;
9554 else if (data
.continue_stmt
)
9555 /* The switch can't return, but might continue. */
9556 *jump_target
= data
.continue_stmt
;
9561 return RECUR (STMT_EXPR_STMT (t
), rval
);
9564 if (cxx_dialect
>= cxx17
)
9565 /* In C++17 lambdas can be constexpr, don't give up yet. */
9567 else if (flags
& tf_error
)
9568 constexpr_error (loc
, fundef_p
, "lambda-expression is not a "
9569 "constant expression before C++17");
9575 case VEC_DELETE_EXPR
:
9576 if (cxx_dialect
>= cxx20
)
9577 /* In C++20, new-expressions are potentially constant. */
9579 else if (flags
& tf_error
)
9580 constexpr_error (loc
, fundef_p
, "new-expression is not a "
9581 "constant expression before C++20");
9584 case DYNAMIC_CAST_EXPR
:
9585 case PSEUDO_DTOR_EXPR
:
9591 case OMP_DISTRIBUTE
:
9595 case OMP_TARGET_DATA
:
9607 case OMP_TARGET_UPDATE
:
9608 case OMP_TARGET_ENTER_DATA
:
9609 case OMP_TARGET_EXIT_DATA
:
9611 case OMP_ATOMIC_READ
:
9612 case OMP_ATOMIC_CAPTURE_OLD
:
9613 case OMP_ATOMIC_CAPTURE_NEW
:
9619 case OACC_HOST_DATA
:
9623 case OACC_ENTER_DATA
:
9624 case OACC_EXIT_DATA
:
9626 /* GCC internal stuff. */
9628 case TRANSACTION_EXPR
:
9629 case AT_ENCODE_EXPR
:
9631 if (flags
& tf_error
)
9632 constexpr_error (loc
, fundef_p
, "expression %qE is not a constant "
9637 if (flags
& tf_error
)
9638 inline_asm_in_constexpr_error (loc
, fundef_p
);
9642 if (cxx_dialect
>= cxx20
)
9643 /* In C++20 virtual calls can be constexpr, don't give up yet. */
9645 else if (flags
& tf_error
)
9646 constexpr_error (loc
, fundef_p
, "virtual functions cannot be "
9647 "%<constexpr%> before C++20");
9651 /* In C++20, a typeid expression whose operand is of polymorphic
9652 class type can be constexpr. */
9654 tree e
= TREE_OPERAND (t
, 0);
9655 if (cxx_dialect
< cxx20
9658 && !type_dependent_expression_p (e
)
9659 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
9661 if (flags
& tf_error
)
9662 constexpr_error (loc
, fundef_p
, "%<typeid%> is not a "
9663 "constant expression because %qE is "
9664 "of polymorphic type", e
);
9670 case POINTER_DIFF_EXPR
:
9681 case SPACESHIP_EXPR
:
9685 case PREINCREMENT_EXPR
:
9686 case POSTINCREMENT_EXPR
:
9687 case PREDECREMENT_EXPR
:
9688 case POSTDECREMENT_EXPR
:
9689 if (cxx_dialect
< cxx14
)
9695 if (TYPE_P (TREE_OPERAND (t
, 0)))
9701 case FIX_TRUNC_EXPR
:
9706 case TRUTH_NOT_EXPR
:
9707 case FIXED_CONVERT_EXPR
:
9708 case UNARY_PLUS_EXPR
:
9709 case UNARY_LEFT_FOLD_EXPR
:
9710 case UNARY_RIGHT_FOLD_EXPR
:
9712 return RECUR (TREE_OPERAND (t
, 0), rval
);
9715 case CONST_CAST_EXPR
:
9716 case STATIC_CAST_EXPR
:
9717 case REINTERPRET_CAST_EXPR
:
9718 case IMPLICIT_CONV_EXPR
:
9719 if (!cast_valid_in_integral_constant_expression_p (TREE_TYPE (t
)))
9720 /* In C++98, a conversion to non-integral type can't be part of a
9721 constant expression. */
9723 if (flags
& tf_error
)
9724 constexpr_error (loc
, fundef_p
,
9725 "cast to non-integral type %qT in a constant "
9726 "expression", TREE_TYPE (t
));
9729 /* This might be a conversion from a class to a (potentially) literal
9730 type. Let's consider it potentially constant since the conversion
9731 might be a constexpr user-defined conversion. */
9732 else if (cxx_dialect
>= cxx11
9733 && (dependent_type_p (TREE_TYPE (t
))
9734 || !COMPLETE_TYPE_P (TREE_TYPE (t
))
9735 || literal_type_p (TREE_TYPE (t
)))
9736 && TREE_OPERAND (t
, 0))
9738 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
9739 /* If this is a dependent type, it could end up being a class
9740 with conversions. */
9741 if (type
== NULL_TREE
|| WILDCARD_TYPE_P (type
))
9743 /* Or a non-dependent class which has conversions. */
9744 else if (CLASS_TYPE_P (type
)
9745 && (TYPE_HAS_CONVERSION (type
) || dependent_scope_p (type
)))
9749 return (RECUR (TREE_OPERAND (t
, 0),
9750 !TYPE_REF_P (TREE_TYPE (t
))));
9753 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
9755 case NON_DEPENDENT_EXPR
:
9756 /* Treat NON_DEPENDENT_EXPR as non-constant: it's not handled by
9757 constexpr evaluation or tsubst, so fold_non_dependent_expr can't
9758 do anything useful with it. And we shouldn't see it in a context
9759 where a constant expression is strictly required, hence the assert. */
9760 gcc_checking_assert (!(flags
& tf_error
));
9763 case CLEANUP_POINT_EXPR
:
9764 case MUST_NOT_THROW_EXPR
:
9765 case TRY_CATCH_EXPR
:
9770 /* For convenience. */
9773 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
9776 tmp
= DECL_EXPR_DECL (t
);
9777 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
)
9778 && (processing_template_decl
9779 ? !decl_maybe_constant_var_p (tmp
)
9780 : !decl_constant_var_p (tmp
)))
9782 if (CP_DECL_THREAD_LOCAL_P (tmp
) && !DECL_REALLY_EXTERN (tmp
))
9784 if (flags
& tf_error
)
9785 constexpr_error (DECL_SOURCE_LOCATION (tmp
), fundef_p
,
9786 "%qD defined %<thread_local%> in "
9787 "%<constexpr%> context", tmp
);
9790 else if (TREE_STATIC (tmp
))
9792 if (flags
& tf_error
)
9793 constexpr_error (DECL_SOURCE_LOCATION (tmp
), fundef_p
,
9794 "%qD defined %<static%> in %<constexpr%> "
9798 else if (!check_for_uninitialized_const_var
9799 (tmp
, /*constexpr_context_p=*/true, flags
))
9803 return RECUR (DECL_INITIAL (tmp
), want_rval
);
9806 case TRY_FINALLY_EXPR
:
9807 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
9808 && RECUR (TREE_OPERAND (t
, 1), any
));
9811 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
9814 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
9815 && !TARGET_EXPR_ELIDING_P (t
)
9816 && !literal_type_p (TREE_TYPE (t
)))
9818 if (flags
& tf_error
)
9820 auto_diagnostic_group d
;
9821 if (constexpr_error (loc
, fundef_p
,
9822 "temporary of non-literal type %qT in a "
9823 "constant expression", TREE_TYPE (t
)))
9824 explain_non_literal_class (TREE_TYPE (t
));
9830 return RECUR (TREE_OPERAND (t
, 1), rval
);
9834 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
9835 constructor_elt
*ce
;
9836 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
9837 if (!RECUR (ce
->value
, want_rval
))
9844 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
9845 || DECL_P (TREE_PURPOSE (t
)));
9846 if (!RECUR (TREE_VALUE (t
), want_rval
))
9848 if (TREE_CHAIN (t
) == NULL_TREE
)
9850 return RECUR (TREE_CHAIN (t
), want_rval
);
9853 case TRUNC_DIV_EXPR
:
9855 case FLOOR_DIV_EXPR
:
9856 case ROUND_DIV_EXPR
:
9857 case TRUNC_MOD_EXPR
:
9859 case ROUND_MOD_EXPR
:
9861 tree denom
= TREE_OPERAND (t
, 1);
9862 if (!RECUR (denom
, rval
))
9864 /* We can't call cxx_eval_outermost_constant_expr on an expression
9865 that hasn't been through instantiate_non_dependent_expr yet. */
9866 if (!processing_template_decl
)
9867 denom
= cxx_eval_outermost_constant_expr (denom
, true);
9868 if (integer_zerop (denom
))
9870 if (flags
& tf_error
)
9871 constexpr_error (input_location
, fundef_p
,
9872 "division by zero is not a constant expression");
9878 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
9884 /* check_return_expr sometimes wraps a TARGET_EXPR in a
9885 COMPOUND_EXPR; don't get confused. */
9886 tree op0
= TREE_OPERAND (t
, 0);
9887 tree op1
= TREE_OPERAND (t
, 1);
9889 if (TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
9890 return RECUR (op0
, want_rval
);
9895 /* If the first operand is the non-short-circuit constant, look at
9896 the second operand; otherwise we only care about the first one for
9898 case TRUTH_AND_EXPR
:
9899 case TRUTH_ANDIF_EXPR
:
9900 tmp
= boolean_true_node
;
9903 case TRUTH_ORIF_EXPR
:
9904 tmp
= boolean_false_node
;
9907 tree op0
= TREE_OPERAND (t
, 0);
9908 tree op1
= TREE_OPERAND (t
, 1);
9909 if (!RECUR (op0
, rval
))
9911 if (!(flags
& tf_error
) && RECUR (op1
, rval
))
9912 /* When quiet, try to avoid expensive trial evaluation by first
9913 checking potentiality of the second operand. */
9915 if (!processing_template_decl
)
9916 op0
= cxx_eval_outermost_constant_expr (op0
, true);
9917 if (tree_int_cst_equal (op0
, tmp
))
9918 return (flags
& tf_error
) ? RECUR (op1
, rval
) : false;
9925 case POINTER_PLUS_EXPR
:
9927 case EXACT_DIV_EXPR
:
9937 case TRUTH_XOR_EXPR
:
9938 case UNORDERED_EXPR
:
9951 case ARRAY_RANGE_REF
:
9955 case BINARY_LEFT_FOLD_EXPR
:
9956 case BINARY_RIGHT_FOLD_EXPR
:
9958 for (i
= 0; i
< 2; ++i
)
9959 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
9964 for (i
= 0; i
< 3; ++i
)
9965 if (!RECUR (TREE_OPERAND (t
, i
), true))
9970 if (COND_EXPR_IS_VEC_DELETE (t
) && cxx_dialect
< cxx20
)
9972 if (flags
& tf_error
)
9973 constexpr_error (loc
, fundef_p
, "%<delete[]%> is not a "
9974 "constant expression");
9980 /* If the condition is a known constant, we know which of the legs we
9981 care about; otherwise we only require that the condition and
9982 either of the legs be potentially constant. */
9983 tmp
= TREE_OPERAND (t
, 0);
9984 if (!RECUR (tmp
, rval
))
9986 if (!processing_template_decl
)
9987 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
9988 /* potential_constant_expression* isn't told if it is called for
9989 manifestly_const_eval or not, so for consteval if always
9990 process both branches as if the condition is not a known
9992 if (TREE_CODE (t
) != IF_STMT
|| !IF_STMT_CONSTEVAL_P (t
))
9994 if (integer_zerop (tmp
))
9995 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
9996 else if (TREE_CODE (tmp
) == INTEGER_CST
)
9997 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
10000 for (i
= 1; i
< 3; ++i
)
10002 tree this_jump_target
= tmp
;
10003 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
10004 want_rval
, strict
, now
, fundef_p
,
10005 tf_none
, &this_jump_target
))
10007 if (returns (&this_jump_target
))
10008 *jump_target
= this_jump_target
;
10009 else if (!returns (jump_target
))
10011 if (breaks (&this_jump_target
)
10012 || continues (&this_jump_target
))
10013 *jump_target
= this_jump_target
;
10016 /* If the then branch is potentially constant, but
10017 does not return, check if the else branch
10018 couldn't return, break or continue. */
10019 hash_set
<tree
> pset
;
10020 check_for_return_continue_data data
= { &pset
, NULL_TREE
,
10023 = cp_walk_tree (&TREE_OPERAND (t
, 2),
10024 check_for_return_continue
, &data
,
10026 *jump_target
= ret_expr
;
10027 else if (*jump_target
== NULL_TREE
)
10029 if (data
.continue_stmt
)
10030 *jump_target
= data
.continue_stmt
;
10031 else if (data
.break_stmt
)
10032 *jump_target
= data
.break_stmt
;
10039 if (flags
& tf_error
)
10041 if (TREE_CODE (t
) == IF_STMT
)
10042 constexpr_error (loc
, fundef_p
, "neither branch of %<if%> is a "
10043 "constant expression");
10045 constexpr_error (loc
, fundef_p
, "expression %qE is not a "
10046 "constant expression", t
);
10050 case VEC_INIT_EXPR
:
10051 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
10053 if (flags
& tf_error
)
10055 if (constexpr_error (loc
, fundef_p
, "non-constant array "
10057 diagnose_non_constexpr_vec_init (t
);
10063 /* We can see these in statement-expressions. */
10067 if (!RECUR (CLEANUP_BODY (t
), any
))
10069 if (!CLEANUP_EH_ONLY (t
) && !RECUR (CLEANUP_EXPR (t
), any
))
10073 case EMPTY_CLASS_EXPR
:
10078 tree
*target
= &TREE_OPERAND (t
, 0);
10079 /* Gotos representing break, continue and cdtor return are OK. */
10080 if (breaks (target
) || continues (target
) || returns (target
))
10082 *jump_target
= *target
;
10085 if (flags
& tf_error
)
10086 constexpr_error (loc
, fundef_p
, "%<goto%> is not a constant "
10091 case ASSERTION_STMT
:
10092 case PRECONDITION_STMT
:
10093 case POSTCONDITION_STMT
:
10094 if (!checked_contract_p (get_contract_semantic (t
)))
10096 return RECUR (CONTRACT_CONDITION (t
), rval
);
10099 t
= LABEL_EXPR_LABEL (t
);
10100 if (DECL_ARTIFICIAL (t
) || cxx_dialect
>= cxx23
)
10102 else if (flags
& tf_error
)
10103 constexpr_error (loc
, fundef_p
, "label definition in %<constexpr%> "
10104 "function only available with %<-std=c++2b%> or "
10105 "%<-std=gnu++2b%>");
10108 case ANNOTATE_EXPR
:
10109 return RECUR (TREE_OPERAND (t
, 0), rval
);
10111 case BIT_CAST_EXPR
:
10112 return RECUR (TREE_OPERAND (t
, 0), rval
);
10114 /* Coroutine await, yield and return expressions are not. */
10115 case CO_AWAIT_EXPR
:
10116 case CO_YIELD_EXPR
:
10117 case CO_RETURN_EXPR
:
10120 case NONTYPE_ARGUMENT_PACK
:
10122 tree args
= ARGUMENT_PACK_ARGS (t
);
10123 int len
= TREE_VEC_LENGTH (args
);
10124 for (int i
= 0; i
< len
; ++i
)
10125 if (!RECUR (TREE_VEC_ELT (args
, i
), any
))
10131 if (objc_non_constant_expr_p (t
))
10134 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
10135 gcc_unreachable ();
10142 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
10143 bool fundef_p
, tsubst_flags_t flags
)
10145 if (flags
& tf_error
)
10147 /* Check potentiality quietly first, as that could be performed more
10148 efficiently in some cases (currently only for TRUTH_*_EXPR). If
10149 that fails, replay the check noisily to give errors. */
10150 flags
&= ~tf_error
;
10151 if (potential_constant_expression_1 (t
, want_rval
, strict
, now
, fundef_p
,
10157 tree target
= NULL_TREE
;
10158 return potential_constant_expression_1 (t
, want_rval
, strict
, now
, fundef_p
,
10162 /* The main entry point to the above. */
10165 potential_constant_expression (tree t
)
10167 return potential_constant_expression_1 (t
, /*want_rval*/false, /*strict*/true,
10168 /*now*/false, /*fundef_p*/false,
10172 /* As above, but require a constant rvalue. */
10175 potential_rvalue_constant_expression (tree t
)
10177 return potential_constant_expression_1 (t
, /*want_rval*/true, /*strict*/true,
10178 /*now*/false, /*fundef_p*/false,
10182 /* Like above, but complain about non-constant expressions. */
10185 require_potential_constant_expression (tree t
)
10187 return potential_constant_expression_1 (t
, /*want_rval*/false, /*strict*/true,
10188 /*now*/false, /*fundef_p*/false,
10189 tf_warning_or_error
);
10192 /* Cross product of the above. */
10195 require_potential_rvalue_constant_expression (tree t
)
10197 return potential_constant_expression_1 (t
, /*want_rval*/true, /*strict*/true,
10198 /*now*/false, /*fundef_p*/false,
10199 tf_warning_or_error
);
10202 /* Like require_potential_rvalue_constant_expression, but fundef_p is true. */
10205 require_potential_rvalue_constant_expression_fncheck (tree t
)
10207 return potential_constant_expression_1 (t
, /*want_rval*/true, /*strict*/true,
10208 /*now*/false, /*fundef_p*/true,
10209 tf_warning_or_error
);
10212 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
10215 require_rvalue_constant_expression (tree t
)
10217 return potential_constant_expression_1 (t
, /*want_rval*/true, /*strict*/true,
10218 /*now*/true, /*fundef_p*/false,
10219 tf_warning_or_error
);
10222 /* Like potential_constant_expression, but don't consider possible constexpr
10223 substitution of the current function. That is, PARM_DECL qualifies under
10224 potential_constant_expression, but not here.
10226 This is basically what you can check when any actual constant values might
10227 be value-dependent. */
10230 is_constant_expression (tree t
)
10232 return potential_constant_expression_1 (t
, /*want_rval*/false, /*strict*/true,
10233 /*now*/true, /*fundef_p*/false,
10237 /* As above, but expect an rvalue. */
10240 is_rvalue_constant_expression (tree t
)
10242 return potential_constant_expression_1 (t
, /*want_rval*/true, /*strict*/true,
10243 /*now*/true, /*fundef_p*/false,
10247 /* Like above, but complain about non-constant expressions. */
10250 require_constant_expression (tree t
)
10252 return potential_constant_expression_1 (t
, /*want_rval*/false, /*strict*/true,
10253 /*now*/true, /*fundef_p*/false,
10254 tf_warning_or_error
);
10257 /* Like is_constant_expression, but allow const variables that are not allowed
10258 under constexpr rules. */
10261 is_static_init_expression (tree t
)
10263 return potential_constant_expression_1 (t
, /*want_rval*/false,
10264 /*strict*/false, /*now*/true,
10265 /*fundef_p*/false, tf_none
);
10268 /* Returns true if T is a potential constant expression that is not
10269 instantiation-dependent, and therefore a candidate for constant folding even
10273 is_nondependent_constant_expression (tree t
)
10275 return (!type_unknown_p (t
)
10276 && is_constant_expression (t
)
10277 && !instantiation_dependent_expression_p (t
));
10280 /* Returns true if T is a potential static initializer expression that is not
10281 instantiation-dependent. */
10284 is_nondependent_static_init_expression (tree t
)
10286 return (!type_unknown_p (t
)
10287 && is_static_init_expression (t
)
10288 && !instantiation_dependent_expression_p (t
));
10291 /* True iff FN is an implicitly constexpr function. */
10294 decl_implicit_constexpr_p (tree fn
)
10296 if (!(flag_implicit_constexpr
10297 && TREE_CODE (fn
) == FUNCTION_DECL
10298 && DECL_DECLARED_CONSTEXPR_P (fn
)))
10301 if (DECL_CLONED_FUNCTION_P (fn
))
10302 fn
= DECL_CLONED_FUNCTION (fn
);
10304 return (DECL_LANG_SPECIFIC (fn
)
10305 && DECL_LANG_SPECIFIC (fn
)->u
.fn
.implicit_constexpr
);
10308 /* Finalize constexpr processing after parsing. */
10311 fini_constexpr (void)
10313 /* The contexpr call and fundef copies tables are no longer needed. */
10314 constexpr_call_table
= NULL
;
10315 fundef_copies_table
= NULL
;
10318 #include "gt-cp-constexpr.h"