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
)
63 || TREE_CODE (t
) == REFERENCE_TYPE
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 (!literal_type_p (type
))
96 if (DECL_DECLARED_CONSTEXPR_P (decl
))
98 error ("the type %qT of %<constexpr%> variable %qD "
99 "is not literal", type
, decl
);
100 explain_non_literal_class (type
);
101 decl
= error_mark_node
;
105 if (!is_instantiation_of_constexpr (current_function_decl
))
107 error ("variable %qD of non-literal type %qT in %<constexpr%> "
108 "function", decl
, type
);
109 explain_non_literal_class (type
);
110 decl
= error_mark_node
;
112 cp_function_chain
->invalid_constexpr
= true;
115 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
116 && variably_modified_type_p (type
, NULL_TREE
))
118 error ("%<constexpr%> variable %qD has variably-modified type %qT",
120 decl
= error_mark_node
;
126 /* Representation of entries in the constexpr function definition table. */
128 struct GTY((for_user
)) constexpr_fundef
{
133 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
135 static hashval_t
hash (constexpr_fundef
*);
136 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
139 /* This table holds all constexpr function definitions seen in
140 the current translation unit. */
142 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
144 /* Utility function used for managing the constexpr function table.
145 Return true if the entries pointed to by P and Q are for the
146 same constexpr function. */
149 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
151 return lhs
->decl
== rhs
->decl
;
154 /* Utility function used for managing the constexpr function table.
155 Return a hash value for the entry pointed to by Q. */
158 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
160 return DECL_UID (fundef
->decl
);
163 /* Return a previously saved definition of function FUN. */
165 static constexpr_fundef
*
166 retrieve_constexpr_fundef (tree fun
)
168 constexpr_fundef fundef
= { NULL
, NULL
};
169 if (constexpr_fundef_table
== NULL
)
173 return constexpr_fundef_table
->find (&fundef
);
176 /* Check whether the parameter and return types of FUN are valid for a
177 constexpr function, and complain if COMPLAIN. */
180 is_valid_constexpr_fn (tree fun
, bool complain
)
184 if (DECL_INHERITED_CTOR (fun
)
185 && TREE_CODE (fun
) == TEMPLATE_DECL
)
189 error ("inherited constructor %qD is not %<constexpr%>",
190 DECL_INHERITED_CTOR (fun
));
194 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
195 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
196 if (!literal_type_p (TREE_TYPE (parm
)))
201 error ("invalid type for parameter %d of %<constexpr%> "
202 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
203 explain_non_literal_class (TREE_TYPE (parm
));
208 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
212 inform (DECL_SOURCE_LOCATION (fun
),
213 "lambdas are implicitly %<constexpr%> only in C++17 and later");
215 else if (!DECL_CONSTRUCTOR_P (fun
))
217 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
218 if (!literal_type_p (rettype
))
223 error ("invalid return type %qT of %<constexpr%> function %q+D",
225 explain_non_literal_class (rettype
);
229 /* C++14 DR 1684 removed this restriction. */
230 if (cxx_dialect
< cxx14
231 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
232 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
236 && pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
237 "enclosing class of %<constexpr%> non-static member "
238 "function %q+#D is not a literal type", fun
))
239 explain_non_literal_class (DECL_CONTEXT (fun
));
242 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
246 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
252 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
253 for a member of an anonymous aggregate, INIT is the initializer for that
254 member, and VEC_OUTER is the vector of constructor elements for the class
255 whose constructor we are processing. Add the initializer to the vector
256 and return true to indicate success. */
259 build_anon_member_initialization (tree member
, tree init
,
260 vec
<constructor_elt
, va_gc
> **vec_outer
)
262 /* MEMBER presents the relevant fields from the inside out, but we need
263 to build up the initializer from the outside in so that we can reuse
264 previously built CONSTRUCTORs if this is, say, the second field in an
265 anonymous struct. So we use a vec as a stack. */
266 auto_vec
<tree
, 2> fields
;
269 fields
.safe_push (TREE_OPERAND (member
, 1));
270 member
= TREE_OPERAND (member
, 0);
272 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
273 && TREE_CODE (member
) == COMPONENT_REF
);
275 /* VEC has the constructor elements vector for the context of FIELD.
276 If FIELD is an anonymous aggregate, we will push inside it. */
277 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
279 while (field
= fields
.pop(),
280 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
283 /* If there is already an outer constructor entry for the anonymous
284 aggregate FIELD, use it; otherwise, insert one. */
285 if (vec_safe_is_empty (*vec
)
286 || (*vec
)->last().index
!= field
)
288 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
289 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
292 ctor
= (*vec
)->last().value
;
293 vec
= &CONSTRUCTOR_ELTS (ctor
);
296 /* Now we're at the innermost field, the one that isn't an anonymous
297 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
298 gcc_assert (fields
.is_empty());
299 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
304 /* Subroutine of build_constexpr_constructor_member_initializers.
305 The expression tree T represents a data member initialization
306 in a (constexpr) constructor definition. Build a pairing of
307 the data member with its initializer, and prepend that pair
308 to the existing initialization pair INITS. */
311 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
314 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
315 t
= TREE_OPERAND (t
, 0);
316 if (TREE_CODE (t
) == EXPR_STMT
)
317 t
= TREE_OPERAND (t
, 0);
318 if (t
== error_mark_node
)
320 if (TREE_CODE (t
) == STATEMENT_LIST
)
322 tree_stmt_iterator i
;
323 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
325 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
330 if (TREE_CODE (t
) == CLEANUP_STMT
)
332 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
333 but we can in a constexpr constructor for a non-literal class. Just
334 ignore it; either all the initialization will be constant, in which
335 case the cleanup can't run, or it can't be constexpr.
336 Still recurse into CLEANUP_BODY. */
337 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
339 if (TREE_CODE (t
) == CONVERT_EXPR
)
340 t
= TREE_OPERAND (t
, 0);
341 if (TREE_CODE (t
) == INIT_EXPR
342 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
343 use what this function builds for cx_check_missing_mem_inits, and
344 assignment in the ctor body doesn't count. */
345 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
347 member
= TREE_OPERAND (t
, 0);
348 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
350 else if (TREE_CODE (t
) == CALL_EXPR
)
352 tree fn
= get_callee_fndecl (t
);
353 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
354 /* We're only interested in calls to subobject constructors. */
356 member
= CALL_EXPR_ARG (t
, 0);
357 /* We don't use build_cplus_new here because it complains about
358 abstract bases. Leaving the call unwrapped means that it has the
359 wrong type, but cxx_eval_constant_expression doesn't care. */
360 init
= break_out_target_exprs (t
);
362 else if (TREE_CODE (t
) == BIND_EXPR
)
363 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
365 /* Don't add anything else to the CONSTRUCTOR. */
367 if (INDIRECT_REF_P (member
))
368 member
= TREE_OPERAND (member
, 0);
369 if (TREE_CODE (member
) == NOP_EXPR
)
373 if (TREE_CODE (op
) == ADDR_EXPR
)
375 gcc_assert (same_type_ignoring_top_level_qualifiers_p
376 (TREE_TYPE (TREE_TYPE (op
)),
377 TREE_TYPE (TREE_TYPE (member
))));
378 /* Initializing a cv-qualified member; we need to look through
382 else if (op
== current_class_ptr
383 && (same_type_ignoring_top_level_qualifiers_p
384 (TREE_TYPE (TREE_TYPE (member
)),
385 current_class_type
)))
386 /* Delegating constructor. */
390 /* This is an initializer for an empty base; keep it for now so
391 we can check it in cxx_eval_bare_aggregate. */
392 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
395 if (TREE_CODE (member
) == ADDR_EXPR
)
396 member
= TREE_OPERAND (member
, 0);
397 if (TREE_CODE (member
) == COMPONENT_REF
)
399 tree aggr
= TREE_OPERAND (member
, 0);
400 if (TREE_CODE (aggr
) == VAR_DECL
)
401 /* Initializing a local variable, don't add anything. */
403 if (TREE_CODE (aggr
) != COMPONENT_REF
)
404 /* Normal member initialization. */
405 member
= TREE_OPERAND (member
, 1);
406 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
407 /* Initializing a member of an anonymous union. */
408 return build_anon_member_initialization (member
, init
, vec
);
410 /* We're initializing a vtable pointer in a base. Leave it as
411 COMPONENT_REF so we remember the path to get to the vfield. */
412 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
415 /* Value-initialization can produce multiple initializers for the
416 same field; use the last one. */
417 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
418 (*vec
)->last().value
= init
;
420 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
424 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
425 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
426 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
429 check_constexpr_bind_expr_vars (tree t
)
431 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
433 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
434 if (TREE_CODE (var
) == TYPE_DECL
435 && DECL_IMPLICIT_TYPEDEF_P (var
)
436 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
441 /* Subroutine of check_constexpr_ctor_body. */
444 check_constexpr_ctor_body_1 (tree last
, tree list
)
446 switch (TREE_CODE (list
))
449 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
450 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
454 case CLEANUP_POINT_EXPR
:
455 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
459 if (!check_constexpr_bind_expr_vars (list
)
460 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
467 case DEBUG_BEGIN_STMT
:
475 /* Make sure that there are no statements after LAST in the constructor
476 body represented by LIST. */
479 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
481 /* C++14 doesn't require a constexpr ctor to have an empty body. */
482 if (cxx_dialect
>= cxx14
)
486 if (TREE_CODE (list
) == STATEMENT_LIST
)
488 tree_stmt_iterator i
= tsi_last (list
);
489 for (; !tsi_end_p (i
); tsi_prev (&i
))
491 tree t
= tsi_stmt (i
);
494 if (!check_constexpr_ctor_body_1 (last
, t
))
501 else if (list
!= last
502 && !check_constexpr_ctor_body_1 (last
, list
))
507 error ("%<constexpr%> constructor does not have empty body");
508 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
513 /* V is a vector of constructor elements built up for the base and member
514 initializers of a constructor for TYPE. They need to be in increasing
515 offset order, which they might not be yet if TYPE has a primary base
516 which is not first in the base-clause or a vptr and at least one base
517 all of which are non-primary. */
519 static vec
<constructor_elt
, va_gc
> *
520 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
522 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
528 field_type
= BINFO_TYPE (pri
);
529 else if (TYPE_CONTAINS_VPTR_P (type
))
530 field_type
= vtbl_ptr_type_node
;
534 /* Find the element for the primary base or vptr and move it to the
535 beginning of the vec. */
536 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
537 if (TREE_TYPE (ce
->index
) == field_type
)
540 if (i
> 0 && i
< vec_safe_length (v
))
542 vec
<constructor_elt
, va_gc
> &vref
= *v
;
543 constructor_elt elt
= vref
[i
];
552 /* Build compile-time evalable representations of member-initializer list
553 for a constexpr constructor. */
556 build_constexpr_constructor_member_initializers (tree type
, tree body
)
558 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
561 switch (TREE_CODE (body
))
563 case MUST_NOT_THROW_EXPR
:
565 body
= TREE_OPERAND (body
, 0);
569 for (tree_stmt_iterator i
= tsi_start (body
);
570 !tsi_end_p (i
); tsi_next (&i
))
573 if (TREE_CODE (body
) == BIND_EXPR
)
579 body
= BIND_EXPR_BODY (body
);
586 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
588 body
= TREE_OPERAND (body
, 0);
589 if (TREE_CODE (body
) == EXPR_STMT
)
590 body
= TREE_OPERAND (body
, 0);
591 if (TREE_CODE (body
) == INIT_EXPR
592 && (same_type_ignoring_top_level_qualifiers_p
593 (TREE_TYPE (TREE_OPERAND (body
, 0)),
594 current_class_type
)))
597 return TREE_OPERAND (body
, 1);
599 ok
= build_data_member_initialization (body
, &vec
);
601 else if (TREE_CODE (body
) == STATEMENT_LIST
)
603 tree_stmt_iterator i
;
604 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
606 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
611 else if (TREE_CODE (body
) == TRY_BLOCK
)
613 error ("body of %<constexpr%> constructor cannot be "
614 "a function-try-block");
615 return error_mark_node
;
617 else if (EXPR_P (body
))
618 ok
= build_data_member_initialization (body
, &vec
);
620 gcc_assert (errorcount
> 0);
623 if (vec_safe_length (vec
) > 0)
625 /* In a delegating constructor, return the target. */
626 constructor_elt
*ce
= &(*vec
)[0];
627 if (ce
->index
== current_class_ptr
)
634 vec
= sort_constexpr_mem_initializers (type
, vec
);
635 return build_constructor (type
, vec
);
638 return error_mark_node
;
641 /* We have an expression tree T that represents a call, either CALL_EXPR
642 or AGGR_INIT_EXPR. If the call is lexically to a named function,
643 retrun the _DECL for that function. */
646 get_function_named_in_call (tree t
)
648 tree fun
= cp_get_callee (t
);
649 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
650 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
651 fun
= TREE_OPERAND (fun
, 0);
655 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
656 declared to be constexpr, or a sub-statement thereof. Returns the
657 return value if suitable, error_mark_node for a statement not allowed in
658 a constexpr function, or NULL_TREE if no return value was found. */
661 constexpr_fn_retval (tree body
)
663 switch (TREE_CODE (body
))
667 tree_stmt_iterator i
;
668 tree expr
= NULL_TREE
;
669 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
671 tree s
= constexpr_fn_retval (tsi_stmt (i
));
672 if (s
== error_mark_node
)
673 return error_mark_node
;
674 else if (s
== NULL_TREE
)
675 /* Keep iterating. */;
677 /* Multiple return statements. */
678 return error_mark_node
;
686 return break_out_target_exprs (TREE_OPERAND (body
, 0));
690 tree decl
= DECL_EXPR_DECL (body
);
691 if (TREE_CODE (decl
) == USING_DECL
692 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
693 || DECL_ARTIFICIAL (decl
))
695 return error_mark_node
;
698 case CLEANUP_POINT_EXPR
:
699 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
702 if (!check_constexpr_bind_expr_vars (body
))
703 return error_mark_node
;
704 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
707 case DEBUG_BEGIN_STMT
:
712 tree fun
= get_function_named_in_call (body
);
714 && DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
)
720 return error_mark_node
;
724 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
725 FUN; do the necessary transformations to turn it into a single expression
726 that we can store in the hash table. */
729 massage_constexpr_body (tree fun
, tree body
)
731 if (DECL_CONSTRUCTOR_P (fun
))
732 body
= build_constexpr_constructor_member_initializers
733 (DECL_CONTEXT (fun
), body
);
734 else if (cxx_dialect
< cxx14
)
736 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
737 body
= EH_SPEC_STMTS (body
);
738 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
739 body
= TREE_OPERAND (body
, 0);
740 body
= constexpr_fn_retval (body
);
745 /* CTYPE is a type constructed from BODY. Return true if some
746 bases/fields are uninitialized, and complain if COMPLAIN. */
749 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
755 if (TREE_CODE (body
) != CONSTRUCTOR
)
757 nelts
= CONSTRUCTOR_NELTS (body
);
759 tree field
= TYPE_FIELDS (ctype
);
761 if (TREE_CODE (ctype
) == UNION_TYPE
)
763 if (nelts
== 0 && next_initializable_field (field
))
766 error ("%<constexpr%> constructor for union %qT must "
767 "initialize exactly one non-static data member", ctype
);
773 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
774 need an explicit initialization. */
776 for (unsigned i
= 0; i
<= nelts
; ++i
)
778 tree index
= NULL_TREE
;
781 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
782 /* Skip base and vtable inits. */
783 if (TREE_CODE (index
) != FIELD_DECL
784 || DECL_ARTIFICIAL (index
))
788 for (; field
!= index
; field
= DECL_CHAIN (field
))
791 if (TREE_CODE (field
) != FIELD_DECL
)
793 if (DECL_UNNAMED_BIT_FIELD (field
))
795 if (DECL_ARTIFICIAL (field
))
797 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
799 /* Recurse to check the anonummous aggregate member. */
800 bad
|= cx_check_missing_mem_inits
801 (TREE_TYPE (field
), NULL_TREE
, complain
);
802 if (bad
&& !complain
)
806 ftype
= strip_array_types (TREE_TYPE (field
));
807 if (type_has_constexpr_default_constructor (ftype
))
809 /* It's OK to skip a member with a trivial constexpr ctor.
810 A constexpr ctor that isn't trivial should have been
812 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
818 error ("member %qD must be initialized by mem-initializer "
819 "in %<constexpr%> constructor", field
);
820 inform (DECL_SOURCE_LOCATION (field
), "declared here");
823 if (field
== NULL_TREE
)
826 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
828 /* Check the anonymous aggregate initializer is valid. */
829 bad
|= cx_check_missing_mem_inits
830 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
831 if (bad
&& !complain
)
834 field
= DECL_CHAIN (field
);
840 /* We are processing the definition of the constexpr function FUN.
841 Check that its BODY fulfills the propriate requirements and
842 enter it in the constexpr function definition table.
843 For constructor BODY is actually the TREE_LIST of the
844 member-initializer list. */
847 register_constexpr_fundef (tree fun
, tree body
)
849 constexpr_fundef entry
;
850 constexpr_fundef
**slot
;
852 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
855 tree massaged
= massage_constexpr_body (fun
, body
);
856 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
858 if (!DECL_CONSTRUCTOR_P (fun
))
859 error ("body of %<constexpr%> function %qD not a return-statement",
864 if (!potential_rvalue_constant_expression (massaged
))
866 if (!DECL_GENERATED_P (fun
))
867 require_potential_rvalue_constant_expression (massaged
);
871 if (DECL_CONSTRUCTOR_P (fun
)
872 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
873 massaged
, !DECL_GENERATED_P (fun
)))
876 /* Create the constexpr function table if necessary. */
877 if (constexpr_fundef_table
== NULL
)
878 constexpr_fundef_table
879 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
883 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
885 gcc_assert (*slot
== NULL
);
886 *slot
= ggc_alloc
<constexpr_fundef
> ();
892 /* FUN is a non-constexpr function called in a context that requires a
893 constant expression. If it comes from a constexpr template, explain why
894 the instantiation isn't constexpr. */
897 explain_invalid_constexpr_fn (tree fun
)
899 static hash_set
<tree
> *diagnosed
;
902 /* Only diagnose defaulted functions, lambdas, or instantiations. */
903 if (!DECL_DEFAULTED_FN (fun
)
904 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
905 && !is_instantiation_of_constexpr (fun
))
907 if (diagnosed
== NULL
)
908 diagnosed
= new hash_set
<tree
>;
909 if (diagnosed
->add (fun
))
910 /* Already explained. */
913 save_loc
= input_location
;
914 if (!lambda_static_thunk_p (fun
))
916 /* Diagnostics should completely ignore the static thunk, so leave
917 input_location set to our caller's location. */
918 input_location
= DECL_SOURCE_LOCATION (fun
);
919 inform (input_location
,
920 "%qD is not usable as a %<constexpr%> function because:", fun
);
922 /* First check the declaration. */
923 if (is_valid_constexpr_fn (fun
, true))
925 /* Then if it's OK, the body. */
926 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
927 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
928 explain_implicit_non_constexpr (fun
);
931 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
932 require_potential_rvalue_constant_expression (body
);
933 if (DECL_CONSTRUCTOR_P (fun
))
934 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
937 input_location
= save_loc
;
940 /* Objects of this type represent calls to constexpr functions
941 along with the bindings of parameters to their arguments, for
942 the purpose of compile time evaluation. */
944 struct GTY((for_user
)) constexpr_call
{
945 /* Description of the constexpr function definition. */
946 constexpr_fundef
*fundef
;
947 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
948 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
949 Note: This arrangement is made to accommodate the use of
950 iterative_hash_template_arg (see pt.c). If you change this
951 representation, also change the hash calculation in
952 cxx_eval_call_expression. */
954 /* Result of the call.
955 NULL means the call is being evaluated.
956 error_mark_node means that the evaluation was erroneous;
957 otherwise, the actuall value of the call. */
959 /* The hash of this call; we remember it here to avoid having to
960 recalculate it when expanding the hash table. */
964 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
966 static hashval_t
hash (constexpr_call
*);
967 static bool equal (constexpr_call
*, constexpr_call
*);
970 enum constexpr_switch_state
{
971 /* Used when processing a switch for the first time by cxx_eval_switch_expr
972 and default: label for that switch has not been seen yet. */
973 css_default_not_seen
,
974 /* Used when processing a switch for the first time by cxx_eval_switch_expr
975 and default: label for that switch has been seen already. */
977 /* Used when processing a switch for the second time by
978 cxx_eval_switch_expr, where default: label should match. */
979 css_default_processing
982 /* The constexpr expansion context. CALL is the current function
983 expansion, CTOR is the current aggregate initializer, OBJECT is the
984 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
985 is a map of values of variables initialized within the expression. */
987 struct constexpr_ctx
{
988 /* The innermost call we're evaluating. */
989 constexpr_call
*call
;
990 /* Values for any temporaries or local variables within the
991 constant-expression. */
992 hash_map
<tree
,tree
> *values
;
993 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
994 aren't inside a loop. */
995 hash_set
<tree
> *save_exprs
;
996 /* The CONSTRUCTOR we're currently building up for an aggregate
999 /* The object we're building the CONSTRUCTOR for. */
1001 /* If inside SWITCH_EXPR. */
1002 constexpr_switch_state
*css_state
;
1003 /* Whether we should error on a non-constant expression or fail quietly. */
1005 /* Whether we are strictly conforming to constant expression rules or
1006 trying harder to get a constant value. */
1010 /* A table of all constexpr calls that have been evaluated by the
1011 compiler in this translation unit. */
1013 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1015 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1016 bool, bool *, bool *, tree
* = NULL
);
1018 /* Compute a hash value for a constexpr call representation. */
1021 constexpr_call_hasher::hash (constexpr_call
*info
)
1026 /* Return true if the objects pointed to by P and Q represent calls
1027 to the same constexpr function with the same arguments.
1028 Otherwise, return false. */
1031 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1037 if (lhs
->hash
!= rhs
->hash
)
1039 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1041 lhs_bindings
= lhs
->bindings
;
1042 rhs_bindings
= rhs
->bindings
;
1043 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1045 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1046 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1047 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1048 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1050 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1051 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1053 return lhs_bindings
== rhs_bindings
;
1056 /* Initialize the constexpr call table, if needed. */
1059 maybe_initialize_constexpr_call_table (void)
1061 if (constexpr_call_table
== NULL
)
1062 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1065 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1066 a function happens to get called recursively, we unshare the callee
1067 function's body and evaluate this unshared copy instead of evaluating the
1070 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1071 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1072 that's keyed off of the original FUNCTION_DECL and whose value is a
1073 TREE_LIST of this function's unused copies awaiting reuse.
1075 This is not GC-deletable to avoid GC affecting UID generation. */
1077 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1079 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1082 maybe_initialize_fundef_copies_table ()
1084 if (fundef_copies_table
== NULL
)
1085 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1088 /* Reuse a copy or create a new unshared copy of the function FUN.
1089 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1090 is parms, TYPE is result. */
1093 get_fundef_copy (tree fun
)
1095 maybe_initialize_fundef_copies_table ();
1099 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1103 /* There is no cached function available, or in use. We can use
1104 the function directly. That the slot is now created records
1105 that this function is now in use. */
1106 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1107 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1109 else if (*slot
== NULL_TREE
)
1111 /* We've already used the function itself, so make a copy. */
1112 copy
= build_tree_list (NULL
, NULL
);
1113 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1117 /* We have a cached function available. */
1119 *slot
= TREE_CHAIN (copy
);
1125 /* Save the copy COPY of function FUN for later reuse by
1126 get_fundef_copy(). By construction, there will always be an entry
1130 save_fundef_copy (tree fun
, tree copy
)
1132 tree
*slot
= fundef_copies_table
->get (fun
);
1133 TREE_CHAIN (copy
) = *slot
;
1137 /* We have an expression tree T that represents a call, either CALL_EXPR
1138 or AGGR_INIT_EXPR. Return the Nth argument. */
1141 get_nth_callarg (tree t
, int n
)
1143 switch (TREE_CODE (t
))
1146 return CALL_EXPR_ARG (t
, n
);
1148 case AGGR_INIT_EXPR
:
1149 return AGGR_INIT_EXPR_ARG (t
, n
);
1157 /* Attempt to evaluate T which represents a call to a builtin function.
1158 We assume here that all builtin functions evaluate to scalar types
1159 represented by _CST nodes. */
1162 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1164 bool *non_constant_p
, bool *overflow_p
)
1166 const int nargs
= call_expr_nargs (t
);
1167 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1171 /* Don't fold __builtin_constant_p within a constexpr function. */
1172 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1174 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1175 in a constexpr function until we have values for the parameters. */
1178 && current_function_decl
1179 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1181 *non_constant_p
= true;
1185 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1186 return constant false for a non-constant argument. */
1187 constexpr_ctx new_ctx
= *ctx
;
1188 new_ctx
.quiet
= true;
1189 bool dummy1
= false, dummy2
= false;
1190 for (i
= 0; i
< nargs
; ++i
)
1192 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1193 false, &dummy1
, &dummy2
);
1195 /* For __built_in_constant_p, fold all expressions with constant values
1196 even if they aren't C++ constant-expressions. */
1197 args
[i
] = cp_fully_fold (args
[i
]);
1200 bool save_ffbcp
= force_folding_builtin_constant_p
;
1201 force_folding_builtin_constant_p
= true;
1202 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1203 CALL_EXPR_FN (t
), nargs
, args
);
1204 force_folding_builtin_constant_p
= save_ffbcp
;
1205 if (new_call
== NULL
)
1207 if (!*non_constant_p
&& !ctx
->quiet
)
1209 /* Do not allow__builtin_unreachable in constexpr function.
1210 The __builtin_unreachable call with BUILTINS_LOCATION
1211 comes from cp_maybe_instrument_return. */
1212 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
1213 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1214 error ("%<constexpr%> call flows off the end of the function");
1217 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1218 CALL_EXPR_FN (t
), nargs
, args
);
1219 error ("%q+E is not a constant expression", new_call
);
1222 *non_constant_p
= true;
1226 if (!is_constant_expression (new_call
))
1228 if (!*non_constant_p
&& !ctx
->quiet
)
1229 error ("%q+E is not a constant expression", new_call
);
1230 *non_constant_p
= true;
1234 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1235 non_constant_p
, overflow_p
);
1238 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1239 the type of the value to match. */
1242 adjust_temp_type (tree type
, tree temp
)
1244 if (TREE_TYPE (temp
) == type
)
1246 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1247 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1248 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1249 gcc_assert (scalarish_type_p (type
));
1250 return cp_fold_convert (type
, temp
);
1253 /* Callback for walk_tree used by unshare_constructor. */
1256 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1260 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1265 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1266 subexpression, return an unshared copy of T. Otherwise return T. */
1269 unshare_constructor (tree t
)
1271 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1272 if (ctor
!= NULL_TREE
)
1273 return unshare_expr (t
);
1277 /* Subroutine of cxx_eval_call_expression.
1278 We are processing a call expression (either CALL_EXPR or
1279 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1280 all arguments and bind their values to correspondings
1281 parameters, making up the NEW_CALL context. */
1284 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1285 constexpr_call
*new_call
,
1286 bool *non_constant_p
, bool *overflow_p
,
1287 bool *non_constant_args
)
1289 const int nargs
= call_expr_nargs (t
);
1290 tree fun
= new_call
->fundef
->decl
;
1291 tree parms
= DECL_ARGUMENTS (fun
);
1293 tree
*p
= &new_call
->bindings
;
1294 for (i
= 0; i
< nargs
; ++i
)
1297 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1298 x
= get_nth_callarg (t
, i
);
1299 /* For member function, the first argument is a pointer to the implied
1300 object. For a constructor, it might still be a dummy object, in
1301 which case we get the real argument from ctx. */
1302 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1303 && is_dummy_object (x
))
1306 x
= build_address (x
);
1308 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1309 non_constant_p
, overflow_p
);
1310 /* Don't VERIFY_CONSTANT here. */
1311 if (*non_constant_p
&& ctx
->quiet
)
1313 /* Just discard ellipsis args after checking their constantitude. */
1317 if (!*non_constant_p
)
1319 /* Don't share a CONSTRUCTOR that might be changed. */
1320 arg
= unshare_constructor (arg
);
1321 /* Make sure the binding has the same type as the parm. But
1322 only for constant args. */
1323 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1324 arg
= adjust_temp_type (type
, arg
);
1325 if (!TREE_CONSTANT (arg
))
1326 *non_constant_args
= true;
1327 *p
= build_tree_list (parms
, arg
);
1328 p
= &TREE_CHAIN (*p
);
1330 parms
= TREE_CHAIN (parms
);
1334 /* Variables and functions to manage constexpr call expansion context.
1335 These do not need to be marked for PCH or GC. */
1337 /* FIXME remember and print actual constant arguments. */
1338 static vec
<tree
> call_stack
;
1339 static int call_stack_tick
;
1340 static int last_cx_error_tick
;
1343 push_cx_call_context (tree call
)
1346 if (!EXPR_HAS_LOCATION (call
))
1347 SET_EXPR_LOCATION (call
, input_location
);
1348 call_stack
.safe_push (call
);
1349 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1355 pop_cx_call_context (void)
1362 cx_error_context (void)
1364 vec
<tree
> r
= vNULL
;
1365 if (call_stack_tick
!= last_cx_error_tick
1366 && !call_stack
.is_empty ())
1368 last_cx_error_tick
= call_stack_tick
;
1372 /* Evaluate a call T to a GCC internal function when possible and return
1373 the evaluated result or, under the control of CTX, give an error, set
1374 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1377 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1379 bool *non_constant_p
, bool *overflow_p
)
1381 enum tree_code opcode
= ERROR_MARK
;
1383 switch (CALL_EXPR_IFN (t
))
1385 case IFN_UBSAN_NULL
:
1386 case IFN_UBSAN_BOUNDS
:
1387 case IFN_UBSAN_VPTR
:
1388 case IFN_FALLTHROUGH
:
1391 case IFN_ADD_OVERFLOW
:
1394 case IFN_SUB_OVERFLOW
:
1395 opcode
= MINUS_EXPR
;
1397 case IFN_MUL_OVERFLOW
:
1402 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1403 false, non_constant_p
, overflow_p
);
1407 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1408 "call to internal function %qE", t
);
1409 *non_constant_p
= true;
1413 /* Evaluate constant arguments using OPCODE and return a complex
1414 number containing the result and the overflow bit. */
1415 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1416 non_constant_p
, overflow_p
);
1417 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1418 non_constant_p
, overflow_p
);
1420 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1422 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1423 tree type
= TREE_TYPE (TREE_TYPE (t
));
1424 tree result
= fold_binary_loc (loc
, opcode
, type
,
1425 fold_convert_loc (loc
, type
, arg0
),
1426 fold_convert_loc (loc
, type
, arg1
));
1428 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1429 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1430 if (TREE_OVERFLOW (result
))
1431 TREE_OVERFLOW (result
) = 0;
1433 return build_complex (TREE_TYPE (t
), result
, ovf
);
1436 *non_constant_p
= true;
1440 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1443 clear_no_implicit_zero (tree ctor
)
1445 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1447 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1448 tree elt
; unsigned HOST_WIDE_INT idx
;
1449 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1450 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1451 clear_no_implicit_zero (elt
);
1455 /* Subroutine of cxx_eval_constant_expression.
1456 Evaluate the call expression tree T in the context of OLD_CALL expression
1460 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1462 bool *non_constant_p
, bool *overflow_p
)
1464 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1465 tree fun
= get_function_named_in_call (t
);
1466 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1469 if (fun
== NULL_TREE
)
1470 return cxx_eval_internal_function (ctx
, t
, lval
,
1471 non_constant_p
, overflow_p
);
1473 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1475 /* Might be a constexpr function pointer. */
1476 fun
= cxx_eval_constant_expression (ctx
, fun
,
1477 /*lval*/false, non_constant_p
,
1480 if (TREE_CODE (fun
) == ADDR_EXPR
)
1481 fun
= TREE_OPERAND (fun
, 0);
1483 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1485 if (!ctx
->quiet
&& !*non_constant_p
)
1486 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1488 *non_constant_p
= true;
1491 if (DECL_CLONED_FUNCTION_P (fun
))
1492 fun
= DECL_CLONED_FUNCTION (fun
);
1494 if (is_ubsan_builtin_p (fun
))
1497 if (is_builtin_fn (fun
))
1498 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1499 lval
, non_constant_p
, overflow_p
);
1500 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1504 if (!lambda_static_thunk_p (fun
))
1505 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1506 explain_invalid_constexpr_fn (fun
);
1508 *non_constant_p
= true;
1512 constexpr_ctx new_ctx
= *ctx
;
1513 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1514 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1516 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1517 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1518 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1519 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1520 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1521 ctx
->values
->put (new_ctx
.object
, ctor
);
1525 /* Shortcut trivial constructor/op=. */
1526 if (trivial_fn_p (fun
))
1528 tree init
= NULL_TREE
;
1529 if (call_expr_nargs (t
) == 2)
1530 init
= convert_from_reference (get_nth_callarg (t
, 1));
1531 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1532 && AGGR_INIT_ZERO_FIRST (t
))
1533 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1536 tree op
= get_nth_callarg (t
, 0);
1537 if (is_dummy_object (op
))
1540 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1541 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1542 new_ctx
.call
= &new_call
;
1543 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1544 non_constant_p
, overflow_p
);
1548 /* We can't defer instantiating the function any longer. */
1549 if (!DECL_INITIAL (fun
)
1550 && DECL_TEMPLOID_INSTANTIATION (fun
))
1552 location_t save_loc
= input_location
;
1553 input_location
= loc
;
1555 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1557 input_location
= save_loc
;
1560 /* If in direct recursive call, optimize definition search. */
1561 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1562 new_call
.fundef
= ctx
->call
->fundef
;
1565 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1566 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1567 || fun
== current_function_decl
)
1571 /* We need to check for current_function_decl here in case we're
1572 being called during cp_fold_function, because at that point
1573 DECL_INITIAL is set properly and we have a fundef but we
1574 haven't lowered invisirefs yet (c++/70344). */
1575 if (DECL_INITIAL (fun
) == error_mark_node
1576 || fun
== current_function_decl
)
1577 error_at (loc
, "%qD called in a constant expression before its "
1578 "definition is complete", fun
);
1579 else if (DECL_INITIAL (fun
))
1581 /* The definition of fun was somehow unsuitable. But pretend
1582 that lambda static thunks don't exist. */
1583 if (!lambda_static_thunk_p (fun
))
1584 error_at (loc
, "%qD called in a constant expression", fun
);
1585 explain_invalid_constexpr_fn (fun
);
1588 error_at (loc
, "%qD used before its definition", fun
);
1590 *non_constant_p
= true;
1595 bool non_constant_args
= false;
1596 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1597 non_constant_p
, overflow_p
, &non_constant_args
);
1598 if (*non_constant_p
)
1601 depth_ok
= push_cx_call_context (t
);
1603 tree result
= NULL_TREE
;
1605 constexpr_call
*entry
= NULL
;
1606 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1608 new_call
.hash
= iterative_hash_template_arg
1609 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1611 /* If we have seen this call before, we are done. */
1612 maybe_initialize_constexpr_call_table ();
1613 constexpr_call
**slot
1614 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1618 /* We need to keep a pointer to the entry, not just the slot, as the
1619 slot can move in the call to cxx_eval_builtin_function_call. */
1620 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1623 /* Calls that are in progress have their result set to NULL,
1624 so that we can detect circular dependencies. */
1625 else if (entry
->result
== NULL
)
1628 error ("call has circular dependency");
1629 *non_constant_p
= true;
1630 entry
->result
= result
= error_mark_node
;
1633 result
= entry
->result
;
1639 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1640 "-fconstexpr-depth= to increase the maximum)",
1641 max_constexpr_depth
);
1642 *non_constant_p
= true;
1643 result
= error_mark_node
;
1647 if (result
&& result
!= error_mark_node
)
1649 else if (!DECL_SAVED_TREE (fun
))
1651 /* When at_eof >= 2, cgraph has started throwing away
1652 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1653 late code generation for VEC_INIT_EXPR, which needs to be
1654 completely reconsidered. */
1655 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1656 *non_constant_p
= true;
1660 tree body
, parms
, res
;
1662 /* Reuse or create a new unshared copy of this function's body. */
1663 tree copy
= get_fundef_copy (fun
);
1664 body
= TREE_PURPOSE (copy
);
1665 parms
= TREE_VALUE (copy
);
1666 res
= TREE_TYPE (copy
);
1668 /* Associate the bindings with the remapped parms. */
1669 tree bound
= new_call
.bindings
;
1670 tree remapped
= parms
;
1673 tree oparm
= TREE_PURPOSE (bound
);
1674 tree arg
= TREE_VALUE (bound
);
1675 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1676 /* Don't share a CONSTRUCTOR that might be changed. */
1677 arg
= unshare_constructor (arg
);
1678 ctx
->values
->put (remapped
, arg
);
1679 bound
= TREE_CHAIN (bound
);
1680 remapped
= DECL_CHAIN (remapped
);
1682 /* Add the RESULT_DECL to the values map, too. */
1683 tree slot
= NULL_TREE
;
1684 if (DECL_BY_REFERENCE (res
))
1686 slot
= AGGR_INIT_EXPR_SLOT (t
);
1687 tree addr
= build_address (slot
);
1688 addr
= build_nop (TREE_TYPE (res
), addr
);
1689 ctx
->values
->put (res
, addr
);
1690 ctx
->values
->put (slot
, NULL_TREE
);
1693 ctx
->values
->put (res
, NULL_TREE
);
1695 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1696 their values after the call. */
1697 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1698 hash_set
<tree
> save_exprs
;
1699 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1700 ctx_with_save_exprs
.call
= &new_call
;
1702 tree jump_target
= NULL_TREE
;
1703 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1704 lval
, non_constant_p
, overflow_p
,
1707 if (DECL_CONSTRUCTOR_P (fun
))
1708 /* This can be null for a subobject constructor call, in
1709 which case what we care about is the initialization
1710 side-effects rather than the value. We could get at the
1711 value by evaluating *this, but we don't bother; there's
1712 no need to put such a call in the hash table. */
1713 result
= lval
? ctx
->object
: ctx
->ctor
;
1714 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1718 result
= *ctx
->values
->get (slot
? slot
: res
);
1719 if (result
== NULL_TREE
&& !*non_constant_p
)
1722 error ("%<constexpr%> call flows off the end "
1724 *non_constant_p
= true;
1728 /* Forget the saved values of the callee's SAVE_EXPRs. */
1729 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1730 iter
!= save_exprs
.end(); ++iter
)
1731 ctx_with_save_exprs
.values
->remove (*iter
);
1733 /* Remove the parms/result from the values map. Is it worth
1734 bothering to do this when the map itself is only live for
1735 one constexpr evaluation? If so, maybe also clear out
1736 other vars from call, maybe in BIND_EXPR handling? */
1737 ctx
->values
->remove (res
);
1739 ctx
->values
->remove (slot
);
1740 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1741 ctx
->values
->remove (parm
);
1743 /* Make the unshared function copy we used available for re-use. */
1744 save_fundef_copy (fun
, copy
);
1747 if (result
== error_mark_node
)
1748 *non_constant_p
= true;
1749 if (*non_constant_p
|| *overflow_p
)
1750 result
= error_mark_node
;
1754 entry
->result
= result
;
1757 /* The result of a constexpr function must be completely initialized. */
1758 if (TREE_CODE (result
) == CONSTRUCTOR
)
1759 clear_no_implicit_zero (result
);
1761 pop_cx_call_context ();
1762 return unshare_constructor (result
);
1765 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1768 reduced_constant_expression_p (tree t
)
1770 switch (TREE_CODE (t
))
1773 /* Even if we can't lower this yet, it's constant. */
1777 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1778 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1779 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1781 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1782 /* An initialized vector would have a VECTOR_CST. */
1785 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1789 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1792 /* We're in the middle of initializing this element. */
1794 if (!reduced_constant_expression_p (val
))
1800 field
= next_initializable_field (DECL_CHAIN (field
));
1805 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1806 /* All the fields are initialized. */
1807 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1811 /* FIXME are we calling this too much? */
1812 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1816 /* Some expressions may have constant operands but are not constant
1817 themselves, such as 1/0. Call this function (or rather, the macro
1818 following it) to check for that condition.
1820 We only call this in places that require an arithmetic constant, not in
1821 places where we might have a non-constant expression that can be a
1822 component of a constant expression, such as the address of a constexpr
1823 variable that might be dereferenced later. */
1826 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1829 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1831 if (!allow_non_constant
)
1832 error ("%q+E is not a constant expression", t
);
1833 *non_constant_p
= true;
1835 if (TREE_OVERFLOW_P (t
))
1837 if (!allow_non_constant
)
1839 permerror (input_location
, "overflow in constant expression");
1840 /* If we're being permissive (and are in an enforcing
1841 context), ignore the overflow. */
1842 if (flag_permissive
)
1843 return *non_constant_p
;
1847 return *non_constant_p
;
1850 /* Check whether the shift operation with code CODE and type TYPE on LHS
1851 and RHS is undefined. If it is, give an error with an explanation,
1852 and return true; return false otherwise. */
1855 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1856 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1858 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1859 || TREE_CODE (lhs
) != INTEGER_CST
1860 || TREE_CODE (rhs
) != INTEGER_CST
)
1863 tree lhstype
= TREE_TYPE (lhs
);
1864 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1866 /* [expr.shift] The behavior is undefined if the right operand
1867 is negative, or greater than or equal to the length in bits
1868 of the promoted left operand. */
1869 if (tree_int_cst_sgn (rhs
) == -1)
1872 permerror (loc
, "right operand of shift expression %q+E is negative",
1873 build2_loc (loc
, code
, type
, lhs
, rhs
));
1874 return (!flag_permissive
|| ctx
->quiet
);
1876 if (compare_tree_int (rhs
, uprec
) >= 0)
1879 permerror (loc
, "right operand of shift expression %q+E is >= than "
1880 "the precision of the left operand",
1881 build2_loc (loc
, code
, type
, lhs
, rhs
));
1882 return (!flag_permissive
|| ctx
->quiet
);
1885 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1886 if E1 has a signed type and non-negative value, and E1x2^E2 is
1887 representable in the corresponding unsigned type of the result type,
1888 then that value, converted to the result type, is the resulting value;
1889 otherwise, the behavior is undefined. */
1890 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1891 && (cxx_dialect
>= cxx11
))
1893 if (tree_int_cst_sgn (lhs
) == -1)
1897 "left operand of shift expression %q+E is negative",
1898 build2_loc (loc
, code
, type
, lhs
, rhs
));
1899 return (!flag_permissive
|| ctx
->quiet
);
1901 /* For signed x << y the following:
1902 (unsigned) x >> ((prec (lhs) - 1) - y)
1903 if > 1, is undefined. The right-hand side of this formula
1904 is the highest bit of the LHS that can be set (starting from 0),
1905 so that the shift doesn't overflow. We then right-shift the LHS
1906 to see whether any other bit is set making the original shift
1907 undefined -- the result is not representable in the corresponding
1909 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1910 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1911 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1912 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1913 if (tree_int_cst_lt (integer_one_node
, t
))
1916 permerror (loc
, "shift expression %q+E overflows",
1917 build2_loc (loc
, code
, type
, lhs
, rhs
));
1918 return (!flag_permissive
|| ctx
->quiet
);
1924 /* Subroutine of cxx_eval_constant_expression.
1925 Attempt to reduce the unary expression tree T to a compile time value.
1926 If successful, return the value. Otherwise issue a diagnostic
1927 and return error_mark_node. */
1930 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1932 bool *non_constant_p
, bool *overflow_p
)
1935 tree orig_arg
= TREE_OPERAND (t
, 0);
1936 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1937 non_constant_p
, overflow_p
);
1938 VERIFY_CONSTANT (arg
);
1939 location_t loc
= EXPR_LOCATION (t
);
1940 enum tree_code code
= TREE_CODE (t
);
1941 tree type
= TREE_TYPE (t
);
1942 r
= fold_unary_loc (loc
, code
, type
, arg
);
1945 if (arg
== orig_arg
)
1948 r
= build1_loc (loc
, code
, type
, arg
);
1950 VERIFY_CONSTANT (r
);
1954 /* Helper function for cxx_eval_binary_expression. Try to optimize
1955 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1956 generic folding should be used. */
1959 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1960 tree lhs
, tree rhs
, bool *non_constant_p
,
1964 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1967 lhs
= TREE_OPERAND (lhs
, 0);
1969 /* &A[i] p+ j => &A[i + j] */
1970 if (TREE_CODE (lhs
) == ARRAY_REF
1971 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1972 && TREE_CODE (rhs
) == INTEGER_CST
1973 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1974 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1976 tree orig_type
= TREE_TYPE (t
);
1977 location_t loc
= EXPR_LOCATION (t
);
1978 tree type
= TREE_TYPE (lhs
);
1980 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1981 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1982 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1984 if (*non_constant_p
)
1986 /* Don't fold an out-of-bound access. */
1987 if (!tree_int_cst_le (t
, nelts
))
1989 rhs
= cp_fold_convert (ssizetype
, rhs
);
1990 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1991 constexpr int A[1]; ... (char *)&A[0] + 1 */
1992 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1993 rhs
, TYPE_SIZE_UNIT (type
))))
1995 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1997 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1998 TYPE_SIZE_UNIT (type
));
1999 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
2000 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
2001 t
, NULL_TREE
, NULL_TREE
);
2002 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2003 t
= cp_fold_convert (orig_type
, t
);
2004 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2005 non_constant_p
, overflow_p
);
2011 /* Subroutine of cxx_eval_constant_expression.
2012 Like cxx_eval_unary_expression, except for binary expressions. */
2015 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2017 bool *non_constant_p
, bool *overflow_p
)
2020 tree orig_lhs
= TREE_OPERAND (t
, 0);
2021 tree orig_rhs
= TREE_OPERAND (t
, 1);
2023 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2024 non_constant_p
, overflow_p
);
2025 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2027 if (*non_constant_p
)
2029 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2030 non_constant_p
, overflow_p
);
2031 if (*non_constant_p
)
2034 location_t loc
= EXPR_LOCATION (t
);
2035 enum tree_code code
= TREE_CODE (t
);
2036 tree type
= TREE_TYPE (t
);
2038 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2040 bool is_code_eq
= (code
== EQ_EXPR
);
2042 if (TREE_CODE (lhs
) == PTRMEM_CST
2043 && TREE_CODE (rhs
) == PTRMEM_CST
)
2044 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2046 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2047 || TREE_CODE (rhs
) == PTRMEM_CST
)
2048 && (null_member_pointer_value_p (lhs
)
2049 || null_member_pointer_value_p (rhs
)))
2050 r
= constant_boolean_node (!is_code_eq
, type
);
2051 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2052 lhs
= cplus_expand_constant (lhs
);
2053 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2054 rhs
= cplus_expand_constant (rhs
);
2056 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2057 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2060 error ("arithmetic involving a null pointer in %qE", lhs
);
2063 else if (code
== POINTER_PLUS_EXPR
)
2064 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2068 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2072 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2075 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2077 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2078 *non_constant_p
= true;
2079 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2080 a local array in a constexpr function. */
2081 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2083 VERIFY_CONSTANT (r
);
2087 /* Subroutine of cxx_eval_constant_expression.
2088 Attempt to evaluate condition expressions. Dead branches are not
2092 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2094 bool *non_constant_p
, bool *overflow_p
,
2097 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2099 non_constant_p
, overflow_p
);
2100 VERIFY_CONSTANT (val
);
2101 /* Don't VERIFY_CONSTANT the other operands. */
2102 if (integer_zerop (val
))
2103 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2105 non_constant_p
, overflow_p
,
2107 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2109 non_constant_p
, overflow_p
,
2113 /* Subroutine of cxx_eval_constant_expression.
2114 Attempt to evaluate vector condition expressions. Unlike
2115 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2116 ternary arithmetics operation, where all 3 arguments have to be
2117 evaluated as constants and then folding computes the result from
2121 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2122 bool *non_constant_p
, bool *overflow_p
)
2124 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2126 non_constant_p
, overflow_p
);
2127 VERIFY_CONSTANT (arg1
);
2128 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2130 non_constant_p
, overflow_p
);
2131 VERIFY_CONSTANT (arg2
);
2132 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2134 non_constant_p
, overflow_p
);
2135 VERIFY_CONSTANT (arg3
);
2136 location_t loc
= EXPR_LOCATION (t
);
2137 tree type
= TREE_TYPE (t
);
2138 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2141 if (arg1
== TREE_OPERAND (t
, 0)
2142 && arg2
== TREE_OPERAND (t
, 1)
2143 && arg3
== TREE_OPERAND (t
, 2))
2146 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2148 VERIFY_CONSTANT (r
);
2152 /* Returns less than, equal to, or greater than zero if KEY is found to be
2153 less than, to match, or to be greater than the constructor_elt's INDEX. */
2156 array_index_cmp (tree key
, tree index
)
2158 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2160 switch (TREE_CODE (index
))
2163 return tree_int_cst_compare (key
, index
);
2166 tree lo
= TREE_OPERAND (index
, 0);
2167 tree hi
= TREE_OPERAND (index
, 1);
2168 if (tree_int_cst_lt (key
, lo
))
2170 else if (tree_int_cst_lt (hi
, key
))
2180 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2181 if none. If INSERT is true, insert a matching element rather than fail. */
2183 static HOST_WIDE_INT
2184 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2186 if (tree_int_cst_sgn (dindex
) < 0)
2189 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2190 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2191 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2193 unsigned HOST_WIDE_INT end
= len
;
2194 unsigned HOST_WIDE_INT begin
= 0;
2196 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2197 that the same is true of the other elements and index directly. */
2200 tree cindex
= (*elts
)[end
- 1].index
;
2201 if (TREE_CODE (cindex
) == INTEGER_CST
2202 && compare_tree_int (cindex
, end
- 1) == 0)
2211 /* Otherwise, find a matching index by means of a binary search. */
2212 while (begin
!= end
)
2214 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2215 constructor_elt
&elt
= (*elts
)[middle
];
2216 tree idx
= elt
.index
;
2218 int cmp
= array_index_cmp (dindex
, idx
);
2225 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2227 /* We need to split the range. */
2229 tree lo
= TREE_OPERAND (idx
, 0);
2230 tree hi
= TREE_OPERAND (idx
, 1);
2231 tree value
= elt
.value
;
2232 dindex
= fold_convert (sizetype
, dindex
);
2233 if (tree_int_cst_lt (lo
, dindex
))
2235 /* There are still some lower elts; shorten the range. */
2236 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2238 if (tree_int_cst_equal (lo
, new_hi
))
2239 /* Only one element left, no longer a range. */
2242 TREE_OPERAND (idx
, 1) = new_hi
;
2243 /* Append the element we want to insert. */
2246 e
.value
= unshare_constructor (value
);
2247 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2250 /* No lower elts, the range elt is now ours. */
2253 if (tree_int_cst_lt (dindex
, hi
))
2255 /* There are still some higher elts; append a range. */
2256 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2258 if (tree_int_cst_equal (new_lo
, hi
))
2261 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2262 e
.value
= unshare_constructor (value
);
2263 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2272 constructor_elt e
= { dindex
, NULL_TREE
};
2273 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2280 /* Under the control of CTX, issue a detailed diagnostic for
2281 an out-of-bounds subscript INDEX into the expression ARRAY. */
2284 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2288 tree arraytype
= TREE_TYPE (array
);
2290 /* Convert the unsigned array subscript to a signed integer to avoid
2291 printing huge numbers for small negative values. */
2292 tree sidx
= fold_convert (ssizetype
, index
);
2295 if (TYPE_DOMAIN (arraytype
))
2296 error ("array subscript value %qE is outside the bounds "
2297 "of array %qD of type %qT", sidx
, array
, arraytype
);
2299 error ("non-zero array subscript %qE is used with array %qD of "
2300 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2301 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2303 else if (TYPE_DOMAIN (arraytype
))
2304 error ("array subscript value %qE is outside the bounds "
2305 "of array type %qT", sidx
, arraytype
);
2307 error ("non-zero array subscript %qE is used with array of type %qT "
2308 "with unknown bounds", sidx
, arraytype
);
2312 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2316 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2317 bool *non_constant_p
, bool *overflow_p
)
2320 if (TREE_CODE (type
) == ARRAY_TYPE
)
2322 if (TYPE_DOMAIN (type
))
2323 nelts
= array_type_nelts_top (type
);
2325 nelts
= size_zero_node
;
2327 else if (VECTOR_TYPE_P (type
))
2328 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2332 /* For VLAs, the number of elements won't be an integer constant. */
2333 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2334 non_constant_p
, overflow_p
);
2338 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2339 STRING_CST STRING. */
2342 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2344 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2347 if (chars_per_elt
== 1)
2348 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2351 const unsigned char *ptr
2352 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2353 + index
* chars_per_elt
);
2354 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2359 /* Subroutine of cxx_eval_constant_expression.
2360 Attempt to reduce a reference to an array slot. */
2363 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2365 bool *non_constant_p
, bool *overflow_p
)
2367 tree oldary
= TREE_OPERAND (t
, 0);
2368 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2370 non_constant_p
, overflow_p
);
2372 HOST_WIDE_INT i
= 0;
2373 tree elem_type
= NULL_TREE
;
2374 unsigned len
= 0, elem_nchars
= 1;
2375 if (*non_constant_p
)
2377 oldidx
= TREE_OPERAND (t
, 1);
2378 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2380 non_constant_p
, overflow_p
);
2381 VERIFY_CONSTANT (index
);
2384 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2385 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2386 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2387 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2388 ary
= TREE_OPERAND (ary
, 0);
2389 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2390 len
= CONSTRUCTOR_NELTS (ary
);
2391 else if (TREE_CODE (ary
) == STRING_CST
)
2393 elem_nchars
= (TYPE_PRECISION (elem_type
)
2394 / TYPE_PRECISION (char_type_node
));
2395 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2397 else if (TREE_CODE (ary
) == VECTOR_CST
)
2398 /* We don't create variable-length VECTOR_CSTs. */
2399 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2402 /* We can't do anything with other tree codes, so use
2403 VERIFY_CONSTANT to complain and fail. */
2404 VERIFY_CONSTANT (ary
);
2408 if (!tree_fits_shwi_p (index
)
2409 || (i
= tree_to_shwi (index
)) < 0)
2411 diag_array_subscript (ctx
, ary
, index
);
2412 *non_constant_p
= true;
2417 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2419 VERIFY_CONSTANT (nelts
);
2421 ? !tree_int_cst_le (index
, nelts
)
2422 : !tree_int_cst_lt (index
, nelts
))
2423 || tree_int_cst_sgn (index
) < 0)
2425 diag_array_subscript (ctx
, ary
, index
);
2426 *non_constant_p
= true;
2430 if (lval
&& ary
== oldary
&& index
== oldidx
)
2433 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2436 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2438 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2449 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2450 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2451 else if (TREE_CODE (ary
) == VECTOR_CST
)
2452 r
= VECTOR_CST_ELT (ary
, i
);
2454 r
= extract_string_elt (ary
, elem_nchars
, i
);
2457 /* Don't VERIFY_CONSTANT here. */
2460 /* Otherwise the element doesn't have a value yet. */
2465 if (TREE_CODE (ary
) == CONSTRUCTOR
2466 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2468 /* 'ary' is part of the aggregate initializer we're currently
2469 building; if there's no initializer for this element yet,
2472 error ("accessing uninitialized array element");
2473 *non_constant_p
= true;
2477 /* If it's within the array bounds but doesn't have an explicit
2478 initializer, it's value-initialized. */
2479 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2480 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2484 /* Subroutine of cxx_eval_constant_expression.
2485 Attempt to reduce a field access of a value of class type. */
2488 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2490 bool *non_constant_p
, bool *overflow_p
)
2492 unsigned HOST_WIDE_INT i
;
2495 tree part
= TREE_OPERAND (t
, 1);
2496 tree orig_whole
= TREE_OPERAND (t
, 0);
2497 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2499 non_constant_p
, overflow_p
);
2500 if (INDIRECT_REF_P (whole
)
2501 && integer_zerop (TREE_OPERAND (whole
, 0))
2503 error ("dereferencing a null pointer in %qE", orig_whole
);
2505 if (TREE_CODE (whole
) == PTRMEM_CST
)
2506 whole
= cplus_expand_constant (whole
);
2507 if (whole
== orig_whole
)
2510 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2511 whole
, part
, NULL_TREE
);
2512 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2514 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2517 error ("%qE is not a constant expression", orig_whole
);
2518 *non_constant_p
= true;
2520 if (DECL_MUTABLE_P (part
))
2523 error ("mutable %qD is not usable in a constant expression", part
);
2524 *non_constant_p
= true;
2526 if (*non_constant_p
)
2528 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2529 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2531 /* Use name match for PMF fields, as a variant will have a
2532 different FIELD_DECL with a different type. */
2533 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2539 /* We're in the middle of initializing it. */
2543 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2544 && CONSTRUCTOR_NELTS (whole
) > 0)
2546 /* DR 1188 says we don't have to deal with this. */
2548 error ("accessing %qD member instead of initialized %qD member in "
2549 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2550 *non_constant_p
= true;
2554 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2555 classes never get represented; throw together a value now. */
2556 if (is_really_empty_class (TREE_TYPE (t
)))
2557 return build_constructor (TREE_TYPE (t
), NULL
);
2559 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2561 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2563 /* 'whole' is part of the aggregate initializer we're currently
2564 building; if there's no initializer for this member yet, that's an
2567 error ("accessing uninitialized member %qD", part
);
2568 *non_constant_p
= true;
2572 /* If there's no explicit init for this field, it's value-initialized. */
2573 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2574 return cxx_eval_constant_expression (ctx
, value
,
2576 non_constant_p
, overflow_p
);
2579 /* Subroutine of cxx_eval_constant_expression.
2580 Attempt to reduce a field access of a value of class type that is
2581 expressed as a BIT_FIELD_REF. */
2584 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2586 bool *non_constant_p
, bool *overflow_p
)
2588 tree orig_whole
= TREE_OPERAND (t
, 0);
2589 tree retval
, fldval
, utype
, mask
;
2590 bool fld_seen
= false;
2591 HOST_WIDE_INT istart
, isize
;
2592 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2594 non_constant_p
, overflow_p
);
2595 tree start
, field
, value
;
2596 unsigned HOST_WIDE_INT i
;
2598 if (whole
== orig_whole
)
2600 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2602 if (!*non_constant_p
2603 && TREE_CODE (whole
) != VECTOR_CST
2604 && TREE_CODE (whole
) != CONSTRUCTOR
)
2607 error ("%qE is not a constant expression", orig_whole
);
2608 *non_constant_p
= true;
2610 if (*non_constant_p
)
2613 if (TREE_CODE (whole
) == VECTOR_CST
)
2614 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2615 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2617 start
= TREE_OPERAND (t
, 2);
2618 istart
= tree_to_shwi (start
);
2619 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2620 utype
= TREE_TYPE (t
);
2621 if (!TYPE_UNSIGNED (utype
))
2622 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2623 retval
= build_int_cst (utype
, 0);
2624 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2626 tree bitpos
= bit_position (field
);
2627 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2629 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2630 && TREE_CODE (value
) == INTEGER_CST
2631 && tree_fits_shwi_p (bitpos
)
2632 && tree_fits_shwi_p (DECL_SIZE (field
)))
2634 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2635 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2636 HOST_WIDE_INT shift
;
2637 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2639 fldval
= fold_convert (utype
, value
);
2640 mask
= build_int_cst_type (utype
, -1);
2641 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2642 size_int (TYPE_PRECISION (utype
) - sz
));
2643 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2644 size_int (TYPE_PRECISION (utype
) - sz
));
2645 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2646 shift
= bit
- istart
;
2647 if (BYTES_BIG_ENDIAN
)
2648 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2649 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2651 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2657 return fold_convert (TREE_TYPE (t
), retval
);
2659 return error_mark_node
;
2662 /* Subroutine of cxx_eval_constant_expression.
2663 Evaluate a short-circuited logical expression T in the context
2664 of a given constexpr CALL. BAILOUT_VALUE is the value for
2665 early return. CONTINUE_VALUE is used here purely for
2666 sanity check purposes. */
2669 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2670 tree bailout_value
, tree continue_value
,
2672 bool *non_constant_p
, bool *overflow_p
)
2675 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2677 non_constant_p
, overflow_p
);
2678 VERIFY_CONSTANT (lhs
);
2679 if (tree_int_cst_equal (lhs
, bailout_value
))
2681 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2682 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2683 lval
, non_constant_p
,
2685 VERIFY_CONSTANT (r
);
2689 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2690 CONSTRUCTOR elements to initialize (part of) an object containing that
2691 field. Return a pointer to the constructor_elt corresponding to the
2692 initialization of the field. */
2694 static constructor_elt
*
2695 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2697 tree aggr
= TREE_OPERAND (ref
, 0);
2698 tree field
= TREE_OPERAND (ref
, 1);
2700 constructor_elt
*ce
;
2702 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2704 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2706 constructor_elt
*base_ce
2707 = base_field_constructor_elt (v
, aggr
);
2708 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2711 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2712 if (ce
->index
== field
)
2719 /* Some of the expressions fed to the constexpr mechanism are calls to
2720 constructors, which have type void. In that case, return the type being
2721 initialized by the constructor. */
2724 initialized_type (tree t
)
2728 tree type
= cv_unqualified (TREE_TYPE (t
));
2729 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2731 /* A constructor call has void type, so we need to look deeper. */
2732 tree fn
= get_function_named_in_call (t
);
2733 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2734 && DECL_CXX_CONSTRUCTOR_P (fn
))
2735 type
= DECL_CONTEXT (fn
);
2740 /* We're about to initialize element INDEX of an array or class from VALUE.
2741 Set up NEW_CTX appropriately by adjusting .object to refer to the
2742 subobject and creating a new CONSTRUCTOR if the element is itself
2743 a class or array. */
2746 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2747 tree index
, tree
&value
)
2751 if (index
&& TREE_CODE (index
) != INTEGER_CST
2752 && TREE_CODE (index
) != FIELD_DECL
)
2753 /* This won't have an element in the new CONSTRUCTOR. */
2756 tree type
= initialized_type (value
);
2757 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2758 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2761 /* The sub-aggregate initializer might contain a placeholder;
2762 update object to refer to the subobject and ctor to refer to
2763 the (newly created) sub-initializer. */
2765 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2766 tree elt
= build_constructor (type
, NULL
);
2767 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2770 if (TREE_CODE (value
) == TARGET_EXPR
)
2771 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2772 value
= TARGET_EXPR_INITIAL (value
);
2775 /* We're about to process an initializer for a class or array TYPE. Make
2776 sure that CTX is set up appropriately. */
2779 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2781 /* We don't bother building a ctor for an empty base subobject. */
2782 if (is_empty_class (type
))
2785 /* We're in the middle of an initializer that might involve placeholders;
2786 our caller should have created a CONSTRUCTOR for us to put the
2787 initializer into. We will either return that constructor or T. */
2788 gcc_assert (ctx
->ctor
);
2789 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2790 (type
, TREE_TYPE (ctx
->ctor
)));
2791 /* We used to check that ctx->ctor was empty, but that isn't the case when
2792 the object is zero-initialized before calling the constructor. */
2795 tree otype
= TREE_TYPE (ctx
->object
);
2796 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2797 /* Handle flexible array members. */
2798 || (TREE_CODE (otype
) == ARRAY_TYPE
2799 && TYPE_DOMAIN (otype
) == NULL_TREE
2800 && TREE_CODE (type
) == ARRAY_TYPE
2801 && (same_type_ignoring_top_level_qualifiers_p
2802 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2804 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2805 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2808 /* Subroutine of cxx_eval_constant_expression.
2809 The expression tree T denotes a C-style array or a C-style
2810 aggregate. Reduce it to a constant expression. */
2813 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2815 bool *non_constant_p
, bool *overflow_p
)
2817 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2818 bool changed
= false;
2819 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2820 tree type
= TREE_TYPE (t
);
2822 constexpr_ctx new_ctx
;
2823 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2825 /* We don't really need the ctx->ctor business for a PMF or
2826 vector, but it's simpler to use the same code. */
2828 new_ctx
.ctor
= build_constructor (type
, NULL
);
2829 new_ctx
.object
= NULL_TREE
;
2832 verify_ctor_sanity (ctx
, type
);
2833 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2834 vec_alloc (*p
, vec_safe_length (v
));
2838 bool constant_p
= true;
2839 bool side_effects_p
= false;
2840 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2842 tree orig_value
= value
;
2843 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2844 if (new_ctx
.ctor
!= ctx
->ctor
)
2845 /* If we built a new CONSTRUCTOR, attach it now so that other
2846 initializers can refer to it. */
2847 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2848 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2850 non_constant_p
, overflow_p
);
2851 /* Don't VERIFY_CONSTANT here. */
2852 if (ctx
->quiet
&& *non_constant_p
)
2854 if (elt
!= orig_value
)
2857 if (!TREE_CONSTANT (elt
))
2859 if (TREE_SIDE_EFFECTS (elt
))
2860 side_effects_p
= true;
2861 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2863 /* This is an initialization of a vfield inside a base
2864 subaggregate that we already initialized; push this
2865 initialization into the previous initialization. */
2866 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2871 && (TREE_CODE (index
) == NOP_EXPR
2872 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2874 /* This is an initializer for an empty base; now that we've
2875 checked that it's constant, we can ignore it. */
2876 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2881 if (new_ctx
.ctor
!= ctx
->ctor
)
2883 /* We appended this element above; update the value. */
2884 gcc_assert ((*p
)->last().index
== index
);
2885 (*p
)->last().value
= elt
;
2888 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2889 /* Adding or replacing an element might change the ctor's flags. */
2890 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
2891 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
2894 if (*non_constant_p
|| !changed
)
2897 /* We're done building this CONSTRUCTOR, so now we can interpret an
2898 element without an explicit initializer as value-initialized. */
2899 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2900 TREE_CONSTANT (t
) = constant_p
;
2901 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2902 if (VECTOR_TYPE_P (type
))
2907 /* Subroutine of cxx_eval_constant_expression.
2908 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2909 initialization of a non-static data member of array type. Reduce it to a
2912 Note that apart from value-initialization (when VALUE_INIT is true),
2913 this is only intended to support value-initialization and the
2914 initializations done by defaulted constructors for classes with
2915 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2916 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2917 for the copy/move constructor. */
2920 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2921 bool value_init
, bool lval
,
2922 bool *non_constant_p
, bool *overflow_p
)
2924 tree elttype
= TREE_TYPE (atype
);
2925 verify_ctor_sanity (ctx
, atype
);
2926 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2927 bool pre_init
= false;
2928 unsigned HOST_WIDE_INT i
;
2930 /* For the default constructor, build up a call to the default
2931 constructor of the element type. We only need to handle class types
2932 here, as for a constructor to be constexpr, all members must be
2933 initialized, which for a defaulted default constructor means they must
2934 be of a class type with a constexpr default constructor. */
2935 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2936 /* We only do this at the lowest level. */;
2937 else if (value_init
)
2939 init
= build_value_init (elttype
, tf_warning_or_error
);
2944 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2945 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2946 &argvec
, elttype
, LOOKUP_NORMAL
,
2947 tf_warning_or_error
);
2948 release_tree_vector (argvec
);
2949 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2953 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
2955 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
2956 for (i
= 0; i
< max
; ++i
)
2958 tree idx
= build_int_cst (size_type_node
, i
);
2961 constexpr_ctx new_ctx
;
2962 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2963 if (new_ctx
.ctor
!= ctx
->ctor
)
2964 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2965 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2967 /* A multidimensional array; recurse. */
2968 if (value_init
|| init
== NULL_TREE
)
2970 eltinit
= NULL_TREE
;
2974 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2975 tf_warning_or_error
);
2976 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2978 non_constant_p
, overflow_p
);
2982 /* Initializing an element using value or default initialization
2983 we just pre-built above. */
2984 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2985 non_constant_p
, overflow_p
);
2990 /* Copying an element. */
2991 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2992 (atype
, TREE_TYPE (init
)));
2993 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2994 tf_warning_or_error
);
2995 if (!lvalue_p (init
))
2996 eltinit
= move (eltinit
);
2997 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2998 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
2999 non_constant_p
, overflow_p
);
3001 if (*non_constant_p
&& !ctx
->quiet
)
3003 if (new_ctx
.ctor
!= ctx
->ctor
)
3005 /* We appended this element above; update the value. */
3006 gcc_assert ((*p
)->last().index
== idx
);
3007 (*p
)->last().value
= eltinit
;
3010 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3011 /* Reuse the result of cxx_eval_constant_expression call
3012 from the first iteration to all others if it is a constant
3013 initializer that doesn't require relocations. */
3016 && (eltinit
== NULL_TREE
3017 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3018 == null_pointer_node
)))
3020 if (new_ctx
.ctor
!= ctx
->ctor
)
3021 eltinit
= new_ctx
.ctor
;
3022 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3023 build_int_cst (size_type_node
, 1),
3024 build_int_cst (size_type_node
, max
- 1));
3025 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3029 vec_safe_reserve (*p
, max
);
3032 if (!*non_constant_p
)
3035 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
3041 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3043 bool *non_constant_p
, bool *overflow_p
)
3045 tree atype
= TREE_TYPE (t
);
3046 tree init
= VEC_INIT_EXPR_INIT (t
);
3047 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3048 VEC_INIT_EXPR_VALUE_INIT (t
),
3049 lval
, non_constant_p
, overflow_p
);
3050 if (*non_constant_p
)
3056 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3057 match. We want to be less strict for simple *& folding; if we have a
3058 non-const temporary that we access through a const pointer, that should
3059 work. We handle this here rather than change fold_indirect_ref_1
3060 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3061 don't really make sense outside of constant expression evaluation. Also
3062 we want to allow folding to COMPONENT_REF, which could cause trouble
3063 with TBAA in fold_indirect_ref_1.
3065 Try to keep this function synced with fold_indirect_ref_1. */
3068 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3072 poly_uint64 const_op01
;
3075 subtype
= TREE_TYPE (sub
);
3076 if (!POINTER_TYPE_P (subtype
))
3079 if (TREE_CODE (sub
) == ADDR_EXPR
)
3081 tree op
= TREE_OPERAND (sub
, 0);
3082 tree optype
= TREE_TYPE (op
);
3084 /* *&CONST_DECL -> to the value of the const decl. */
3085 if (TREE_CODE (op
) == CONST_DECL
)
3086 return DECL_INITIAL (op
);
3087 /* *&p => p; make sure to handle *&"str"[cst] here. */
3088 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
3089 /* Also handle the case where the desired type is an array of unknown
3090 bounds because the variable has had its bounds deduced since the
3091 ADDR_EXPR was created. */
3092 || (TREE_CODE (type
) == ARRAY_TYPE
3093 && TREE_CODE (optype
) == ARRAY_TYPE
3094 && TYPE_DOMAIN (type
) == NULL_TREE
3095 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3098 tree fop
= fold_read_from_constant_string (op
);
3104 /* *(foo *)&fooarray => fooarray[0] */
3105 else if (TREE_CODE (optype
) == ARRAY_TYPE
3106 && (same_type_ignoring_top_level_qualifiers_p
3107 (type
, TREE_TYPE (optype
))))
3109 tree type_domain
= TYPE_DOMAIN (optype
);
3110 tree min_val
= size_zero_node
;
3111 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3112 min_val
= TYPE_MIN_VALUE (type_domain
);
3113 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3114 NULL_TREE
, NULL_TREE
);
3116 /* *(foo *)&complexfoo => __real__ complexfoo */
3117 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3118 && (same_type_ignoring_top_level_qualifiers_p
3119 (type
, TREE_TYPE (optype
))))
3120 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3121 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3122 else if (VECTOR_TYPE_P (optype
)
3123 && (same_type_ignoring_top_level_qualifiers_p
3124 (type
, TREE_TYPE (optype
))))
3126 tree part_width
= TYPE_SIZE (type
);
3127 tree index
= bitsize_int (0);
3128 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3131 /* Also handle conversion to an empty base class, which
3132 is represented with a NOP_EXPR. */
3133 else if (is_empty_class (type
)
3134 && CLASS_TYPE_P (optype
)
3135 && DERIVED_FROM_P (type
, optype
))
3140 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3141 else if (RECORD_OR_UNION_TYPE_P (optype
))
3143 tree field
= TYPE_FIELDS (optype
);
3144 for (; field
; field
= DECL_CHAIN (field
))
3145 if (TREE_CODE (field
) == FIELD_DECL
3146 && TREE_TYPE (field
) != error_mark_node
3147 && integer_zerop (byte_position (field
))
3148 && (same_type_ignoring_top_level_qualifiers_p
3149 (TREE_TYPE (field
), type
)))
3150 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3153 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3154 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3156 tree op00
= TREE_OPERAND (sub
, 0);
3157 tree op01
= TREE_OPERAND (sub
, 1);
3160 if (TREE_CODE (op00
) == ADDR_EXPR
)
3163 op00
= TREE_OPERAND (op00
, 0);
3164 op00type
= TREE_TYPE (op00
);
3166 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3167 if (VECTOR_TYPE_P (op00type
)
3168 && same_type_ignoring_top_level_qualifiers_p
3169 (type
, TREE_TYPE (op00type
))
3170 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3171 but we want to treat offsets with MSB set as negative.
3172 For the code below negative offsets are invalid and
3173 TYPE_SIZE of the element is something unsigned, so
3174 check whether op01 fits into poly_int64, which implies
3175 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3176 then just use poly_uint64 because we want to treat the
3177 value as unsigned. */
3178 && tree_fits_poly_int64_p (op01
))
3180 tree part_width
= TYPE_SIZE (type
);
3181 poly_uint64 max_offset
3182 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3183 * TYPE_VECTOR_SUBPARTS (op00type
));
3184 if (known_lt (const_op01
, max_offset
))
3186 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3187 return fold_build3_loc (loc
,
3188 BIT_FIELD_REF
, type
, op00
,
3192 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3193 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3194 && (same_type_ignoring_top_level_qualifiers_p
3195 (type
, TREE_TYPE (op00type
))))
3197 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3199 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3201 /* ((foo *)&fooarray)[1] => fooarray[1] */
3202 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3203 && (same_type_ignoring_top_level_qualifiers_p
3204 (type
, TREE_TYPE (op00type
))))
3206 tree type_domain
= TYPE_DOMAIN (op00type
);
3207 tree min_val
= size_zero_node
;
3208 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3209 min_val
= TYPE_MIN_VALUE (type_domain
);
3210 offset_int off
= wi::to_offset (op01
);
3211 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3212 offset_int remainder
;
3213 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3214 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3216 off
= off
+ wi::to_offset (min_val
);
3217 op01
= wide_int_to_tree (sizetype
, off
);
3218 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3219 NULL_TREE
, NULL_TREE
);
3222 /* Also handle conversion to an empty base class, which
3223 is represented with a NOP_EXPR. */
3224 else if (is_empty_class (type
)
3225 && CLASS_TYPE_P (op00type
)
3226 && DERIVED_FROM_P (type
, op00type
))
3231 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3232 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3234 tree field
= TYPE_FIELDS (op00type
);
3235 for (; field
; field
= DECL_CHAIN (field
))
3236 if (TREE_CODE (field
) == FIELD_DECL
3237 && TREE_TYPE (field
) != error_mark_node
3238 && tree_int_cst_equal (byte_position (field
), op01
)
3239 && (same_type_ignoring_top_level_qualifiers_p
3240 (TREE_TYPE (field
), type
)))
3241 return fold_build3 (COMPONENT_REF
, type
, op00
,
3246 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3247 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3248 && (same_type_ignoring_top_level_qualifiers_p
3249 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3252 tree min_val
= size_zero_node
;
3254 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3258 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3259 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3260 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3261 min_val
= TYPE_MIN_VALUE (type_domain
);
3262 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3270 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3272 bool *non_constant_p
, bool *overflow_p
)
3274 tree orig_op0
= TREE_OPERAND (t
, 0);
3275 bool empty_base
= false;
3277 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3278 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3280 if (TREE_CODE (t
) == MEM_REF
3281 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3283 gcc_assert (ctx
->quiet
);
3284 *non_constant_p
= true;
3288 /* First try to simplify it directly. */
3289 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3293 /* If that didn't work, evaluate the operand first. */
3294 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3295 /*lval*/false, non_constant_p
,
3297 /* Don't VERIFY_CONSTANT here. */
3298 if (*non_constant_p
)
3301 if (!lval
&& integer_zerop (op0
))
3304 error ("dereferencing a null pointer");
3305 *non_constant_p
= true;
3309 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3313 /* We couldn't fold to a constant value. Make sure it's not
3314 something we should have been able to fold. */
3317 if (TREE_CODE (sub
) == ADDR_EXPR
)
3319 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3320 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3321 /* DR 1188 says we don't have to deal with this. */
3323 error ("accessing value of %qE through a %qT glvalue in a "
3324 "constant expression", build_fold_indirect_ref (sub
),
3326 *non_constant_p
= true;
3330 if (lval
&& op0
!= orig_op0
)
3331 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3333 VERIFY_CONSTANT (t
);
3338 r
= cxx_eval_constant_expression (ctx
, r
,
3339 lval
, non_constant_p
, overflow_p
);
3340 if (*non_constant_p
)
3343 /* If we're pulling out the value of an empty base, just return an empty
3345 if (empty_base
&& !lval
)
3347 r
= build_constructor (TREE_TYPE (t
), NULL
);
3348 TREE_CONSTANT (r
) = true;
3354 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3355 Shared between potential_constant_expression and
3356 cxx_eval_constant_expression. */
3359 non_const_var_error (tree r
)
3361 tree type
= TREE_TYPE (r
);
3362 error ("the value of %qD is not usable in a constant "
3364 /* Avoid error cascade. */
3365 if (DECL_INITIAL (r
) == error_mark_node
)
3367 if (DECL_DECLARED_CONSTEXPR_P (r
))
3368 inform (DECL_SOURCE_LOCATION (r
),
3369 "%qD used in its own initializer", r
);
3370 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3372 if (!CP_TYPE_CONST_P (type
))
3373 inform (DECL_SOURCE_LOCATION (r
),
3374 "%q#D is not const", r
);
3375 else if (CP_TYPE_VOLATILE_P (type
))
3376 inform (DECL_SOURCE_LOCATION (r
),
3377 "%q#D is volatile", r
);
3378 else if (!DECL_INITIAL (r
)
3379 || !TREE_CONSTANT (DECL_INITIAL (r
))
3380 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3381 inform (DECL_SOURCE_LOCATION (r
),
3382 "%qD was not initialized with a constant "
3387 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3388 inform (DECL_SOURCE_LOCATION (r
),
3389 "%qD was not initialized with a constant "
3393 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3394 inform (DECL_SOURCE_LOCATION (r
),
3395 "%qD was not declared %<constexpr%>", r
);
3397 inform (DECL_SOURCE_LOCATION (r
),
3398 "%qD does not have integral or enumeration type",
3403 /* Subroutine of cxx_eval_constant_expression.
3404 Like cxx_eval_unary_expression, except for trinary expressions. */
3407 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3409 bool *non_constant_p
, bool *overflow_p
)
3415 for (i
= 0; i
< 3; i
++)
3417 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3419 non_constant_p
, overflow_p
);
3420 VERIFY_CONSTANT (args
[i
]);
3423 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3424 args
[0], args
[1], args
[2]);
3425 if (val
== NULL_TREE
)
3427 VERIFY_CONSTANT (val
);
3431 /* True if T was declared in a function declared to be constexpr, and
3432 therefore potentially constant in C++14. */
3435 var_in_constexpr_fn (tree t
)
3437 tree ctx
= DECL_CONTEXT (t
);
3438 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3439 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3442 /* True if T was declared in a function that might be constexpr: either a
3443 function that was declared constexpr, or a C++17 lambda op(). */
3446 var_in_maybe_constexpr_fn (tree t
)
3448 if (cxx_dialect
>= cxx17
3449 && DECL_FUNCTION_SCOPE_P (t
)
3450 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3452 return var_in_constexpr_fn (t
);
3455 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3456 build_over_call we implement trivial copy of a class with tail padding using
3457 assignment of character arrays, which is valid in normal code, but not in
3458 constexpr evaluation. We don't need to worry about clobbering tail padding
3459 in constexpr evaluation, so strip the type punning. */
3462 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3464 if (TREE_CODE (target
) == MEM_REF
3465 && TREE_CODE (init
) == MEM_REF
3466 && TREE_TYPE (target
) == TREE_TYPE (init
)
3467 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3468 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3470 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3471 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3475 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3478 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3480 bool *non_constant_p
, bool *overflow_p
)
3482 constexpr_ctx new_ctx
= *ctx
;
3484 tree init
= TREE_OPERAND (t
, 1);
3485 if (TREE_CLOBBER_P (init
))
3486 /* Just ignore clobbers. */
3489 /* First we figure out where we're storing to. */
3490 tree target
= TREE_OPERAND (t
, 0);
3492 maybe_simplify_trivial_copy (target
, init
);
3494 tree type
= TREE_TYPE (target
);
3495 target
= cxx_eval_constant_expression (ctx
, target
,
3497 non_constant_p
, overflow_p
);
3498 if (*non_constant_p
)
3501 /* cxx_eval_array_reference for lval = true allows references one past
3502 end of array, because it does not know if it is just taking address
3503 (which is valid), or actual dereference. Here we know it is
3504 a dereference, so diagnose it here. */
3505 for (tree probe
= target
; probe
; )
3507 switch (TREE_CODE (probe
))
3511 ary
= TREE_OPERAND (probe
, 0);
3512 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3513 non_constant_p
, overflow_p
);
3514 VERIFY_CONSTANT (nelts
);
3515 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3516 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3517 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3519 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3520 *non_constant_p
= true;
3527 probe
= TREE_OPERAND (probe
, 0);
3536 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3538 /* For initialization of an empty base, the original target will be
3539 *(base*)this, which the above evaluation resolves to the object
3540 argument, which has the derived type rather than the base type. In
3541 this situation, just evaluate the initializer and return, since
3542 there's no actual data to store. */
3543 gcc_assert (is_empty_class (type
));
3544 return cxx_eval_constant_expression (ctx
, init
, false,
3545 non_constant_p
, overflow_p
);
3548 /* And then find the underlying variable. */
3549 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3550 tree object
= NULL_TREE
;
3551 for (tree probe
= target
; object
== NULL_TREE
; )
3553 switch (TREE_CODE (probe
))
3558 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3559 vec_safe_push (refs
, TREE_TYPE (probe
));
3560 probe
= TREE_OPERAND (probe
, 0);
3568 /* And then find/build up our initializer for the path to the subobject
3569 we're initializing. */
3571 if (object
== ctx
->object
&& VAR_P (object
)
3572 && DECL_NAME (object
) && ctx
->call
== NULL
)
3573 /* The variable we're building up an aggregate initializer for is outside
3574 the constant-expression, so don't evaluate the store. We check
3575 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3577 else if (DECL_P (object
))
3578 valp
= ctx
->values
->get (object
);
3583 /* A constant-expression cannot modify objects from outside the
3584 constant-expression. */
3586 error ("modification of %qE is not a constant expression", object
);
3587 *non_constant_p
= true;
3590 type
= TREE_TYPE (object
);
3591 bool no_zero_init
= true;
3593 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3594 while (!refs
->is_empty())
3596 if (*valp
== NULL_TREE
)
3598 *valp
= build_constructor (type
, NULL
);
3599 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3601 else if (TREE_CODE (*valp
) == STRING_CST
)
3603 /* An array was initialized with a string constant, and now
3604 we're writing into one of its elements. Explode the
3605 single initialization into a set of element
3607 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3609 tree string
= *valp
;
3610 tree elt_type
= TREE_TYPE (type
);
3611 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3612 / TYPE_PRECISION (char_type_node
));
3613 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3614 tree ary_ctor
= build_constructor (type
, NULL
);
3616 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3617 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3619 constructor_elt elt
=
3621 build_int_cst (size_type_node
, ix
),
3622 extract_string_elt (string
, chars_per_elt
, ix
)
3624 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3630 /* If the value of object is already zero-initialized, any new ctors for
3631 subobjects will also be zero-initialized. */
3632 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3634 vec_safe_push (ctors
, *valp
);
3636 enum tree_code code
= TREE_CODE (type
);
3638 tree index
= refs
->pop();
3640 constructor_elt
*cep
= NULL
;
3641 if (code
== ARRAY_TYPE
)
3644 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3645 gcc_assert (i
>= 0);
3646 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3647 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3651 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3653 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3654 Usually we meet initializers in that order, but it is
3655 possible for base types to be placed not in program
3657 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3658 unsigned HOST_WIDE_INT idx
;
3660 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3661 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3662 /* Changing active member. */
3663 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3666 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3667 idx
++, fields
= DECL_CHAIN (fields
))
3669 if (index
== cep
->index
)
3672 /* The field we're initializing must be on the field
3673 list. Look to see if it is present before the
3674 field the current ELT initializes. */
3675 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3676 if (index
== fields
)
3680 /* We fell off the end of the CONSTRUCTOR, so insert a new
3681 entry at the end. */
3684 constructor_elt ce
= { index
, NULL_TREE
};
3686 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3687 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3693 release_tree_vector (refs
);
3695 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3697 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3698 wants to modify it. */
3699 if (*valp
== NULL_TREE
)
3701 *valp
= build_constructor (type
, NULL
);
3702 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3704 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3705 *valp
= cplus_expand_constant (*valp
);
3706 new_ctx
.ctor
= *valp
;
3707 new_ctx
.object
= target
;
3710 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3711 non_constant_p
, overflow_p
);
3712 /* Don't share a CONSTRUCTOR that might be changed later. */
3713 init
= unshare_constructor (init
);
3714 if (target
== object
)
3715 /* The hash table might have moved since the get earlier. */
3716 valp
= ctx
->values
->get (object
);
3718 if (TREE_CODE (init
) == CONSTRUCTOR
)
3720 /* An outer ctx->ctor might be pointing to *valp, so replace
3722 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3723 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3724 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3725 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3726 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3731 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3732 CONSTRUCTORs, if any. */
3735 bool c
= TREE_CONSTANT (init
);
3736 bool s
= TREE_SIDE_EFFECTS (init
);
3738 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3741 TREE_CONSTANT (elt
) = false;
3743 TREE_SIDE_EFFECTS (elt
) = true;
3745 release_tree_vector (ctors
);
3747 if (*non_constant_p
)
3755 /* Evaluate a ++ or -- expression. */
3758 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3760 bool *non_constant_p
, bool *overflow_p
)
3762 enum tree_code code
= TREE_CODE (t
);
3763 tree type
= TREE_TYPE (t
);
3764 tree op
= TREE_OPERAND (t
, 0);
3765 tree offset
= TREE_OPERAND (t
, 1);
3766 gcc_assert (TREE_CONSTANT (offset
));
3768 /* The operand as an lvalue. */
3769 op
= cxx_eval_constant_expression (ctx
, op
, true,
3770 non_constant_p
, overflow_p
);
3772 /* The operand as an rvalue. */
3774 = cxx_eval_constant_expression (ctx
, op
, false,
3775 non_constant_p
, overflow_p
);
3776 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3777 a local array in a constexpr function. */
3778 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3780 VERIFY_CONSTANT (val
);
3782 /* The modified value. */
3783 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3785 if (POINTER_TYPE_P (type
))
3787 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3788 offset
= convert_to_ptrofftype (offset
);
3790 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3791 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3794 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3796 VERIFY_CONSTANT (mod
);
3798 /* Storing the modified value. */
3799 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3800 cxx_eval_constant_expression (ctx
, store
,
3801 true, non_constant_p
, overflow_p
);
3803 /* And the value of the expression. */
3804 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3806 /* Prefix ops are lvalues. */
3810 /* But we optimize when the caller wants an rvalue. */
3814 /* Postfix ops are rvalues. */
3818 /* Predicates for the meaning of *jump_target. */
3821 returns (tree
*jump_target
)
3824 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3825 || (TREE_CODE (*jump_target
) == LABEL_DECL
3826 && LABEL_DECL_CDTOR (*jump_target
)));
3830 breaks (tree
*jump_target
)
3833 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3834 && LABEL_DECL_BREAK (*jump_target
))
3835 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3839 continues (tree
*jump_target
)
3842 && TREE_CODE (*jump_target
) == LABEL_DECL
3843 && LABEL_DECL_CONTINUE (*jump_target
);
3847 switches (tree
*jump_target
)
3850 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3853 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3854 STMT matches *jump_target. If we're looking for a case label and we see
3855 the default label, note it in ctx->css_state. */
3858 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3860 switch (TREE_CODE (*jump_target
))
3863 if (TREE_CODE (stmt
) == LABEL_EXPR
3864 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3869 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3871 gcc_assert (ctx
->css_state
!= NULL
);
3872 if (!CASE_LOW (stmt
))
3874 /* default: should appear just once in a SWITCH_EXPR
3875 body (excluding nested SWITCH_EXPR). */
3876 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3877 /* When evaluating SWITCH_EXPR body for the second time,
3878 return true for the default: label. */
3879 if (*ctx
->css_state
== css_default_processing
)
3881 *ctx
->css_state
= css_default_seen
;
3883 else if (CASE_HIGH (stmt
))
3885 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3886 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3889 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3900 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3901 semantics, for switch, break, continue, and return. */
3904 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3905 bool *non_constant_p
, bool *overflow_p
,
3908 tree_stmt_iterator i
;
3910 /* In a statement-expression we want to return the last value.
3911 For empty statement expression return void_node. */
3915 local_target
= NULL_TREE
;
3916 jump_target
= &local_target
;
3918 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3920 tree stmt
= tsi_stmt (i
);
3921 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
3923 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3924 non_constant_p
, overflow_p
,
3926 if (*non_constant_p
)
3928 if (returns (jump_target
) || breaks (jump_target
))
3934 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3935 semantics; continue semantics are covered by cxx_eval_statement_list. */
3938 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3939 bool *non_constant_p
, bool *overflow_p
,
3942 constexpr_ctx new_ctx
= *ctx
;
3944 tree body
= TREE_OPERAND (t
, 0);
3948 hash_set
<tree
> save_exprs
;
3949 new_ctx
.save_exprs
= &save_exprs
;
3951 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3952 non_constant_p
, overflow_p
, jump_target
);
3954 /* Forget saved values of SAVE_EXPRs. */
3955 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3956 iter
!= save_exprs
.end(); ++iter
)
3957 new_ctx
.values
->remove (*iter
);
3958 if (++count
>= constexpr_loop_limit
)
3961 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3962 "%<constexpr%> loop iteration count exceeds limit of %d "
3963 "(use -fconstexpr-loop-limit= to increase the limit)",
3964 constexpr_loop_limit
);
3965 *non_constant_p
= true;
3969 while (!returns (jump_target
)
3970 && !breaks (jump_target
)
3971 && !switches (jump_target
)
3972 && !*non_constant_p
);
3974 if (breaks (jump_target
))
3975 *jump_target
= NULL_TREE
;
3980 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3984 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3985 bool *non_constant_p
, bool *overflow_p
,
3988 tree cond
= TREE_OPERAND (t
, 0);
3989 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3990 non_constant_p
, overflow_p
);
3991 VERIFY_CONSTANT (cond
);
3992 *jump_target
= cond
;
3994 tree body
= TREE_OPERAND (t
, 1);
3995 constexpr_ctx new_ctx
= *ctx
;
3996 constexpr_switch_state css
= css_default_not_seen
;
3997 new_ctx
.css_state
= &css
;
3998 cxx_eval_constant_expression (&new_ctx
, body
, false,
3999 non_constant_p
, overflow_p
, jump_target
);
4000 if (switches (jump_target
) && css
== css_default_seen
)
4002 /* If the SWITCH_EXPR body has default: label, process it once again,
4003 this time instructing label_matches to return true for default:
4004 label on switches (jump_target). */
4005 css
= css_default_processing
;
4006 cxx_eval_constant_expression (&new_ctx
, body
, false,
4007 non_constant_p
, overflow_p
, jump_target
);
4009 if (breaks (jump_target
) || switches (jump_target
))
4010 *jump_target
= NULL_TREE
;
4014 /* Find the object of TYPE under initialization in CTX. */
4017 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4022 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4023 can is a minor optimization. */
4024 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4030 /* Since an object cannot have a field of its own type, we can search outward
4031 from ctx->object to find the unique containing object of TYPE. */
4032 tree ob
= ctx
->object
;
4035 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4037 if (handled_component_p (ob
))
4038 ob
= TREE_OPERAND (ob
, 0);
4046 /* Attempt to reduce the expression T to a constant value.
4047 On failure, issue diagnostic and return error_mark_node. */
4048 /* FIXME unify with c_fully_fold */
4049 /* FIXME overflow_p is too global */
4052 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4054 bool *non_constant_p
, bool *overflow_p
,
4057 constexpr_ctx new_ctx
;
4060 if (jump_target
&& *jump_target
)
4062 /* If we are jumping, ignore all statements/expressions except those
4063 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4064 switch (TREE_CODE (t
))
4067 case STATEMENT_LIST
:
4072 case CASE_LABEL_EXPR
:
4073 if (label_matches (ctx
, jump_target
, t
))
4075 *jump_target
= NULL_TREE
;
4081 if (t
== error_mark_node
)
4083 *non_constant_p
= true;
4086 if (CONSTANT_CLASS_P (t
))
4088 if (TREE_OVERFLOW (t
))
4091 permerror (input_location
, "overflow in constant expression");
4092 if (!flag_permissive
|| ctx
->quiet
)
4096 if (TREE_CODE (t
) == INTEGER_CST
4097 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
4098 && !integer_zerop (t
))
4101 error ("value %qE of type %qT is not a constant expression",
4103 *non_constant_p
= true;
4109 tree_code tcode
= TREE_CODE (t
);
4115 /* We ask for an rvalue for the RESULT_DECL when indirecting
4116 through an invisible reference, or in named return value
4118 if (tree
*p
= ctx
->values
->get (t
))
4123 error ("%qE is not a constant expression", t
);
4124 *non_constant_p
= true;
4129 if (DECL_HAS_VALUE_EXPR_P (t
))
4130 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4131 lval
, non_constant_p
, overflow_p
);
4134 /* We used to not check lval for CONST_DECL, but darwin.c uses
4135 CONST_DECL for aggregate constants. */
4138 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4139 && is_really_empty_class (TREE_TYPE (t
)))
4141 /* If the class is empty, we aren't actually loading anything. */
4142 r
= build_constructor (TREE_TYPE (t
), NULL
);
4143 TREE_CONSTANT (r
) = true;
4145 else if (ctx
->strict
)
4146 r
= decl_really_constant_value (t
);
4148 r
= decl_constant_value (t
);
4149 if (TREE_CODE (r
) == TARGET_EXPR
4150 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4151 r
= TARGET_EXPR_INITIAL (r
);
4153 if (tree
*p
= ctx
->values
->get (r
))
4154 if (*p
!= NULL_TREE
)
4159 non_const_var_error (r
);
4160 *non_constant_p
= true;
4164 case DEBUG_BEGIN_STMT
:
4165 /* ??? It might be nice to retain this information somehow, so
4166 as to be able to step into a constexpr function call. */
4173 case CASE_LABEL_EXPR
:
4178 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4180 else if (tree
*p
= ctx
->values
->get (r
))
4183 /* Defer in case this is only used for its type. */;
4184 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4185 /* Defer, there's no lvalue->rvalue conversion. */;
4186 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4187 && is_really_empty_class (TREE_TYPE (t
)))
4189 /* If the class is empty, we aren't actually loading anything. */
4190 r
= build_constructor (TREE_TYPE (t
), NULL
);
4191 TREE_CONSTANT (r
) = true;
4196 error ("%qE is not a constant expression", t
);
4197 *non_constant_p
= true;
4202 case AGGR_INIT_EXPR
:
4203 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4204 non_constant_p
, overflow_p
);
4209 r
= DECL_EXPR_DECL (t
);
4210 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4211 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4215 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4216 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4217 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4221 if (tree init
= DECL_INITIAL (r
))
4223 init
= cxx_eval_constant_expression (ctx
, init
,
4225 non_constant_p
, overflow_p
);
4226 /* Don't share a CONSTRUCTOR that might be changed. */
4227 init
= unshare_constructor (init
);
4228 ctx
->values
->put (r
, init
);
4230 else if (ctx
== &new_ctx
)
4231 /* We gave it a CONSTRUCTOR above. */;
4233 ctx
->values
->put (r
, NULL_TREE
);
4238 if (!literal_type_p (TREE_TYPE (t
)))
4242 error ("temporary of non-literal type %qT in a "
4243 "constant expression", TREE_TYPE (t
));
4244 explain_non_literal_class (TREE_TYPE (t
));
4246 *non_constant_p
= true;
4249 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4251 /* We're being expanded without an explicit target, so start
4252 initializing a new object; expansion with an explicit target
4253 strips the TARGET_EXPR before we get here. */
4255 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4256 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4257 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4258 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4261 /* Pass false for 'lval' because this indicates
4262 initialization of a temporary. */
4263 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4265 non_constant_p
, overflow_p
);
4266 if (!*non_constant_p
)
4267 /* Adjust the type of the result to the type of the temporary. */
4268 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4271 tree slot
= TARGET_EXPR_SLOT (t
);
4272 r
= unshare_constructor (r
);
4273 ctx
->values
->put (slot
, r
);
4280 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4281 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4282 non_constant_p
, overflow_p
);
4286 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4288 non_constant_p
, overflow_p
);
4292 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4293 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4295 non_constant_p
, overflow_p
);
4300 /* Can happen with ({ return true; }) && false; passed to
4301 maybe_constant_value. There is nothing to jump over in this
4302 case, and the bug will be diagnosed later. */
4303 gcc_assert (ctx
->quiet
);
4304 *non_constant_p
= true;
4309 /* Avoid evaluating a SAVE_EXPR more than once. */
4310 if (tree
*p
= ctx
->values
->get (t
))
4314 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4315 non_constant_p
, overflow_p
);
4316 ctx
->values
->put (t
, r
);
4317 if (ctx
->save_exprs
)
4318 ctx
->save_exprs
->add (t
);
4322 case NON_LVALUE_EXPR
:
4323 case TRY_CATCH_EXPR
:
4325 case CLEANUP_POINT_EXPR
:
4326 case MUST_NOT_THROW_EXPR
:
4329 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4331 non_constant_p
, overflow_p
,
4335 case TRY_FINALLY_EXPR
:
4336 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4337 non_constant_p
, overflow_p
,
4339 if (!*non_constant_p
)
4340 /* Also evaluate the cleanup. */
4341 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4342 non_constant_p
, overflow_p
,
4346 /* These differ from cxx_eval_unary_expression in that this doesn't
4347 check for a constant operand or result; an address can be
4348 constant without its operand being, and vice versa. */
4351 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4352 non_constant_p
, overflow_p
);
4357 tree oldop
= TREE_OPERAND (t
, 0);
4358 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4360 non_constant_p
, overflow_p
);
4361 /* Don't VERIFY_CONSTANT here. */
4362 if (*non_constant_p
)
4364 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4365 /* This function does more aggressive folding than fold itself. */
4366 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4367 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4376 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4377 non_constant_p
, overflow_p
);
4378 if (r
== error_mark_node
)
4380 else if (r
== TREE_OPERAND (t
, 0))
4383 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4388 case FIX_TRUNC_EXPR
:
4393 case TRUTH_NOT_EXPR
:
4394 case FIXED_CONVERT_EXPR
:
4395 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4396 non_constant_p
, overflow_p
);
4400 r
= fold_sizeof_expr (t
);
4401 VERIFY_CONSTANT (r
);
4406 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4407 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4408 introduced by build_call_a. */
4409 tree op0
= TREE_OPERAND (t
, 0);
4410 tree op1
= TREE_OPERAND (t
, 1);
4412 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4413 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4414 r
= cxx_eval_constant_expression (ctx
, op0
,
4415 lval
, non_constant_p
, overflow_p
,
4419 /* Check that the LHS is constant and then discard it. */
4420 cxx_eval_constant_expression (ctx
, op0
,
4421 true, non_constant_p
, overflow_p
,
4423 if (*non_constant_p
)
4425 op1
= TREE_OPERAND (t
, 1);
4426 r
= cxx_eval_constant_expression (ctx
, op1
,
4427 lval
, non_constant_p
, overflow_p
,
4433 case POINTER_PLUS_EXPR
:
4434 case POINTER_DIFF_EXPR
:
4438 case TRUNC_DIV_EXPR
:
4440 case FLOOR_DIV_EXPR
:
4441 case ROUND_DIV_EXPR
:
4442 case TRUNC_MOD_EXPR
:
4444 case ROUND_MOD_EXPR
:
4446 case EXACT_DIV_EXPR
:
4456 case TRUTH_XOR_EXPR
:
4463 case UNORDERED_EXPR
:
4473 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4474 non_constant_p
, overflow_p
);
4477 /* fold can introduce non-IF versions of these; still treat them as
4478 short-circuiting. */
4479 case TRUTH_AND_EXPR
:
4480 case TRUTH_ANDIF_EXPR
:
4481 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4484 non_constant_p
, overflow_p
);
4488 case TRUTH_ORIF_EXPR
:
4489 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4492 non_constant_p
, overflow_p
);
4496 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4497 non_constant_p
, overflow_p
);
4501 if (is_overloaded_fn (t
))
4503 /* We can only get here in checking mode via
4504 build_non_dependent_expr, because any expression that
4505 calls or takes the address of the function will have
4506 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4507 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4508 *non_constant_p
= true;
4511 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4512 non_constant_p
, overflow_p
);
4516 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4517 non_constant_p
, overflow_p
);
4521 if (jump_target
&& *jump_target
)
4523 /* When jumping to a label, the label might be either in the
4524 then or else blocks, so process then block first in skipping
4525 mode first, and if we are still in the skipping mode at its end,
4526 process the else block too. */
4527 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4528 lval
, non_constant_p
, overflow_p
,
4531 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4532 lval
, non_constant_p
, overflow_p
,
4536 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4537 non_constant_p
, overflow_p
,
4541 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4546 if (TREE_CONSTANT (t
))
4548 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4549 VECTOR_CST if applicable. */
4550 verify_constructor_flags (t
);
4551 if (TREE_CONSTANT (t
))
4554 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4555 non_constant_p
, overflow_p
);
4559 /* We can get this in a defaulted constructor for a class with a
4560 non-static data member of array type. Either the initializer will
4561 be NULL, meaning default-initialization, or it will be an lvalue
4562 or xvalue of the same type, meaning direct-initialization from the
4563 corresponding member. */
4564 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4565 non_constant_p
, overflow_p
);
4570 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4571 non_constant_p
, overflow_p
);
4575 case VIEW_CONVERT_EXPR
:
4577 case UNARY_PLUS_EXPR
:
4579 tree oldop
= TREE_OPERAND (t
, 0);
4581 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4583 non_constant_p
, overflow_p
);
4584 if (*non_constant_p
)
4586 tree type
= TREE_TYPE (t
);
4587 if (TREE_CODE (op
) == PTRMEM_CST
4588 && !TYPE_PTRMEM_P (type
))
4589 op
= cplus_expand_constant (op
);
4590 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4592 if (same_type_ignoring_top_level_qualifiers_p (type
,
4594 || can_convert_qual (type
, op
))
4595 return cp_fold_convert (type
, op
);
4599 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4600 "a reinterpret_cast is not a constant expression");
4601 *non_constant_p
= true;
4606 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4608 if (integer_zerop (op
))
4610 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4613 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4614 "dereferencing a null pointer");
4615 *non_constant_p
= true;
4618 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4620 tree from
= TREE_TYPE (op
);
4622 if (!can_convert (type
, from
, tf_none
))
4625 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4626 "conversion of %qT null pointer to %qT "
4627 "is not a constant expression",
4629 *non_constant_p
= true;
4636 /* This detects for example:
4637 reinterpret_cast<void*>(sizeof 0)
4640 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4641 "%<reinterpret_cast<%T>(%E)%> is not "
4642 "a constant expression",
4644 *non_constant_p
= true;
4648 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4649 /* We didn't fold at the top so we could check for ptr-int
4652 if (tcode
== UNARY_PLUS_EXPR
)
4653 r
= fold_convert (TREE_TYPE (t
), op
);
4655 r
= fold_build1 (tcode
, type
, op
);
4656 /* Conversion of an out-of-range value has implementation-defined
4657 behavior; the language considers it different from arithmetic
4658 overflow, which is undefined. */
4659 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4660 TREE_OVERFLOW (r
) = false;
4664 case EMPTY_CLASS_EXPR
:
4665 /* This is good enough for a function argument that might not get
4666 used, and they can't do anything with it, so just return it. */
4669 case STATEMENT_LIST
:
4671 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4672 return cxx_eval_statement_list (&new_ctx
, t
,
4673 non_constant_p
, overflow_p
, jump_target
);
4676 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4678 non_constant_p
, overflow_p
,
4681 case PREINCREMENT_EXPR
:
4682 case POSTINCREMENT_EXPR
:
4683 case PREDECREMENT_EXPR
:
4684 case POSTDECREMENT_EXPR
:
4685 return cxx_eval_increment_expression (ctx
, t
,
4686 lval
, non_constant_p
, overflow_p
);
4692 case VEC_DELETE_EXPR
:
4695 /* GCC internal stuff. */
4698 case NON_DEPENDENT_EXPR
:
4702 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4703 "expression %qE is not a constant expression", t
);
4704 *non_constant_p
= true;
4707 case PLACEHOLDER_EXPR
:
4708 /* Use of the value or address of the current object. */
4709 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4710 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4711 non_constant_p
, overflow_p
);
4712 /* A placeholder without a referent. We can get here when
4713 checking whether NSDMIs are noexcept, or in massage_init_elt;
4714 just say it's non-constant for now. */
4715 gcc_assert (ctx
->quiet
);
4716 *non_constant_p
= true;
4721 tree cond
= TREE_OPERAND (t
, 0);
4722 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4723 non_constant_p
, overflow_p
);
4724 VERIFY_CONSTANT (cond
);
4725 if (integer_nonzerop (cond
))
4731 *jump_target
= TREE_OPERAND (t
, 0);
4732 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4733 /* Allow for jumping to a cdtor_label. */
4734 || returns (jump_target
));
4738 cxx_eval_loop_expr (ctx
, t
,
4739 non_constant_p
, overflow_p
, jump_target
);
4743 cxx_eval_switch_expr (ctx
, t
,
4744 non_constant_p
, overflow_p
, jump_target
);
4748 /* It's possible to get a requires-expression in a constant
4749 expression. For example:
4751 template<typename T> concept bool C() {
4752 return requires (T t) { t; };
4755 template<typename T> requires !C<T>() void f(T);
4757 Normalization leaves f with the associated constraint
4758 '!requires (T t) { ... }' which is not transformed into
4760 if (!processing_template_decl
)
4761 return evaluate_constraint_expression (t
, NULL_TREE
);
4763 *non_constant_p
= true;
4767 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4769 non_constant_p
, overflow_p
,
4778 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4780 /* This function doesn't know how to deal with pre-genericize
4781 statements; this can only happen with statement-expressions,
4782 so for now just fail. */
4784 error_at (EXPR_LOCATION (t
),
4785 "statement is not a constant expression");
4788 internal_error ("unexpected expression %qE of kind %s", t
,
4789 get_tree_code_name (TREE_CODE (t
)));
4790 *non_constant_p
= true;
4794 if (r
== error_mark_node
)
4795 *non_constant_p
= true;
4797 if (*non_constant_p
)
4804 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4805 bool strict
= true, tree object
= NULL_TREE
)
4807 auto_timevar
time (TV_CONSTEXPR
);
4809 bool non_constant_p
= false;
4810 bool overflow_p
= false;
4811 hash_map
<tree
,tree
> map
;
4813 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4814 allow_non_constant
, strict
};
4816 tree type
= initialized_type (t
);
4818 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4820 /* In C++14 an NSDMI can participate in aggregate initialization,
4821 and can refer to the address of the object being initialized, so
4822 we need to pass in the relevant VAR_DECL if we want to do the
4823 evaluation in a single pass. The evaluation will dynamically
4824 update ctx.values for the VAR_DECL. We use the same strategy
4825 for C++11 constexpr constructors that refer to the object being
4827 ctx
.ctor
= build_constructor (type
, NULL
);
4828 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4831 if (TREE_CODE (t
) == TARGET_EXPR
)
4832 object
= TARGET_EXPR_SLOT (t
);
4833 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4834 object
= AGGR_INIT_EXPR_SLOT (t
);
4836 ctx
.object
= object
;
4838 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4839 (type
, TREE_TYPE (object
)));
4840 if (object
&& DECL_P (object
))
4841 map
.put (object
, ctx
.ctor
);
4842 if (TREE_CODE (r
) == TARGET_EXPR
)
4843 /* Avoid creating another CONSTRUCTOR when we expand the
4845 r
= TARGET_EXPR_INITIAL (r
);
4848 r
= cxx_eval_constant_expression (&ctx
, r
,
4849 false, &non_constant_p
, &overflow_p
);
4851 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4853 /* Mutable logic is a bit tricky: we want to allow initialization of
4854 constexpr variables with mutable members, but we can't copy those
4855 members to another constexpr variable. */
4856 if (TREE_CODE (r
) == CONSTRUCTOR
4857 && CONSTRUCTOR_MUTABLE_POISON (r
))
4859 if (!allow_non_constant
)
4860 error ("%qE is not a constant expression because it refers to "
4861 "mutable subobjects of %qT", t
, type
);
4862 non_constant_p
= true;
4865 if (TREE_CODE (r
) == CONSTRUCTOR
4866 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4868 if (!allow_non_constant
)
4869 error ("%qE is not a constant expression because it refers to "
4870 "an incompletely initialized variable", t
);
4871 TREE_CONSTANT (r
) = false;
4872 non_constant_p
= true;
4875 /* Technically we should check this for all subexpressions, but that
4876 runs into problems with our internal representation of pointer
4877 subtraction and the 5.19 rules are still in flux. */
4878 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4879 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4880 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4882 if (!allow_non_constant
)
4883 error ("conversion from pointer type %qT "
4884 "to arithmetic type %qT in a constant expression",
4885 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4886 non_constant_p
= true;
4889 if (!non_constant_p
&& overflow_p
)
4890 non_constant_p
= true;
4892 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4894 bool should_unshare
= true;
4895 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4896 should_unshare
= false;
4898 if (non_constant_p
&& !allow_non_constant
)
4899 return error_mark_node
;
4900 else if (non_constant_p
&& TREE_CONSTANT (r
))
4902 /* This isn't actually constant, so unset TREE_CONSTANT.
4903 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
4904 it to be set if it is invariant address, even when it is not
4905 a valid C++ constant expression. Wrap it with a NOP_EXPR
4907 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
4909 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4910 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4912 r
= build_nop (TREE_TYPE (r
), r
);
4913 TREE_CONSTANT (r
) = false;
4915 else if (non_constant_p
|| r
== t
)
4919 r
= unshare_expr (r
);
4921 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4923 if (TREE_CODE (t
) == TARGET_EXPR
4924 && TARGET_EXPR_INITIAL (t
) == r
)
4928 r
= get_target_expr (r
);
4929 TREE_CONSTANT (r
) = true;
4937 /* Returns true if T is a valid subexpression of a constant expression,
4938 even if it isn't itself a constant expression. */
4941 is_sub_constant_expr (tree t
)
4943 bool non_constant_p
= false;
4944 bool overflow_p
= false;
4945 hash_map
<tree
, tree
> map
;
4947 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4949 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4951 return !non_constant_p
&& !overflow_p
;
4954 /* If T represents a constant expression returns its reduced value.
4955 Otherwise return error_mark_node. If T is dependent, then
4959 cxx_constant_value (tree t
, tree decl
)
4961 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4964 /* Helper routine for fold_simple function. Either return simplified
4965 expression T, otherwise NULL_TREE.
4966 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4967 even if we are within template-declaration. So be careful on call, as in
4968 such case types can be undefined. */
4971 fold_simple_1 (tree t
)
4974 enum tree_code code
= TREE_CODE (t
);
4986 return fold_sizeof_expr (t
);
4994 case TRUTH_NOT_EXPR
:
4996 case VIEW_CONVERT_EXPR
:
4999 case FIX_TRUNC_EXPR
:
5000 case FIXED_CONVERT_EXPR
:
5001 case ADDR_SPACE_CONVERT_EXPR
:
5003 op1
= TREE_OPERAND (t
, 0);
5005 t
= const_unop (code
, TREE_TYPE (t
), op1
);
5009 if (CONVERT_EXPR_CODE_P (code
)
5010 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
5011 TREE_OVERFLOW (t
) = false;
5019 /* If T is a simple constant expression, returns its simplified value.
5020 Otherwise returns T. In contrast to maybe_constant_value we
5021 simplify only few operations on constant-expressions, and we don't
5022 try to simplify constexpressions. */
5025 fold_simple (tree t
)
5027 if (processing_template_decl
)
5030 tree r
= fold_simple_1 (t
);
5037 /* If T is a constant expression, returns its reduced value.
5038 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5039 Otherwise, returns a version of T without TREE_CONSTANT. */
5041 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5044 maybe_constant_value (tree t
, tree decl
)
5048 if (!is_nondependent_constant_expression (t
))
5050 if (TREE_OVERFLOW_P (t
))
5052 t
= build_nop (TREE_TYPE (t
), t
);
5053 TREE_CONSTANT (t
) = false;
5057 else if (CONSTANT_CLASS_P (t
))
5058 /* No caching or evaluation needed. */
5061 if (cv_cache
== NULL
)
5062 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5063 if (tree
*cached
= cv_cache
->get (t
))
5066 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
5067 gcc_checking_assert (r
== t
5068 || CONVERT_EXPR_P (t
)
5069 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5070 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5071 || !cp_tree_equal (r
, t
));
5072 cv_cache
->put (t
, r
);
5076 /* Dispose of the whole CV_CACHE. */
5079 clear_cv_cache (void)
5081 if (cv_cache
!= NULL
)
5085 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5088 clear_cv_and_fold_caches (void)
5091 clear_fold_cache ();
5094 /* Like maybe_constant_value but first fully instantiate the argument.
5096 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5097 (t, tf_none) followed by maybe_constant_value but is more efficient,
5098 because calls instantiation_dependent_expression_p and
5099 potential_constant_expression at most once. */
5102 fold_non_dependent_expr (tree t
)
5107 /* If we're in a template, but T isn't value dependent, simplify
5108 it. We're supposed to treat:
5110 template <typename T> void f(T[1 + 1]);
5111 template <typename T> void f(T[2]);
5113 as two declarations of the same function, for example. */
5114 if (processing_template_decl
)
5116 if (is_nondependent_constant_expression (t
))
5118 processing_template_decl_sentinel s
;
5119 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
5121 if (type_unknown_p (t
)
5122 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5124 if (TREE_OVERFLOW_P (t
))
5126 t
= build_nop (TREE_TYPE (t
), t
);
5127 TREE_CONSTANT (t
) = false;
5132 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
5133 /* cp_tree_equal looks through NOPs, so allow them. */
5134 gcc_checking_assert (r
== t
5135 || CONVERT_EXPR_P (t
)
5136 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5137 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5138 || !cp_tree_equal (r
, t
));
5141 else if (TREE_OVERFLOW_P (t
))
5143 t
= build_nop (TREE_TYPE (t
), t
);
5144 TREE_CONSTANT (t
) = false;
5149 return maybe_constant_value (t
);
5152 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5153 than wrapped in a TARGET_EXPR. */
5156 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
)
5160 if (TREE_CODE (t
) == EXPR_STMT
)
5161 t
= TREE_OPERAND (t
, 0);
5162 if (TREE_CODE (t
) == CONVERT_EXPR
5163 && VOID_TYPE_P (TREE_TYPE (t
)))
5164 t
= TREE_OPERAND (t
, 0);
5165 if (TREE_CODE (t
) == INIT_EXPR
)
5166 t
= TREE_OPERAND (t
, 1);
5167 if (TREE_CODE (t
) == TARGET_EXPR
)
5168 t
= TARGET_EXPR_INITIAL (t
);
5169 if (!is_nondependent_static_init_expression (t
))
5170 /* Don't try to evaluate it. */;
5171 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5172 /* No evaluation needed. */;
5174 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
, false, decl
);
5175 if (TREE_CODE (t
) == TARGET_EXPR
)
5177 tree init
= TARGET_EXPR_INITIAL (t
);
5178 if (TREE_CODE (init
) == CONSTRUCTOR
)
5184 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5187 maybe_constant_init (tree t
, tree decl
)
5189 return maybe_constant_init_1 (t
, decl
, true);
5192 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5195 cxx_constant_init (tree t
, tree decl
)
5197 return maybe_constant_init_1 (t
, decl
, false);
5201 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5202 /* Return true if the object referred to by REF has automatic or thread
5205 enum { ck_ok
, ck_bad
, ck_unknown
};
5207 check_automatic_or_tls (tree ref
)
5210 poly_int64 bitsize
, bitpos
;
5212 int volatilep
= 0, unsignedp
= 0;
5213 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5214 &mode
, &unsignedp
, &volatilep
, false);
5217 /* If there isn't a decl in the middle, we don't know the linkage here,
5218 and this isn't a constant expression anyway. */
5221 dk
= decl_storage_duration (decl
);
5222 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5226 /* Return true if T denotes a potentially constant expression. Issue
5227 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5228 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5229 consider the expression in the current context, independent of constexpr
5232 C++0x [expr.const] used to say
5234 6 An expression is a potential constant expression if it is
5235 a constant expression where all occurrences of function
5236 parameters are replaced by arbitrary constant expressions
5237 of the appropriate type.
5239 2 A conditional expression is a constant expression unless it
5240 involves one of the following as a potentially evaluated
5241 subexpression (3.2), but subexpressions of logical AND (5.14),
5242 logical OR (5.15), and conditional (5.16) operations that are
5243 not evaluated are not considered. */
5246 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5247 tsubst_flags_t flags
)
5249 #define RECUR(T,RV) \
5250 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5252 enum { any
= false, rval
= true };
5256 if (t
== error_mark_node
)
5260 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5261 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5263 if (flags
& tf_error
)
5264 error_at (loc
, "expression %qE has side-effects", t
);
5267 if (CONSTANT_CLASS_P (t
))
5269 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5270 && TREE_TYPE (t
) == error_mark_node
)
5273 switch (TREE_CODE (t
))
5279 case TEMPLATE_ID_EXPR
:
5282 case CASE_LABEL_EXPR
:
5288 case TEMPLATE_PARM_INDEX
:
5290 case IDENTIFIER_NODE
:
5291 case USERDEF_LITERAL
:
5292 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5297 case PLACEHOLDER_EXPR
:
5302 case DEBUG_BEGIN_STMT
:
5308 if (flags
& tf_error
)
5309 error ("%qE is not a constant expression", t
);
5314 case AGGR_INIT_EXPR
:
5316 /* -- an invocation of a function other than a constexpr function
5317 or a constexpr constructor. */
5319 tree fun
= get_function_named_in_call (t
);
5320 const int nargs
= call_expr_nargs (t
);
5323 if (fun
== NULL_TREE
)
5325 /* Reset to allow the function to continue past the end
5326 of the block below. Otherwise return early. */
5329 if (TREE_CODE (t
) == CALL_EXPR
5330 && CALL_EXPR_FN (t
) == NULL_TREE
)
5331 switch (CALL_EXPR_IFN (t
))
5333 /* These should be ignored, they are optimized away from
5334 constexpr functions. */
5335 case IFN_UBSAN_NULL
:
5336 case IFN_UBSAN_BOUNDS
:
5337 case IFN_UBSAN_VPTR
:
5338 case IFN_FALLTHROUGH
:
5341 case IFN_ADD_OVERFLOW
:
5342 case IFN_SUB_OVERFLOW
:
5343 case IFN_MUL_OVERFLOW
:
5353 /* fold_call_expr can't do anything with IFN calls. */
5354 if (flags
& tf_error
)
5355 error_at (loc
, "call to internal function %qE", t
);
5360 if (fun
&& is_overloaded_fn (fun
))
5362 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5364 if (builtin_valid_in_constant_expr_p (fun
))
5366 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5367 /* Allow any built-in function; if the expansion
5368 isn't constant, we'll deal with that then. */
5369 && !is_builtin_fn (fun
))
5371 if (flags
& tf_error
)
5373 error_at (loc
, "call to non-%<constexpr%> function %qD",
5375 explain_invalid_constexpr_fn (fun
);
5379 /* A call to a non-static member function takes the address
5380 of the object as the first argument. But in a constant
5381 expression the address will be folded away, so look
5383 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5384 && !DECL_CONSTRUCTOR_P (fun
))
5386 tree x
= get_nth_callarg (t
, 0);
5387 if (is_this_parameter (x
))
5389 /* Don't require an immediately constant value, as
5390 constexpr substitution might not use the value. */
5391 bool sub_now
= false;
5392 if (!potential_constant_expression_1 (x
, rval
, strict
,
5400 if (!RECUR (fun
, true))
5402 fun
= get_first_fn (fun
);
5404 /* Skip initial arguments to base constructors. */
5405 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5406 i
= num_artificial_parms_for (fun
);
5407 fun
= DECL_ORIGIN (fun
);
5411 if (RECUR (fun
, rval
))
5412 /* Might end up being a constant function pointer. */;
5416 for (; i
< nargs
; ++i
)
5418 tree x
= get_nth_callarg (t
, i
);
5419 /* In a template, reference arguments haven't been converted to
5420 REFERENCE_TYPE and we might not even know if the parameter
5421 is a reference, so accept lvalue constants too. */
5422 bool rv
= processing_template_decl
? any
: rval
;
5423 /* Don't require an immediately constant value, as constexpr
5424 substitution might not use the value of the argument. */
5425 bool sub_now
= false;
5426 if (!potential_constant_expression_1 (x
, rv
, strict
,
5433 case NON_LVALUE_EXPR
:
5434 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5435 -- an lvalue of integral type that refers to a non-volatile
5436 const variable or static data member initialized with
5437 constant expressions, or
5439 -- an lvalue of literal type that refers to non-volatile
5440 object defined with constexpr, or that refers to a
5441 sub-object of such an object; */
5442 return RECUR (TREE_OPERAND (t
, 0), rval
);
5445 if (DECL_HAS_VALUE_EXPR_P (t
))
5447 if (now
&& is_normal_capture_proxy (t
))
5449 /* -- in a lambda-expression, a reference to this or to a
5450 variable with automatic storage duration defined outside that
5451 lambda-expression, where the reference would be an
5453 if (flags
& tf_error
)
5455 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5456 error ("lambda capture of %qE is not a constant expression",
5458 if (!want_rval
&& decl_constant_var_p (cap
))
5459 inform (input_location
, "because it is used as a glvalue");
5463 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5466 && !var_in_maybe_constexpr_fn (t
)
5467 && !type_dependent_expression_p (t
)
5468 && !decl_maybe_constant_var_p (t
)
5470 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5471 || (DECL_INITIAL (t
)
5472 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5473 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5474 && !is_really_empty_class (TREE_TYPE (t
)))
5476 if (flags
& tf_error
)
5477 non_const_var_error (t
);
5484 case VIEW_CONVERT_EXPR
:
5485 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5486 may change to something more specific to type-punning (DR 1312). */
5488 tree from
= TREE_OPERAND (t
, 0);
5489 if (POINTER_TYPE_P (TREE_TYPE (t
))
5490 && TREE_CODE (from
) == INTEGER_CST
5491 && !integer_zerop (from
))
5493 if (flags
& tf_error
)
5494 error_at (loc
, "reinterpret_cast from integer to pointer");
5497 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5500 case ADDRESSOF_EXPR
:
5501 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5502 t
= TREE_OPERAND (t
, 0);
5503 goto handle_addr_expr
;
5506 /* -- a unary operator & that is applied to an lvalue that
5507 designates an object with thread or automatic storage
5509 t
= TREE_OPERAND (t
, 0);
5511 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5512 /* A pointer-to-member constant. */
5517 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5518 any checking here, as we might dereference the pointer later. If
5519 we remove this code, also remove check_automatic_or_tls. */
5520 i
= check_automatic_or_tls (t
);
5525 if (flags
& tf_error
)
5526 error ("address-of an object %qE with thread local or "
5527 "automatic storage is not a constant expression", t
);
5531 return RECUR (t
, any
);
5539 /* -- a class member access unless its postfix-expression is
5540 of literal type or of pointer to literal type. */
5541 /* This test would be redundant, as it follows from the
5542 postfix-expression being a potential constant expression. */
5543 if (type_unknown_p (t
))
5545 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5547 case EXPR_PACK_EXPANSION
:
5548 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5552 tree x
= TREE_OPERAND (t
, 0);
5554 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5556 if (!var_in_maybe_constexpr_fn (x
))
5558 if (flags
& tf_error
)
5559 error_at (loc
, "use of %<this%> in a constant expression");
5564 return RECUR (x
, rval
);
5567 case STATEMENT_LIST
:
5569 tree_stmt_iterator i
;
5570 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5572 if (!RECUR (tsi_stmt (i
), any
))
5580 if (cxx_dialect
< cxx14
)
5582 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5584 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5589 if (cxx_dialect
< cxx14
)
5591 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5593 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5598 if (!RECUR (DO_COND (t
), rval
))
5600 if (!RECUR (DO_BODY (t
), any
))
5605 if (!RECUR (FOR_INIT_STMT (t
), any
))
5607 if (!RECUR (FOR_COND (t
), rval
))
5609 if (!RECUR (FOR_EXPR (t
), any
))
5611 if (!RECUR (FOR_BODY (t
), any
))
5615 case RANGE_FOR_STMT
:
5616 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5618 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5623 if (!RECUR (WHILE_COND (t
), rval
))
5625 if (!RECUR (WHILE_BODY (t
), any
))
5630 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5632 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5633 unreachable labels would be checked. */
5637 return RECUR (STMT_EXPR_STMT (t
), rval
);
5640 if (cxx_dialect
>= cxx17
)
5641 /* In C++17 lambdas can be constexpr, don't give up yet. */
5643 else if (flags
& tf_error
)
5644 error_at (loc
, "lambda-expression is not a constant expression "
5648 case DYNAMIC_CAST_EXPR
:
5649 case PSEUDO_DTOR_EXPR
:
5653 case VEC_DELETE_EXPR
:
5659 case OMP_DISTRIBUTE
:
5662 case OMP_TARGET_DATA
:
5671 case OMP_TARGET_UPDATE
:
5672 case OMP_TARGET_ENTER_DATA
:
5673 case OMP_TARGET_EXIT_DATA
:
5675 case OMP_ATOMIC_READ
:
5676 case OMP_ATOMIC_CAPTURE_OLD
:
5677 case OMP_ATOMIC_CAPTURE_NEW
:
5681 case OACC_HOST_DATA
:
5685 case OACC_ENTER_DATA
:
5686 case OACC_EXIT_DATA
:
5688 /* GCC internal stuff. */
5691 case TRANSACTION_EXPR
:
5693 case AT_ENCODE_EXPR
:
5695 if (flags
& tf_error
)
5696 error_at (loc
, "expression %qE is not a constant expression", t
);
5700 /* -- a typeid expression whose operand is of polymorphic
5703 tree e
= TREE_OPERAND (t
, 0);
5704 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5705 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5707 if (flags
& tf_error
)
5708 error_at (loc
, "typeid-expression is not a constant expression "
5709 "because %qE is of polymorphic type", e
);
5715 case POINTER_DIFF_EXPR
:
5729 case PREINCREMENT_EXPR
:
5730 case POSTINCREMENT_EXPR
:
5731 case PREDECREMENT_EXPR
:
5732 case POSTDECREMENT_EXPR
:
5733 if (cxx_dialect
< cxx14
)
5739 if (TYPE_P (TREE_OPERAND (t
, 0)))
5745 case FIX_TRUNC_EXPR
:
5749 case TRUTH_NOT_EXPR
:
5750 case FIXED_CONVERT_EXPR
:
5751 case UNARY_PLUS_EXPR
:
5752 case UNARY_LEFT_FOLD_EXPR
:
5753 case UNARY_RIGHT_FOLD_EXPR
:
5755 return RECUR (TREE_OPERAND (t
, 0), rval
);
5758 case CONST_CAST_EXPR
:
5759 case STATIC_CAST_EXPR
:
5760 case REINTERPRET_CAST_EXPR
:
5761 case IMPLICIT_CONV_EXPR
:
5762 if (cxx_dialect
< cxx11
5763 && !dependent_type_p (TREE_TYPE (t
))
5764 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5765 /* In C++98, a conversion to non-integral type can't be part of a
5766 constant expression. */
5768 if (flags
& tf_error
)
5770 "cast to non-integral type %qT in a constant expression",
5775 return (RECUR (TREE_OPERAND (t
, 0),
5776 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5779 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5781 case CLEANUP_POINT_EXPR
:
5782 case MUST_NOT_THROW_EXPR
:
5783 case TRY_CATCH_EXPR
:
5788 case NON_DEPENDENT_EXPR
:
5789 /* For convenience. */
5793 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5796 tmp
= DECL_EXPR_DECL (t
);
5797 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5799 if (TREE_STATIC (tmp
))
5801 if (flags
& tf_error
)
5802 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5803 "%<static%> in %<constexpr%> context", tmp
);
5806 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5808 if (flags
& tf_error
)
5809 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5810 "%<thread_local%> in %<constexpr%> context", tmp
);
5813 else if (!check_for_uninitialized_const_var
5814 (tmp
, /*constexpr_context_p=*/true, flags
))
5817 return RECUR (tmp
, want_rval
);
5819 case TRY_FINALLY_EXPR
:
5820 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5821 && RECUR (TREE_OPERAND (t
, 1), any
));
5824 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5827 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
5828 && !literal_type_p (TREE_TYPE (t
)))
5830 if (flags
& tf_error
)
5832 error_at (loc
, "temporary of non-literal type %qT in a "
5833 "constant expression", TREE_TYPE (t
));
5834 explain_non_literal_class (TREE_TYPE (t
));
5840 return RECUR (TREE_OPERAND (t
, 1), rval
);
5844 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5845 constructor_elt
*ce
;
5846 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5847 if (!RECUR (ce
->value
, want_rval
))
5854 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5855 || DECL_P (TREE_PURPOSE (t
)));
5856 if (!RECUR (TREE_VALUE (t
), want_rval
))
5858 if (TREE_CHAIN (t
) == NULL_TREE
)
5860 return RECUR (TREE_CHAIN (t
), want_rval
);
5863 case TRUNC_DIV_EXPR
:
5865 case FLOOR_DIV_EXPR
:
5866 case ROUND_DIV_EXPR
:
5867 case TRUNC_MOD_EXPR
:
5869 case ROUND_MOD_EXPR
:
5871 tree denom
= TREE_OPERAND (t
, 1);
5872 if (!RECUR (denom
, rval
))
5874 /* We can't call cxx_eval_outermost_constant_expr on an expression
5875 that hasn't been through instantiate_non_dependent_expr yet. */
5876 if (!processing_template_decl
)
5877 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5878 if (integer_zerop (denom
))
5880 if (flags
& tf_error
)
5881 error ("division by zero is not a constant expression");
5887 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5893 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5894 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5895 introduced by build_call_a. */
5896 tree op0
= TREE_OPERAND (t
, 0);
5897 tree op1
= TREE_OPERAND (t
, 1);
5899 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5900 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5901 return RECUR (op0
, want_rval
);
5906 /* If the first operand is the non-short-circuit constant, look at
5907 the second operand; otherwise we only care about the first one for
5909 case TRUTH_AND_EXPR
:
5910 case TRUTH_ANDIF_EXPR
:
5911 tmp
= boolean_true_node
;
5914 case TRUTH_ORIF_EXPR
:
5915 tmp
= boolean_false_node
;
5918 tree op
= TREE_OPERAND (t
, 0);
5919 if (!RECUR (op
, rval
))
5921 if (!processing_template_decl
)
5922 op
= cxx_eval_outermost_constant_expr (op
, true);
5923 if (tree_int_cst_equal (op
, tmp
))
5924 return RECUR (TREE_OPERAND (t
, 1), rval
);
5931 case POINTER_PLUS_EXPR
:
5933 case EXACT_DIV_EXPR
:
5943 case TRUTH_XOR_EXPR
:
5944 case UNORDERED_EXPR
:
5957 case ARRAY_RANGE_REF
:
5961 case BINARY_LEFT_FOLD_EXPR
:
5962 case BINARY_RIGHT_FOLD_EXPR
:
5964 for (i
= 0; i
< 2; ++i
)
5965 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5971 for (i
= 0; i
< 3; ++i
)
5972 if (!RECUR (TREE_OPERAND (t
, i
), true))
5977 if (COND_EXPR_IS_VEC_DELETE (t
))
5979 if (flags
& tf_error
)
5980 error_at (loc
, "%<delete[]%> is not a constant expression");
5986 /* If the condition is a known constant, we know which of the legs we
5987 care about; otherwise we only require that the condition and
5988 either of the legs be potentially constant. */
5989 tmp
= TREE_OPERAND (t
, 0);
5990 if (!RECUR (tmp
, rval
))
5992 if (!processing_template_decl
)
5993 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5994 if (integer_zerop (tmp
))
5995 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5996 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5997 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5998 for (i
= 1; i
< 3; ++i
)
5999 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
6000 want_rval
, strict
, now
, tf_none
))
6002 if (flags
& tf_error
)
6003 error_at (loc
, "expression %qE is not a constant expression", t
);
6007 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
6009 if (flags
& tf_error
)
6011 error_at (loc
, "non-constant array initialization");
6012 diagnose_non_constexpr_vec_init (t
);
6018 /* We can see these in statement-expressions. */
6022 case EMPTY_CLASS_EXPR
:
6028 tree
*target
= &TREE_OPERAND (t
, 0);
6029 /* Gotos representing break and continue are OK. */
6030 if (breaks (target
) || continues (target
))
6032 if (flags
& tf_error
)
6033 error_at (loc
, "%<goto%> is not a constant expression");
6038 return RECUR (TREE_OPERAND (t
, 0), rval
);
6041 if (objc_is_property_ref (t
))
6044 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6051 /* The main entry point to the above. */
6054 potential_constant_expression (tree t
)
6056 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6059 /* As above, but require a constant rvalue. */
6062 potential_rvalue_constant_expression (tree t
)
6064 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6067 /* Like above, but complain about non-constant expressions. */
6070 require_potential_constant_expression (tree t
)
6072 return potential_constant_expression_1 (t
, false, true, false,
6073 tf_warning_or_error
);
6076 /* Cross product of the above. */
6079 require_potential_rvalue_constant_expression (tree t
)
6081 return potential_constant_expression_1 (t
, true, true, false,
6082 tf_warning_or_error
);
6085 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6088 require_rvalue_constant_expression (tree t
)
6090 return potential_constant_expression_1 (t
, true, true, true,
6091 tf_warning_or_error
);
6094 /* Like potential_constant_expression, but don't consider possible constexpr
6095 substitution of the current function. That is, PARM_DECL qualifies under
6096 potential_constant_expression, but not here.
6098 This is basically what you can check when any actual constant values might
6099 be value-dependent. */
6102 is_constant_expression (tree t
)
6104 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6107 /* Like above, but complain about non-constant expressions. */
6110 require_constant_expression (tree t
)
6112 return potential_constant_expression_1 (t
, false, true, true,
6113 tf_warning_or_error
);
6116 /* Like is_constant_expression, but allow const variables that are not allowed
6117 under constexpr rules. */
6120 is_static_init_expression (tree t
)
6122 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6125 /* Returns true if T is a potential constant expression that is not
6126 instantiation-dependent, and therefore a candidate for constant folding even
6130 is_nondependent_constant_expression (tree t
)
6132 return (!type_unknown_p (t
)
6133 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6134 && is_constant_expression (t
)
6135 && !instantiation_dependent_expression_p (t
));
6138 /* Returns true if T is a potential static initializer expression that is not
6139 instantiation-dependent. */
6142 is_nondependent_static_init_expression (tree t
)
6144 return (!type_unknown_p (t
)
6145 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6146 && is_static_init_expression (t
)
6147 && !instantiation_dependent_expression_p (t
));
6150 /* Finalize constexpr processing after parsing. */
6153 fini_constexpr (void)
6155 /* The contexpr call and fundef copies tables are no longer needed. */
6156 constexpr_call_table
= NULL
;
6157 fundef_copies_table
= NULL
;
6160 #include "gt-cp-constexpr.h"