1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2018 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
34 #include "gimple-fold.h"
37 static bool verify_constant (tree
, bool, bool *, bool *);
38 #define VERIFY_CONSTANT(X) \
40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
44 /* Returns true iff FUN is an instantiation of a constexpr function
45 template or a defaulted constexpr function. */
48 is_instantiation_of_constexpr (tree fun
)
50 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
52 || (DECL_DEFAULTED_FN (fun
)
53 && DECL_DECLARED_CONSTEXPR_P (fun
)));
56 /* Return true if T is a literal type. */
59 literal_type_p (tree t
)
64 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
68 t
= complete_type (t
);
69 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
70 return CLASSTYPE_LITERAL_P (t
);
72 if (TREE_CODE (t
) == ARRAY_TYPE
)
73 return literal_type_p (strip_array_types (t
));
77 /* If DECL is a variable declared `constexpr', require its type
78 be literal. Return error_mark_node if we give an error, the
82 ensure_literal_type_for_constexpr_object (tree decl
)
84 tree type
= TREE_TYPE (decl
);
86 && (DECL_DECLARED_CONSTEXPR_P (decl
)
87 || var_in_constexpr_fn (decl
))
88 && !processing_template_decl
)
90 tree stype
= strip_array_types (type
);
91 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
92 /* Don't complain here, we'll complain about incompleteness
93 when we try to initialize the variable. */;
94 else if (type_uses_auto (type
))
95 /* We don't know the actual type yet. */;
96 else if (!literal_type_p (type
))
98 if (DECL_DECLARED_CONSTEXPR_P (decl
))
100 auto_diagnostic_group d
;
101 error_at (DECL_SOURCE_LOCATION (decl
),
102 "the type %qT of %<constexpr%> variable %qD "
103 "is not literal", type
, decl
);
104 explain_non_literal_class (type
);
105 decl
= error_mark_node
;
109 if (!is_instantiation_of_constexpr (current_function_decl
))
111 auto_diagnostic_group d
;
112 error_at (DECL_SOURCE_LOCATION (decl
),
113 "variable %qD of non-literal type %qT in "
114 "%<constexpr%> function", decl
, type
);
115 explain_non_literal_class (type
);
116 decl
= error_mark_node
;
118 cp_function_chain
->invalid_constexpr
= true;
121 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
122 && variably_modified_type_p (type
, NULL_TREE
))
124 error_at (DECL_SOURCE_LOCATION (decl
),
125 "%<constexpr%> variable %qD has variably-modified "
126 "type %qT", decl
, type
);
127 decl
= error_mark_node
;
133 /* Representation of entries in the constexpr function definition table. */
135 struct GTY((for_user
)) constexpr_fundef
{
140 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
142 static hashval_t
hash (constexpr_fundef
*);
143 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
146 /* This table holds all constexpr function definitions seen in
147 the current translation unit. */
149 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
151 /* Utility function used for managing the constexpr function table.
152 Return true if the entries pointed to by P and Q are for the
153 same constexpr function. */
156 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
158 return lhs
->decl
== rhs
->decl
;
161 /* Utility function used for managing the constexpr function table.
162 Return a hash value for the entry pointed to by Q. */
165 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
167 return DECL_UID (fundef
->decl
);
170 /* Return a previously saved definition of function FUN. */
172 static constexpr_fundef
*
173 retrieve_constexpr_fundef (tree fun
)
175 constexpr_fundef fundef
= { NULL
, NULL
};
176 if (constexpr_fundef_table
== NULL
)
180 return constexpr_fundef_table
->find (&fundef
);
183 /* Check whether the parameter and return types of FUN are valid for a
184 constexpr function, and complain if COMPLAIN. */
187 is_valid_constexpr_fn (tree fun
, bool complain
)
191 if (DECL_INHERITED_CTOR (fun
)
192 && TREE_CODE (fun
) == TEMPLATE_DECL
)
196 error ("inherited constructor %qD is not %<constexpr%>",
197 DECL_INHERITED_CTOR (fun
));
201 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
202 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
203 if (!literal_type_p (TREE_TYPE (parm
)))
208 auto_diagnostic_group d
;
209 error ("invalid type for parameter %d of %<constexpr%> "
210 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
211 explain_non_literal_class (TREE_TYPE (parm
));
216 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
220 inform (DECL_SOURCE_LOCATION (fun
),
221 "lambdas are implicitly %<constexpr%> only in C++17 and later");
223 else if (!DECL_CONSTRUCTOR_P (fun
))
225 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
226 if (!literal_type_p (rettype
))
231 auto_diagnostic_group d
;
232 error ("invalid return type %qT of %<constexpr%> function %q+D",
234 explain_non_literal_class (rettype
);
238 /* C++14 DR 1684 removed this restriction. */
239 if (cxx_dialect
< cxx14
240 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
241 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
246 auto_diagnostic_group d
;
247 if (pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
248 "enclosing class of %<constexpr%> non-static"
249 " member function %q+#D is not a literal type",
251 explain_non_literal_class (DECL_CONTEXT (fun
));
255 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
259 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
265 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
266 for a member of an anonymous aggregate, INIT is the initializer for that
267 member, and VEC_OUTER is the vector of constructor elements for the class
268 whose constructor we are processing. Add the initializer to the vector
269 and return true to indicate success. */
272 build_anon_member_initialization (tree member
, tree init
,
273 vec
<constructor_elt
, va_gc
> **vec_outer
)
275 /* MEMBER presents the relevant fields from the inside out, but we need
276 to build up the initializer from the outside in so that we can reuse
277 previously built CONSTRUCTORs if this is, say, the second field in an
278 anonymous struct. So we use a vec as a stack. */
279 auto_vec
<tree
, 2> fields
;
282 fields
.safe_push (TREE_OPERAND (member
, 1));
283 member
= TREE_OPERAND (member
, 0);
285 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
286 && TREE_CODE (member
) == COMPONENT_REF
);
288 /* VEC has the constructor elements vector for the context of FIELD.
289 If FIELD is an anonymous aggregate, we will push inside it. */
290 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
292 while (field
= fields
.pop(),
293 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
296 /* If there is already an outer constructor entry for the anonymous
297 aggregate FIELD, use it; otherwise, insert one. */
298 if (vec_safe_is_empty (*vec
)
299 || (*vec
)->last().index
!= field
)
301 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
302 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
305 ctor
= (*vec
)->last().value
;
306 vec
= &CONSTRUCTOR_ELTS (ctor
);
309 /* Now we're at the innermost field, the one that isn't an anonymous
310 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
311 gcc_assert (fields
.is_empty());
312 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
317 /* Subroutine of build_constexpr_constructor_member_initializers.
318 The expression tree T represents a data member initialization
319 in a (constexpr) constructor definition. Build a pairing of
320 the data member with its initializer, and prepend that pair
321 to the existing initialization pair INITS. */
324 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
327 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
328 t
= TREE_OPERAND (t
, 0);
329 if (TREE_CODE (t
) == EXPR_STMT
)
330 t
= TREE_OPERAND (t
, 0);
331 if (t
== error_mark_node
)
333 if (TREE_CODE (t
) == STATEMENT_LIST
)
335 tree_stmt_iterator i
;
336 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
338 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
343 if (TREE_CODE (t
) == CLEANUP_STMT
)
345 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
346 but we can in a constexpr constructor for a non-literal class. Just
347 ignore it; either all the initialization will be constant, in which
348 case the cleanup can't run, or it can't be constexpr.
349 Still recurse into CLEANUP_BODY. */
350 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
352 if (TREE_CODE (t
) == CONVERT_EXPR
)
353 t
= TREE_OPERAND (t
, 0);
354 if (TREE_CODE (t
) == INIT_EXPR
355 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
356 use what this function builds for cx_check_missing_mem_inits, and
357 assignment in the ctor body doesn't count. */
358 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
360 member
= TREE_OPERAND (t
, 0);
361 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
363 else if (TREE_CODE (t
) == CALL_EXPR
)
365 tree fn
= get_callee_fndecl (t
);
366 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
367 /* We're only interested in calls to subobject constructors. */
369 member
= CALL_EXPR_ARG (t
, 0);
370 /* We don't use build_cplus_new here because it complains about
371 abstract bases. Leaving the call unwrapped means that it has the
372 wrong type, but cxx_eval_constant_expression doesn't care. */
373 init
= break_out_target_exprs (t
);
375 else if (TREE_CODE (t
) == BIND_EXPR
)
376 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
378 /* Don't add anything else to the CONSTRUCTOR. */
380 if (INDIRECT_REF_P (member
))
381 member
= TREE_OPERAND (member
, 0);
382 if (TREE_CODE (member
) == NOP_EXPR
)
386 if (TREE_CODE (op
) == ADDR_EXPR
)
388 gcc_assert (same_type_ignoring_top_level_qualifiers_p
389 (TREE_TYPE (TREE_TYPE (op
)),
390 TREE_TYPE (TREE_TYPE (member
))));
391 /* Initializing a cv-qualified member; we need to look through
395 else if (op
== current_class_ptr
396 && (same_type_ignoring_top_level_qualifiers_p
397 (TREE_TYPE (TREE_TYPE (member
)),
398 current_class_type
)))
399 /* Delegating constructor. */
403 /* This is an initializer for an empty base; keep it for now so
404 we can check it in cxx_eval_bare_aggregate. */
405 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
408 if (TREE_CODE (member
) == ADDR_EXPR
)
409 member
= TREE_OPERAND (member
, 0);
410 if (TREE_CODE (member
) == COMPONENT_REF
)
412 tree aggr
= TREE_OPERAND (member
, 0);
413 if (TREE_CODE (aggr
) == VAR_DECL
)
414 /* Initializing a local variable, don't add anything. */
416 if (TREE_CODE (aggr
) != COMPONENT_REF
)
417 /* Normal member initialization. */
418 member
= TREE_OPERAND (member
, 1);
419 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
420 /* Initializing a member of an anonymous union. */
421 return build_anon_member_initialization (member
, init
, vec
);
423 /* We're initializing a vtable pointer in a base. Leave it as
424 COMPONENT_REF so we remember the path to get to the vfield. */
425 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
428 /* Value-initialization can produce multiple initializers for the
429 same field; use the last one. */
430 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
431 (*vec
)->last().value
= init
;
433 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
437 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
438 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
439 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
442 check_constexpr_bind_expr_vars (tree t
)
444 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
446 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
447 if (TREE_CODE (var
) == TYPE_DECL
448 && DECL_IMPLICIT_TYPEDEF_P (var
)
449 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
454 /* Subroutine of check_constexpr_ctor_body. */
457 check_constexpr_ctor_body_1 (tree last
, tree list
)
459 switch (TREE_CODE (list
))
462 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
463 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
467 case CLEANUP_POINT_EXPR
:
468 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
472 if (!check_constexpr_bind_expr_vars (list
)
473 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
480 case DEBUG_BEGIN_STMT
:
488 /* Make sure that there are no statements after LAST in the constructor
489 body represented by LIST. */
492 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
494 /* C++14 doesn't require a constexpr ctor to have an empty body. */
495 if (cxx_dialect
>= cxx14
)
499 if (TREE_CODE (list
) == STATEMENT_LIST
)
501 tree_stmt_iterator i
= tsi_last (list
);
502 for (; !tsi_end_p (i
); tsi_prev (&i
))
504 tree t
= tsi_stmt (i
);
507 if (!check_constexpr_ctor_body_1 (last
, t
))
514 else if (list
!= last
515 && !check_constexpr_ctor_body_1 (last
, list
))
520 error ("%<constexpr%> constructor does not have empty body");
521 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
526 /* V is a vector of constructor elements built up for the base and member
527 initializers of a constructor for TYPE. They need to be in increasing
528 offset order, which they might not be yet if TYPE has a primary base
529 which is not first in the base-clause or a vptr and at least one base
530 all of which are non-primary. */
532 static vec
<constructor_elt
, va_gc
> *
533 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
535 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
541 field_type
= BINFO_TYPE (pri
);
542 else if (TYPE_CONTAINS_VPTR_P (type
))
543 field_type
= vtbl_ptr_type_node
;
547 /* Find the element for the primary base or vptr and move it to the
548 beginning of the vec. */
549 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
550 if (TREE_TYPE (ce
->index
) == field_type
)
553 if (i
> 0 && i
< vec_safe_length (v
))
555 vec
<constructor_elt
, va_gc
> &vref
= *v
;
556 constructor_elt elt
= vref
[i
];
565 /* Build compile-time evalable representations of member-initializer list
566 for a constexpr constructor. */
569 build_constexpr_constructor_member_initializers (tree type
, tree body
)
571 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
574 switch (TREE_CODE (body
))
576 case MUST_NOT_THROW_EXPR
:
578 body
= TREE_OPERAND (body
, 0);
582 for (tree_stmt_iterator i
= tsi_start (body
);
583 !tsi_end_p (i
); tsi_next (&i
))
586 if (TREE_CODE (body
) == BIND_EXPR
)
592 body
= BIND_EXPR_BODY (body
);
599 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
601 body
= TREE_OPERAND (body
, 0);
602 if (TREE_CODE (body
) == EXPR_STMT
)
603 body
= TREE_OPERAND (body
, 0);
604 if (TREE_CODE (body
) == INIT_EXPR
605 && (same_type_ignoring_top_level_qualifiers_p
606 (TREE_TYPE (TREE_OPERAND (body
, 0)),
607 current_class_type
)))
610 return TREE_OPERAND (body
, 1);
612 ok
= build_data_member_initialization (body
, &vec
);
614 else if (TREE_CODE (body
) == STATEMENT_LIST
)
616 tree_stmt_iterator i
;
617 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
619 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
624 else if (TREE_CODE (body
) == TRY_BLOCK
)
626 error ("body of %<constexpr%> constructor cannot be "
627 "a function-try-block");
628 return error_mark_node
;
630 else if (EXPR_P (body
))
631 ok
= build_data_member_initialization (body
, &vec
);
633 gcc_assert (errorcount
> 0);
636 if (vec_safe_length (vec
) > 0)
638 /* In a delegating constructor, return the target. */
639 constructor_elt
*ce
= &(*vec
)[0];
640 if (ce
->index
== current_class_ptr
)
647 vec
= sort_constexpr_mem_initializers (type
, vec
);
648 return build_constructor (type
, vec
);
651 return error_mark_node
;
654 /* We have an expression tree T that represents a call, either CALL_EXPR
655 or AGGR_INIT_EXPR. If the call is lexically to a named function,
656 retrun the _DECL for that function. */
659 get_function_named_in_call (tree t
)
661 tree fun
= cp_get_callee (t
);
662 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
663 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
664 fun
= TREE_OPERAND (fun
, 0);
668 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
669 declared to be constexpr, or a sub-statement thereof. Returns the
670 return value if suitable, error_mark_node for a statement not allowed in
671 a constexpr function, or NULL_TREE if no return value was found. */
674 constexpr_fn_retval (tree body
)
676 switch (TREE_CODE (body
))
680 tree_stmt_iterator i
;
681 tree expr
= NULL_TREE
;
682 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
684 tree s
= constexpr_fn_retval (tsi_stmt (i
));
685 if (s
== error_mark_node
)
686 return error_mark_node
;
687 else if (s
== NULL_TREE
)
688 /* Keep iterating. */;
690 /* Multiple return statements. */
691 return error_mark_node
;
699 return break_out_target_exprs (TREE_OPERAND (body
, 0));
703 tree decl
= DECL_EXPR_DECL (body
);
704 if (TREE_CODE (decl
) == USING_DECL
705 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
706 || DECL_ARTIFICIAL (decl
))
708 return error_mark_node
;
711 case CLEANUP_POINT_EXPR
:
712 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
715 if (!check_constexpr_bind_expr_vars (body
))
716 return error_mark_node
;
717 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
720 case DEBUG_BEGIN_STMT
:
725 tree fun
= get_function_named_in_call (body
);
727 && fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
))
733 return error_mark_node
;
737 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
738 FUN; do the necessary transformations to turn it into a single expression
739 that we can store in the hash table. */
742 massage_constexpr_body (tree fun
, tree body
)
744 if (DECL_CONSTRUCTOR_P (fun
))
745 body
= build_constexpr_constructor_member_initializers
746 (DECL_CONTEXT (fun
), body
);
747 else if (cxx_dialect
< cxx14
)
749 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
750 body
= EH_SPEC_STMTS (body
);
751 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
752 body
= TREE_OPERAND (body
, 0);
753 body
= constexpr_fn_retval (body
);
758 /* CTYPE is a type constructed from BODY. Return true if some
759 bases/fields are uninitialized, and complain if COMPLAIN. */
762 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
768 if (TREE_CODE (body
) != CONSTRUCTOR
)
770 nelts
= CONSTRUCTOR_NELTS (body
);
772 tree field
= TYPE_FIELDS (ctype
);
774 if (TREE_CODE (ctype
) == UNION_TYPE
)
776 if (nelts
== 0 && next_initializable_field (field
))
779 error ("%<constexpr%> constructor for union %qT must "
780 "initialize exactly one non-static data member", ctype
);
786 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
787 need an explicit initialization. */
789 for (unsigned i
= 0; i
<= nelts
; ++i
)
791 tree index
= NULL_TREE
;
794 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
795 /* Skip base and vtable inits. */
796 if (TREE_CODE (index
) != FIELD_DECL
797 || DECL_ARTIFICIAL (index
))
801 for (; field
!= index
; field
= DECL_CHAIN (field
))
804 if (TREE_CODE (field
) != FIELD_DECL
)
806 if (DECL_UNNAMED_BIT_FIELD (field
))
808 if (DECL_ARTIFICIAL (field
))
810 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
812 /* Recurse to check the anonummous aggregate member. */
813 bad
|= cx_check_missing_mem_inits
814 (TREE_TYPE (field
), NULL_TREE
, complain
);
815 if (bad
&& !complain
)
819 ftype
= strip_array_types (TREE_TYPE (field
));
820 if (type_has_constexpr_default_constructor (ftype
))
822 /* It's OK to skip a member with a trivial constexpr ctor.
823 A constexpr ctor that isn't trivial should have been
825 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
831 auto_diagnostic_group d
;
832 error ("member %qD must be initialized by mem-initializer "
833 "in %<constexpr%> constructor", field
);
834 inform (DECL_SOURCE_LOCATION (field
), "declared here");
837 if (field
== NULL_TREE
)
840 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
842 /* Check the anonymous aggregate initializer is valid. */
843 bad
|= cx_check_missing_mem_inits
844 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
845 if (bad
&& !complain
)
848 field
= DECL_CHAIN (field
);
854 /* We are processing the definition of the constexpr function FUN.
855 Check that its BODY fulfills the propriate requirements and
856 enter it in the constexpr function definition table.
857 For constructor BODY is actually the TREE_LIST of the
858 member-initializer list. */
861 register_constexpr_fundef (tree fun
, tree body
)
863 constexpr_fundef entry
;
864 constexpr_fundef
**slot
;
866 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
869 tree massaged
= massage_constexpr_body (fun
, body
);
870 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
872 if (!DECL_CONSTRUCTOR_P (fun
))
873 error ("body of %<constexpr%> function %qD not a return-statement",
878 if (!potential_rvalue_constant_expression (massaged
))
880 if (!DECL_GENERATED_P (fun
))
881 require_potential_rvalue_constant_expression (massaged
);
885 if (DECL_CONSTRUCTOR_P (fun
)
886 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
887 massaged
, !DECL_GENERATED_P (fun
)))
890 /* Create the constexpr function table if necessary. */
891 if (constexpr_fundef_table
== NULL
)
892 constexpr_fundef_table
893 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
897 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
899 gcc_assert (*slot
== NULL
);
900 *slot
= ggc_alloc
<constexpr_fundef
> ();
906 /* FUN is a non-constexpr function called in a context that requires a
907 constant expression. If it comes from a constexpr template, explain why
908 the instantiation isn't constexpr. */
911 explain_invalid_constexpr_fn (tree fun
)
913 static hash_set
<tree
> *diagnosed
;
916 /* Only diagnose defaulted functions, lambdas, or instantiations. */
917 if (!DECL_DEFAULTED_FN (fun
)
918 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
919 && !is_instantiation_of_constexpr (fun
))
921 if (diagnosed
== NULL
)
922 diagnosed
= new hash_set
<tree
>;
923 if (diagnosed
->add (fun
))
924 /* Already explained. */
927 save_loc
= input_location
;
928 if (!lambda_static_thunk_p (fun
))
930 /* Diagnostics should completely ignore the static thunk, so leave
931 input_location set to our caller's location. */
932 input_location
= DECL_SOURCE_LOCATION (fun
);
933 inform (input_location
,
934 "%qD is not usable as a %<constexpr%> function because:", fun
);
936 /* First check the declaration. */
937 if (is_valid_constexpr_fn (fun
, true))
939 /* Then if it's OK, the body. */
940 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
941 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
942 explain_implicit_non_constexpr (fun
);
945 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
946 require_potential_rvalue_constant_expression (body
);
947 if (DECL_CONSTRUCTOR_P (fun
))
948 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
951 input_location
= save_loc
;
954 /* Objects of this type represent calls to constexpr functions
955 along with the bindings of parameters to their arguments, for
956 the purpose of compile time evaluation. */
958 struct GTY((for_user
)) constexpr_call
{
959 /* Description of the constexpr function definition. */
960 constexpr_fundef
*fundef
;
961 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
962 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
963 Note: This arrangement is made to accommodate the use of
964 iterative_hash_template_arg (see pt.c). If you change this
965 representation, also change the hash calculation in
966 cxx_eval_call_expression. */
968 /* Result of the call.
969 NULL means the call is being evaluated.
970 error_mark_node means that the evaluation was erroneous;
971 otherwise, the actuall value of the call. */
973 /* The hash of this call; we remember it here to avoid having to
974 recalculate it when expanding the hash table. */
978 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
980 static hashval_t
hash (constexpr_call
*);
981 static bool equal (constexpr_call
*, constexpr_call
*);
984 enum constexpr_switch_state
{
985 /* Used when processing a switch for the first time by cxx_eval_switch_expr
986 and default: label for that switch has not been seen yet. */
987 css_default_not_seen
,
988 /* Used when processing a switch for the first time by cxx_eval_switch_expr
989 and default: label for that switch has been seen already. */
991 /* Used when processing a switch for the second time by
992 cxx_eval_switch_expr, where default: label should match. */
993 css_default_processing
996 /* The constexpr expansion context. CALL is the current function
997 expansion, CTOR is the current aggregate initializer, OBJECT is the
998 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
999 is a map of values of variables initialized within the expression. */
1001 struct constexpr_ctx
{
1002 /* The innermost call we're evaluating. */
1003 constexpr_call
*call
;
1004 /* Values for any temporaries or local variables within the
1005 constant-expression. */
1006 hash_map
<tree
,tree
> *values
;
1007 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
1008 aren't inside a loop. */
1009 hash_set
<tree
> *save_exprs
;
1010 /* The CONSTRUCTOR we're currently building up for an aggregate
1013 /* The object we're building the CONSTRUCTOR for. */
1015 /* If inside SWITCH_EXPR. */
1016 constexpr_switch_state
*css_state
;
1017 /* Whether we should error on a non-constant expression or fail quietly. */
1019 /* Whether we are strictly conforming to constant expression rules or
1020 trying harder to get a constant value. */
1022 /* Whether __builtin_is_constant_evaluated () should be true. */
1023 bool pretend_const_required
;
1026 /* A table of all constexpr calls that have been evaluated by the
1027 compiler in this translation unit. */
1029 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1031 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1032 bool, bool *, bool *, tree
* = NULL
);
1034 /* Compute a hash value for a constexpr call representation. */
1037 constexpr_call_hasher::hash (constexpr_call
*info
)
1042 /* Return true if the objects pointed to by P and Q represent calls
1043 to the same constexpr function with the same arguments.
1044 Otherwise, return false. */
1047 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1053 if (lhs
->hash
!= rhs
->hash
)
1055 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1057 lhs_bindings
= lhs
->bindings
;
1058 rhs_bindings
= rhs
->bindings
;
1059 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1061 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1062 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1063 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1064 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1066 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1067 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1069 return lhs_bindings
== rhs_bindings
;
1072 /* Initialize the constexpr call table, if needed. */
1075 maybe_initialize_constexpr_call_table (void)
1077 if (constexpr_call_table
== NULL
)
1078 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1081 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1082 a function happens to get called recursively, we unshare the callee
1083 function's body and evaluate this unshared copy instead of evaluating the
1086 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1087 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1088 that's keyed off of the original FUNCTION_DECL and whose value is a
1089 TREE_LIST of this function's unused copies awaiting reuse.
1091 This is not GC-deletable to avoid GC affecting UID generation. */
1093 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1095 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1098 maybe_initialize_fundef_copies_table ()
1100 if (fundef_copies_table
== NULL
)
1101 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1104 /* Reuse a copy or create a new unshared copy of the function FUN.
1105 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1106 is parms, TYPE is result. */
1109 get_fundef_copy (tree fun
)
1111 maybe_initialize_fundef_copies_table ();
1115 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1119 /* There is no cached function available, or in use. We can use
1120 the function directly. That the slot is now created records
1121 that this function is now in use. */
1122 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1123 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1125 else if (*slot
== NULL_TREE
)
1127 /* We've already used the function itself, so make a copy. */
1128 copy
= build_tree_list (NULL
, NULL
);
1129 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1133 /* We have a cached function available. */
1135 *slot
= TREE_CHAIN (copy
);
1141 /* Save the copy COPY of function FUN for later reuse by
1142 get_fundef_copy(). By construction, there will always be an entry
1146 save_fundef_copy (tree fun
, tree copy
)
1148 tree
*slot
= fundef_copies_table
->get (fun
);
1149 TREE_CHAIN (copy
) = *slot
;
1153 /* We have an expression tree T that represents a call, either CALL_EXPR
1154 or AGGR_INIT_EXPR. Return the Nth argument. */
1157 get_nth_callarg (tree t
, int n
)
1159 switch (TREE_CODE (t
))
1162 return CALL_EXPR_ARG (t
, n
);
1164 case AGGR_INIT_EXPR
:
1165 return AGGR_INIT_EXPR_ARG (t
, n
);
1173 /* Attempt to evaluate T which represents a call to a builtin function.
1174 We assume here that all builtin functions evaluate to scalar types
1175 represented by _CST nodes. */
1178 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1180 bool *non_constant_p
, bool *overflow_p
)
1182 const int nargs
= call_expr_nargs (t
);
1183 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1187 /* Don't fold __builtin_constant_p within a constexpr function. */
1188 bool bi_const_p
= DECL_IS_BUILTIN_CONSTANT_P (fun
);
1190 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1191 in a constexpr function until we have values for the parameters. */
1194 && current_function_decl
1195 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1197 *non_constant_p
= true;
1201 /* For __builtin_is_constant_evaluated, defer it if not
1202 ctx->pretend_const_required, otherwise fold it to true. */
1203 if (fndecl_built_in_p (fun
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
1206 if (!ctx
->pretend_const_required
)
1208 *non_constant_p
= true;
1211 return boolean_true_node
;
1214 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1215 return constant false for a non-constant argument. */
1216 constexpr_ctx new_ctx
= *ctx
;
1217 new_ctx
.quiet
= true;
1218 bool dummy1
= false, dummy2
= false;
1219 for (i
= 0; i
< nargs
; ++i
)
1221 args
[i
] = CALL_EXPR_ARG (t
, i
);
1222 /* If builtin_valid_in_constant_expr_p is true,
1223 potential_constant_expression_1 has not recursed into the arguments
1224 of the builtin, verify it here. */
1225 if (!builtin_valid_in_constant_expr_p (fun
)
1226 || potential_constant_expression (args
[i
]))
1227 args
[i
] = cxx_eval_constant_expression (&new_ctx
, args
[i
], false,
1230 /* For __built_in_constant_p, fold all expressions with constant values
1231 even if they aren't C++ constant-expressions. */
1232 args
[i
] = cp_fully_fold (args
[i
]);
1235 bool save_ffbcp
= force_folding_builtin_constant_p
;
1236 force_folding_builtin_constant_p
= true;
1237 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1238 CALL_EXPR_FN (t
), nargs
, args
);
1239 force_folding_builtin_constant_p
= save_ffbcp
;
1240 if (new_call
== NULL
)
1242 if (!*non_constant_p
&& !ctx
->quiet
)
1244 /* Do not allow__builtin_unreachable in constexpr function.
1245 The __builtin_unreachable call with BUILTINS_LOCATION
1246 comes from cp_maybe_instrument_return. */
1247 if (fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
)
1248 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1249 error ("%<constexpr%> call flows off the end of the function");
1252 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1253 CALL_EXPR_FN (t
), nargs
, args
);
1254 error ("%q+E is not a constant expression", new_call
);
1257 *non_constant_p
= true;
1261 if (!is_constant_expression (new_call
))
1263 if (!*non_constant_p
&& !ctx
->quiet
)
1264 error ("%q+E is not a constant expression", new_call
);
1265 *non_constant_p
= true;
1269 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1270 non_constant_p
, overflow_p
);
1273 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1274 the type of the value to match. */
1277 adjust_temp_type (tree type
, tree temp
)
1279 if (TREE_TYPE (temp
) == type
)
1281 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1282 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1283 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1284 gcc_assert (scalarish_type_p (type
));
1285 return cp_fold_convert (type
, temp
);
1288 /* Callback for walk_tree used by unshare_constructor. */
1291 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1295 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1300 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1301 subexpression, return an unshared copy of T. Otherwise return T. */
1304 unshare_constructor (tree t
)
1306 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1307 if (ctor
!= NULL_TREE
)
1308 return unshare_expr (t
);
1312 /* Subroutine of cxx_eval_call_expression.
1313 We are processing a call expression (either CALL_EXPR or
1314 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1315 all arguments and bind their values to correspondings
1316 parameters, making up the NEW_CALL context. */
1319 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1320 constexpr_call
*new_call
,
1321 bool *non_constant_p
, bool *overflow_p
,
1322 bool *non_constant_args
)
1324 const int nargs
= call_expr_nargs (t
);
1325 tree fun
= new_call
->fundef
->decl
;
1326 tree parms
= DECL_ARGUMENTS (fun
);
1328 tree
*p
= &new_call
->bindings
;
1329 for (i
= 0; i
< nargs
; ++i
)
1332 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1333 x
= get_nth_callarg (t
, i
);
1334 /* For member function, the first argument is a pointer to the implied
1335 object. For a constructor, it might still be a dummy object, in
1336 which case we get the real argument from ctx. */
1337 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1338 && is_dummy_object (x
))
1341 x
= build_address (x
);
1343 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1344 non_constant_p
, overflow_p
);
1345 /* Don't VERIFY_CONSTANT here. */
1346 if (*non_constant_p
&& ctx
->quiet
)
1348 /* Just discard ellipsis args after checking their constantitude. */
1352 if (!*non_constant_p
)
1354 /* Don't share a CONSTRUCTOR that might be changed. */
1355 arg
= unshare_constructor (arg
);
1356 /* Make sure the binding has the same type as the parm. But
1357 only for constant args. */
1358 if (!TYPE_REF_P (type
))
1359 arg
= adjust_temp_type (type
, arg
);
1360 if (!TREE_CONSTANT (arg
))
1361 *non_constant_args
= true;
1362 *p
= build_tree_list (parms
, arg
);
1363 p
= &TREE_CHAIN (*p
);
1365 parms
= TREE_CHAIN (parms
);
1369 /* Variables and functions to manage constexpr call expansion context.
1370 These do not need to be marked for PCH or GC. */
1372 /* FIXME remember and print actual constant arguments. */
1373 static vec
<tree
> call_stack
;
1374 static int call_stack_tick
;
1375 static int last_cx_error_tick
;
1378 push_cx_call_context (tree call
)
1381 if (!EXPR_HAS_LOCATION (call
))
1382 SET_EXPR_LOCATION (call
, input_location
);
1383 call_stack
.safe_push (call
);
1384 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1390 pop_cx_call_context (void)
1397 cx_error_context (void)
1399 vec
<tree
> r
= vNULL
;
1400 if (call_stack_tick
!= last_cx_error_tick
1401 && !call_stack
.is_empty ())
1403 last_cx_error_tick
= call_stack_tick
;
1407 /* Evaluate a call T to a GCC internal function when possible and return
1408 the evaluated result or, under the control of CTX, give an error, set
1409 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1412 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1414 bool *non_constant_p
, bool *overflow_p
)
1416 enum tree_code opcode
= ERROR_MARK
;
1418 switch (CALL_EXPR_IFN (t
))
1420 case IFN_UBSAN_NULL
:
1421 case IFN_UBSAN_BOUNDS
:
1422 case IFN_UBSAN_VPTR
:
1423 case IFN_FALLTHROUGH
:
1426 case IFN_ADD_OVERFLOW
:
1429 case IFN_SUB_OVERFLOW
:
1430 opcode
= MINUS_EXPR
;
1432 case IFN_MUL_OVERFLOW
:
1437 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1438 false, non_constant_p
, overflow_p
);
1442 error_at (cp_expr_loc_or_loc (t
, input_location
),
1443 "call to internal function %qE", t
);
1444 *non_constant_p
= true;
1448 /* Evaluate constant arguments using OPCODE and return a complex
1449 number containing the result and the overflow bit. */
1450 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1451 non_constant_p
, overflow_p
);
1452 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1453 non_constant_p
, overflow_p
);
1455 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1457 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1458 tree type
= TREE_TYPE (TREE_TYPE (t
));
1459 tree result
= fold_binary_loc (loc
, opcode
, type
,
1460 fold_convert_loc (loc
, type
, arg0
),
1461 fold_convert_loc (loc
, type
, arg1
));
1463 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1464 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1465 if (TREE_OVERFLOW (result
))
1466 TREE_OVERFLOW (result
) = 0;
1468 return build_complex (TREE_TYPE (t
), result
, ovf
);
1471 *non_constant_p
= true;
1475 /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */
1478 clear_no_implicit_zero (tree ctor
)
1480 if (CONSTRUCTOR_NO_CLEARING (ctor
))
1482 CONSTRUCTOR_NO_CLEARING (ctor
) = false;
1483 tree elt
; unsigned HOST_WIDE_INT idx
;
1484 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1485 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1486 clear_no_implicit_zero (elt
);
1490 /* Subroutine of cxx_eval_constant_expression.
1491 Evaluate the call expression tree T in the context of OLD_CALL expression
1495 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1497 bool *non_constant_p
, bool *overflow_p
)
1499 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1500 tree fun
= get_function_named_in_call (t
);
1501 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1504 if (fun
== NULL_TREE
)
1505 return cxx_eval_internal_function (ctx
, t
, lval
,
1506 non_constant_p
, overflow_p
);
1508 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1510 /* Might be a constexpr function pointer. */
1511 fun
= cxx_eval_constant_expression (ctx
, fun
,
1512 /*lval*/false, non_constant_p
,
1515 if (TREE_CODE (fun
) == ADDR_EXPR
)
1516 fun
= TREE_OPERAND (fun
, 0);
1518 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1520 if (!ctx
->quiet
&& !*non_constant_p
)
1521 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1523 *non_constant_p
= true;
1526 if (DECL_CLONED_FUNCTION_P (fun
))
1527 fun
= DECL_CLONED_FUNCTION (fun
);
1529 if (is_ubsan_builtin_p (fun
))
1532 if (fndecl_built_in_p (fun
))
1533 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1534 lval
, non_constant_p
, overflow_p
);
1535 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1539 if (!lambda_static_thunk_p (fun
))
1540 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1541 explain_invalid_constexpr_fn (fun
);
1543 *non_constant_p
= true;
1547 constexpr_ctx new_ctx
= *ctx
;
1548 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1549 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1551 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1552 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1553 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1554 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1555 CONSTRUCTOR_NO_CLEARING (ctor
) = true;
1556 ctx
->values
->put (new_ctx
.object
, ctor
);
1560 /* Shortcut trivial constructor/op=. */
1561 if (trivial_fn_p (fun
))
1563 tree init
= NULL_TREE
;
1564 if (call_expr_nargs (t
) == 2)
1565 init
= convert_from_reference (get_nth_callarg (t
, 1));
1566 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1567 && AGGR_INIT_ZERO_FIRST (t
))
1568 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1571 tree op
= get_nth_callarg (t
, 0);
1572 if (is_dummy_object (op
))
1575 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1576 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1577 new_ctx
.call
= &new_call
;
1578 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1579 non_constant_p
, overflow_p
);
1583 /* We can't defer instantiating the function any longer. */
1584 if (!DECL_INITIAL (fun
)
1585 && DECL_TEMPLOID_INSTANTIATION (fun
))
1587 location_t save_loc
= input_location
;
1588 input_location
= loc
;
1590 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1592 input_location
= save_loc
;
1595 /* If in direct recursive call, optimize definition search. */
1596 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1597 new_call
.fundef
= ctx
->call
->fundef
;
1600 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1601 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1602 || fun
== current_function_decl
)
1606 /* We need to check for current_function_decl here in case we're
1607 being called during cp_fold_function, because at that point
1608 DECL_INITIAL is set properly and we have a fundef but we
1609 haven't lowered invisirefs yet (c++/70344). */
1610 if (DECL_INITIAL (fun
) == error_mark_node
1611 || fun
== current_function_decl
)
1612 error_at (loc
, "%qD called in a constant expression before its "
1613 "definition is complete", fun
);
1614 else if (DECL_INITIAL (fun
))
1616 /* The definition of fun was somehow unsuitable. But pretend
1617 that lambda static thunks don't exist. */
1618 if (!lambda_static_thunk_p (fun
))
1619 error_at (loc
, "%qD called in a constant expression", fun
);
1620 explain_invalid_constexpr_fn (fun
);
1623 error_at (loc
, "%qD used before its definition", fun
);
1625 *non_constant_p
= true;
1630 bool non_constant_args
= false;
1631 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1632 non_constant_p
, overflow_p
, &non_constant_args
);
1633 if (*non_constant_p
)
1636 depth_ok
= push_cx_call_context (t
);
1638 tree result
= NULL_TREE
;
1640 constexpr_call
*entry
= NULL
;
1641 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1643 new_call
.hash
= iterative_hash_template_arg
1644 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1646 /* If we have seen this call before, we are done. */
1647 maybe_initialize_constexpr_call_table ();
1648 constexpr_call
**slot
1649 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1653 /* We need to keep a pointer to the entry, not just the slot, as the
1654 slot can move in the call to cxx_eval_builtin_function_call. */
1655 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1658 /* Calls that are in progress have their result set to NULL,
1659 so that we can detect circular dependencies. */
1660 else if (entry
->result
== NULL
)
1663 error ("call has circular dependency");
1664 *non_constant_p
= true;
1665 entry
->result
= result
= error_mark_node
;
1668 result
= entry
->result
;
1674 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1675 "%<-fconstexpr-depth=%> to increase the maximum)",
1676 max_constexpr_depth
);
1677 *non_constant_p
= true;
1678 result
= error_mark_node
;
1682 if (result
&& result
!= error_mark_node
)
1684 else if (!DECL_SAVED_TREE (fun
))
1686 /* When at_eof >= 2, cgraph has started throwing away
1687 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1688 late code generation for VEC_INIT_EXPR, which needs to be
1689 completely reconsidered. */
1690 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1691 *non_constant_p
= true;
1695 tree body
, parms
, res
;
1697 /* Reuse or create a new unshared copy of this function's body. */
1698 tree copy
= get_fundef_copy (fun
);
1699 body
= TREE_PURPOSE (copy
);
1700 parms
= TREE_VALUE (copy
);
1701 res
= TREE_TYPE (copy
);
1703 /* Associate the bindings with the remapped parms. */
1704 tree bound
= new_call
.bindings
;
1705 tree remapped
= parms
;
1708 tree oparm
= TREE_PURPOSE (bound
);
1709 tree arg
= TREE_VALUE (bound
);
1710 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1711 /* Don't share a CONSTRUCTOR that might be changed. */
1712 arg
= unshare_constructor (arg
);
1713 ctx
->values
->put (remapped
, arg
);
1714 bound
= TREE_CHAIN (bound
);
1715 remapped
= DECL_CHAIN (remapped
);
1717 /* Add the RESULT_DECL to the values map, too. */
1718 tree slot
= NULL_TREE
;
1719 if (DECL_BY_REFERENCE (res
))
1721 slot
= AGGR_INIT_EXPR_SLOT (t
);
1722 tree addr
= build_address (slot
);
1723 addr
= build_nop (TREE_TYPE (res
), addr
);
1724 ctx
->values
->put (res
, addr
);
1725 ctx
->values
->put (slot
, NULL_TREE
);
1728 ctx
->values
->put (res
, NULL_TREE
);
1730 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1731 their values after the call. */
1732 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1733 hash_set
<tree
> save_exprs
;
1734 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1735 ctx_with_save_exprs
.call
= &new_call
;
1737 tree jump_target
= NULL_TREE
;
1738 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1739 lval
, non_constant_p
, overflow_p
,
1742 if (DECL_CONSTRUCTOR_P (fun
))
1743 /* This can be null for a subobject constructor call, in
1744 which case what we care about is the initialization
1745 side-effects rather than the value. We could get at the
1746 value by evaluating *this, but we don't bother; there's
1747 no need to put such a call in the hash table. */
1748 result
= lval
? ctx
->object
: ctx
->ctor
;
1749 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1753 result
= *ctx
->values
->get (slot
? slot
: res
);
1754 if (result
== NULL_TREE
&& !*non_constant_p
)
1757 error ("%<constexpr%> call flows off the end "
1759 *non_constant_p
= true;
1763 /* Forget the saved values of the callee's SAVE_EXPRs. */
1764 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1765 iter
!= save_exprs
.end(); ++iter
)
1766 ctx_with_save_exprs
.values
->remove (*iter
);
1768 /* Remove the parms/result from the values map. Is it worth
1769 bothering to do this when the map itself is only live for
1770 one constexpr evaluation? If so, maybe also clear out
1771 other vars from call, maybe in BIND_EXPR handling? */
1772 ctx
->values
->remove (res
);
1774 ctx
->values
->remove (slot
);
1775 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1776 ctx
->values
->remove (parm
);
1778 /* Make the unshared function copy we used available for re-use. */
1779 save_fundef_copy (fun
, copy
);
1782 if (result
== error_mark_node
)
1783 *non_constant_p
= true;
1784 if (*non_constant_p
|| *overflow_p
)
1785 result
= error_mark_node
;
1789 entry
->result
= result
;
1792 /* The result of a constexpr function must be completely initialized. */
1793 if (TREE_CODE (result
) == CONSTRUCTOR
)
1794 clear_no_implicit_zero (result
);
1796 pop_cx_call_context ();
1797 return unshare_constructor (result
);
1800 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1803 reduced_constant_expression_p (tree t
)
1808 switch (TREE_CODE (t
))
1811 /* Even if we can't lower this yet, it's constant. */
1815 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1816 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1817 if (CONSTRUCTOR_NO_CLEARING (t
))
1819 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1820 /* An initialized vector would have a VECTOR_CST. */
1823 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1827 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1829 /* If VAL is null, we're in the middle of initializing this
1831 if (!reduced_constant_expression_p (val
))
1837 field
= next_initializable_field (DECL_CHAIN (field
));
1842 else if (CONSTRUCTOR_NO_CLEARING (t
))
1843 /* All the fields are initialized. */
1844 CONSTRUCTOR_NO_CLEARING (t
) = false;
1848 /* FIXME are we calling this too much? */
1849 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1853 /* Some expressions may have constant operands but are not constant
1854 themselves, such as 1/0. Call this function to check for that
1857 We only call this in places that require an arithmetic constant, not in
1858 places where we might have a non-constant expression that can be a
1859 component of a constant expression, such as the address of a constexpr
1860 variable that might be dereferenced later. */
1863 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1866 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1868 if (!allow_non_constant
)
1869 error ("%q+E is not a constant expression", t
);
1870 *non_constant_p
= true;
1872 if (TREE_OVERFLOW_P (t
))
1874 if (!allow_non_constant
)
1876 permerror (input_location
, "overflow in constant expression");
1877 /* If we're being permissive (and are in an enforcing
1878 context), ignore the overflow. */
1879 if (flag_permissive
)
1880 return *non_constant_p
;
1884 return *non_constant_p
;
1887 /* Check whether the shift operation with code CODE and type TYPE on LHS
1888 and RHS is undefined. If it is, give an error with an explanation,
1889 and return true; return false otherwise. */
1892 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1893 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1895 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1896 || TREE_CODE (lhs
) != INTEGER_CST
1897 || TREE_CODE (rhs
) != INTEGER_CST
)
1900 tree lhstype
= TREE_TYPE (lhs
);
1901 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1903 /* [expr.shift] The behavior is undefined if the right operand
1904 is negative, or greater than or equal to the length in bits
1905 of the promoted left operand. */
1906 if (tree_int_cst_sgn (rhs
) == -1)
1909 permerror (loc
, "right operand of shift expression %q+E is negative",
1910 build2_loc (loc
, code
, type
, lhs
, rhs
));
1911 return (!flag_permissive
|| ctx
->quiet
);
1913 if (compare_tree_int (rhs
, uprec
) >= 0)
1916 permerror (loc
, "right operand of shift expression %q+E is >= than "
1917 "the precision of the left operand",
1918 build2_loc (loc
, code
, type
, lhs
, rhs
));
1919 return (!flag_permissive
|| ctx
->quiet
);
1922 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1923 if E1 has a signed type and non-negative value, and E1x2^E2 is
1924 representable in the corresponding unsigned type of the result type,
1925 then that value, converted to the result type, is the resulting value;
1926 otherwise, the behavior is undefined.
1928 The value of E1 << E2 is the unique value congruent to E1 x 2^E2 modulo
1929 2^N, where N is the range exponent of the type of the result. */
1930 if (code
== LSHIFT_EXPR
1931 && !TYPE_UNSIGNED (lhstype
)
1932 && cxx_dialect
>= cxx11
1933 && cxx_dialect
< cxx2a
)
1935 if (tree_int_cst_sgn (lhs
) == -1)
1939 "left operand of shift expression %q+E is negative",
1940 build2_loc (loc
, code
, type
, lhs
, rhs
));
1941 return (!flag_permissive
|| ctx
->quiet
);
1943 /* For signed x << y the following:
1944 (unsigned) x >> ((prec (lhs) - 1) - y)
1945 if > 1, is undefined. The right-hand side of this formula
1946 is the highest bit of the LHS that can be set (starting from 0),
1947 so that the shift doesn't overflow. We then right-shift the LHS
1948 to see whether any other bit is set making the original shift
1949 undefined -- the result is not representable in the corresponding
1951 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1952 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1953 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1954 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1955 if (tree_int_cst_lt (integer_one_node
, t
))
1958 permerror (loc
, "shift expression %q+E overflows",
1959 build2_loc (loc
, code
, type
, lhs
, rhs
));
1960 return (!flag_permissive
|| ctx
->quiet
);
1966 /* Subroutine of cxx_eval_constant_expression.
1967 Attempt to reduce the unary expression tree T to a compile time value.
1968 If successful, return the value. Otherwise issue a diagnostic
1969 and return error_mark_node. */
1972 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1974 bool *non_constant_p
, bool *overflow_p
)
1977 tree orig_arg
= TREE_OPERAND (t
, 0);
1978 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1979 non_constant_p
, overflow_p
);
1980 VERIFY_CONSTANT (arg
);
1981 location_t loc
= EXPR_LOCATION (t
);
1982 enum tree_code code
= TREE_CODE (t
);
1983 tree type
= TREE_TYPE (t
);
1984 r
= fold_unary_loc (loc
, code
, type
, arg
);
1987 if (arg
== orig_arg
)
1990 r
= build1_loc (loc
, code
, type
, arg
);
1992 VERIFY_CONSTANT (r
);
1996 /* Helper function for cxx_eval_binary_expression. Try to optimize
1997 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1998 generic folding should be used. */
2001 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
2002 tree lhs
, tree rhs
, bool *non_constant_p
,
2006 if (TREE_CODE (lhs
) != ADDR_EXPR
)
2009 lhs
= TREE_OPERAND (lhs
, 0);
2011 /* &A[i] p+ j => &A[i + j] */
2012 if (TREE_CODE (lhs
) == ARRAY_REF
2013 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
2014 && TREE_CODE (rhs
) == INTEGER_CST
2015 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
2016 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
2018 tree orig_type
= TREE_TYPE (t
);
2019 location_t loc
= EXPR_LOCATION (t
);
2020 tree type
= TREE_TYPE (lhs
);
2022 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
2023 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
2024 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2026 if (*non_constant_p
)
2028 /* Don't fold an out-of-bound access. */
2029 if (!tree_int_cst_le (t
, nelts
))
2031 rhs
= cp_fold_convert (ssizetype
, rhs
);
2032 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
2033 constexpr int A[1]; ... (char *)&A[0] + 1 */
2034 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
2035 rhs
, TYPE_SIZE_UNIT (type
))))
2037 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2039 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
2040 TYPE_SIZE_UNIT (type
));
2041 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
2042 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
2043 t
, NULL_TREE
, NULL_TREE
);
2044 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2045 t
= cp_fold_convert (orig_type
, t
);
2046 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2047 non_constant_p
, overflow_p
);
2053 /* Subroutine of cxx_eval_constant_expression.
2054 Like cxx_eval_unary_expression, except for binary expressions. */
2057 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2059 bool *non_constant_p
, bool *overflow_p
)
2062 tree orig_lhs
= TREE_OPERAND (t
, 0);
2063 tree orig_rhs
= TREE_OPERAND (t
, 1);
2065 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2066 non_constant_p
, overflow_p
);
2067 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2069 if (*non_constant_p
)
2071 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2072 non_constant_p
, overflow_p
);
2073 if (*non_constant_p
)
2076 location_t loc
= EXPR_LOCATION (t
);
2077 enum tree_code code
= TREE_CODE (t
);
2078 tree type
= TREE_TYPE (t
);
2080 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2082 bool is_code_eq
= (code
== EQ_EXPR
);
2084 if (TREE_CODE (lhs
) == PTRMEM_CST
2085 && TREE_CODE (rhs
) == PTRMEM_CST
)
2087 tree lmem
= PTRMEM_CST_MEMBER (lhs
);
2088 tree rmem
= PTRMEM_CST_MEMBER (rhs
);
2090 if (TREE_CODE (lmem
) == TREE_CODE (rmem
)
2091 && TREE_CODE (lmem
) == FIELD_DECL
2092 && TREE_CODE (DECL_CONTEXT (lmem
)) == UNION_TYPE
2093 && same_type_p (DECL_CONTEXT (lmem
),
2094 DECL_CONTEXT (rmem
)))
2095 /* If both refer to (possibly different) members of the same union
2096 (12.3), they compare equal. */
2099 eq
= cp_tree_equal (lhs
, rhs
);
2100 r
= constant_boolean_node (eq
== is_code_eq
, type
);
2102 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2103 || TREE_CODE (rhs
) == PTRMEM_CST
)
2104 && (null_member_pointer_value_p (lhs
)
2105 || null_member_pointer_value_p (rhs
)))
2106 r
= constant_boolean_node (!is_code_eq
, type
);
2107 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2108 lhs
= cplus_expand_constant (lhs
);
2109 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2110 rhs
= cplus_expand_constant (rhs
);
2112 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2113 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2116 error ("arithmetic involving a null pointer in %qE", lhs
);
2117 *non_constant_p
= true;
2120 else if (code
== POINTER_PLUS_EXPR
)
2121 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2125 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2129 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2132 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2134 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2135 *non_constant_p
= true;
2136 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2137 a local array in a constexpr function. */
2138 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (lhs
));
2140 VERIFY_CONSTANT (r
);
2144 /* Subroutine of cxx_eval_constant_expression.
2145 Attempt to evaluate condition expressions. Dead branches are not
2149 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2151 bool *non_constant_p
, bool *overflow_p
,
2154 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2156 non_constant_p
, overflow_p
);
2157 VERIFY_CONSTANT (val
);
2158 /* Don't VERIFY_CONSTANT the other operands. */
2159 if (integer_zerop (val
))
2160 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2162 non_constant_p
, overflow_p
,
2164 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2166 non_constant_p
, overflow_p
,
2170 /* Subroutine of cxx_eval_constant_expression.
2171 Attempt to evaluate vector condition expressions. Unlike
2172 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2173 ternary arithmetics operation, where all 3 arguments have to be
2174 evaluated as constants and then folding computes the result from
2178 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2179 bool *non_constant_p
, bool *overflow_p
)
2181 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2183 non_constant_p
, overflow_p
);
2184 VERIFY_CONSTANT (arg1
);
2185 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2187 non_constant_p
, overflow_p
);
2188 VERIFY_CONSTANT (arg2
);
2189 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2191 non_constant_p
, overflow_p
);
2192 VERIFY_CONSTANT (arg3
);
2193 location_t loc
= EXPR_LOCATION (t
);
2194 tree type
= TREE_TYPE (t
);
2195 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2198 if (arg1
== TREE_OPERAND (t
, 0)
2199 && arg2
== TREE_OPERAND (t
, 1)
2200 && arg3
== TREE_OPERAND (t
, 2))
2203 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2205 VERIFY_CONSTANT (r
);
2209 /* Returns less than, equal to, or greater than zero if KEY is found to be
2210 less than, to match, or to be greater than the constructor_elt's INDEX. */
2213 array_index_cmp (tree key
, tree index
)
2215 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2217 switch (TREE_CODE (index
))
2220 return tree_int_cst_compare (key
, index
);
2223 tree lo
= TREE_OPERAND (index
, 0);
2224 tree hi
= TREE_OPERAND (index
, 1);
2225 if (tree_int_cst_lt (key
, lo
))
2227 else if (tree_int_cst_lt (hi
, key
))
2237 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2238 if none. If INSERT is true, insert a matching element rather than fail. */
2240 static HOST_WIDE_INT
2241 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2243 if (tree_int_cst_sgn (dindex
) < 0)
2246 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2247 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2248 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2250 unsigned HOST_WIDE_INT end
= len
;
2251 unsigned HOST_WIDE_INT begin
= 0;
2253 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2254 that the same is true of the other elements and index directly. */
2257 tree cindex
= (*elts
)[end
- 1].index
;
2258 if (TREE_CODE (cindex
) == INTEGER_CST
2259 && compare_tree_int (cindex
, end
- 1) == 0)
2268 /* Otherwise, find a matching index by means of a binary search. */
2269 while (begin
!= end
)
2271 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2272 constructor_elt
&elt
= (*elts
)[middle
];
2273 tree idx
= elt
.index
;
2275 int cmp
= array_index_cmp (dindex
, idx
);
2282 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2284 /* We need to split the range. */
2286 tree lo
= TREE_OPERAND (idx
, 0);
2287 tree hi
= TREE_OPERAND (idx
, 1);
2288 tree value
= elt
.value
;
2289 dindex
= fold_convert (sizetype
, dindex
);
2290 if (tree_int_cst_lt (lo
, dindex
))
2292 /* There are still some lower elts; shorten the range. */
2293 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2295 if (tree_int_cst_equal (lo
, new_hi
))
2296 /* Only one element left, no longer a range. */
2299 TREE_OPERAND (idx
, 1) = new_hi
;
2300 /* Append the element we want to insert. */
2303 e
.value
= unshare_constructor (value
);
2304 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2307 /* No lower elts, the range elt is now ours. */
2310 if (tree_int_cst_lt (dindex
, hi
))
2312 /* There are still some higher elts; append a range. */
2313 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2315 if (tree_int_cst_equal (new_lo
, hi
))
2318 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2319 e
.value
= unshare_constructor (value
);
2320 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2329 constructor_elt e
= { dindex
, NULL_TREE
};
2330 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2337 /* Under the control of CTX, issue a detailed diagnostic for
2338 an out-of-bounds subscript INDEX into the expression ARRAY. */
2341 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2345 tree arraytype
= TREE_TYPE (array
);
2347 /* Convert the unsigned array subscript to a signed integer to avoid
2348 printing huge numbers for small negative values. */
2349 tree sidx
= fold_convert (ssizetype
, index
);
2352 if (TYPE_DOMAIN (arraytype
))
2353 error ("array subscript value %qE is outside the bounds "
2354 "of array %qD of type %qT", sidx
, array
, arraytype
);
2356 error ("non-zero array subscript %qE is used with array %qD of "
2357 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2358 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2360 else if (TYPE_DOMAIN (arraytype
))
2361 error ("array subscript value %qE is outside the bounds "
2362 "of array type %qT", sidx
, arraytype
);
2364 error ("non-zero array subscript %qE is used with array of type %qT "
2365 "with unknown bounds", sidx
, arraytype
);
2369 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2373 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2374 bool *non_constant_p
, bool *overflow_p
)
2377 if (TREE_CODE (type
) == ARRAY_TYPE
)
2379 if (TYPE_DOMAIN (type
))
2380 nelts
= array_type_nelts_top (type
);
2382 nelts
= size_zero_node
;
2384 else if (VECTOR_TYPE_P (type
))
2385 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2389 /* For VLAs, the number of elements won't be an integer constant. */
2390 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2391 non_constant_p
, overflow_p
);
2395 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2396 STRING_CST STRING. */
2399 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2401 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2404 if (chars_per_elt
== 1)
2405 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2408 const unsigned char *ptr
2409 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2410 + index
* chars_per_elt
);
2411 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2416 /* Subroutine of cxx_eval_constant_expression.
2417 Attempt to reduce a reference to an array slot. */
2420 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2422 bool *non_constant_p
, bool *overflow_p
)
2424 tree oldary
= TREE_OPERAND (t
, 0);
2425 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2427 non_constant_p
, overflow_p
);
2429 HOST_WIDE_INT i
= 0;
2430 tree elem_type
= NULL_TREE
;
2431 unsigned len
= 0, elem_nchars
= 1;
2432 if (*non_constant_p
)
2434 oldidx
= TREE_OPERAND (t
, 1);
2435 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2437 non_constant_p
, overflow_p
);
2438 VERIFY_CONSTANT (index
);
2441 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2442 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2443 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2444 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2445 ary
= TREE_OPERAND (ary
, 0);
2446 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2447 len
= CONSTRUCTOR_NELTS (ary
);
2448 else if (TREE_CODE (ary
) == STRING_CST
)
2450 elem_nchars
= (TYPE_PRECISION (elem_type
)
2451 / TYPE_PRECISION (char_type_node
));
2452 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2454 else if (TREE_CODE (ary
) == VECTOR_CST
)
2455 /* We don't create variable-length VECTOR_CSTs. */
2456 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2459 /* We can't do anything with other tree codes, so use
2460 VERIFY_CONSTANT to complain and fail. */
2461 VERIFY_CONSTANT (ary
);
2465 if (!tree_fits_shwi_p (index
)
2466 || (i
= tree_to_shwi (index
)) < 0)
2468 diag_array_subscript (ctx
, ary
, index
);
2469 *non_constant_p
= true;
2474 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2476 VERIFY_CONSTANT (nelts
);
2478 ? !tree_int_cst_le (index
, nelts
)
2479 : !tree_int_cst_lt (index
, nelts
))
2480 || tree_int_cst_sgn (index
) < 0)
2482 diag_array_subscript (ctx
, ary
, index
);
2483 *non_constant_p
= true;
2487 if (lval
&& ary
== oldary
&& index
== oldidx
)
2490 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2493 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2495 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2506 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2507 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2508 else if (TREE_CODE (ary
) == VECTOR_CST
)
2509 r
= VECTOR_CST_ELT (ary
, i
);
2511 r
= extract_string_elt (ary
, elem_nchars
, i
);
2514 /* Don't VERIFY_CONSTANT here. */
2517 /* Otherwise the element doesn't have a value yet. */
2522 if (TREE_CODE (ary
) == CONSTRUCTOR
2523 && CONSTRUCTOR_NO_CLEARING (ary
))
2525 /* 'ary' is part of the aggregate initializer we're currently
2526 building; if there's no initializer for this element yet,
2529 error ("accessing uninitialized array element");
2530 *non_constant_p
= true;
2534 /* If it's within the array bounds but doesn't have an explicit
2535 initializer, it's value-initialized. */
2536 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2537 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2541 /* Subroutine of cxx_eval_constant_expression.
2542 Attempt to reduce a field access of a value of class type. */
2545 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2547 bool *non_constant_p
, bool *overflow_p
)
2549 unsigned HOST_WIDE_INT i
;
2552 tree part
= TREE_OPERAND (t
, 1);
2553 tree orig_whole
= TREE_OPERAND (t
, 0);
2554 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2556 non_constant_p
, overflow_p
);
2557 if (INDIRECT_REF_P (whole
)
2558 && integer_zerop (TREE_OPERAND (whole
, 0)))
2561 error ("dereferencing a null pointer in %qE", orig_whole
);
2562 *non_constant_p
= true;
2566 if (TREE_CODE (whole
) == PTRMEM_CST
)
2567 whole
= cplus_expand_constant (whole
);
2568 if (whole
== orig_whole
)
2571 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2572 whole
, part
, NULL_TREE
);
2573 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2575 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2578 error ("%qE is not a constant expression", orig_whole
);
2579 *non_constant_p
= true;
2581 if (DECL_MUTABLE_P (part
))
2584 error ("mutable %qD is not usable in a constant expression", part
);
2585 *non_constant_p
= true;
2587 if (*non_constant_p
)
2589 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2590 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2592 /* Use name match for PMF fields, as a variant will have a
2593 different FIELD_DECL with a different type. */
2594 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2600 /* We're in the middle of initializing it. */
2604 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2605 && CONSTRUCTOR_NELTS (whole
) > 0)
2607 /* DR 1188 says we don't have to deal with this. */
2609 error ("accessing %qD member instead of initialized %qD member in "
2610 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2611 *non_constant_p
= true;
2615 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2616 classes never get represented; throw together a value now. */
2617 if (is_really_empty_class (TREE_TYPE (t
)))
2618 return build_constructor (TREE_TYPE (t
), NULL
);
2620 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2622 if (CONSTRUCTOR_NO_CLEARING (whole
))
2624 /* 'whole' is part of the aggregate initializer we're currently
2625 building; if there's no initializer for this member yet, that's an
2628 error ("accessing uninitialized member %qD", part
);
2629 *non_constant_p
= true;
2633 /* If there's no explicit init for this field, it's value-initialized. */
2634 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2635 return cxx_eval_constant_expression (ctx
, value
,
2637 non_constant_p
, overflow_p
);
2640 /* Subroutine of cxx_eval_constant_expression.
2641 Attempt to reduce a field access of a value of class type that is
2642 expressed as a BIT_FIELD_REF. */
2645 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2647 bool *non_constant_p
, bool *overflow_p
)
2649 tree orig_whole
= TREE_OPERAND (t
, 0);
2650 tree retval
, fldval
, utype
, mask
;
2651 bool fld_seen
= false;
2652 HOST_WIDE_INT istart
, isize
;
2653 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2655 non_constant_p
, overflow_p
);
2656 tree start
, field
, value
;
2657 unsigned HOST_WIDE_INT i
;
2659 if (whole
== orig_whole
)
2661 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2663 if (!*non_constant_p
2664 && TREE_CODE (whole
) != VECTOR_CST
2665 && TREE_CODE (whole
) != CONSTRUCTOR
)
2668 error ("%qE is not a constant expression", orig_whole
);
2669 *non_constant_p
= true;
2671 if (*non_constant_p
)
2674 if (TREE_CODE (whole
) == VECTOR_CST
)
2675 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2676 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2678 start
= TREE_OPERAND (t
, 2);
2679 istart
= tree_to_shwi (start
);
2680 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2681 utype
= TREE_TYPE (t
);
2682 if (!TYPE_UNSIGNED (utype
))
2683 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2684 retval
= build_int_cst (utype
, 0);
2685 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2687 tree bitpos
= bit_position (field
);
2688 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2690 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2691 && TREE_CODE (value
) == INTEGER_CST
2692 && tree_fits_shwi_p (bitpos
)
2693 && tree_fits_shwi_p (DECL_SIZE (field
)))
2695 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2696 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2697 HOST_WIDE_INT shift
;
2698 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2700 fldval
= fold_convert (utype
, value
);
2701 mask
= build_int_cst_type (utype
, -1);
2702 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2703 size_int (TYPE_PRECISION (utype
) - sz
));
2704 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2705 size_int (TYPE_PRECISION (utype
) - sz
));
2706 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2707 shift
= bit
- istart
;
2708 if (BYTES_BIG_ENDIAN
)
2709 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2710 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2712 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2718 return fold_convert (TREE_TYPE (t
), retval
);
2720 return error_mark_node
;
2723 /* Subroutine of cxx_eval_constant_expression.
2724 Evaluate a short-circuited logical expression T in the context
2725 of a given constexpr CALL. BAILOUT_VALUE is the value for
2726 early return. CONTINUE_VALUE is used here purely for
2727 sanity check purposes. */
2730 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2731 tree bailout_value
, tree continue_value
,
2733 bool *non_constant_p
, bool *overflow_p
)
2736 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2738 non_constant_p
, overflow_p
);
2739 VERIFY_CONSTANT (lhs
);
2740 if (tree_int_cst_equal (lhs
, bailout_value
))
2742 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2743 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2744 lval
, non_constant_p
,
2746 VERIFY_CONSTANT (r
);
2750 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2751 CONSTRUCTOR elements to initialize (part of) an object containing that
2752 field. Return a pointer to the constructor_elt corresponding to the
2753 initialization of the field. */
2755 static constructor_elt
*
2756 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2758 tree aggr
= TREE_OPERAND (ref
, 0);
2759 tree field
= TREE_OPERAND (ref
, 1);
2761 constructor_elt
*ce
;
2763 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2765 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2767 constructor_elt
*base_ce
2768 = base_field_constructor_elt (v
, aggr
);
2769 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2772 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2773 if (ce
->index
== field
)
2780 /* Some of the expressions fed to the constexpr mechanism are calls to
2781 constructors, which have type void. In that case, return the type being
2782 initialized by the constructor. */
2785 initialized_type (tree t
)
2789 tree type
= TREE_TYPE (t
);
2790 if (!VOID_TYPE_P (type
))
2791 /* No need to look deeper. */;
2792 else if (TREE_CODE (t
) == CALL_EXPR
)
2794 /* A constructor call has void type, so we need to look deeper. */
2795 tree fn
= get_function_named_in_call (t
);
2796 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2797 && DECL_CXX_CONSTRUCTOR_P (fn
))
2798 type
= DECL_CONTEXT (fn
);
2800 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
2801 type
= TREE_TYPE (AGGR_INIT_EXPR_SLOT (t
));
2802 return cv_unqualified (type
);
2805 /* We're about to initialize element INDEX of an array or class from VALUE.
2806 Set up NEW_CTX appropriately by adjusting .object to refer to the
2807 subobject and creating a new CONSTRUCTOR if the element is itself
2808 a class or array. */
2811 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2812 tree index
, tree
&value
)
2816 if (index
&& TREE_CODE (index
) != INTEGER_CST
2817 && TREE_CODE (index
) != FIELD_DECL
)
2818 /* This won't have an element in the new CONSTRUCTOR. */
2821 tree type
= initialized_type (value
);
2822 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2823 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2826 /* The sub-aggregate initializer might contain a placeholder;
2827 update object to refer to the subobject and ctor to refer to
2828 the (newly created) sub-initializer. */
2830 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2831 tree elt
= build_constructor (type
, NULL
);
2832 CONSTRUCTOR_NO_CLEARING (elt
) = true;
2835 if (TREE_CODE (value
) == TARGET_EXPR
)
2836 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2837 value
= TARGET_EXPR_INITIAL (value
);
2840 /* We're about to process an initializer for a class or array TYPE. Make
2841 sure that CTX is set up appropriately. */
2844 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2846 /* We don't bother building a ctor for an empty base subobject. */
2847 if (is_empty_class (type
))
2850 /* We're in the middle of an initializer that might involve placeholders;
2851 our caller should have created a CONSTRUCTOR for us to put the
2852 initializer into. We will either return that constructor or T. */
2853 gcc_assert (ctx
->ctor
);
2854 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2855 (type
, TREE_TYPE (ctx
->ctor
)));
2856 /* We used to check that ctx->ctor was empty, but that isn't the case when
2857 the object is zero-initialized before calling the constructor. */
2860 tree otype
= TREE_TYPE (ctx
->object
);
2861 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2862 /* Handle flexible array members. */
2863 || (TREE_CODE (otype
) == ARRAY_TYPE
2864 && TYPE_DOMAIN (otype
) == NULL_TREE
2865 && TREE_CODE (type
) == ARRAY_TYPE
2866 && (same_type_ignoring_top_level_qualifiers_p
2867 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2869 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2870 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2873 /* Subroutine of cxx_eval_constant_expression.
2874 The expression tree T denotes a C-style array or a C-style
2875 aggregate. Reduce it to a constant expression. */
2878 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2880 bool *non_constant_p
, bool *overflow_p
)
2882 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2883 bool changed
= false;
2884 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2885 tree type
= TREE_TYPE (t
);
2887 constexpr_ctx new_ctx
;
2888 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2890 /* We don't really need the ctx->ctor business for a PMF or
2891 vector, but it's simpler to use the same code. */
2893 new_ctx
.ctor
= build_constructor (type
, NULL
);
2894 new_ctx
.object
= NULL_TREE
;
2897 verify_ctor_sanity (ctx
, type
);
2898 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2899 vec_alloc (*p
, vec_safe_length (v
));
2903 bool constant_p
= true;
2904 bool side_effects_p
= false;
2905 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2907 tree orig_value
= value
;
2908 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2909 if (new_ctx
.ctor
!= ctx
->ctor
)
2910 /* If we built a new CONSTRUCTOR, attach it now so that other
2911 initializers can refer to it. */
2912 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2913 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2915 non_constant_p
, overflow_p
);
2916 /* Don't VERIFY_CONSTANT here. */
2917 if (ctx
->quiet
&& *non_constant_p
)
2919 if (elt
!= orig_value
)
2922 if (!TREE_CONSTANT (elt
))
2924 if (TREE_SIDE_EFFECTS (elt
))
2925 side_effects_p
= true;
2926 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2928 /* This is an initialization of a vfield inside a base
2929 subaggregate that we already initialized; push this
2930 initialization into the previous initialization. */
2931 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2936 && (TREE_CODE (index
) == NOP_EXPR
2937 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2939 /* This is an initializer for an empty base; now that we've
2940 checked that it's constant, we can ignore it. */
2941 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2946 if (new_ctx
.ctor
!= ctx
->ctor
)
2948 /* We appended this element above; update the value. */
2949 gcc_assert ((*p
)->last().index
== index
);
2950 (*p
)->last().value
= elt
;
2953 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2954 /* Adding or replacing an element might change the ctor's flags. */
2955 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
2956 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
2959 if (*non_constant_p
|| !changed
)
2962 /* We're done building this CONSTRUCTOR, so now we can interpret an
2963 element without an explicit initializer as value-initialized. */
2964 CONSTRUCTOR_NO_CLEARING (t
) = false;
2965 TREE_CONSTANT (t
) = constant_p
;
2966 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2967 if (VECTOR_TYPE_P (type
))
2972 /* Subroutine of cxx_eval_constant_expression.
2973 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2974 initialization of a non-static data member of array type. Reduce it to a
2977 Note that apart from value-initialization (when VALUE_INIT is true),
2978 this is only intended to support value-initialization and the
2979 initializations done by defaulted constructors for classes with
2980 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2981 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2982 for the copy/move constructor. */
2985 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2986 bool value_init
, bool lval
,
2987 bool *non_constant_p
, bool *overflow_p
)
2989 tree elttype
= TREE_TYPE (atype
);
2990 verify_ctor_sanity (ctx
, atype
);
2991 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2992 bool pre_init
= false;
2993 unsigned HOST_WIDE_INT i
;
2994 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
2996 /* For the default constructor, build up a call to the default
2997 constructor of the element type. We only need to handle class types
2998 here, as for a constructor to be constexpr, all members must be
2999 initialized, which for a defaulted default constructor means they must
3000 be of a class type with a constexpr default constructor. */
3001 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3002 /* We only do this at the lowest level. */;
3003 else if (value_init
)
3005 init
= build_value_init (elttype
, complain
);
3010 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
3011 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
3012 &argvec
, elttype
, LOOKUP_NORMAL
,
3014 release_tree_vector (argvec
);
3015 init
= build_aggr_init_expr (elttype
, init
);
3019 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
3021 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
3022 for (i
= 0; i
< max
; ++i
)
3024 tree idx
= build_int_cst (size_type_node
, i
);
3027 constexpr_ctx new_ctx
;
3028 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
3029 if (new_ctx
.ctor
!= ctx
->ctor
)
3030 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
3031 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3033 /* A multidimensional array; recurse. */
3034 if (value_init
|| init
== NULL_TREE
)
3036 eltinit
= NULL_TREE
;
3040 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3041 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
3043 non_constant_p
, overflow_p
);
3047 /* Initializing an element using value or default initialization
3048 we just pre-built above. */
3049 if (init
== void_node
)
3050 /* Trivial default-init, don't do anything to the CONSTRUCTOR. */
3052 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
3053 non_constant_p
, overflow_p
);
3058 /* Copying an element. */
3059 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3060 (atype
, TREE_TYPE (init
)));
3061 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3062 if (!lvalue_p (init
))
3063 eltinit
= move (eltinit
);
3064 eltinit
= force_rvalue (eltinit
, complain
);
3065 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
3066 non_constant_p
, overflow_p
);
3068 if (*non_constant_p
&& !ctx
->quiet
)
3070 if (new_ctx
.ctor
!= ctx
->ctor
)
3072 /* We appended this element above; update the value. */
3073 gcc_assert ((*p
)->last().index
== idx
);
3074 (*p
)->last().value
= eltinit
;
3077 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3078 /* Reuse the result of cxx_eval_constant_expression call
3079 from the first iteration to all others if it is a constant
3080 initializer that doesn't require relocations. */
3083 && (eltinit
== NULL_TREE
3084 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3085 == null_pointer_node
)))
3087 if (new_ctx
.ctor
!= ctx
->ctor
)
3088 eltinit
= new_ctx
.ctor
;
3089 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3090 build_int_cst (size_type_node
, 1),
3091 build_int_cst (size_type_node
, max
- 1));
3092 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3096 vec_safe_reserve (*p
, max
);
3099 if (!*non_constant_p
)
3102 CONSTRUCTOR_NO_CLEARING (init
) = false;
3108 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3110 bool *non_constant_p
, bool *overflow_p
)
3112 tree atype
= TREE_TYPE (t
);
3113 tree init
= VEC_INIT_EXPR_INIT (t
);
3114 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3115 VEC_INIT_EXPR_VALUE_INIT (t
),
3116 lval
, non_constant_p
, overflow_p
);
3117 if (*non_constant_p
)
3123 /* Like same_type_ignoring_top_level_qualifiers_p, but also handle the case
3124 where the desired type is an array of unknown bounds because the variable
3125 has had its bounds deduced since the wrapping expression was created. */
3128 same_type_ignoring_tlq_and_bounds_p (tree type1
, tree type2
)
3130 while (TREE_CODE (type1
) == ARRAY_TYPE
3131 && TREE_CODE (type2
) == ARRAY_TYPE
3132 && (!TYPE_DOMAIN (type1
) || !TYPE_DOMAIN (type2
)))
3134 type1
= TREE_TYPE (type1
);
3135 type2
= TREE_TYPE (type2
);
3137 return same_type_ignoring_top_level_qualifiers_p (type1
, type2
);
3140 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3141 match. We want to be less strict for simple *& folding; if we have a
3142 non-const temporary that we access through a const pointer, that should
3143 work. We handle this here rather than change fold_indirect_ref_1
3144 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3145 don't really make sense outside of constant expression evaluation. Also
3146 we want to allow folding to COMPONENT_REF, which could cause trouble
3147 with TBAA in fold_indirect_ref_1.
3149 Try to keep this function synced with fold_indirect_ref_1. */
3152 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3156 poly_uint64 const_op01
;
3159 subtype
= TREE_TYPE (sub
);
3160 if (!INDIRECT_TYPE_P (subtype
))
3163 if (TREE_CODE (sub
) == ADDR_EXPR
)
3165 tree op
= TREE_OPERAND (sub
, 0);
3166 tree optype
= TREE_TYPE (op
);
3168 /* *&CONST_DECL -> to the value of the const decl. */
3169 if (TREE_CODE (op
) == CONST_DECL
)
3170 return DECL_INITIAL (op
);
3171 /* *&p => p; make sure to handle *&"str"[cst] here. */
3172 if (same_type_ignoring_tlq_and_bounds_p (optype
, type
))
3174 tree fop
= fold_read_from_constant_string (op
);
3180 /* *(foo *)&fooarray => fooarray[0] */
3181 else if (TREE_CODE (optype
) == ARRAY_TYPE
3182 && (same_type_ignoring_top_level_qualifiers_p
3183 (type
, TREE_TYPE (optype
))))
3185 tree type_domain
= TYPE_DOMAIN (optype
);
3186 tree min_val
= size_zero_node
;
3187 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3188 min_val
= TYPE_MIN_VALUE (type_domain
);
3189 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3190 NULL_TREE
, NULL_TREE
);
3192 /* *(foo *)&complexfoo => __real__ complexfoo */
3193 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3194 && (same_type_ignoring_top_level_qualifiers_p
3195 (type
, TREE_TYPE (optype
))))
3196 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3197 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3198 else if (VECTOR_TYPE_P (optype
)
3199 && (same_type_ignoring_top_level_qualifiers_p
3200 (type
, TREE_TYPE (optype
))))
3202 tree part_width
= TYPE_SIZE (type
);
3203 tree index
= bitsize_int (0);
3204 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3207 /* Also handle conversion to an empty base class, which
3208 is represented with a NOP_EXPR. */
3209 else if (is_empty_class (type
)
3210 && CLASS_TYPE_P (optype
)
3211 && DERIVED_FROM_P (type
, optype
))
3216 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3217 else if (RECORD_OR_UNION_TYPE_P (optype
))
3219 tree field
= TYPE_FIELDS (optype
);
3220 for (; field
; field
= DECL_CHAIN (field
))
3221 if (TREE_CODE (field
) == FIELD_DECL
3222 && TREE_TYPE (field
) != error_mark_node
3223 && integer_zerop (byte_position (field
))
3224 && (same_type_ignoring_top_level_qualifiers_p
3225 (TREE_TYPE (field
), type
)))
3226 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3229 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3230 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3232 tree op00
= TREE_OPERAND (sub
, 0);
3233 tree op01
= TREE_OPERAND (sub
, 1);
3236 if (TREE_CODE (op00
) == ADDR_EXPR
)
3239 op00
= TREE_OPERAND (op00
, 0);
3240 op00type
= TREE_TYPE (op00
);
3242 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3243 if (VECTOR_TYPE_P (op00type
)
3244 && same_type_ignoring_top_level_qualifiers_p
3245 (type
, TREE_TYPE (op00type
))
3246 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3247 but we want to treat offsets with MSB set as negative.
3248 For the code below negative offsets are invalid and
3249 TYPE_SIZE of the element is something unsigned, so
3250 check whether op01 fits into poly_int64, which implies
3251 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3252 then just use poly_uint64 because we want to treat the
3253 value as unsigned. */
3254 && tree_fits_poly_int64_p (op01
))
3256 tree part_width
= TYPE_SIZE (type
);
3257 poly_uint64 max_offset
3258 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3259 * TYPE_VECTOR_SUBPARTS (op00type
));
3260 if (known_lt (const_op01
, max_offset
))
3262 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3263 return fold_build3_loc (loc
,
3264 BIT_FIELD_REF
, type
, op00
,
3268 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3269 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3270 && (same_type_ignoring_top_level_qualifiers_p
3271 (type
, TREE_TYPE (op00type
))))
3273 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3275 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3277 /* ((foo *)&fooarray)[1] => fooarray[1] */
3278 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3279 && (same_type_ignoring_top_level_qualifiers_p
3280 (type
, TREE_TYPE (op00type
))))
3282 tree type_domain
= TYPE_DOMAIN (op00type
);
3283 tree min_val
= size_zero_node
;
3284 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3285 min_val
= TYPE_MIN_VALUE (type_domain
);
3286 offset_int off
= wi::to_offset (op01
);
3287 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3288 offset_int remainder
;
3289 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3290 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3292 off
= off
+ wi::to_offset (min_val
);
3293 op01
= wide_int_to_tree (sizetype
, off
);
3294 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3295 NULL_TREE
, NULL_TREE
);
3298 /* Also handle conversion to an empty base class, which
3299 is represented with a NOP_EXPR. */
3300 else if (is_empty_class (type
)
3301 && CLASS_TYPE_P (op00type
)
3302 && DERIVED_FROM_P (type
, op00type
))
3307 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3308 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3310 tree field
= TYPE_FIELDS (op00type
);
3311 for (; field
; field
= DECL_CHAIN (field
))
3312 if (TREE_CODE (field
) == FIELD_DECL
3313 && TREE_TYPE (field
) != error_mark_node
3314 && tree_int_cst_equal (byte_position (field
), op01
)
3315 && (same_type_ignoring_top_level_qualifiers_p
3316 (TREE_TYPE (field
), type
)))
3317 return fold_build3 (COMPONENT_REF
, type
, op00
,
3322 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3323 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3324 && (same_type_ignoring_top_level_qualifiers_p
3325 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3328 tree min_val
= size_zero_node
;
3330 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3334 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3335 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3336 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3337 min_val
= TYPE_MIN_VALUE (type_domain
);
3338 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3346 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3348 bool *non_constant_p
, bool *overflow_p
)
3350 tree orig_op0
= TREE_OPERAND (t
, 0);
3351 bool empty_base
= false;
3353 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3354 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3356 if (TREE_CODE (t
) == MEM_REF
3357 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3359 gcc_assert (ctx
->quiet
);
3360 *non_constant_p
= true;
3364 /* First try to simplify it directly. */
3365 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3369 /* If that didn't work, evaluate the operand first. */
3370 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3371 /*lval*/false, non_constant_p
,
3373 /* Don't VERIFY_CONSTANT here. */
3374 if (*non_constant_p
)
3377 if (!lval
&& integer_zerop (op0
))
3380 error ("dereferencing a null pointer");
3381 *non_constant_p
= true;
3385 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3389 /* We couldn't fold to a constant value. Make sure it's not
3390 something we should have been able to fold. */
3393 if (TREE_CODE (sub
) == ADDR_EXPR
)
3395 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3396 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3397 /* DR 1188 says we don't have to deal with this. */
3399 error ("accessing value of %qE through a %qT glvalue in a "
3400 "constant expression", build_fold_indirect_ref (sub
),
3402 *non_constant_p
= true;
3406 if (lval
&& op0
!= orig_op0
)
3407 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3409 VERIFY_CONSTANT (t
);
3414 r
= cxx_eval_constant_expression (ctx
, r
,
3415 lval
, non_constant_p
, overflow_p
);
3416 if (*non_constant_p
)
3419 /* If we're pulling out the value of an empty base, just return an empty
3421 if (empty_base
&& !lval
)
3423 r
= build_constructor (TREE_TYPE (t
), NULL
);
3424 TREE_CONSTANT (r
) = true;
3430 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3431 Shared between potential_constant_expression and
3432 cxx_eval_constant_expression. */
3435 non_const_var_error (tree r
)
3437 tree type
= TREE_TYPE (r
);
3438 error ("the value of %qD is not usable in a constant "
3440 /* Avoid error cascade. */
3441 if (DECL_INITIAL (r
) == error_mark_node
)
3443 if (DECL_DECLARED_CONSTEXPR_P (r
))
3444 inform (DECL_SOURCE_LOCATION (r
),
3445 "%qD used in its own initializer", r
);
3446 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3448 if (!CP_TYPE_CONST_P (type
))
3449 inform (DECL_SOURCE_LOCATION (r
),
3450 "%q#D is not const", r
);
3451 else if (CP_TYPE_VOLATILE_P (type
))
3452 inform (DECL_SOURCE_LOCATION (r
),
3453 "%q#D is volatile", r
);
3454 else if (!DECL_INITIAL (r
)
3455 || !TREE_CONSTANT (DECL_INITIAL (r
))
3456 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3457 inform (DECL_SOURCE_LOCATION (r
),
3458 "%qD was not initialized with a constant "
3463 else if (TYPE_REF_P (type
))
3464 inform (DECL_SOURCE_LOCATION (r
),
3465 "%qD was not initialized with a constant "
3469 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3470 inform (DECL_SOURCE_LOCATION (r
),
3471 "%qD was not declared %<constexpr%>", r
);
3473 inform (DECL_SOURCE_LOCATION (r
),
3474 "%qD does not have integral or enumeration type",
3479 /* Subroutine of cxx_eval_constant_expression.
3480 Like cxx_eval_unary_expression, except for trinary expressions. */
3483 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3485 bool *non_constant_p
, bool *overflow_p
)
3491 for (i
= 0; i
< 3; i
++)
3493 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3495 non_constant_p
, overflow_p
);
3496 VERIFY_CONSTANT (args
[i
]);
3499 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3500 args
[0], args
[1], args
[2]);
3501 if (val
== NULL_TREE
)
3503 VERIFY_CONSTANT (val
);
3507 /* True if T was declared in a function declared to be constexpr, and
3508 therefore potentially constant in C++14. */
3511 var_in_constexpr_fn (tree t
)
3513 tree ctx
= DECL_CONTEXT (t
);
3514 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3515 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3518 /* True if T was declared in a function that might be constexpr: either a
3519 function that was declared constexpr, or a C++17 lambda op(). */
3522 var_in_maybe_constexpr_fn (tree t
)
3524 if (cxx_dialect
>= cxx17
3525 && DECL_FUNCTION_SCOPE_P (t
)
3526 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3528 return var_in_constexpr_fn (t
);
3531 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3532 build_over_call we implement trivial copy of a class with tail padding using
3533 assignment of character arrays, which is valid in normal code, but not in
3534 constexpr evaluation. We don't need to worry about clobbering tail padding
3535 in constexpr evaluation, so strip the type punning. */
3538 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3540 if (TREE_CODE (target
) == MEM_REF
3541 && TREE_CODE (init
) == MEM_REF
3542 && TREE_TYPE (target
) == TREE_TYPE (init
)
3543 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3544 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3546 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3547 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3551 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3554 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3556 bool *non_constant_p
, bool *overflow_p
)
3558 constexpr_ctx new_ctx
= *ctx
;
3560 tree init
= TREE_OPERAND (t
, 1);
3561 if (TREE_CLOBBER_P (init
))
3562 /* Just ignore clobbers. */
3565 /* First we figure out where we're storing to. */
3566 tree target
= TREE_OPERAND (t
, 0);
3568 maybe_simplify_trivial_copy (target
, init
);
3570 tree type
= TREE_TYPE (target
);
3571 target
= cxx_eval_constant_expression (ctx
, target
,
3573 non_constant_p
, overflow_p
);
3574 if (*non_constant_p
)
3577 /* cxx_eval_array_reference for lval = true allows references one past
3578 end of array, because it does not know if it is just taking address
3579 (which is valid), or actual dereference. Here we know it is
3580 a dereference, so diagnose it here. */
3581 for (tree probe
= target
; probe
; )
3583 switch (TREE_CODE (probe
))
3587 ary
= TREE_OPERAND (probe
, 0);
3588 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3589 non_constant_p
, overflow_p
);
3590 VERIFY_CONSTANT (nelts
);
3591 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3592 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3593 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3595 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3596 *non_constant_p
= true;
3603 probe
= TREE_OPERAND (probe
, 0);
3612 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3614 /* For initialization of an empty base, the original target will be
3615 *(base*)this, which the above evaluation resolves to the object
3616 argument, which has the derived type rather than the base type. In
3617 this situation, just evaluate the initializer and return, since
3618 there's no actual data to store. */
3619 gcc_assert (is_empty_class (type
));
3620 return cxx_eval_constant_expression (ctx
, init
, false,
3621 non_constant_p
, overflow_p
);
3624 /* And then find the underlying variable. */
3625 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3626 tree object
= NULL_TREE
;
3627 for (tree probe
= target
; object
== NULL_TREE
; )
3629 switch (TREE_CODE (probe
))
3634 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3635 vec_safe_push (refs
, TREE_TYPE (probe
));
3636 probe
= TREE_OPERAND (probe
, 0);
3644 /* And then find/build up our initializer for the path to the subobject
3645 we're initializing. */
3647 if (object
== ctx
->object
&& VAR_P (object
)
3648 && DECL_NAME (object
) && ctx
->call
== NULL
)
3649 /* The variable we're building up an aggregate initializer for is outside
3650 the constant-expression, so don't evaluate the store. We check
3651 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3653 else if (DECL_P (object
))
3654 valp
= ctx
->values
->get (object
);
3659 /* A constant-expression cannot modify objects from outside the
3660 constant-expression. */
3662 error ("modification of %qE is not a constant expression", object
);
3663 *non_constant_p
= true;
3666 type
= TREE_TYPE (object
);
3667 bool no_zero_init
= true;
3669 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3670 while (!refs
->is_empty())
3672 if (*valp
== NULL_TREE
)
3674 *valp
= build_constructor (type
, NULL
);
3675 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3677 else if (TREE_CODE (*valp
) == STRING_CST
)
3679 /* An array was initialized with a string constant, and now
3680 we're writing into one of its elements. Explode the
3681 single initialization into a set of element
3683 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3685 tree string
= *valp
;
3686 tree elt_type
= TREE_TYPE (type
);
3687 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3688 / TYPE_PRECISION (char_type_node
));
3689 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3690 tree ary_ctor
= build_constructor (type
, NULL
);
3692 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3693 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3695 constructor_elt elt
=
3697 build_int_cst (size_type_node
, ix
),
3698 extract_string_elt (string
, chars_per_elt
, ix
)
3700 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3706 /* If the value of object is already zero-initialized, any new ctors for
3707 subobjects will also be zero-initialized. */
3708 no_zero_init
= CONSTRUCTOR_NO_CLEARING (*valp
);
3710 vec_safe_push (ctors
, *valp
);
3712 enum tree_code code
= TREE_CODE (type
);
3714 tree index
= refs
->pop();
3716 constructor_elt
*cep
= NULL
;
3717 if (code
== ARRAY_TYPE
)
3720 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3721 gcc_assert (i
>= 0);
3722 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3723 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3727 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3729 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3730 Usually we meet initializers in that order, but it is
3731 possible for base types to be placed not in program
3733 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3734 unsigned HOST_WIDE_INT idx
;
3736 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3737 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3738 /* Changing active member. */
3739 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3742 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3743 idx
++, fields
= DECL_CHAIN (fields
))
3745 if (index
== cep
->index
)
3748 /* The field we're initializing must be on the field
3749 list. Look to see if it is present before the
3750 field the current ELT initializes. */
3751 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3752 if (index
== fields
)
3756 /* We fell off the end of the CONSTRUCTOR, so insert a new
3757 entry at the end. */
3760 constructor_elt ce
= { index
, NULL_TREE
};
3762 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3763 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3769 release_tree_vector (refs
);
3771 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3773 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3774 wants to modify it. */
3775 if (*valp
== NULL_TREE
)
3777 *valp
= build_constructor (type
, NULL
);
3778 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3780 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3781 *valp
= cplus_expand_constant (*valp
);
3782 new_ctx
.ctor
= *valp
;
3783 new_ctx
.object
= target
;
3786 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3787 non_constant_p
, overflow_p
);
3788 /* Don't share a CONSTRUCTOR that might be changed later. */
3789 init
= unshare_constructor (init
);
3790 if (target
== object
)
3791 /* The hash table might have moved since the get earlier. */
3792 valp
= ctx
->values
->get (object
);
3794 if (TREE_CODE (init
) == CONSTRUCTOR
)
3796 /* An outer ctx->ctor might be pointing to *valp, so replace
3798 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3799 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3800 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3801 CONSTRUCTOR_NO_CLEARING (*valp
)
3802 = CONSTRUCTOR_NO_CLEARING (init
);
3807 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3808 CONSTRUCTORs, if any. */
3811 bool c
= TREE_CONSTANT (init
);
3812 bool s
= TREE_SIDE_EFFECTS (init
);
3814 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3817 TREE_CONSTANT (elt
) = false;
3819 TREE_SIDE_EFFECTS (elt
) = true;
3821 release_tree_vector (ctors
);
3823 if (*non_constant_p
)
3831 /* Evaluate a ++ or -- expression. */
3834 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3836 bool *non_constant_p
, bool *overflow_p
)
3838 enum tree_code code
= TREE_CODE (t
);
3839 tree type
= TREE_TYPE (t
);
3840 tree op
= TREE_OPERAND (t
, 0);
3841 tree offset
= TREE_OPERAND (t
, 1);
3842 gcc_assert (TREE_CONSTANT (offset
));
3844 /* The operand as an lvalue. */
3845 op
= cxx_eval_constant_expression (ctx
, op
, true,
3846 non_constant_p
, overflow_p
);
3848 /* The operand as an rvalue. */
3850 = cxx_eval_constant_expression (ctx
, op
, false,
3851 non_constant_p
, overflow_p
);
3852 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3853 a local array in a constexpr function. */
3854 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (val
));
3856 VERIFY_CONSTANT (val
);
3858 /* The modified value. */
3859 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3861 if (INDIRECT_TYPE_P (type
))
3863 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3864 offset
= convert_to_ptrofftype (offset
);
3866 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3867 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3870 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3872 VERIFY_CONSTANT (mod
);
3874 /* Storing the modified value. */
3875 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3876 cxx_eval_constant_expression (ctx
, store
,
3877 true, non_constant_p
, overflow_p
);
3879 /* And the value of the expression. */
3880 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3882 /* Prefix ops are lvalues. */
3886 /* But we optimize when the caller wants an rvalue. */
3890 /* Postfix ops are rvalues. */
3894 /* Predicates for the meaning of *jump_target. */
3897 returns (tree
*jump_target
)
3900 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3901 || (TREE_CODE (*jump_target
) == LABEL_DECL
3902 && LABEL_DECL_CDTOR (*jump_target
)));
3906 breaks (tree
*jump_target
)
3909 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3910 && LABEL_DECL_BREAK (*jump_target
))
3911 || TREE_CODE (*jump_target
) == BREAK_STMT
3912 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3916 continues (tree
*jump_target
)
3919 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3920 && LABEL_DECL_CONTINUE (*jump_target
))
3921 || TREE_CODE (*jump_target
) == CONTINUE_STMT
);
3926 switches (tree
*jump_target
)
3929 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3932 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3933 STMT matches *jump_target. If we're looking for a case label and we see
3934 the default label, note it in ctx->css_state. */
3937 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3939 switch (TREE_CODE (*jump_target
))
3942 if (TREE_CODE (stmt
) == LABEL_EXPR
3943 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3948 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3950 gcc_assert (ctx
->css_state
!= NULL
);
3951 if (!CASE_LOW (stmt
))
3953 /* default: should appear just once in a SWITCH_EXPR
3954 body (excluding nested SWITCH_EXPR). */
3955 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3956 /* When evaluating SWITCH_EXPR body for the second time,
3957 return true for the default: label. */
3958 if (*ctx
->css_state
== css_default_processing
)
3960 *ctx
->css_state
= css_default_seen
;
3962 else if (CASE_HIGH (stmt
))
3964 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3965 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3968 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3979 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3980 semantics, for switch, break, continue, and return. */
3983 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3984 bool *non_constant_p
, bool *overflow_p
,
3987 tree_stmt_iterator i
;
3989 /* In a statement-expression we want to return the last value.
3990 For empty statement expression return void_node. */
3994 local_target
= NULL_TREE
;
3995 jump_target
= &local_target
;
3997 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3999 tree stmt
= tsi_stmt (i
);
4000 /* We've found a continue, so skip everything until we reach
4001 the label its jumping to. */
4002 if (continues (jump_target
))
4004 if (label_matches (ctx
, jump_target
, stmt
))
4006 *jump_target
= NULL_TREE
;
4010 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
4012 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
4013 non_constant_p
, overflow_p
,
4015 if (*non_constant_p
)
4017 if (returns (jump_target
) || breaks (jump_target
))
4023 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
4024 semantics; continue semantics are covered by cxx_eval_statement_list. */
4027 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
4028 bool *non_constant_p
, bool *overflow_p
,
4031 constexpr_ctx new_ctx
= *ctx
;
4033 tree body
= TREE_OPERAND (t
, 0);
4037 hash_set
<tree
> save_exprs
;
4038 new_ctx
.save_exprs
= &save_exprs
;
4040 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
4041 non_constant_p
, overflow_p
, jump_target
);
4043 /* Forget saved values of SAVE_EXPRs. */
4044 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
4045 iter
!= save_exprs
.end(); ++iter
)
4046 new_ctx
.values
->remove (*iter
);
4047 if (++count
>= constexpr_loop_limit
)
4050 error_at (cp_expr_loc_or_loc (t
, input_location
),
4051 "%<constexpr%> loop iteration count exceeds limit of %d "
4052 "(use -fconstexpr-loop-limit= to increase the limit)",
4053 constexpr_loop_limit
);
4054 *non_constant_p
= true;
4058 while (!returns (jump_target
)
4059 && !breaks (jump_target
)
4060 && !switches (jump_target
)
4061 && !*non_constant_p
);
4063 if (breaks (jump_target
))
4064 *jump_target
= NULL_TREE
;
4069 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
4073 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
4074 bool *non_constant_p
, bool *overflow_p
,
4077 tree cond
= TREE_OPERAND (t
, 0);
4078 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
4079 non_constant_p
, overflow_p
);
4080 VERIFY_CONSTANT (cond
);
4081 *jump_target
= cond
;
4083 tree body
= TREE_OPERAND (t
, 1);
4084 constexpr_ctx new_ctx
= *ctx
;
4085 constexpr_switch_state css
= css_default_not_seen
;
4086 new_ctx
.css_state
= &css
;
4087 cxx_eval_constant_expression (&new_ctx
, body
, false,
4088 non_constant_p
, overflow_p
, jump_target
);
4089 if (switches (jump_target
) && css
== css_default_seen
)
4091 /* If the SWITCH_EXPR body has default: label, process it once again,
4092 this time instructing label_matches to return true for default:
4093 label on switches (jump_target). */
4094 css
= css_default_processing
;
4095 cxx_eval_constant_expression (&new_ctx
, body
, false,
4096 non_constant_p
, overflow_p
, jump_target
);
4098 if (breaks (jump_target
) || switches (jump_target
))
4099 *jump_target
= NULL_TREE
;
4103 /* Find the object of TYPE under initialization in CTX. */
4106 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4111 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4112 can is a minor optimization. */
4113 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4119 /* Since an object cannot have a field of its own type, we can search outward
4120 from ctx->object to find the unique containing object of TYPE. */
4121 tree ob
= ctx
->object
;
4124 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4126 if (handled_component_p (ob
))
4127 ob
= TREE_OPERAND (ob
, 0);
4135 /* Attempt to reduce the expression T to a constant value.
4136 On failure, issue diagnostic and return error_mark_node. */
4137 /* FIXME unify with c_fully_fold */
4138 /* FIXME overflow_p is too global */
4141 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4143 bool *non_constant_p
, bool *overflow_p
,
4144 tree
*jump_target
/* = NULL */)
4146 constexpr_ctx new_ctx
;
4149 if (jump_target
&& *jump_target
)
4151 /* If we are jumping, ignore all statements/expressions except those
4152 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4153 switch (TREE_CODE (t
))
4156 case STATEMENT_LIST
:
4161 case CASE_LABEL_EXPR
:
4162 if (label_matches (ctx
, jump_target
, t
))
4164 *jump_target
= NULL_TREE
;
4170 if (error_operand_p (t
))
4172 *non_constant_p
= true;
4175 if (CONSTANT_CLASS_P (t
))
4177 if (TREE_OVERFLOW (t
))
4180 permerror (input_location
, "overflow in constant expression");
4181 if (!flag_permissive
|| ctx
->quiet
)
4185 if (TREE_CODE (t
) == INTEGER_CST
4186 && TYPE_PTR_P (TREE_TYPE (t
))
4187 && !integer_zerop (t
))
4190 error ("value %qE of type %qT is not a constant expression",
4192 *non_constant_p
= true;
4198 tree_code tcode
= TREE_CODE (t
);
4204 /* We ask for an rvalue for the RESULT_DECL when indirecting
4205 through an invisible reference, or in named return value
4207 if (tree
*p
= ctx
->values
->get (t
))
4212 error ("%qE is not a constant expression", t
);
4213 *non_constant_p
= true;
4218 if (DECL_HAS_VALUE_EXPR_P (t
))
4219 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4220 lval
, non_constant_p
, overflow_p
);
4223 /* We used to not check lval for CONST_DECL, but darwin.c uses
4224 CONST_DECL for aggregate constants. */
4227 /* is_really_empty_class doesn't take into account _vptr, so initializing
4228 otherwise empty class with { } would overwrite the initializer that
4229 initialize_vtable created for us. */
4230 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4231 && !TYPE_POLYMORPHIC_P (TREE_TYPE (t
))
4232 && is_really_empty_class (TREE_TYPE (t
)))
4234 /* If the class is empty, we aren't actually loading anything. */
4235 r
= build_constructor (TREE_TYPE (t
), NULL
);
4236 TREE_CONSTANT (r
) = true;
4238 else if (ctx
->strict
)
4239 r
= decl_really_constant_value (t
);
4241 r
= decl_constant_value (t
);
4242 if (TREE_CODE (r
) == TARGET_EXPR
4243 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4244 r
= TARGET_EXPR_INITIAL (r
);
4246 if (tree
*p
= ctx
->values
->get (r
))
4247 if (*p
!= NULL_TREE
)
4252 non_const_var_error (r
);
4253 *non_constant_p
= true;
4257 case DEBUG_BEGIN_STMT
:
4258 /* ??? It might be nice to retain this information somehow, so
4259 as to be able to step into a constexpr function call. */
4266 case CASE_LABEL_EXPR
:
4271 if (lval
&& !TYPE_REF_P (TREE_TYPE (t
)))
4273 else if (tree
*p
= ctx
->values
->get (r
))
4276 /* Defer in case this is only used for its type. */;
4277 else if (TYPE_REF_P (TREE_TYPE (t
)))
4278 /* Defer, there's no lvalue->rvalue conversion. */;
4279 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4280 && is_really_empty_class (TREE_TYPE (t
)))
4282 /* If the class is empty, we aren't actually loading anything. */
4283 r
= build_constructor (TREE_TYPE (t
), NULL
);
4284 TREE_CONSTANT (r
) = true;
4289 error ("%qE is not a constant expression", t
);
4290 *non_constant_p
= true;
4295 case AGGR_INIT_EXPR
:
4296 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4297 non_constant_p
, overflow_p
);
4302 r
= DECL_EXPR_DECL (t
);
4303 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4304 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4308 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4309 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4310 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4314 if (tree init
= DECL_INITIAL (r
))
4316 init
= cxx_eval_constant_expression (ctx
, init
,
4318 non_constant_p
, overflow_p
);
4319 /* Don't share a CONSTRUCTOR that might be changed. */
4320 init
= unshare_constructor (init
);
4321 ctx
->values
->put (r
, init
);
4323 else if (ctx
== &new_ctx
)
4324 /* We gave it a CONSTRUCTOR above. */;
4326 ctx
->values
->put (r
, NULL_TREE
);
4331 if (!literal_type_p (TREE_TYPE (t
)))
4335 auto_diagnostic_group d
;
4336 error ("temporary of non-literal type %qT in a "
4337 "constant expression", TREE_TYPE (t
));
4338 explain_non_literal_class (TREE_TYPE (t
));
4340 *non_constant_p
= true;
4343 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4345 /* We're being expanded without an explicit target, so start
4346 initializing a new object; expansion with an explicit target
4347 strips the TARGET_EXPR before we get here. */
4349 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4350 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4351 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4352 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4355 /* Pass false for 'lval' because this indicates
4356 initialization of a temporary. */
4357 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4359 non_constant_p
, overflow_p
);
4360 if (!*non_constant_p
)
4361 /* Adjust the type of the result to the type of the temporary. */
4362 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4365 tree slot
= TARGET_EXPR_SLOT (t
);
4366 r
= unshare_constructor (r
);
4367 ctx
->values
->put (slot
, r
);
4374 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4375 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4376 non_constant_p
, overflow_p
);
4380 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4382 non_constant_p
, overflow_p
);
4386 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4387 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4389 non_constant_p
, overflow_p
);
4394 /* Can happen with ({ return true; }) && false; passed to
4395 maybe_constant_value. There is nothing to jump over in this
4396 case, and the bug will be diagnosed later. */
4397 gcc_assert (ctx
->quiet
);
4398 *non_constant_p
= true;
4403 /* Avoid evaluating a SAVE_EXPR more than once. */
4404 if (tree
*p
= ctx
->values
->get (t
))
4408 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4409 non_constant_p
, overflow_p
);
4410 ctx
->values
->put (t
, r
);
4411 if (ctx
->save_exprs
)
4412 ctx
->save_exprs
->add (t
);
4416 case NON_LVALUE_EXPR
:
4417 case TRY_CATCH_EXPR
:
4419 case CLEANUP_POINT_EXPR
:
4420 case MUST_NOT_THROW_EXPR
:
4423 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4425 non_constant_p
, overflow_p
,
4429 case TRY_FINALLY_EXPR
:
4430 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4431 non_constant_p
, overflow_p
,
4433 if (!*non_constant_p
)
4434 /* Also evaluate the cleanup. */
4435 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4436 non_constant_p
, overflow_p
,
4440 /* These differ from cxx_eval_unary_expression in that this doesn't
4441 check for a constant operand or result; an address can be
4442 constant without its operand being, and vice versa. */
4445 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4446 non_constant_p
, overflow_p
);
4451 tree oldop
= TREE_OPERAND (t
, 0);
4452 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4454 non_constant_p
, overflow_p
);
4455 /* Don't VERIFY_CONSTANT here. */
4456 if (*non_constant_p
)
4458 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4459 /* This function does more aggressive folding than fold itself. */
4460 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4461 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4470 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4471 non_constant_p
, overflow_p
);
4472 if (r
== error_mark_node
)
4474 else if (r
== TREE_OPERAND (t
, 0))
4477 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4482 case FIX_TRUNC_EXPR
:
4488 case TRUTH_NOT_EXPR
:
4489 case FIXED_CONVERT_EXPR
:
4490 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4491 non_constant_p
, overflow_p
);
4495 r
= fold_sizeof_expr (t
);
4496 VERIFY_CONSTANT (r
);
4501 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4502 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4503 introduced by build_call_a. */
4504 tree op0
= TREE_OPERAND (t
, 0);
4505 tree op1
= TREE_OPERAND (t
, 1);
4507 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4508 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4509 r
= cxx_eval_constant_expression (ctx
, op0
,
4510 lval
, non_constant_p
, overflow_p
,
4514 /* Check that the LHS is constant and then discard it. */
4515 cxx_eval_constant_expression (ctx
, op0
,
4516 true, non_constant_p
, overflow_p
,
4518 if (*non_constant_p
)
4520 op1
= TREE_OPERAND (t
, 1);
4521 r
= cxx_eval_constant_expression (ctx
, op1
,
4522 lval
, non_constant_p
, overflow_p
,
4528 case POINTER_PLUS_EXPR
:
4529 case POINTER_DIFF_EXPR
:
4533 case TRUNC_DIV_EXPR
:
4535 case FLOOR_DIV_EXPR
:
4536 case ROUND_DIV_EXPR
:
4537 case TRUNC_MOD_EXPR
:
4539 case ROUND_MOD_EXPR
:
4541 case EXACT_DIV_EXPR
:
4551 case TRUTH_XOR_EXPR
:
4558 case UNORDERED_EXPR
:
4568 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4569 non_constant_p
, overflow_p
);
4572 /* fold can introduce non-IF versions of these; still treat them as
4573 short-circuiting. */
4574 case TRUTH_AND_EXPR
:
4575 case TRUTH_ANDIF_EXPR
:
4576 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4579 non_constant_p
, overflow_p
);
4583 case TRUTH_ORIF_EXPR
:
4584 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4587 non_constant_p
, overflow_p
);
4591 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4592 non_constant_p
, overflow_p
);
4596 if (is_overloaded_fn (t
))
4598 /* We can only get here in checking mode via
4599 build_non_dependent_expr, because any expression that
4600 calls or takes the address of the function will have
4601 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4602 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4603 *non_constant_p
= true;
4606 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4607 non_constant_p
, overflow_p
);
4611 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4612 non_constant_p
, overflow_p
);
4616 if (jump_target
&& *jump_target
)
4618 /* When jumping to a label, the label might be either in the
4619 then or else blocks, so process then block first in skipping
4620 mode first, and if we are still in the skipping mode at its end,
4621 process the else block too. */
4622 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4623 lval
, non_constant_p
, overflow_p
,
4626 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4627 lval
, non_constant_p
, overflow_p
,
4631 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4632 non_constant_p
, overflow_p
,
4636 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4641 if (TREE_CONSTANT (t
))
4643 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4644 VECTOR_CST if applicable. */
4645 verify_constructor_flags (t
);
4646 if (TREE_CONSTANT (t
))
4649 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4650 non_constant_p
, overflow_p
);
4654 /* We can get this in a defaulted constructor for a class with a
4655 non-static data member of array type. Either the initializer will
4656 be NULL, meaning default-initialization, or it will be an lvalue
4657 or xvalue of the same type, meaning direct-initialization from the
4658 corresponding member. */
4659 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4660 non_constant_p
, overflow_p
);
4664 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4665 non_constant_p
, overflow_p
);
4669 if (REINTERPRET_CAST_P (t
))
4672 error_at (cp_expr_loc_or_loc (t
, input_location
),
4673 "a reinterpret_cast is not a constant expression");
4674 *non_constant_p
= true;
4679 case VIEW_CONVERT_EXPR
:
4680 case UNARY_PLUS_EXPR
:
4682 tree oldop
= TREE_OPERAND (t
, 0);
4684 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4686 non_constant_p
, overflow_p
);
4687 if (*non_constant_p
)
4689 tree type
= TREE_TYPE (t
);
4690 if (TREE_CODE (op
) == PTRMEM_CST
4691 && !TYPE_PTRMEM_P (type
))
4692 op
= cplus_expand_constant (op
);
4694 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4696 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (op
))
4697 && !can_convert_qual (type
, op
))
4698 op
= cplus_expand_constant (op
);
4699 return cp_fold_convert (type
, op
);
4702 if (INDIRECT_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4704 if (integer_zerop (op
))
4706 if (TYPE_REF_P (type
))
4709 error_at (cp_expr_loc_or_loc (t
, input_location
),
4710 "dereferencing a null pointer");
4711 *non_constant_p
= true;
4714 else if (TYPE_PTR_P (TREE_TYPE (op
)))
4716 tree from
= TREE_TYPE (op
);
4718 if (!can_convert (type
, from
, tf_none
))
4721 error_at (cp_expr_loc_or_loc (t
, input_location
),
4722 "conversion of %qT null pointer to %qT "
4723 "is not a constant expression",
4725 *non_constant_p
= true;
4732 /* This detects for example:
4733 reinterpret_cast<void*>(sizeof 0)
4736 error_at (cp_expr_loc_or_loc (t
, input_location
),
4737 "%<reinterpret_cast<%T>(%E)%> is not "
4738 "a constant expression",
4740 *non_constant_p
= true;
4745 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4746 /* We didn't fold at the top so we could check for ptr-int
4750 /* Handle an array's bounds having been deduced after we built
4751 the wrapping expression. */
4752 if (same_type_ignoring_tlq_and_bounds_p (type
, TREE_TYPE (op
)))
4754 else if (tcode
== UNARY_PLUS_EXPR
)
4755 r
= fold_convert (TREE_TYPE (t
), op
);
4757 r
= fold_build1 (tcode
, type
, op
);
4759 /* Conversion of an out-of-range value has implementation-defined
4760 behavior; the language considers it different from arithmetic
4761 overflow, which is undefined. */
4762 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4763 TREE_OVERFLOW (r
) = false;
4767 case EMPTY_CLASS_EXPR
:
4768 /* This is good enough for a function argument that might not get
4769 used, and they can't do anything with it, so just return it. */
4772 case STATEMENT_LIST
:
4774 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4775 return cxx_eval_statement_list (&new_ctx
, t
,
4776 non_constant_p
, overflow_p
, jump_target
);
4779 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4781 non_constant_p
, overflow_p
,
4784 case PREINCREMENT_EXPR
:
4785 case POSTINCREMENT_EXPR
:
4786 case PREDECREMENT_EXPR
:
4787 case POSTDECREMENT_EXPR
:
4788 return cxx_eval_increment_expression (ctx
, t
,
4789 lval
, non_constant_p
, overflow_p
);
4795 case VEC_DELETE_EXPR
:
4798 /* GCC internal stuff. */
4800 case NON_DEPENDENT_EXPR
:
4804 error_at (cp_expr_loc_or_loc (t
, input_location
),
4805 "expression %qE is not a constant expression", t
);
4806 *non_constant_p
= true;
4811 /* Virtual function call. Let the constexpr machinery figure out
4812 the dynamic type. */
4813 int token
= tree_to_shwi (OBJ_TYPE_REF_TOKEN (t
));
4814 tree obj
= OBJ_TYPE_REF_OBJECT (t
);
4815 obj
= cxx_eval_constant_expression (ctx
, obj
, lval
, non_constant_p
,
4817 /* We expect something in the form of &x.D.2103.D.2094; get x. */
4818 if (TREE_CODE (obj
) != ADDR_EXPR
)
4821 error_at (cp_expr_loc_or_loc (t
, input_location
),
4822 "expression %qE is not a constant expression", t
);
4823 *non_constant_p
= true;
4826 obj
= TREE_OPERAND (obj
, 0);
4827 while (TREE_CODE (obj
) == COMPONENT_REF
4828 && DECL_FIELD_IS_BASE (TREE_OPERAND (obj
, 1)))
4829 obj
= TREE_OPERAND (obj
, 0);
4830 tree objtype
= TREE_TYPE (obj
);
4831 /* Find the function decl in the virtual functions list. TOKEN is
4832 the DECL_VINDEX that says which function we're looking for. */
4833 tree virtuals
= BINFO_VIRTUALS (TYPE_BINFO (objtype
));
4834 r
= TREE_VALUE (chain_index (token
, virtuals
));
4838 case PLACEHOLDER_EXPR
:
4839 /* Use of the value or address of the current object. */
4840 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4841 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4842 non_constant_p
, overflow_p
);
4843 /* A placeholder without a referent. We can get here when
4844 checking whether NSDMIs are noexcept, or in massage_init_elt;
4845 just say it's non-constant for now. */
4846 gcc_assert (ctx
->quiet
);
4847 *non_constant_p
= true;
4852 tree cond
= TREE_OPERAND (t
, 0);
4853 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4854 non_constant_p
, overflow_p
);
4855 VERIFY_CONSTANT (cond
);
4856 if (integer_nonzerop (cond
))
4862 *jump_target
= TREE_OPERAND (t
, 0);
4863 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4864 /* Allow for jumping to a cdtor_label. */
4865 || returns (jump_target
));
4869 cxx_eval_loop_expr (ctx
, t
,
4870 non_constant_p
, overflow_p
, jump_target
);
4874 cxx_eval_switch_expr (ctx
, t
,
4875 non_constant_p
, overflow_p
, jump_target
);
4879 /* It's possible to get a requires-expression in a constant
4880 expression. For example:
4882 template<typename T> concept bool C() {
4883 return requires (T t) { t; };
4886 template<typename T> requires !C<T>() void f(T);
4888 Normalization leaves f with the associated constraint
4889 '!requires (T t) { ... }' which is not transformed into
4891 if (!processing_template_decl
)
4892 return evaluate_constraint_expression (t
, NULL_TREE
);
4894 *non_constant_p
= true;
4898 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4900 non_constant_p
, overflow_p
,
4909 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4911 /* This function doesn't know how to deal with pre-genericize
4912 statements; this can only happen with statement-expressions,
4913 so for now just fail. */
4915 error_at (EXPR_LOCATION (t
),
4916 "statement is not a constant expression");
4919 internal_error ("unexpected expression %qE of kind %s", t
,
4920 get_tree_code_name (TREE_CODE (t
)));
4921 *non_constant_p
= true;
4925 if (r
== error_mark_node
)
4926 *non_constant_p
= true;
4928 if (*non_constant_p
)
4934 /* P0859: A function is needed for constant evaluation if it is a constexpr
4935 function that is named by an expression ([basic.def.odr]) that is
4936 potentially constant evaluated.
4938 So we need to instantiate any constexpr functions mentioned by the
4939 expression even if the definition isn't needed for evaluating the
4943 instantiate_cx_fn_r (tree
*tp
, int *walk_subtrees
, void */
*data*/
)
4945 if (TREE_CODE (*tp
) == FUNCTION_DECL
4946 && DECL_DECLARED_CONSTEXPR_P (*tp
)
4947 && !DECL_INITIAL (*tp
)
4948 && !trivial_fn_p (*tp
)
4949 && DECL_TEMPLOID_INSTANTIATION (*tp
))
4952 instantiate_decl (*tp
, /*defer_ok*/false, /*expl_inst*/false);
4955 else if (TREE_CODE (*tp
) == CALL_EXPR
4956 || TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
4958 if (EXPR_HAS_LOCATION (*tp
))
4959 input_location
= EXPR_LOCATION (*tp
);
4968 instantiate_constexpr_fns (tree t
)
4970 location_t loc
= input_location
;
4971 cp_walk_tree_without_duplicates (&t
, instantiate_cx_fn_r
, NULL
);
4972 input_location
= loc
;
4975 /* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
4976 STRICT has the same sense as for constant_value_1: true if we only allow
4977 conforming C++ constant expressions, or false if we want a constant value
4978 even if it doesn't conform.
4979 PRETEND_CONST_REQUIRED is true if T is required to be const-evaluated as
4980 per P0595 even when ALLOW_NON_CONSTANT is true. */
4983 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4985 bool pretend_const_required
= false,
4986 tree object
= NULL_TREE
)
4988 auto_timevar
time (TV_CONSTEXPR
);
4990 bool non_constant_p
= false;
4991 bool overflow_p
= false;
4992 hash_map
<tree
,tree
> map
;
4994 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4995 allow_non_constant
, strict
,
4996 pretend_const_required
|| !allow_non_constant
};
4998 tree type
= initialized_type (t
);
5000 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5002 /* In C++14 an NSDMI can participate in aggregate initialization,
5003 and can refer to the address of the object being initialized, so
5004 we need to pass in the relevant VAR_DECL if we want to do the
5005 evaluation in a single pass. The evaluation will dynamically
5006 update ctx.values for the VAR_DECL. We use the same strategy
5007 for C++11 constexpr constructors that refer to the object being
5009 ctx
.ctor
= build_constructor (type
, NULL
);
5010 CONSTRUCTOR_NO_CLEARING (ctx
.ctor
) = true;
5013 if (TREE_CODE (t
) == TARGET_EXPR
)
5014 object
= TARGET_EXPR_SLOT (t
);
5015 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5016 object
= AGGR_INIT_EXPR_SLOT (t
);
5018 ctx
.object
= object
;
5020 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5021 (type
, TREE_TYPE (object
)));
5022 if (object
&& DECL_P (object
))
5023 map
.put (object
, ctx
.ctor
);
5024 if (TREE_CODE (r
) == TARGET_EXPR
)
5025 /* Avoid creating another CONSTRUCTOR when we expand the
5027 r
= TARGET_EXPR_INITIAL (r
);
5030 instantiate_constexpr_fns (r
);
5031 r
= cxx_eval_constant_expression (&ctx
, r
,
5032 false, &non_constant_p
, &overflow_p
);
5034 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
5036 /* Mutable logic is a bit tricky: we want to allow initialization of
5037 constexpr variables with mutable members, but we can't copy those
5038 members to another constexpr variable. */
5039 if (TREE_CODE (r
) == CONSTRUCTOR
5040 && CONSTRUCTOR_MUTABLE_POISON (r
))
5042 if (!allow_non_constant
)
5043 error ("%qE is not a constant expression because it refers to "
5044 "mutable subobjects of %qT", t
, type
);
5045 non_constant_p
= true;
5048 if (TREE_CODE (r
) == CONSTRUCTOR
5049 && CONSTRUCTOR_NO_CLEARING (r
))
5051 if (!allow_non_constant
)
5052 error ("%qE is not a constant expression because it refers to "
5053 "an incompletely initialized variable", t
);
5054 TREE_CONSTANT (r
) = false;
5055 non_constant_p
= true;
5058 /* Technically we should check this for all subexpressions, but that
5059 runs into problems with our internal representation of pointer
5060 subtraction and the 5.19 rules are still in flux. */
5061 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
5062 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
5063 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
5065 if (!allow_non_constant
)
5066 error ("conversion from pointer type %qT "
5067 "to arithmetic type %qT in a constant expression",
5068 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
5069 non_constant_p
= true;
5072 if (!non_constant_p
&& overflow_p
)
5073 non_constant_p
= true;
5075 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
5077 bool should_unshare
= true;
5078 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
5079 should_unshare
= false;
5081 if (non_constant_p
&& !allow_non_constant
)
5082 return error_mark_node
;
5083 else if (non_constant_p
&& TREE_CONSTANT (r
))
5085 /* If __builtin_is_constant_evaluated () was evaluated to true
5086 and the result is not a valid constant expression, we need to
5088 if (pretend_const_required
)
5089 return cxx_eval_outermost_constant_expr (t
, true, strict
,
5091 /* This isn't actually constant, so unset TREE_CONSTANT.
5092 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
5093 it to be set if it is invariant address, even when it is not
5094 a valid C++ constant expression. Wrap it with a NOP_EXPR
5096 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
5098 else if (TREE_CODE (r
) == CONSTRUCTOR
)
5099 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
5101 r
= build_nop (TREE_TYPE (r
), r
);
5102 TREE_CONSTANT (r
) = false;
5104 else if (non_constant_p
)
5108 r
= unshare_expr (r
);
5110 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
5112 r
= adjust_temp_type (type
, r
);
5113 if (TREE_CODE (t
) == TARGET_EXPR
5114 && TARGET_EXPR_INITIAL (t
) == r
)
5116 else if (TREE_CODE (t
) != CONSTRUCTOR
)
5118 r
= get_target_expr (r
);
5119 TREE_CONSTANT (r
) = true;
5126 /* Returns true if T is a valid subexpression of a constant expression,
5127 even if it isn't itself a constant expression. */
5130 is_sub_constant_expr (tree t
)
5132 bool non_constant_p
= false;
5133 bool overflow_p
= false;
5134 hash_map
<tree
, tree
> map
;
5137 = { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true, false };
5139 instantiate_constexpr_fns (t
);
5140 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
5142 return !non_constant_p
&& !overflow_p
;
5145 /* If T represents a constant expression returns its reduced value.
5146 Otherwise return error_mark_node. If T is dependent, then
5150 cxx_constant_value (tree t
, tree decl
)
5152 return cxx_eval_outermost_constant_expr (t
, false, true, true, decl
);
5155 /* Helper routine for fold_simple function. Either return simplified
5156 expression T, otherwise NULL_TREE.
5157 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
5158 even if we are within template-declaration. So be careful on call, as in
5159 such case types can be undefined. */
5162 fold_simple_1 (tree t
)
5165 enum tree_code code
= TREE_CODE (t
);
5177 return fold_sizeof_expr (t
);
5186 case TRUTH_NOT_EXPR
:
5188 case VIEW_CONVERT_EXPR
:
5191 case FIX_TRUNC_EXPR
:
5192 case FIXED_CONVERT_EXPR
:
5193 case ADDR_SPACE_CONVERT_EXPR
:
5195 op1
= TREE_OPERAND (t
, 0);
5197 t
= const_unop (code
, TREE_TYPE (t
), op1
);
5201 if (CONVERT_EXPR_CODE_P (code
)
5202 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
5203 TREE_OVERFLOW (t
) = false;
5211 /* If T is a simple constant expression, returns its simplified value.
5212 Otherwise returns T. In contrast to maybe_constant_value we
5213 simplify only few operations on constant-expressions, and we don't
5214 try to simplify constexpressions. */
5217 fold_simple (tree t
)
5219 if (processing_template_decl
)
5222 tree r
= fold_simple_1 (t
);
5229 /* If T is a constant expression, returns its reduced value.
5230 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5231 Otherwise, returns a version of T without TREE_CONSTANT. */
5233 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5236 maybe_constant_value (tree t
, tree decl
)
5240 if (!is_nondependent_constant_expression (t
))
5242 if (TREE_OVERFLOW_P (t
))
5244 t
= build_nop (TREE_TYPE (t
), t
);
5245 TREE_CONSTANT (t
) = false;
5249 else if (CONSTANT_CLASS_P (t
))
5250 /* No caching or evaluation needed. */
5253 if (cv_cache
== NULL
)
5254 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5255 if (tree
*cached
= cv_cache
->get (t
))
5258 r
= cxx_eval_outermost_constant_expr (t
, true, true, false, decl
);
5259 gcc_checking_assert (r
== t
5260 || CONVERT_EXPR_P (t
)
5261 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5262 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5263 || !cp_tree_equal (r
, t
));
5264 cv_cache
->put (t
, r
);
5268 /* Dispose of the whole CV_CACHE. */
5271 clear_cv_cache (void)
5273 if (cv_cache
!= NULL
)
5277 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5280 clear_cv_and_fold_caches (void)
5283 clear_fold_cache ();
5286 /* Like maybe_constant_value but first fully instantiate the argument.
5288 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5289 (t, complain) followed by maybe_constant_value but is more efficient,
5290 because it calls instantiation_dependent_expression_p and
5291 potential_constant_expression at most once.
5293 Callers should generally pass their active complain, or if they are in a
5294 non-template, diagnosing context, they can use the default of
5295 tf_warning_or_error. Callers that might be within a template context, don't
5296 have a complain parameter, and aren't going to remember the result for long
5297 (e.g. null_ptr_cst_p), can pass tf_none and deal with error_mark_node
5301 fold_non_dependent_expr (tree t
,
5302 tsubst_flags_t complain
/* = tf_warning_or_error */)
5307 /* If we're in a template, but T isn't value dependent, simplify
5308 it. We're supposed to treat:
5310 template <typename T> void f(T[1 + 1]);
5311 template <typename T> void f(T[2]);
5313 as two declarations of the same function, for example. */
5314 if (processing_template_decl
)
5316 if (is_nondependent_constant_expression (t
))
5318 processing_template_decl_sentinel s
;
5319 t
= instantiate_non_dependent_expr_internal (t
, complain
);
5321 if (type_unknown_p (t
)
5322 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5324 if (TREE_OVERFLOW_P (t
))
5326 t
= build_nop (TREE_TYPE (t
), t
);
5327 TREE_CONSTANT (t
) = false;
5332 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, false,
5334 /* cp_tree_equal looks through NOPs, so allow them. */
5335 gcc_checking_assert (r
== t
5336 || CONVERT_EXPR_P (t
)
5337 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5338 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5339 || !cp_tree_equal (r
, t
));
5342 else if (TREE_OVERFLOW_P (t
))
5344 t
= build_nop (TREE_TYPE (t
), t
);
5345 TREE_CONSTANT (t
) = false;
5350 return maybe_constant_value (t
);
5353 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5354 than wrapped in a TARGET_EXPR.
5355 ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5356 PRETEND_CONST_REQUIRED is true if T is required to be const-evaluated as
5357 per P0595 even when ALLOW_NON_CONSTANT is true. */
5360 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
,
5361 bool pretend_const_required
)
5365 if (TREE_CODE (t
) == EXPR_STMT
)
5366 t
= TREE_OPERAND (t
, 0);
5367 if (TREE_CODE (t
) == CONVERT_EXPR
5368 && VOID_TYPE_P (TREE_TYPE (t
)))
5369 t
= TREE_OPERAND (t
, 0);
5370 if (TREE_CODE (t
) == INIT_EXPR
)
5371 t
= TREE_OPERAND (t
, 1);
5372 if (TREE_CODE (t
) == TARGET_EXPR
)
5373 t
= TARGET_EXPR_INITIAL (t
);
5374 if (!is_nondependent_static_init_expression (t
))
5375 /* Don't try to evaluate it. */;
5376 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5377 /* No evaluation needed. */;
5379 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
,
5381 pretend_const_required
, decl
);
5382 if (TREE_CODE (t
) == TARGET_EXPR
)
5384 tree init
= TARGET_EXPR_INITIAL (t
);
5385 if (TREE_CODE (init
) == CONSTRUCTOR
)
5391 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5394 maybe_constant_init (tree t
, tree decl
, bool pretend_const_required
)
5396 return maybe_constant_init_1 (t
, decl
, true, pretend_const_required
);
5399 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5402 cxx_constant_init (tree t
, tree decl
)
5404 return maybe_constant_init_1 (t
, decl
, false, true);
5408 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5409 /* Return true if the object referred to by REF has automatic or thread
5412 enum { ck_ok
, ck_bad
, ck_unknown
};
5414 check_automatic_or_tls (tree ref
)
5417 poly_int64 bitsize
, bitpos
;
5419 int volatilep
= 0, unsignedp
= 0;
5420 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5421 &mode
, &unsignedp
, &volatilep
, false);
5424 /* If there isn't a decl in the middle, we don't know the linkage here,
5425 and this isn't a constant expression anyway. */
5428 dk
= decl_storage_duration (decl
);
5429 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5433 /* Return true if T denotes a potentially constant expression. Issue
5434 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5435 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5436 consider the expression in the current context, independent of constexpr
5439 C++0x [expr.const] used to say
5441 6 An expression is a potential constant expression if it is
5442 a constant expression where all occurrences of function
5443 parameters are replaced by arbitrary constant expressions
5444 of the appropriate type.
5446 2 A conditional expression is a constant expression unless it
5447 involves one of the following as a potentially evaluated
5448 subexpression (3.2), but subexpressions of logical AND (5.14),
5449 logical OR (5.15), and conditional (5.16) operations that are
5450 not evaluated are not considered. */
5453 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5454 tsubst_flags_t flags
, tree
*jump_target
)
5456 #define RECUR(T,RV) \
5457 potential_constant_expression_1 ((T), (RV), strict, now, flags, jump_target)
5459 enum { any
= false, rval
= true };
5463 if (t
== error_mark_node
)
5467 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
5470 /* If we are jumping, ignore everything. This is simpler than the
5471 cxx_eval_constant_expression handling because we only need to be
5472 conservatively correct, and we don't necessarily have a constant value
5473 available, so we don't bother with switch tracking. */
5476 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5478 if (flags
& tf_error
)
5479 error_at (loc
, "expression %qE has side-effects", t
);
5482 if (CONSTANT_CLASS_P (t
))
5484 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5485 && TREE_TYPE (t
) == error_mark_node
)
5488 switch (TREE_CODE (t
))
5494 case TEMPLATE_ID_EXPR
:
5497 case CASE_LABEL_EXPR
:
5503 case TEMPLATE_PARM_INDEX
:
5505 case IDENTIFIER_NODE
:
5506 case USERDEF_LITERAL
:
5507 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5512 case PLACEHOLDER_EXPR
:
5515 case DEBUG_BEGIN_STMT
:
5519 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5531 if (flags
& tf_error
)
5532 error ("%qE is not a constant expression", t
);
5537 case AGGR_INIT_EXPR
:
5539 /* -- an invocation of a function other than a constexpr function
5540 or a constexpr constructor. */
5542 tree fun
= get_function_named_in_call (t
);
5543 const int nargs
= call_expr_nargs (t
);
5546 if (fun
== NULL_TREE
)
5548 /* Reset to allow the function to continue past the end
5549 of the block below. Otherwise return early. */
5552 if (TREE_CODE (t
) == CALL_EXPR
5553 && CALL_EXPR_FN (t
) == NULL_TREE
)
5554 switch (CALL_EXPR_IFN (t
))
5556 /* These should be ignored, they are optimized away from
5557 constexpr functions. */
5558 case IFN_UBSAN_NULL
:
5559 case IFN_UBSAN_BOUNDS
:
5560 case IFN_UBSAN_VPTR
:
5561 case IFN_FALLTHROUGH
:
5564 case IFN_ADD_OVERFLOW
:
5565 case IFN_SUB_OVERFLOW
:
5566 case IFN_MUL_OVERFLOW
:
5576 /* fold_call_expr can't do anything with IFN calls. */
5577 if (flags
& tf_error
)
5578 error_at (loc
, "call to internal function %qE", t
);
5583 if (fun
&& is_overloaded_fn (fun
))
5585 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5587 if (builtin_valid_in_constant_expr_p (fun
))
5589 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5590 /* Allow any built-in function; if the expansion
5591 isn't constant, we'll deal with that then. */
5592 && !fndecl_built_in_p (fun
))
5594 if (flags
& tf_error
)
5596 error_at (loc
, "call to non-%<constexpr%> function %qD",
5598 explain_invalid_constexpr_fn (fun
);
5602 /* A call to a non-static member function takes the address
5603 of the object as the first argument. But in a constant
5604 expression the address will be folded away, so look
5606 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5607 && !DECL_CONSTRUCTOR_P (fun
))
5609 tree x
= get_nth_callarg (t
, 0);
5610 if (is_this_parameter (x
))
5612 /* Don't require an immediately constant value, as
5613 constexpr substitution might not use the value. */
5614 bool sub_now
= false;
5615 if (!potential_constant_expression_1 (x
, rval
, strict
,
5624 if (!RECUR (fun
, true))
5626 fun
= get_first_fn (fun
);
5628 /* Skip initial arguments to base constructors. */
5629 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5630 i
= num_artificial_parms_for (fun
);
5631 fun
= DECL_ORIGIN (fun
);
5635 if (RECUR (fun
, rval
))
5636 /* Might end up being a constant function pointer. */;
5640 for (; i
< nargs
; ++i
)
5642 tree x
= get_nth_callarg (t
, i
);
5643 /* In a template, reference arguments haven't been converted to
5644 REFERENCE_TYPE and we might not even know if the parameter
5645 is a reference, so accept lvalue constants too. */
5646 bool rv
= processing_template_decl
? any
: rval
;
5647 /* Don't require an immediately constant value, as constexpr
5648 substitution might not use the value of the argument. */
5649 bool sub_now
= false;
5650 if (!potential_constant_expression_1 (x
, rv
, strict
,
5651 sub_now
, flags
, jump_target
))
5657 case NON_LVALUE_EXPR
:
5658 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5659 -- an lvalue of integral type that refers to a non-volatile
5660 const variable or static data member initialized with
5661 constant expressions, or
5663 -- an lvalue of literal type that refers to non-volatile
5664 object defined with constexpr, or that refers to a
5665 sub-object of such an object; */
5666 return RECUR (TREE_OPERAND (t
, 0), rval
);
5669 if (DECL_HAS_VALUE_EXPR_P (t
))
5671 if (now
&& is_normal_capture_proxy (t
))
5673 /* -- in a lambda-expression, a reference to this or to a
5674 variable with automatic storage duration defined outside that
5675 lambda-expression, where the reference would be an
5677 if (flags
& tf_error
)
5679 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5680 error ("lambda capture of %qE is not a constant expression",
5682 if (!want_rval
&& decl_constant_var_p (cap
))
5683 inform (input_location
, "because it is used as a glvalue");
5687 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5690 && !var_in_maybe_constexpr_fn (t
)
5691 && !type_dependent_expression_p (t
)
5692 && !decl_maybe_constant_var_p (t
)
5694 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5695 || (DECL_INITIAL (t
)
5696 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5697 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5698 && !is_really_empty_class (TREE_TYPE (t
)))
5700 if (flags
& tf_error
)
5701 non_const_var_error (t
);
5708 case VIEW_CONVERT_EXPR
:
5709 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5710 may change to something more specific to type-punning (DR 1312). */
5712 tree from
= TREE_OPERAND (t
, 0);
5713 if (INDIRECT_TYPE_P (TREE_TYPE (t
))
5714 && TREE_CODE (from
) == INTEGER_CST
5715 && !integer_zerop (from
))
5717 if (flags
& tf_error
)
5718 error_at (loc
, "reinterpret_cast from integer to pointer");
5721 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5724 case ADDRESSOF_EXPR
:
5725 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5726 t
= TREE_OPERAND (t
, 0);
5727 goto handle_addr_expr
;
5730 /* -- a unary operator & that is applied to an lvalue that
5731 designates an object with thread or automatic storage
5733 t
= TREE_OPERAND (t
, 0);
5735 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5736 /* A pointer-to-member constant. */
5741 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5742 any checking here, as we might dereference the pointer later. If
5743 we remove this code, also remove check_automatic_or_tls. */
5744 i
= check_automatic_or_tls (t
);
5749 if (flags
& tf_error
)
5750 error ("address-of an object %qE with thread local or "
5751 "automatic storage is not a constant expression", t
);
5755 return RECUR (t
, any
);
5763 /* -- a class member access unless its postfix-expression is
5764 of literal type or of pointer to literal type. */
5765 /* This test would be redundant, as it follows from the
5766 postfix-expression being a potential constant expression. */
5767 if (type_unknown_p (t
))
5769 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5771 case EXPR_PACK_EXPANSION
:
5772 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5776 tree x
= TREE_OPERAND (t
, 0);
5778 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5780 if (!var_in_maybe_constexpr_fn (x
))
5782 if (flags
& tf_error
)
5783 error_at (loc
, "use of %<this%> in a constant expression");
5788 return RECUR (x
, rval
);
5791 case STATEMENT_LIST
:
5793 tree_stmt_iterator i
;
5794 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5796 if (!RECUR (tsi_stmt (i
), any
))
5804 if (cxx_dialect
< cxx14
)
5806 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5808 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5813 if (cxx_dialect
< cxx14
)
5815 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5817 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5822 if (!RECUR (DO_COND (t
), rval
))
5824 if (!RECUR (DO_BODY (t
), any
))
5826 if (breaks (jump_target
) || continues (jump_target
))
5827 *jump_target
= NULL_TREE
;
5831 if (!RECUR (FOR_INIT_STMT (t
), any
))
5834 if (!RECUR (tmp
, rval
))
5838 if (!processing_template_decl
)
5839 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5840 /* If we couldn't evaluate the condition, it might not ever be
5842 if (!integer_onep (tmp
))
5845 if (!RECUR (FOR_EXPR (t
), any
))
5847 if (!RECUR (FOR_BODY (t
), any
))
5849 if (breaks (jump_target
) || continues (jump_target
))
5850 *jump_target
= NULL_TREE
;
5853 case RANGE_FOR_STMT
:
5854 if (!RECUR (RANGE_FOR_INIT_STMT (t
), any
))
5856 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5858 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5860 if (breaks (jump_target
) || continues (jump_target
))
5861 *jump_target
= NULL_TREE
;
5865 tmp
= WHILE_COND (t
);
5866 if (!RECUR (tmp
, rval
))
5868 if (!processing_template_decl
)
5869 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5870 /* If we couldn't evaluate the condition, it might not ever be true. */
5871 if (!integer_onep (tmp
))
5873 if (!RECUR (WHILE_BODY (t
), any
))
5875 if (breaks (jump_target
) || continues (jump_target
))
5876 *jump_target
= NULL_TREE
;
5880 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5882 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5883 unreachable labels would be checked. */
5887 return RECUR (STMT_EXPR_STMT (t
), rval
);
5890 if (cxx_dialect
>= cxx17
)
5891 /* In C++17 lambdas can be constexpr, don't give up yet. */
5893 else if (flags
& tf_error
)
5894 error_at (loc
, "lambda-expression is not a constant expression "
5898 case DYNAMIC_CAST_EXPR
:
5899 case PSEUDO_DTOR_EXPR
:
5903 case VEC_DELETE_EXPR
:
5909 case OMP_DISTRIBUTE
:
5912 case OMP_TARGET_DATA
:
5921 case OMP_TARGET_UPDATE
:
5922 case OMP_TARGET_ENTER_DATA
:
5923 case OMP_TARGET_EXIT_DATA
:
5925 case OMP_ATOMIC_READ
:
5926 case OMP_ATOMIC_CAPTURE_OLD
:
5927 case OMP_ATOMIC_CAPTURE_NEW
:
5932 case OACC_HOST_DATA
:
5936 case OACC_ENTER_DATA
:
5937 case OACC_EXIT_DATA
:
5939 /* GCC internal stuff. */
5941 case TRANSACTION_EXPR
:
5943 case AT_ENCODE_EXPR
:
5945 if (flags
& tf_error
)
5946 error_at (loc
, "expression %qE is not a constant expression", t
);
5950 if (cxx_dialect
>= cxx2a
)
5951 /* In C++2a virtual calls can be constexpr, don't give up yet. */
5953 else if (flags
& tf_error
)
5954 error_at (loc
, "virtual functions cannot be constexpr before C++2a");
5958 /* -- a typeid expression whose operand is of polymorphic
5961 tree e
= TREE_OPERAND (t
, 0);
5962 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5963 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5965 if (flags
& tf_error
)
5966 error_at (loc
, "typeid-expression is not a constant expression "
5967 "because %qE is of polymorphic type", e
);
5973 case POINTER_DIFF_EXPR
:
5987 case PREINCREMENT_EXPR
:
5988 case POSTINCREMENT_EXPR
:
5989 case PREDECREMENT_EXPR
:
5990 case POSTDECREMENT_EXPR
:
5991 if (cxx_dialect
< cxx14
)
5997 if (TYPE_P (TREE_OPERAND (t
, 0)))
6003 case FIX_TRUNC_EXPR
:
6008 case TRUTH_NOT_EXPR
:
6009 case FIXED_CONVERT_EXPR
:
6010 case UNARY_PLUS_EXPR
:
6011 case UNARY_LEFT_FOLD_EXPR
:
6012 case UNARY_RIGHT_FOLD_EXPR
:
6014 return RECUR (TREE_OPERAND (t
, 0), rval
);
6017 case CONST_CAST_EXPR
:
6018 case STATIC_CAST_EXPR
:
6019 case REINTERPRET_CAST_EXPR
:
6020 case IMPLICIT_CONV_EXPR
:
6021 if (cxx_dialect
< cxx11
6022 && !dependent_type_p (TREE_TYPE (t
))
6023 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
6024 /* In C++98, a conversion to non-integral type can't be part of a
6025 constant expression. */
6027 if (flags
& tf_error
)
6029 "cast to non-integral type %qT in a constant expression",
6033 /* This might be a conversion from a class to a (potentially) literal
6034 type. Let's consider it potentially constant since the conversion
6035 might be a constexpr user-defined conversion. */
6036 else if (cxx_dialect
>= cxx11
6037 && (dependent_type_p (TREE_TYPE (t
))
6038 || !COMPLETE_TYPE_P (TREE_TYPE (t
))
6039 || literal_type_p (TREE_TYPE (t
)))
6040 && TREE_OPERAND (t
, 0))
6042 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6043 /* If this is a dependent type, it could end up being a class
6044 with conversions. */
6045 if (type
== NULL_TREE
|| WILDCARD_TYPE_P (type
))
6047 /* Or a non-dependent class which has conversions. */
6048 else if (CLASS_TYPE_P (type
)
6049 && (TYPE_HAS_CONVERSION (type
) || dependent_scope_p (type
)))
6053 return (RECUR (TREE_OPERAND (t
, 0),
6054 !TYPE_REF_P (TREE_TYPE (t
))));
6057 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
6059 case CLEANUP_POINT_EXPR
:
6060 case MUST_NOT_THROW_EXPR
:
6061 case TRY_CATCH_EXPR
:
6066 case NON_DEPENDENT_EXPR
:
6067 /* For convenience. */
6070 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6073 tmp
= DECL_EXPR_DECL (t
);
6074 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
6076 if (TREE_STATIC (tmp
))
6078 if (flags
& tf_error
)
6079 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6080 "%<static%> in %<constexpr%> context", tmp
);
6083 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
6085 if (flags
& tf_error
)
6086 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6087 "%<thread_local%> in %<constexpr%> context", tmp
);
6090 else if (!check_for_uninitialized_const_var
6091 (tmp
, /*constexpr_context_p=*/true, flags
))
6094 return RECUR (tmp
, want_rval
);
6096 case TRY_FINALLY_EXPR
:
6097 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
6098 && RECUR (TREE_OPERAND (t
, 1), any
));
6101 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6104 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
6105 && !literal_type_p (TREE_TYPE (t
)))
6107 if (flags
& tf_error
)
6109 auto_diagnostic_group d
;
6110 error_at (loc
, "temporary of non-literal type %qT in a "
6111 "constant expression", TREE_TYPE (t
));
6112 explain_non_literal_class (TREE_TYPE (t
));
6118 return RECUR (TREE_OPERAND (t
, 1), rval
);
6122 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
6123 constructor_elt
*ce
;
6124 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
6125 if (!RECUR (ce
->value
, want_rval
))
6132 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
6133 || DECL_P (TREE_PURPOSE (t
)));
6134 if (!RECUR (TREE_VALUE (t
), want_rval
))
6136 if (TREE_CHAIN (t
) == NULL_TREE
)
6138 return RECUR (TREE_CHAIN (t
), want_rval
);
6141 case TRUNC_DIV_EXPR
:
6143 case FLOOR_DIV_EXPR
:
6144 case ROUND_DIV_EXPR
:
6145 case TRUNC_MOD_EXPR
:
6147 case ROUND_MOD_EXPR
:
6149 tree denom
= TREE_OPERAND (t
, 1);
6150 if (!RECUR (denom
, rval
))
6152 /* We can't call cxx_eval_outermost_constant_expr on an expression
6153 that hasn't been through instantiate_non_dependent_expr yet. */
6154 if (!processing_template_decl
)
6155 denom
= cxx_eval_outermost_constant_expr (denom
, true);
6156 if (integer_zerop (denom
))
6158 if (flags
& tf_error
)
6159 error ("division by zero is not a constant expression");
6165 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6171 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6172 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6173 introduced by build_call_a. */
6174 tree op0
= TREE_OPERAND (t
, 0);
6175 tree op1
= TREE_OPERAND (t
, 1);
6177 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
6178 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
6179 return RECUR (op0
, want_rval
);
6184 /* If the first operand is the non-short-circuit constant, look at
6185 the second operand; otherwise we only care about the first one for
6187 case TRUTH_AND_EXPR
:
6188 case TRUTH_ANDIF_EXPR
:
6189 tmp
= boolean_true_node
;
6192 case TRUTH_ORIF_EXPR
:
6193 tmp
= boolean_false_node
;
6196 tree op
= TREE_OPERAND (t
, 0);
6197 if (!RECUR (op
, rval
))
6199 if (!processing_template_decl
)
6200 op
= cxx_eval_outermost_constant_expr (op
, true);
6201 if (tree_int_cst_equal (op
, tmp
))
6202 return RECUR (TREE_OPERAND (t
, 1), rval
);
6209 case POINTER_PLUS_EXPR
:
6211 case EXACT_DIV_EXPR
:
6221 case TRUTH_XOR_EXPR
:
6222 case UNORDERED_EXPR
:
6235 case ARRAY_RANGE_REF
:
6239 case BINARY_LEFT_FOLD_EXPR
:
6240 case BINARY_RIGHT_FOLD_EXPR
:
6242 for (i
= 0; i
< 2; ++i
)
6243 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
6248 for (i
= 0; i
< 3; ++i
)
6249 if (!RECUR (TREE_OPERAND (t
, i
), true))
6254 if (COND_EXPR_IS_VEC_DELETE (t
))
6256 if (flags
& tf_error
)
6257 error_at (loc
, "%<delete[]%> is not a constant expression");
6263 /* If the condition is a known constant, we know which of the legs we
6264 care about; otherwise we only require that the condition and
6265 either of the legs be potentially constant. */
6266 tmp
= TREE_OPERAND (t
, 0);
6267 if (!RECUR (tmp
, rval
))
6269 if (!processing_template_decl
)
6270 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6271 if (integer_zerop (tmp
))
6272 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
6273 else if (TREE_CODE (tmp
) == INTEGER_CST
)
6274 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6275 for (i
= 1; i
< 3; ++i
)
6276 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
6277 want_rval
, strict
, now
,
6278 tf_none
, jump_target
))
6280 if (flags
& tf_error
)
6281 error_at (loc
, "expression %qE is not a constant expression", t
);
6285 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
6287 if (flags
& tf_error
)
6289 error_at (loc
, "non-constant array initialization");
6290 diagnose_non_constexpr_vec_init (t
);
6296 /* We can see these in statement-expressions. */
6300 case EMPTY_CLASS_EXPR
:
6306 tree
*target
= &TREE_OPERAND (t
, 0);
6307 /* Gotos representing break and continue are OK. */
6308 if (breaks (target
) || continues (target
))
6310 *jump_target
= *target
;
6313 if (flags
& tf_error
)
6314 error_at (loc
, "%<goto%> is not a constant expression");
6319 return RECUR (TREE_OPERAND (t
, 0), rval
);
6322 if (objc_is_property_ref (t
))
6325 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6333 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
6334 tsubst_flags_t flags
)
6336 tree target
= NULL_TREE
;
6337 return potential_constant_expression_1 (t
, want_rval
, strict
, now
,
6341 /* The main entry point to the above. */
6344 potential_constant_expression (tree t
)
6346 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6349 /* As above, but require a constant rvalue. */
6352 potential_rvalue_constant_expression (tree t
)
6354 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6357 /* Like above, but complain about non-constant expressions. */
6360 require_potential_constant_expression (tree t
)
6362 return potential_constant_expression_1 (t
, false, true, false,
6363 tf_warning_or_error
);
6366 /* Cross product of the above. */
6369 require_potential_rvalue_constant_expression (tree t
)
6371 return potential_constant_expression_1 (t
, true, true, false,
6372 tf_warning_or_error
);
6375 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6378 require_rvalue_constant_expression (tree t
)
6380 return potential_constant_expression_1 (t
, true, true, true,
6381 tf_warning_or_error
);
6384 /* Like potential_constant_expression, but don't consider possible constexpr
6385 substitution of the current function. That is, PARM_DECL qualifies under
6386 potential_constant_expression, but not here.
6388 This is basically what you can check when any actual constant values might
6389 be value-dependent. */
6392 is_constant_expression (tree t
)
6394 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6397 /* Like above, but complain about non-constant expressions. */
6400 require_constant_expression (tree t
)
6402 return potential_constant_expression_1 (t
, false, true, true,
6403 tf_warning_or_error
);
6406 /* Like is_constant_expression, but allow const variables that are not allowed
6407 under constexpr rules. */
6410 is_static_init_expression (tree t
)
6412 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6415 /* Returns true if T is a potential constant expression that is not
6416 instantiation-dependent, and therefore a candidate for constant folding even
6420 is_nondependent_constant_expression (tree t
)
6422 return (!type_unknown_p (t
)
6423 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6424 && is_constant_expression (t
)
6425 && !instantiation_dependent_expression_p (t
));
6428 /* Returns true if T is a potential static initializer expression that is not
6429 instantiation-dependent. */
6432 is_nondependent_static_init_expression (tree t
)
6434 return (!type_unknown_p (t
)
6435 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6436 && is_static_init_expression (t
)
6437 && !instantiation_dependent_expression_p (t
));
6440 /* Finalize constexpr processing after parsing. */
6443 fini_constexpr (void)
6445 /* The contexpr call and fundef copies tables are no longer needed. */
6446 constexpr_call_table
= NULL
;
6447 fundef_copies_table
= NULL
;
6450 #include "gt-cp-constexpr.h"