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
);
1175 && current_function_decl
1176 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1178 *non_constant_p
= true;
1182 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1183 return constant false for a non-constant argument. */
1184 constexpr_ctx new_ctx
= *ctx
;
1185 new_ctx
.quiet
= true;
1186 bool dummy1
= false, dummy2
= false;
1187 for (i
= 0; i
< nargs
; ++i
)
1189 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1190 false, &dummy1
, &dummy2
);
1192 /* For __built_in_constant_p, fold all expressions with constant values
1193 even if they aren't C++ constant-expressions. */
1194 args
[i
] = cp_fully_fold (args
[i
]);
1197 bool save_ffbcp
= force_folding_builtin_constant_p
;
1198 force_folding_builtin_constant_p
= true;
1199 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1200 CALL_EXPR_FN (t
), nargs
, args
);
1201 force_folding_builtin_constant_p
= save_ffbcp
;
1202 if (new_call
== NULL
)
1204 if (!*non_constant_p
&& !ctx
->quiet
)
1206 /* Do not allow__builtin_unreachable in constexpr function.
1207 The __builtin_unreachable call with BUILTINS_LOCATION
1208 comes from cp_maybe_instrument_return. */
1209 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
1210 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1211 error ("%<constexpr%> call flows off the end of the function");
1214 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1215 CALL_EXPR_FN (t
), nargs
, args
);
1216 error ("%q+E is not a constant expression", new_call
);
1219 *non_constant_p
= true;
1223 if (!is_constant_expression (new_call
))
1225 if (!*non_constant_p
&& !ctx
->quiet
)
1226 error ("%q+E is not a constant expression", new_call
);
1227 *non_constant_p
= true;
1231 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1232 non_constant_p
, overflow_p
);
1235 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1236 the type of the value to match. */
1239 adjust_temp_type (tree type
, tree temp
)
1241 if (TREE_TYPE (temp
) == type
)
1243 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1244 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1245 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1246 gcc_assert (scalarish_type_p (type
));
1247 return cp_fold_convert (type
, temp
);
1250 /* Callback for walk_tree used by unshare_constructor. */
1253 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1257 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1262 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1263 subexpression, return an unshared copy of T. Otherwise return T. */
1266 unshare_constructor (tree t
)
1268 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1269 if (ctor
!= NULL_TREE
)
1270 return unshare_expr (t
);
1274 /* Subroutine of cxx_eval_call_expression.
1275 We are processing a call expression (either CALL_EXPR or
1276 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1277 all arguments and bind their values to correspondings
1278 parameters, making up the NEW_CALL context. */
1281 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1282 constexpr_call
*new_call
,
1283 bool *non_constant_p
, bool *overflow_p
,
1284 bool *non_constant_args
)
1286 const int nargs
= call_expr_nargs (t
);
1287 tree fun
= new_call
->fundef
->decl
;
1288 tree parms
= DECL_ARGUMENTS (fun
);
1290 tree
*p
= &new_call
->bindings
;
1291 for (i
= 0; i
< nargs
; ++i
)
1294 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1295 x
= get_nth_callarg (t
, i
);
1296 /* For member function, the first argument is a pointer to the implied
1297 object. For a constructor, it might still be a dummy object, in
1298 which case we get the real argument from ctx. */
1299 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1300 && is_dummy_object (x
))
1303 x
= build_address (x
);
1305 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1306 non_constant_p
, overflow_p
);
1307 /* Don't VERIFY_CONSTANT here. */
1308 if (*non_constant_p
&& ctx
->quiet
)
1310 /* Just discard ellipsis args after checking their constantitude. */
1314 if (!*non_constant_p
)
1316 /* Don't share a CONSTRUCTOR that might be changed. */
1317 arg
= unshare_constructor (arg
);
1318 /* Make sure the binding has the same type as the parm. But
1319 only for constant args. */
1320 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1321 arg
= adjust_temp_type (type
, arg
);
1322 if (!TREE_CONSTANT (arg
))
1323 *non_constant_args
= true;
1324 *p
= build_tree_list (parms
, arg
);
1325 p
= &TREE_CHAIN (*p
);
1327 parms
= TREE_CHAIN (parms
);
1331 /* Variables and functions to manage constexpr call expansion context.
1332 These do not need to be marked for PCH or GC. */
1334 /* FIXME remember and print actual constant arguments. */
1335 static vec
<tree
> call_stack
;
1336 static int call_stack_tick
;
1337 static int last_cx_error_tick
;
1340 push_cx_call_context (tree call
)
1343 if (!EXPR_HAS_LOCATION (call
))
1344 SET_EXPR_LOCATION (call
, input_location
);
1345 call_stack
.safe_push (call
);
1346 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1352 pop_cx_call_context (void)
1359 cx_error_context (void)
1361 vec
<tree
> r
= vNULL
;
1362 if (call_stack_tick
!= last_cx_error_tick
1363 && !call_stack
.is_empty ())
1365 last_cx_error_tick
= call_stack_tick
;
1369 /* Evaluate a call T to a GCC internal function when possible and return
1370 the evaluated result or, under the control of CTX, give an error, set
1371 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1374 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1376 bool *non_constant_p
, bool *overflow_p
)
1378 enum tree_code opcode
= ERROR_MARK
;
1380 switch (CALL_EXPR_IFN (t
))
1382 case IFN_UBSAN_NULL
:
1383 case IFN_UBSAN_BOUNDS
:
1384 case IFN_UBSAN_VPTR
:
1385 case IFN_FALLTHROUGH
:
1388 case IFN_ADD_OVERFLOW
:
1391 case IFN_SUB_OVERFLOW
:
1392 opcode
= MINUS_EXPR
;
1394 case IFN_MUL_OVERFLOW
:
1399 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1400 false, non_constant_p
, overflow_p
);
1404 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1405 "call to internal function %qE", t
);
1406 *non_constant_p
= true;
1410 /* Evaluate constant arguments using OPCODE and return a complex
1411 number containing the result and the overflow bit. */
1412 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1413 non_constant_p
, overflow_p
);
1414 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1415 non_constant_p
, overflow_p
);
1417 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1419 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1420 tree type
= TREE_TYPE (TREE_TYPE (t
));
1421 tree result
= fold_binary_loc (loc
, opcode
, type
,
1422 fold_convert_loc (loc
, type
, arg0
),
1423 fold_convert_loc (loc
, type
, arg1
));
1425 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1426 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1427 if (TREE_OVERFLOW (result
))
1428 TREE_OVERFLOW (result
) = 0;
1430 return build_complex (TREE_TYPE (t
), result
, ovf
);
1433 *non_constant_p
= true;
1437 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1440 clear_no_implicit_zero (tree ctor
)
1442 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1444 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1445 tree elt
; unsigned HOST_WIDE_INT idx
;
1446 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1447 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1448 clear_no_implicit_zero (elt
);
1452 /* Subroutine of cxx_eval_constant_expression.
1453 Evaluate the call expression tree T in the context of OLD_CALL expression
1457 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1459 bool *non_constant_p
, bool *overflow_p
)
1461 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1462 tree fun
= get_function_named_in_call (t
);
1463 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1466 if (fun
== NULL_TREE
)
1467 return cxx_eval_internal_function (ctx
, t
, lval
,
1468 non_constant_p
, overflow_p
);
1470 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1472 /* Might be a constexpr function pointer. */
1473 fun
= cxx_eval_constant_expression (ctx
, fun
,
1474 /*lval*/false, non_constant_p
,
1477 if (TREE_CODE (fun
) == ADDR_EXPR
)
1478 fun
= TREE_OPERAND (fun
, 0);
1480 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1482 if (!ctx
->quiet
&& !*non_constant_p
)
1483 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1485 *non_constant_p
= true;
1488 if (DECL_CLONED_FUNCTION_P (fun
))
1489 fun
= DECL_CLONED_FUNCTION (fun
);
1491 if (is_ubsan_builtin_p (fun
))
1494 if (is_builtin_fn (fun
))
1495 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1496 lval
, non_constant_p
, overflow_p
);
1497 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1501 if (!lambda_static_thunk_p (fun
))
1502 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1503 explain_invalid_constexpr_fn (fun
);
1505 *non_constant_p
= true;
1509 constexpr_ctx new_ctx
= *ctx
;
1510 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1511 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1513 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1514 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1515 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1516 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1517 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1518 ctx
->values
->put (new_ctx
.object
, ctor
);
1522 /* Shortcut trivial constructor/op=. */
1523 if (trivial_fn_p (fun
))
1525 tree init
= NULL_TREE
;
1526 if (call_expr_nargs (t
) == 2)
1527 init
= convert_from_reference (get_nth_callarg (t
, 1));
1528 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1529 && AGGR_INIT_ZERO_FIRST (t
))
1530 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1533 tree op
= get_nth_callarg (t
, 0);
1534 if (is_dummy_object (op
))
1537 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1538 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1539 new_ctx
.call
= &new_call
;
1540 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1541 non_constant_p
, overflow_p
);
1545 /* We can't defer instantiating the function any longer. */
1546 if (!DECL_INITIAL (fun
)
1547 && DECL_TEMPLOID_INSTANTIATION (fun
))
1549 location_t save_loc
= input_location
;
1550 input_location
= loc
;
1552 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1554 input_location
= save_loc
;
1557 /* If in direct recursive call, optimize definition search. */
1558 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1559 new_call
.fundef
= ctx
->call
->fundef
;
1562 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1563 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1564 || fun
== current_function_decl
)
1568 /* We need to check for current_function_decl here in case we're
1569 being called during cp_fold_function, because at that point
1570 DECL_INITIAL is set properly and we have a fundef but we
1571 haven't lowered invisirefs yet (c++/70344). */
1572 if (DECL_INITIAL (fun
) == error_mark_node
1573 || fun
== current_function_decl
)
1574 error_at (loc
, "%qD called in a constant expression before its "
1575 "definition is complete", fun
);
1576 else if (DECL_INITIAL (fun
))
1578 /* The definition of fun was somehow unsuitable. But pretend
1579 that lambda static thunks don't exist. */
1580 if (!lambda_static_thunk_p (fun
))
1581 error_at (loc
, "%qD called in a constant expression", fun
);
1582 explain_invalid_constexpr_fn (fun
);
1585 error_at (loc
, "%qD used before its definition", fun
);
1587 *non_constant_p
= true;
1592 bool non_constant_args
= false;
1593 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1594 non_constant_p
, overflow_p
, &non_constant_args
);
1595 if (*non_constant_p
)
1598 depth_ok
= push_cx_call_context (t
);
1600 tree result
= NULL_TREE
;
1602 constexpr_call
*entry
= NULL
;
1603 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1605 new_call
.hash
= iterative_hash_template_arg
1606 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1608 /* If we have seen this call before, we are done. */
1609 maybe_initialize_constexpr_call_table ();
1610 constexpr_call
**slot
1611 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1615 /* We need to keep a pointer to the entry, not just the slot, as the
1616 slot can move in the call to cxx_eval_builtin_function_call. */
1617 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1620 /* Calls that are in progress have their result set to NULL,
1621 so that we can detect circular dependencies. */
1622 else if (entry
->result
== NULL
)
1625 error ("call has circular dependency");
1626 *non_constant_p
= true;
1627 entry
->result
= result
= error_mark_node
;
1630 result
= entry
->result
;
1636 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1637 "-fconstexpr-depth= to increase the maximum)",
1638 max_constexpr_depth
);
1639 *non_constant_p
= true;
1640 result
= error_mark_node
;
1644 if (result
&& result
!= error_mark_node
)
1646 else if (!DECL_SAVED_TREE (fun
))
1648 /* When at_eof >= 2, cgraph has started throwing away
1649 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1650 late code generation for VEC_INIT_EXPR, which needs to be
1651 completely reconsidered. */
1652 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1653 *non_constant_p
= true;
1657 tree body
, parms
, res
;
1659 /* Reuse or create a new unshared copy of this function's body. */
1660 tree copy
= get_fundef_copy (fun
);
1661 body
= TREE_PURPOSE (copy
);
1662 parms
= TREE_VALUE (copy
);
1663 res
= TREE_TYPE (copy
);
1665 /* Associate the bindings with the remapped parms. */
1666 tree bound
= new_call
.bindings
;
1667 tree remapped
= parms
;
1670 tree oparm
= TREE_PURPOSE (bound
);
1671 tree arg
= TREE_VALUE (bound
);
1672 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1673 /* Don't share a CONSTRUCTOR that might be changed. */
1674 arg
= unshare_constructor (arg
);
1675 ctx
->values
->put (remapped
, arg
);
1676 bound
= TREE_CHAIN (bound
);
1677 remapped
= DECL_CHAIN (remapped
);
1679 /* Add the RESULT_DECL to the values map, too. */
1680 tree slot
= NULL_TREE
;
1681 if (DECL_BY_REFERENCE (res
))
1683 slot
= AGGR_INIT_EXPR_SLOT (t
);
1684 tree addr
= build_address (slot
);
1685 addr
= build_nop (TREE_TYPE (res
), addr
);
1686 ctx
->values
->put (res
, addr
);
1687 ctx
->values
->put (slot
, NULL_TREE
);
1690 ctx
->values
->put (res
, NULL_TREE
);
1692 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1693 their values after the call. */
1694 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1695 hash_set
<tree
> save_exprs
;
1696 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1697 ctx_with_save_exprs
.call
= &new_call
;
1699 tree jump_target
= NULL_TREE
;
1700 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1701 lval
, non_constant_p
, overflow_p
,
1704 if (DECL_CONSTRUCTOR_P (fun
))
1705 /* This can be null for a subobject constructor call, in
1706 which case what we care about is the initialization
1707 side-effects rather than the value. We could get at the
1708 value by evaluating *this, but we don't bother; there's
1709 no need to put such a call in the hash table. */
1710 result
= lval
? ctx
->object
: ctx
->ctor
;
1711 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1715 result
= *ctx
->values
->get (slot
? slot
: res
);
1716 if (result
== NULL_TREE
&& !*non_constant_p
)
1719 error ("%<constexpr%> call flows off the end "
1721 *non_constant_p
= true;
1725 /* Forget the saved values of the callee's SAVE_EXPRs. */
1726 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1727 iter
!= save_exprs
.end(); ++iter
)
1728 ctx_with_save_exprs
.values
->remove (*iter
);
1730 /* Remove the parms/result from the values map. Is it worth
1731 bothering to do this when the map itself is only live for
1732 one constexpr evaluation? If so, maybe also clear out
1733 other vars from call, maybe in BIND_EXPR handling? */
1734 ctx
->values
->remove (res
);
1736 ctx
->values
->remove (slot
);
1737 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1738 ctx
->values
->remove (parm
);
1740 /* Make the unshared function copy we used available for re-use. */
1741 save_fundef_copy (fun
, copy
);
1744 if (result
== error_mark_node
)
1745 *non_constant_p
= true;
1746 if (*non_constant_p
|| *overflow_p
)
1747 result
= error_mark_node
;
1751 entry
->result
= result
;
1754 /* The result of a constexpr function must be completely initialized. */
1755 if (TREE_CODE (result
) == CONSTRUCTOR
)
1756 clear_no_implicit_zero (result
);
1758 pop_cx_call_context ();
1759 return unshare_constructor (result
);
1762 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1765 reduced_constant_expression_p (tree t
)
1767 switch (TREE_CODE (t
))
1770 /* Even if we can't lower this yet, it's constant. */
1774 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1775 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1776 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1778 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1779 /* An initialized vector would have a VECTOR_CST. */
1782 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1786 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1789 /* We're in the middle of initializing this element. */
1791 if (!reduced_constant_expression_p (val
))
1797 field
= next_initializable_field (DECL_CHAIN (field
));
1802 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1803 /* All the fields are initialized. */
1804 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1808 /* FIXME are we calling this too much? */
1809 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1813 /* Some expressions may have constant operands but are not constant
1814 themselves, such as 1/0. Call this function (or rather, the macro
1815 following it) to check for that condition.
1817 We only call this in places that require an arithmetic constant, not in
1818 places where we might have a non-constant expression that can be a
1819 component of a constant expression, such as the address of a constexpr
1820 variable that might be dereferenced later. */
1823 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1826 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1828 if (!allow_non_constant
)
1829 error ("%q+E is not a constant expression", t
);
1830 *non_constant_p
= true;
1832 if (TREE_OVERFLOW_P (t
))
1834 if (!allow_non_constant
)
1836 permerror (input_location
, "overflow in constant expression");
1837 /* If we're being permissive (and are in an enforcing
1838 context), ignore the overflow. */
1839 if (flag_permissive
)
1840 return *non_constant_p
;
1844 return *non_constant_p
;
1847 /* Check whether the shift operation with code CODE and type TYPE on LHS
1848 and RHS is undefined. If it is, give an error with an explanation,
1849 and return true; return false otherwise. */
1852 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1853 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1855 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1856 || TREE_CODE (lhs
) != INTEGER_CST
1857 || TREE_CODE (rhs
) != INTEGER_CST
)
1860 tree lhstype
= TREE_TYPE (lhs
);
1861 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1863 /* [expr.shift] The behavior is undefined if the right operand
1864 is negative, or greater than or equal to the length in bits
1865 of the promoted left operand. */
1866 if (tree_int_cst_sgn (rhs
) == -1)
1869 permerror (loc
, "right operand of shift expression %q+E is negative",
1870 build2_loc (loc
, code
, type
, lhs
, rhs
));
1871 return (!flag_permissive
|| ctx
->quiet
);
1873 if (compare_tree_int (rhs
, uprec
) >= 0)
1876 permerror (loc
, "right operand of shift expression %q+E is >= than "
1877 "the precision of the left operand",
1878 build2_loc (loc
, code
, type
, lhs
, rhs
));
1879 return (!flag_permissive
|| ctx
->quiet
);
1882 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1883 if E1 has a signed type and non-negative value, and E1x2^E2 is
1884 representable in the corresponding unsigned type of the result type,
1885 then that value, converted to the result type, is the resulting value;
1886 otherwise, the behavior is undefined. */
1887 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1888 && (cxx_dialect
>= cxx11
))
1890 if (tree_int_cst_sgn (lhs
) == -1)
1894 "left operand of shift expression %q+E is negative",
1895 build2_loc (loc
, code
, type
, lhs
, rhs
));
1896 return (!flag_permissive
|| ctx
->quiet
);
1898 /* For signed x << y the following:
1899 (unsigned) x >> ((prec (lhs) - 1) - y)
1900 if > 1, is undefined. The right-hand side of this formula
1901 is the highest bit of the LHS that can be set (starting from 0),
1902 so that the shift doesn't overflow. We then right-shift the LHS
1903 to see whether any other bit is set making the original shift
1904 undefined -- the result is not representable in the corresponding
1906 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1907 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1908 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1909 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1910 if (tree_int_cst_lt (integer_one_node
, t
))
1913 permerror (loc
, "shift expression %q+E overflows",
1914 build2_loc (loc
, code
, type
, lhs
, rhs
));
1915 return (!flag_permissive
|| ctx
->quiet
);
1921 /* Subroutine of cxx_eval_constant_expression.
1922 Attempt to reduce the unary expression tree T to a compile time value.
1923 If successful, return the value. Otherwise issue a diagnostic
1924 and return error_mark_node. */
1927 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1929 bool *non_constant_p
, bool *overflow_p
)
1932 tree orig_arg
= TREE_OPERAND (t
, 0);
1933 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1934 non_constant_p
, overflow_p
);
1935 VERIFY_CONSTANT (arg
);
1936 location_t loc
= EXPR_LOCATION (t
);
1937 enum tree_code code
= TREE_CODE (t
);
1938 tree type
= TREE_TYPE (t
);
1939 r
= fold_unary_loc (loc
, code
, type
, arg
);
1942 if (arg
== orig_arg
)
1945 r
= build1_loc (loc
, code
, type
, arg
);
1947 VERIFY_CONSTANT (r
);
1951 /* Helper function for cxx_eval_binary_expression. Try to optimize
1952 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1953 generic folding should be used. */
1956 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1957 tree lhs
, tree rhs
, bool *non_constant_p
,
1961 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1964 lhs
= TREE_OPERAND (lhs
, 0);
1966 /* &A[i] p+ j => &A[i + j] */
1967 if (TREE_CODE (lhs
) == ARRAY_REF
1968 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1969 && TREE_CODE (rhs
) == INTEGER_CST
1970 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1971 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1973 tree orig_type
= TREE_TYPE (t
);
1974 location_t loc
= EXPR_LOCATION (t
);
1975 tree type
= TREE_TYPE (lhs
);
1977 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1978 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1979 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1981 if (*non_constant_p
)
1983 /* Don't fold an out-of-bound access. */
1984 if (!tree_int_cst_le (t
, nelts
))
1986 rhs
= cp_fold_convert (ssizetype
, rhs
);
1987 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1988 constexpr int A[1]; ... (char *)&A[0] + 1 */
1989 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1990 rhs
, TYPE_SIZE_UNIT (type
))))
1992 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1994 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1995 TYPE_SIZE_UNIT (type
));
1996 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1997 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1998 t
, NULL_TREE
, NULL_TREE
);
1999 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2000 t
= cp_fold_convert (orig_type
, t
);
2001 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2002 non_constant_p
, overflow_p
);
2008 /* Subroutine of cxx_eval_constant_expression.
2009 Like cxx_eval_unary_expression, except for binary expressions. */
2012 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2014 bool *non_constant_p
, bool *overflow_p
)
2017 tree orig_lhs
= TREE_OPERAND (t
, 0);
2018 tree orig_rhs
= TREE_OPERAND (t
, 1);
2020 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2021 non_constant_p
, overflow_p
);
2022 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2024 if (*non_constant_p
)
2026 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2027 non_constant_p
, overflow_p
);
2028 if (*non_constant_p
)
2031 location_t loc
= EXPR_LOCATION (t
);
2032 enum tree_code code
= TREE_CODE (t
);
2033 tree type
= TREE_TYPE (t
);
2035 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2037 bool is_code_eq
= (code
== EQ_EXPR
);
2039 if (TREE_CODE (lhs
) == PTRMEM_CST
2040 && TREE_CODE (rhs
) == PTRMEM_CST
)
2041 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2043 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2044 || TREE_CODE (rhs
) == PTRMEM_CST
)
2045 && (null_member_pointer_value_p (lhs
)
2046 || null_member_pointer_value_p (rhs
)))
2047 r
= constant_boolean_node (!is_code_eq
, type
);
2048 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2049 lhs
= cplus_expand_constant (lhs
);
2050 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2051 rhs
= cplus_expand_constant (rhs
);
2053 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2054 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2057 error ("arithmetic involving a null pointer in %qE", lhs
);
2060 else if (code
== POINTER_PLUS_EXPR
)
2061 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2065 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2069 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2072 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2074 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2075 *non_constant_p
= true;
2076 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2077 a local array in a constexpr function. */
2078 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2080 VERIFY_CONSTANT (r
);
2084 /* Subroutine of cxx_eval_constant_expression.
2085 Attempt to evaluate condition expressions. Dead branches are not
2089 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2091 bool *non_constant_p
, bool *overflow_p
,
2094 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2096 non_constant_p
, overflow_p
);
2097 VERIFY_CONSTANT (val
);
2098 /* Don't VERIFY_CONSTANT the other operands. */
2099 if (integer_zerop (val
))
2100 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2102 non_constant_p
, overflow_p
,
2104 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2106 non_constant_p
, overflow_p
,
2110 /* Subroutine of cxx_eval_constant_expression.
2111 Attempt to evaluate vector condition expressions. Unlike
2112 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2113 ternary arithmetics operation, where all 3 arguments have to be
2114 evaluated as constants and then folding computes the result from
2118 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2119 bool *non_constant_p
, bool *overflow_p
)
2121 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2123 non_constant_p
, overflow_p
);
2124 VERIFY_CONSTANT (arg1
);
2125 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2127 non_constant_p
, overflow_p
);
2128 VERIFY_CONSTANT (arg2
);
2129 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2131 non_constant_p
, overflow_p
);
2132 VERIFY_CONSTANT (arg3
);
2133 location_t loc
= EXPR_LOCATION (t
);
2134 tree type
= TREE_TYPE (t
);
2135 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2138 if (arg1
== TREE_OPERAND (t
, 0)
2139 && arg2
== TREE_OPERAND (t
, 1)
2140 && arg3
== TREE_OPERAND (t
, 2))
2143 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2145 VERIFY_CONSTANT (r
);
2149 /* Returns less than, equal to, or greater than zero if KEY is found to be
2150 less than, to match, or to be greater than the constructor_elt's INDEX. */
2153 array_index_cmp (tree key
, tree index
)
2155 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2157 switch (TREE_CODE (index
))
2160 return tree_int_cst_compare (key
, index
);
2163 tree lo
= TREE_OPERAND (index
, 0);
2164 tree hi
= TREE_OPERAND (index
, 1);
2165 if (tree_int_cst_lt (key
, lo
))
2167 else if (tree_int_cst_lt (hi
, key
))
2177 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2178 if none. If INSERT is true, insert a matching element rather than fail. */
2180 static HOST_WIDE_INT
2181 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2183 if (tree_int_cst_sgn (dindex
) < 0)
2186 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2187 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2188 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2190 unsigned HOST_WIDE_INT end
= len
;
2191 unsigned HOST_WIDE_INT begin
= 0;
2193 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2194 that the same is true of the other elements and index directly. */
2197 tree cindex
= (*elts
)[end
- 1].index
;
2198 if (TREE_CODE (cindex
) == INTEGER_CST
2199 && compare_tree_int (cindex
, end
- 1) == 0)
2208 /* Otherwise, find a matching index by means of a binary search. */
2209 while (begin
!= end
)
2211 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2212 constructor_elt
&elt
= (*elts
)[middle
];
2213 tree idx
= elt
.index
;
2215 int cmp
= array_index_cmp (dindex
, idx
);
2222 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2224 /* We need to split the range. */
2226 tree lo
= TREE_OPERAND (idx
, 0);
2227 tree hi
= TREE_OPERAND (idx
, 1);
2228 tree value
= elt
.value
;
2229 dindex
= fold_convert (sizetype
, dindex
);
2230 if (tree_int_cst_lt (lo
, dindex
))
2232 /* There are still some lower elts; shorten the range. */
2233 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2235 if (tree_int_cst_equal (lo
, new_hi
))
2236 /* Only one element left, no longer a range. */
2239 TREE_OPERAND (idx
, 1) = new_hi
;
2240 /* Append the element we want to insert. */
2243 e
.value
= unshare_constructor (value
);
2244 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2247 /* No lower elts, the range elt is now ours. */
2250 if (tree_int_cst_lt (dindex
, hi
))
2252 /* There are still some higher elts; append a range. */
2253 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2255 if (tree_int_cst_equal (new_lo
, hi
))
2258 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2259 e
.value
= unshare_constructor (value
);
2260 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2269 constructor_elt e
= { dindex
, NULL_TREE
};
2270 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2277 /* Under the control of CTX, issue a detailed diagnostic for
2278 an out-of-bounds subscript INDEX into the expression ARRAY. */
2281 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2285 tree arraytype
= TREE_TYPE (array
);
2287 /* Convert the unsigned array subscript to a signed integer to avoid
2288 printing huge numbers for small negative values. */
2289 tree sidx
= fold_convert (ssizetype
, index
);
2292 if (TYPE_DOMAIN (arraytype
))
2293 error ("array subscript value %qE is outside the bounds "
2294 "of array %qD of type %qT", sidx
, array
, arraytype
);
2296 error ("non-zero array subscript %qE is used with array %qD of "
2297 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2298 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2300 else if (TYPE_DOMAIN (arraytype
))
2301 error ("array subscript value %qE is outside the bounds "
2302 "of array type %qT", sidx
, arraytype
);
2304 error ("non-zero array subscript %qE is used with array of type %qT "
2305 "with unknown bounds", sidx
, arraytype
);
2309 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2313 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2314 bool *non_constant_p
, bool *overflow_p
)
2317 if (TREE_CODE (type
) == ARRAY_TYPE
)
2319 if (TYPE_DOMAIN (type
))
2320 nelts
= array_type_nelts_top (type
);
2322 nelts
= size_zero_node
;
2324 else if (VECTOR_TYPE_P (type
))
2325 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2329 /* For VLAs, the number of elements won't be an integer constant. */
2330 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2331 non_constant_p
, overflow_p
);
2335 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2336 STRING_CST STRING. */
2339 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2341 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2344 if (chars_per_elt
== 1)
2345 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2348 const unsigned char *ptr
2349 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2350 + index
* chars_per_elt
);
2351 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2356 /* Subroutine of cxx_eval_constant_expression.
2357 Attempt to reduce a reference to an array slot. */
2360 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2362 bool *non_constant_p
, bool *overflow_p
)
2364 tree oldary
= TREE_OPERAND (t
, 0);
2365 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2367 non_constant_p
, overflow_p
);
2369 HOST_WIDE_INT i
= 0;
2370 tree elem_type
= NULL_TREE
;
2371 unsigned len
= 0, elem_nchars
= 1;
2372 if (*non_constant_p
)
2374 oldidx
= TREE_OPERAND (t
, 1);
2375 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2377 non_constant_p
, overflow_p
);
2378 VERIFY_CONSTANT (index
);
2381 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2382 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2383 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2384 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2385 ary
= TREE_OPERAND (ary
, 0);
2386 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2387 len
= CONSTRUCTOR_NELTS (ary
);
2388 else if (TREE_CODE (ary
) == STRING_CST
)
2390 elem_nchars
= (TYPE_PRECISION (elem_type
)
2391 / TYPE_PRECISION (char_type_node
));
2392 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2394 else if (TREE_CODE (ary
) == VECTOR_CST
)
2395 /* We don't create variable-length VECTOR_CSTs. */
2396 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2399 /* We can't do anything with other tree codes, so use
2400 VERIFY_CONSTANT to complain and fail. */
2401 VERIFY_CONSTANT (ary
);
2405 if (!tree_fits_shwi_p (index
)
2406 || (i
= tree_to_shwi (index
)) < 0)
2408 diag_array_subscript (ctx
, ary
, index
);
2409 *non_constant_p
= true;
2414 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2416 VERIFY_CONSTANT (nelts
);
2418 ? !tree_int_cst_le (index
, nelts
)
2419 : !tree_int_cst_lt (index
, nelts
))
2420 || tree_int_cst_sgn (index
) < 0)
2422 diag_array_subscript (ctx
, ary
, index
);
2423 *non_constant_p
= true;
2427 if (lval
&& ary
== oldary
&& index
== oldidx
)
2430 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2433 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2435 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2446 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2447 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2448 else if (TREE_CODE (ary
) == VECTOR_CST
)
2449 r
= VECTOR_CST_ELT (ary
, i
);
2451 r
= extract_string_elt (ary
, elem_nchars
, i
);
2454 /* Don't VERIFY_CONSTANT here. */
2457 /* Otherwise the element doesn't have a value yet. */
2462 if (TREE_CODE (ary
) == CONSTRUCTOR
2463 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2465 /* 'ary' is part of the aggregate initializer we're currently
2466 building; if there's no initializer for this element yet,
2469 error ("accessing uninitialized array element");
2470 *non_constant_p
= true;
2474 /* If it's within the array bounds but doesn't have an explicit
2475 initializer, it's value-initialized. */
2476 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2477 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2481 /* Subroutine of cxx_eval_constant_expression.
2482 Attempt to reduce a field access of a value of class type. */
2485 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2487 bool *non_constant_p
, bool *overflow_p
)
2489 unsigned HOST_WIDE_INT i
;
2492 tree part
= TREE_OPERAND (t
, 1);
2493 tree orig_whole
= TREE_OPERAND (t
, 0);
2494 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2496 non_constant_p
, overflow_p
);
2497 if (INDIRECT_REF_P (whole
)
2498 && integer_zerop (TREE_OPERAND (whole
, 0))
2500 error ("dereferencing a null pointer in %qE", orig_whole
);
2502 if (TREE_CODE (whole
) == PTRMEM_CST
)
2503 whole
= cplus_expand_constant (whole
);
2504 if (whole
== orig_whole
)
2507 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2508 whole
, part
, NULL_TREE
);
2509 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2511 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2514 error ("%qE is not a constant expression", orig_whole
);
2515 *non_constant_p
= true;
2517 if (DECL_MUTABLE_P (part
))
2520 error ("mutable %qD is not usable in a constant expression", part
);
2521 *non_constant_p
= true;
2523 if (*non_constant_p
)
2525 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2526 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2528 /* Use name match for PMF fields, as a variant will have a
2529 different FIELD_DECL with a different type. */
2530 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2536 /* We're in the middle of initializing it. */
2540 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2541 && CONSTRUCTOR_NELTS (whole
) > 0)
2543 /* DR 1188 says we don't have to deal with this. */
2545 error ("accessing %qD member instead of initialized %qD member in "
2546 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2547 *non_constant_p
= true;
2551 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2552 classes never get represented; throw together a value now. */
2553 if (is_really_empty_class (TREE_TYPE (t
)))
2554 return build_constructor (TREE_TYPE (t
), NULL
);
2556 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2558 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2560 /* 'whole' is part of the aggregate initializer we're currently
2561 building; if there's no initializer for this member yet, that's an
2564 error ("accessing uninitialized member %qD", part
);
2565 *non_constant_p
= true;
2569 /* If there's no explicit init for this field, it's value-initialized. */
2570 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2571 return cxx_eval_constant_expression (ctx
, value
,
2573 non_constant_p
, overflow_p
);
2576 /* Subroutine of cxx_eval_constant_expression.
2577 Attempt to reduce a field access of a value of class type that is
2578 expressed as a BIT_FIELD_REF. */
2581 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2583 bool *non_constant_p
, bool *overflow_p
)
2585 tree orig_whole
= TREE_OPERAND (t
, 0);
2586 tree retval
, fldval
, utype
, mask
;
2587 bool fld_seen
= false;
2588 HOST_WIDE_INT istart
, isize
;
2589 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2591 non_constant_p
, overflow_p
);
2592 tree start
, field
, value
;
2593 unsigned HOST_WIDE_INT i
;
2595 if (whole
== orig_whole
)
2597 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2599 if (!*non_constant_p
2600 && TREE_CODE (whole
) != VECTOR_CST
2601 && TREE_CODE (whole
) != CONSTRUCTOR
)
2604 error ("%qE is not a constant expression", orig_whole
);
2605 *non_constant_p
= true;
2607 if (*non_constant_p
)
2610 if (TREE_CODE (whole
) == VECTOR_CST
)
2611 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2612 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2614 start
= TREE_OPERAND (t
, 2);
2615 istart
= tree_to_shwi (start
);
2616 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2617 utype
= TREE_TYPE (t
);
2618 if (!TYPE_UNSIGNED (utype
))
2619 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2620 retval
= build_int_cst (utype
, 0);
2621 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2623 tree bitpos
= bit_position (field
);
2624 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2626 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2627 && TREE_CODE (value
) == INTEGER_CST
2628 && tree_fits_shwi_p (bitpos
)
2629 && tree_fits_shwi_p (DECL_SIZE (field
)))
2631 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2632 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2633 HOST_WIDE_INT shift
;
2634 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2636 fldval
= fold_convert (utype
, value
);
2637 mask
= build_int_cst_type (utype
, -1);
2638 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2639 size_int (TYPE_PRECISION (utype
) - sz
));
2640 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2641 size_int (TYPE_PRECISION (utype
) - sz
));
2642 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2643 shift
= bit
- istart
;
2644 if (BYTES_BIG_ENDIAN
)
2645 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2646 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2648 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2654 return fold_convert (TREE_TYPE (t
), retval
);
2656 return error_mark_node
;
2659 /* Subroutine of cxx_eval_constant_expression.
2660 Evaluate a short-circuited logical expression T in the context
2661 of a given constexpr CALL. BAILOUT_VALUE is the value for
2662 early return. CONTINUE_VALUE is used here purely for
2663 sanity check purposes. */
2666 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2667 tree bailout_value
, tree continue_value
,
2669 bool *non_constant_p
, bool *overflow_p
)
2672 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2674 non_constant_p
, overflow_p
);
2675 VERIFY_CONSTANT (lhs
);
2676 if (tree_int_cst_equal (lhs
, bailout_value
))
2678 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2679 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2680 lval
, non_constant_p
,
2682 VERIFY_CONSTANT (r
);
2686 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2687 CONSTRUCTOR elements to initialize (part of) an object containing that
2688 field. Return a pointer to the constructor_elt corresponding to the
2689 initialization of the field. */
2691 static constructor_elt
*
2692 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2694 tree aggr
= TREE_OPERAND (ref
, 0);
2695 tree field
= TREE_OPERAND (ref
, 1);
2697 constructor_elt
*ce
;
2699 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2701 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2703 constructor_elt
*base_ce
2704 = base_field_constructor_elt (v
, aggr
);
2705 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2708 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2709 if (ce
->index
== field
)
2716 /* Some of the expressions fed to the constexpr mechanism are calls to
2717 constructors, which have type void. In that case, return the type being
2718 initialized by the constructor. */
2721 initialized_type (tree t
)
2725 tree type
= cv_unqualified (TREE_TYPE (t
));
2726 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2728 /* A constructor call has void type, so we need to look deeper. */
2729 tree fn
= get_function_named_in_call (t
);
2730 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2731 && DECL_CXX_CONSTRUCTOR_P (fn
))
2732 type
= DECL_CONTEXT (fn
);
2737 /* We're about to initialize element INDEX of an array or class from VALUE.
2738 Set up NEW_CTX appropriately by adjusting .object to refer to the
2739 subobject and creating a new CONSTRUCTOR if the element is itself
2740 a class or array. */
2743 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2744 tree index
, tree
&value
)
2748 if (index
&& TREE_CODE (index
) != INTEGER_CST
2749 && TREE_CODE (index
) != FIELD_DECL
)
2750 /* This won't have an element in the new CONSTRUCTOR. */
2753 tree type
= initialized_type (value
);
2754 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2755 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2758 /* The sub-aggregate initializer might contain a placeholder;
2759 update object to refer to the subobject and ctor to refer to
2760 the (newly created) sub-initializer. */
2762 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2763 tree elt
= build_constructor (type
, NULL
);
2764 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2767 if (TREE_CODE (value
) == TARGET_EXPR
)
2768 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2769 value
= TARGET_EXPR_INITIAL (value
);
2772 /* We're about to process an initializer for a class or array TYPE. Make
2773 sure that CTX is set up appropriately. */
2776 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2778 /* We don't bother building a ctor for an empty base subobject. */
2779 if (is_empty_class (type
))
2782 /* We're in the middle of an initializer that might involve placeholders;
2783 our caller should have created a CONSTRUCTOR for us to put the
2784 initializer into. We will either return that constructor or T. */
2785 gcc_assert (ctx
->ctor
);
2786 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2787 (type
, TREE_TYPE (ctx
->ctor
)));
2788 /* We used to check that ctx->ctor was empty, but that isn't the case when
2789 the object is zero-initialized before calling the constructor. */
2792 tree otype
= TREE_TYPE (ctx
->object
);
2793 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2794 /* Handle flexible array members. */
2795 || (TREE_CODE (otype
) == ARRAY_TYPE
2796 && TYPE_DOMAIN (otype
) == NULL_TREE
2797 && TREE_CODE (type
) == ARRAY_TYPE
2798 && (same_type_ignoring_top_level_qualifiers_p
2799 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2801 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2802 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2805 /* Subroutine of cxx_eval_constant_expression.
2806 The expression tree T denotes a C-style array or a C-style
2807 aggregate. Reduce it to a constant expression. */
2810 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2812 bool *non_constant_p
, bool *overflow_p
)
2814 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2815 bool changed
= false;
2816 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2817 tree type
= TREE_TYPE (t
);
2819 constexpr_ctx new_ctx
;
2820 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2822 /* We don't really need the ctx->ctor business for a PMF or
2823 vector, but it's simpler to use the same code. */
2825 new_ctx
.ctor
= build_constructor (type
, NULL
);
2826 new_ctx
.object
= NULL_TREE
;
2829 verify_ctor_sanity (ctx
, type
);
2830 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2831 vec_alloc (*p
, vec_safe_length (v
));
2835 bool constant_p
= true;
2836 bool side_effects_p
= false;
2837 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2839 tree orig_value
= value
;
2840 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2841 if (new_ctx
.ctor
!= ctx
->ctor
)
2842 /* If we built a new CONSTRUCTOR, attach it now so that other
2843 initializers can refer to it. */
2844 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2845 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2847 non_constant_p
, overflow_p
);
2848 /* Don't VERIFY_CONSTANT here. */
2849 if (ctx
->quiet
&& *non_constant_p
)
2851 if (elt
!= orig_value
)
2854 if (!TREE_CONSTANT (elt
))
2856 if (TREE_SIDE_EFFECTS (elt
))
2857 side_effects_p
= true;
2858 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2860 /* This is an initialization of a vfield inside a base
2861 subaggregate that we already initialized; push this
2862 initialization into the previous initialization. */
2863 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2868 && (TREE_CODE (index
) == NOP_EXPR
2869 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2871 /* This is an initializer for an empty base; now that we've
2872 checked that it's constant, we can ignore it. */
2873 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2876 else if (new_ctx
.ctor
!= ctx
->ctor
)
2878 /* We appended this element above; update the value. */
2879 gcc_assert ((*p
)->last().index
== index
);
2880 (*p
)->last().value
= elt
;
2884 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2885 /* Adding an element might change the ctor's flags. */
2886 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
2887 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
2890 if (*non_constant_p
|| !changed
)
2893 /* We're done building this CONSTRUCTOR, so now we can interpret an
2894 element without an explicit initializer as value-initialized. */
2895 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2896 TREE_CONSTANT (t
) = constant_p
;
2897 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2898 if (VECTOR_TYPE_P (type
))
2903 /* Subroutine of cxx_eval_constant_expression.
2904 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2905 initialization of a non-static data member of array type. Reduce it to a
2908 Note that apart from value-initialization (when VALUE_INIT is true),
2909 this is only intended to support value-initialization and the
2910 initializations done by defaulted constructors for classes with
2911 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2912 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2913 for the copy/move constructor. */
2916 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2917 bool value_init
, bool lval
,
2918 bool *non_constant_p
, bool *overflow_p
)
2920 tree elttype
= TREE_TYPE (atype
);
2921 verify_ctor_sanity (ctx
, atype
);
2922 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2923 bool pre_init
= false;
2924 unsigned HOST_WIDE_INT i
;
2926 /* For the default constructor, build up a call to the default
2927 constructor of the element type. We only need to handle class types
2928 here, as for a constructor to be constexpr, all members must be
2929 initialized, which for a defaulted default constructor means they must
2930 be of a class type with a constexpr default constructor. */
2931 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2932 /* We only do this at the lowest level. */;
2933 else if (value_init
)
2935 init
= build_value_init (elttype
, tf_warning_or_error
);
2940 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2941 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2942 &argvec
, elttype
, LOOKUP_NORMAL
,
2943 tf_warning_or_error
);
2944 release_tree_vector (argvec
);
2945 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2949 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
2951 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
2952 for (i
= 0; i
< max
; ++i
)
2954 tree idx
= build_int_cst (size_type_node
, i
);
2957 constexpr_ctx new_ctx
;
2958 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2959 if (new_ctx
.ctor
!= ctx
->ctor
)
2960 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2961 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2963 /* A multidimensional array; recurse. */
2964 if (value_init
|| init
== NULL_TREE
)
2966 eltinit
= NULL_TREE
;
2970 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2971 tf_warning_or_error
);
2972 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2974 non_constant_p
, overflow_p
);
2978 /* Initializing an element using value or default initialization
2979 we just pre-built above. */
2980 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2981 non_constant_p
, overflow_p
);
2986 /* Copying an element. */
2987 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2988 (atype
, TREE_TYPE (init
)));
2989 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2990 tf_warning_or_error
);
2991 if (!lvalue_p (init
))
2992 eltinit
= move (eltinit
);
2993 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2994 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
2995 non_constant_p
, overflow_p
);
2997 if (*non_constant_p
&& !ctx
->quiet
)
2999 if (new_ctx
.ctor
!= ctx
->ctor
)
3001 /* We appended this element above; update the value. */
3002 gcc_assert ((*p
)->last().index
== idx
);
3003 (*p
)->last().value
= eltinit
;
3006 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3007 /* Reuse the result of cxx_eval_constant_expression call
3008 from the first iteration to all others if it is a constant
3009 initializer that doesn't require relocations. */
3012 && (eltinit
== NULL_TREE
3013 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3014 == null_pointer_node
)))
3016 if (new_ctx
.ctor
!= ctx
->ctor
)
3017 eltinit
= new_ctx
.ctor
;
3018 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3019 build_int_cst (size_type_node
, 1),
3020 build_int_cst (size_type_node
, max
- 1));
3021 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3025 vec_safe_reserve (*p
, max
);
3028 if (!*non_constant_p
)
3031 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
3037 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3039 bool *non_constant_p
, bool *overflow_p
)
3041 tree atype
= TREE_TYPE (t
);
3042 tree init
= VEC_INIT_EXPR_INIT (t
);
3043 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3044 VEC_INIT_EXPR_VALUE_INIT (t
),
3045 lval
, non_constant_p
, overflow_p
);
3046 if (*non_constant_p
)
3052 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3053 match. We want to be less strict for simple *& folding; if we have a
3054 non-const temporary that we access through a const pointer, that should
3055 work. We handle this here rather than change fold_indirect_ref_1
3056 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3057 don't really make sense outside of constant expression evaluation. Also
3058 we want to allow folding to COMPONENT_REF, which could cause trouble
3059 with TBAA in fold_indirect_ref_1.
3061 Try to keep this function synced with fold_indirect_ref_1. */
3064 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3068 poly_uint64 const_op01
;
3071 subtype
= TREE_TYPE (sub
);
3072 if (!POINTER_TYPE_P (subtype
))
3075 if (TREE_CODE (sub
) == ADDR_EXPR
)
3077 tree op
= TREE_OPERAND (sub
, 0);
3078 tree optype
= TREE_TYPE (op
);
3080 /* *&CONST_DECL -> to the value of the const decl. */
3081 if (TREE_CODE (op
) == CONST_DECL
)
3082 return DECL_INITIAL (op
);
3083 /* *&p => p; make sure to handle *&"str"[cst] here. */
3084 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
3085 /* Also handle the case where the desired type is an array of unknown
3086 bounds because the variable has had its bounds deduced since the
3087 ADDR_EXPR was created. */
3088 || (TREE_CODE (type
) == ARRAY_TYPE
3089 && TREE_CODE (optype
) == ARRAY_TYPE
3090 && TYPE_DOMAIN (type
) == NULL_TREE
3091 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3094 tree fop
= fold_read_from_constant_string (op
);
3100 /* *(foo *)&fooarray => fooarray[0] */
3101 else if (TREE_CODE (optype
) == ARRAY_TYPE
3102 && (same_type_ignoring_top_level_qualifiers_p
3103 (type
, TREE_TYPE (optype
))))
3105 tree type_domain
= TYPE_DOMAIN (optype
);
3106 tree min_val
= size_zero_node
;
3107 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3108 min_val
= TYPE_MIN_VALUE (type_domain
);
3109 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3110 NULL_TREE
, NULL_TREE
);
3112 /* *(foo *)&complexfoo => __real__ complexfoo */
3113 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3114 && (same_type_ignoring_top_level_qualifiers_p
3115 (type
, TREE_TYPE (optype
))))
3116 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3117 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3118 else if (VECTOR_TYPE_P (optype
)
3119 && (same_type_ignoring_top_level_qualifiers_p
3120 (type
, TREE_TYPE (optype
))))
3122 tree part_width
= TYPE_SIZE (type
);
3123 tree index
= bitsize_int (0);
3124 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3127 /* Also handle conversion to an empty base class, which
3128 is represented with a NOP_EXPR. */
3129 else if (is_empty_class (type
)
3130 && CLASS_TYPE_P (optype
)
3131 && DERIVED_FROM_P (type
, optype
))
3136 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3137 else if (RECORD_OR_UNION_TYPE_P (optype
))
3139 tree field
= TYPE_FIELDS (optype
);
3140 for (; field
; field
= DECL_CHAIN (field
))
3141 if (TREE_CODE (field
) == FIELD_DECL
3142 && TREE_TYPE (field
) != error_mark_node
3143 && integer_zerop (byte_position (field
))
3144 && (same_type_ignoring_top_level_qualifiers_p
3145 (TREE_TYPE (field
), type
)))
3146 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3149 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3150 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3152 tree op00
= TREE_OPERAND (sub
, 0);
3153 tree op01
= TREE_OPERAND (sub
, 1);
3156 if (TREE_CODE (op00
) == ADDR_EXPR
)
3159 op00
= TREE_OPERAND (op00
, 0);
3160 op00type
= TREE_TYPE (op00
);
3162 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3163 if (VECTOR_TYPE_P (op00type
)
3164 && same_type_ignoring_top_level_qualifiers_p
3165 (type
, TREE_TYPE (op00type
))
3166 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3167 but we want to treat offsets with MSB set as negative.
3168 For the code below negative offsets are invalid and
3169 TYPE_SIZE of the element is something unsigned, so
3170 check whether op01 fits into poly_int64, which implies
3171 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3172 then just use poly_uint64 because we want to treat the
3173 value as unsigned. */
3174 && tree_fits_poly_int64_p (op01
))
3176 tree part_width
= TYPE_SIZE (type
);
3177 poly_uint64 max_offset
3178 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3179 * TYPE_VECTOR_SUBPARTS (op00type
));
3180 if (known_lt (const_op01
, max_offset
))
3182 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3183 return fold_build3_loc (loc
,
3184 BIT_FIELD_REF
, type
, op00
,
3188 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3189 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3190 && (same_type_ignoring_top_level_qualifiers_p
3191 (type
, TREE_TYPE (op00type
))))
3193 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3195 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3197 /* ((foo *)&fooarray)[1] => fooarray[1] */
3198 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3199 && (same_type_ignoring_top_level_qualifiers_p
3200 (type
, TREE_TYPE (op00type
))))
3202 tree type_domain
= TYPE_DOMAIN (op00type
);
3203 tree min_val
= size_zero_node
;
3204 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3205 min_val
= TYPE_MIN_VALUE (type_domain
);
3206 offset_int off
= wi::to_offset (op01
);
3207 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3208 offset_int remainder
;
3209 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3210 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3212 off
= off
+ wi::to_offset (min_val
);
3213 op01
= wide_int_to_tree (sizetype
, off
);
3214 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3215 NULL_TREE
, NULL_TREE
);
3218 /* Also handle conversion to an empty base class, which
3219 is represented with a NOP_EXPR. */
3220 else if (is_empty_class (type
)
3221 && CLASS_TYPE_P (op00type
)
3222 && DERIVED_FROM_P (type
, op00type
))
3227 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3228 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3230 tree field
= TYPE_FIELDS (op00type
);
3231 for (; field
; field
= DECL_CHAIN (field
))
3232 if (TREE_CODE (field
) == FIELD_DECL
3233 && TREE_TYPE (field
) != error_mark_node
3234 && tree_int_cst_equal (byte_position (field
), op01
)
3235 && (same_type_ignoring_top_level_qualifiers_p
3236 (TREE_TYPE (field
), type
)))
3237 return fold_build3 (COMPONENT_REF
, type
, op00
,
3242 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3243 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3244 && (same_type_ignoring_top_level_qualifiers_p
3245 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3248 tree min_val
= size_zero_node
;
3250 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3254 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3255 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3256 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3257 min_val
= TYPE_MIN_VALUE (type_domain
);
3258 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3266 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3268 bool *non_constant_p
, bool *overflow_p
)
3270 tree orig_op0
= TREE_OPERAND (t
, 0);
3271 bool empty_base
= false;
3273 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3274 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3276 if (TREE_CODE (t
) == MEM_REF
3277 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3279 gcc_assert (ctx
->quiet
);
3280 *non_constant_p
= true;
3284 /* First try to simplify it directly. */
3285 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3289 /* If that didn't work, evaluate the operand first. */
3290 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3291 /*lval*/false, non_constant_p
,
3293 /* Don't VERIFY_CONSTANT here. */
3294 if (*non_constant_p
)
3297 if (!lval
&& integer_zerop (op0
))
3300 error ("dereferencing a null pointer");
3301 *non_constant_p
= true;
3305 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3309 /* We couldn't fold to a constant value. Make sure it's not
3310 something we should have been able to fold. */
3313 if (TREE_CODE (sub
) == ADDR_EXPR
)
3315 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3316 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3317 /* DR 1188 says we don't have to deal with this. */
3319 error ("accessing value of %qE through a %qT glvalue in a "
3320 "constant expression", build_fold_indirect_ref (sub
),
3322 *non_constant_p
= true;
3326 if (lval
&& op0
!= orig_op0
)
3327 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3329 VERIFY_CONSTANT (t
);
3334 r
= cxx_eval_constant_expression (ctx
, r
,
3335 lval
, non_constant_p
, overflow_p
);
3336 if (*non_constant_p
)
3339 /* If we're pulling out the value of an empty base, just return an empty
3341 if (empty_base
&& !lval
)
3343 r
= build_constructor (TREE_TYPE (t
), NULL
);
3344 TREE_CONSTANT (r
) = true;
3350 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3351 Shared between potential_constant_expression and
3352 cxx_eval_constant_expression. */
3355 non_const_var_error (tree r
)
3357 tree type
= TREE_TYPE (r
);
3358 error ("the value of %qD is not usable in a constant "
3360 /* Avoid error cascade. */
3361 if (DECL_INITIAL (r
) == error_mark_node
)
3363 if (DECL_DECLARED_CONSTEXPR_P (r
))
3364 inform (DECL_SOURCE_LOCATION (r
),
3365 "%qD used in its own initializer", r
);
3366 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3368 if (!CP_TYPE_CONST_P (type
))
3369 inform (DECL_SOURCE_LOCATION (r
),
3370 "%q#D is not const", r
);
3371 else if (CP_TYPE_VOLATILE_P (type
))
3372 inform (DECL_SOURCE_LOCATION (r
),
3373 "%q#D is volatile", r
);
3374 else if (!DECL_INITIAL (r
)
3375 || !TREE_CONSTANT (DECL_INITIAL (r
))
3376 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3377 inform (DECL_SOURCE_LOCATION (r
),
3378 "%qD was not initialized with a constant "
3383 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3384 inform (DECL_SOURCE_LOCATION (r
),
3385 "%qD was not initialized with a constant "
3389 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3390 inform (DECL_SOURCE_LOCATION (r
),
3391 "%qD was not declared %<constexpr%>", r
);
3393 inform (DECL_SOURCE_LOCATION (r
),
3394 "%qD does not have integral or enumeration type",
3399 /* Subroutine of cxx_eval_constant_expression.
3400 Like cxx_eval_unary_expression, except for trinary expressions. */
3403 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3405 bool *non_constant_p
, bool *overflow_p
)
3411 for (i
= 0; i
< 3; i
++)
3413 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3415 non_constant_p
, overflow_p
);
3416 VERIFY_CONSTANT (args
[i
]);
3419 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3420 args
[0], args
[1], args
[2]);
3421 if (val
== NULL_TREE
)
3423 VERIFY_CONSTANT (val
);
3427 /* True if T was declared in a function declared to be constexpr, and
3428 therefore potentially constant in C++14. */
3431 var_in_constexpr_fn (tree t
)
3433 tree ctx
= DECL_CONTEXT (t
);
3434 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3435 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3438 /* True if T was declared in a function that might be constexpr: either a
3439 function that was declared constexpr, or a C++17 lambda op(). */
3442 var_in_maybe_constexpr_fn (tree t
)
3444 if (cxx_dialect
>= cxx17
3445 && DECL_FUNCTION_SCOPE_P (t
)
3446 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3448 return var_in_constexpr_fn (t
);
3451 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3452 build_over_call we implement trivial copy of a class with tail padding using
3453 assignment of character arrays, which is valid in normal code, but not in
3454 constexpr evaluation. We don't need to worry about clobbering tail padding
3455 in constexpr evaluation, so strip the type punning. */
3458 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3460 if (TREE_CODE (target
) == MEM_REF
3461 && TREE_CODE (init
) == MEM_REF
3462 && TREE_TYPE (target
) == TREE_TYPE (init
)
3463 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3464 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3466 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3467 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3471 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3474 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3476 bool *non_constant_p
, bool *overflow_p
)
3478 constexpr_ctx new_ctx
= *ctx
;
3480 tree init
= TREE_OPERAND (t
, 1);
3481 if (TREE_CLOBBER_P (init
))
3482 /* Just ignore clobbers. */
3485 /* First we figure out where we're storing to. */
3486 tree target
= TREE_OPERAND (t
, 0);
3488 maybe_simplify_trivial_copy (target
, init
);
3490 tree type
= TREE_TYPE (target
);
3491 target
= cxx_eval_constant_expression (ctx
, target
,
3493 non_constant_p
, overflow_p
);
3494 if (*non_constant_p
)
3497 /* cxx_eval_array_reference for lval = true allows references one past
3498 end of array, because it does not know if it is just taking address
3499 (which is valid), or actual dereference. Here we know it is
3500 a dereference, so diagnose it here. */
3501 for (tree probe
= target
; probe
; )
3503 switch (TREE_CODE (probe
))
3507 ary
= TREE_OPERAND (probe
, 0);
3508 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3509 non_constant_p
, overflow_p
);
3510 VERIFY_CONSTANT (nelts
);
3511 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3512 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3513 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3515 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3516 *non_constant_p
= true;
3523 probe
= TREE_OPERAND (probe
, 0);
3532 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3534 /* For initialization of an empty base, the original target will be
3535 *(base*)this, which the above evaluation resolves to the object
3536 argument, which has the derived type rather than the base type. In
3537 this situation, just evaluate the initializer and return, since
3538 there's no actual data to store. */
3539 gcc_assert (is_empty_class (type
));
3540 return cxx_eval_constant_expression (ctx
, init
, false,
3541 non_constant_p
, overflow_p
);
3544 /* And then find the underlying variable. */
3545 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3546 tree object
= NULL_TREE
;
3547 for (tree probe
= target
; object
== NULL_TREE
; )
3549 switch (TREE_CODE (probe
))
3554 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3555 vec_safe_push (refs
, TREE_TYPE (probe
));
3556 probe
= TREE_OPERAND (probe
, 0);
3564 /* And then find/build up our initializer for the path to the subobject
3565 we're initializing. */
3567 if (object
== ctx
->object
&& VAR_P (object
)
3568 && DECL_NAME (object
) && ctx
->call
== NULL
)
3569 /* The variable we're building up an aggregate initializer for is outside
3570 the constant-expression, so don't evaluate the store. We check
3571 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3573 else if (DECL_P (object
))
3574 valp
= ctx
->values
->get (object
);
3579 /* A constant-expression cannot modify objects from outside the
3580 constant-expression. */
3582 error ("modification of %qE is not a constant expression", object
);
3583 *non_constant_p
= true;
3586 type
= TREE_TYPE (object
);
3587 bool no_zero_init
= true;
3589 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3590 while (!refs
->is_empty())
3592 if (*valp
== NULL_TREE
)
3594 *valp
= build_constructor (type
, NULL
);
3595 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3597 else if (TREE_CODE (*valp
) == STRING_CST
)
3599 /* An array was initialized with a string constant, and now
3600 we're writing into one of its elements. Explode the
3601 single initialization into a set of element
3603 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3605 tree string
= *valp
;
3606 tree elt_type
= TREE_TYPE (type
);
3607 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3608 / TYPE_PRECISION (char_type_node
));
3609 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3610 tree ary_ctor
= build_constructor (type
, NULL
);
3612 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3613 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3615 constructor_elt elt
=
3617 build_int_cst (size_type_node
, ix
),
3618 extract_string_elt (string
, chars_per_elt
, ix
)
3620 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3626 /* If the value of object is already zero-initialized, any new ctors for
3627 subobjects will also be zero-initialized. */
3628 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3630 vec_safe_push (ctors
, *valp
);
3632 enum tree_code code
= TREE_CODE (type
);
3634 tree index
= refs
->pop();
3636 constructor_elt
*cep
= NULL
;
3637 if (code
== ARRAY_TYPE
)
3640 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3641 gcc_assert (i
>= 0);
3642 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3643 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3647 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3649 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3650 Usually we meet initializers in that order, but it is
3651 possible for base types to be placed not in program
3653 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3654 unsigned HOST_WIDE_INT idx
;
3656 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3657 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3658 /* Changing active member. */
3659 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3662 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3663 idx
++, fields
= DECL_CHAIN (fields
))
3665 if (index
== cep
->index
)
3668 /* The field we're initializing must be on the field
3669 list. Look to see if it is present before the
3670 field the current ELT initializes. */
3671 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3672 if (index
== fields
)
3676 /* We fell off the end of the CONSTRUCTOR, so insert a new
3677 entry at the end. */
3680 constructor_elt ce
= { index
, NULL_TREE
};
3682 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3683 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3689 release_tree_vector (refs
);
3691 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3693 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3694 wants to modify it. */
3695 if (*valp
== NULL_TREE
)
3697 *valp
= build_constructor (type
, NULL
);
3698 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3700 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3701 *valp
= cplus_expand_constant (*valp
);
3702 new_ctx
.ctor
= *valp
;
3703 new_ctx
.object
= target
;
3706 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3707 non_constant_p
, overflow_p
);
3708 /* Don't share a CONSTRUCTOR that might be changed later. */
3709 init
= unshare_constructor (init
);
3710 if (target
== object
)
3711 /* The hash table might have moved since the get earlier. */
3712 valp
= ctx
->values
->get (object
);
3714 if (TREE_CODE (init
) == CONSTRUCTOR
)
3716 /* An outer ctx->ctor might be pointing to *valp, so replace
3718 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3719 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3720 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3721 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3722 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3727 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3728 CONSTRUCTORs, if any. */
3731 bool c
= TREE_CONSTANT (init
);
3732 bool s
= TREE_SIDE_EFFECTS (init
);
3734 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3737 TREE_CONSTANT (elt
) = false;
3739 TREE_SIDE_EFFECTS (elt
) = true;
3741 release_tree_vector (ctors
);
3743 if (*non_constant_p
)
3751 /* Evaluate a ++ or -- expression. */
3754 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3756 bool *non_constant_p
, bool *overflow_p
)
3758 enum tree_code code
= TREE_CODE (t
);
3759 tree type
= TREE_TYPE (t
);
3760 tree op
= TREE_OPERAND (t
, 0);
3761 tree offset
= TREE_OPERAND (t
, 1);
3762 gcc_assert (TREE_CONSTANT (offset
));
3764 /* The operand as an lvalue. */
3765 op
= cxx_eval_constant_expression (ctx
, op
, true,
3766 non_constant_p
, overflow_p
);
3768 /* The operand as an rvalue. */
3770 = cxx_eval_constant_expression (ctx
, op
, false,
3771 non_constant_p
, overflow_p
);
3772 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3773 a local array in a constexpr function. */
3774 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3776 VERIFY_CONSTANT (val
);
3778 /* The modified value. */
3779 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3781 if (POINTER_TYPE_P (type
))
3783 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3784 offset
= convert_to_ptrofftype (offset
);
3786 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3787 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3790 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3792 VERIFY_CONSTANT (mod
);
3794 /* Storing the modified value. */
3795 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3796 cxx_eval_constant_expression (ctx
, store
,
3797 true, non_constant_p
, overflow_p
);
3799 /* And the value of the expression. */
3800 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3802 /* Prefix ops are lvalues. */
3806 /* But we optimize when the caller wants an rvalue. */
3810 /* Postfix ops are rvalues. */
3814 /* Predicates for the meaning of *jump_target. */
3817 returns (tree
*jump_target
)
3820 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3821 || (TREE_CODE (*jump_target
) == LABEL_DECL
3822 && LABEL_DECL_CDTOR (*jump_target
)));
3826 breaks (tree
*jump_target
)
3829 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3830 && LABEL_DECL_BREAK (*jump_target
))
3831 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3835 continues (tree
*jump_target
)
3838 && TREE_CODE (*jump_target
) == LABEL_DECL
3839 && LABEL_DECL_CONTINUE (*jump_target
);
3843 switches (tree
*jump_target
)
3846 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3849 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3850 STMT matches *jump_target. If we're looking for a case label and we see
3851 the default label, note it in ctx->css_state. */
3854 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3856 switch (TREE_CODE (*jump_target
))
3859 if (TREE_CODE (stmt
) == LABEL_EXPR
3860 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3865 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3867 gcc_assert (ctx
->css_state
!= NULL
);
3868 if (!CASE_LOW (stmt
))
3870 /* default: should appear just once in a SWITCH_EXPR
3871 body (excluding nested SWITCH_EXPR). */
3872 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3873 /* When evaluating SWITCH_EXPR body for the second time,
3874 return true for the default: label. */
3875 if (*ctx
->css_state
== css_default_processing
)
3877 *ctx
->css_state
= css_default_seen
;
3879 else if (CASE_HIGH (stmt
))
3881 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3882 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3885 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3896 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3897 semantics, for switch, break, continue, and return. */
3900 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3901 bool *non_constant_p
, bool *overflow_p
,
3904 tree_stmt_iterator i
;
3906 /* In a statement-expression we want to return the last value.
3907 For empty statement expression return void_node. */
3911 local_target
= NULL_TREE
;
3912 jump_target
= &local_target
;
3914 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3916 tree stmt
= tsi_stmt (i
);
3917 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
3919 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3920 non_constant_p
, overflow_p
,
3922 if (*non_constant_p
)
3924 if (returns (jump_target
) || breaks (jump_target
))
3930 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3931 semantics; continue semantics are covered by cxx_eval_statement_list. */
3934 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3935 bool *non_constant_p
, bool *overflow_p
,
3938 constexpr_ctx new_ctx
= *ctx
;
3940 tree body
= TREE_OPERAND (t
, 0);
3944 hash_set
<tree
> save_exprs
;
3945 new_ctx
.save_exprs
= &save_exprs
;
3947 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3948 non_constant_p
, overflow_p
, jump_target
);
3950 /* Forget saved values of SAVE_EXPRs. */
3951 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3952 iter
!= save_exprs
.end(); ++iter
)
3953 new_ctx
.values
->remove (*iter
);
3954 if (++count
>= constexpr_loop_limit
)
3957 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3958 "%<constexpr%> loop iteration count exceeds limit of %d "
3959 "(use -fconstexpr-loop-limit= to increase the limit)",
3960 constexpr_loop_limit
);
3961 *non_constant_p
= true;
3965 while (!returns (jump_target
)
3966 && !breaks (jump_target
)
3967 && !switches (jump_target
)
3968 && !*non_constant_p
);
3970 if (breaks (jump_target
))
3971 *jump_target
= NULL_TREE
;
3976 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3980 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3981 bool *non_constant_p
, bool *overflow_p
,
3984 tree cond
= TREE_OPERAND (t
, 0);
3985 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3986 non_constant_p
, overflow_p
);
3987 VERIFY_CONSTANT (cond
);
3988 *jump_target
= cond
;
3990 tree body
= TREE_OPERAND (t
, 1);
3991 constexpr_ctx new_ctx
= *ctx
;
3992 constexpr_switch_state css
= css_default_not_seen
;
3993 new_ctx
.css_state
= &css
;
3994 cxx_eval_constant_expression (&new_ctx
, body
, false,
3995 non_constant_p
, overflow_p
, jump_target
);
3996 if (switches (jump_target
) && css
== css_default_seen
)
3998 /* If the SWITCH_EXPR body has default: label, process it once again,
3999 this time instructing label_matches to return true for default:
4000 label on switches (jump_target). */
4001 css
= css_default_processing
;
4002 cxx_eval_constant_expression (&new_ctx
, body
, false,
4003 non_constant_p
, overflow_p
, jump_target
);
4005 if (breaks (jump_target
) || switches (jump_target
))
4006 *jump_target
= NULL_TREE
;
4010 /* Find the object of TYPE under initialization in CTX. */
4013 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4018 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4019 can is a minor optimization. */
4020 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4026 /* Since an object cannot have a field of its own type, we can search outward
4027 from ctx->object to find the unique containing object of TYPE. */
4028 tree ob
= ctx
->object
;
4031 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4033 if (handled_component_p (ob
))
4034 ob
= TREE_OPERAND (ob
, 0);
4042 /* Attempt to reduce the expression T to a constant value.
4043 On failure, issue diagnostic and return error_mark_node. */
4044 /* FIXME unify with c_fully_fold */
4045 /* FIXME overflow_p is too global */
4048 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4050 bool *non_constant_p
, bool *overflow_p
,
4053 constexpr_ctx new_ctx
;
4056 if (jump_target
&& *jump_target
)
4058 /* If we are jumping, ignore all statements/expressions except those
4059 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4060 switch (TREE_CODE (t
))
4063 case STATEMENT_LIST
:
4068 case CASE_LABEL_EXPR
:
4069 if (label_matches (ctx
, jump_target
, t
))
4071 *jump_target
= NULL_TREE
;
4077 if (t
== error_mark_node
)
4079 *non_constant_p
= true;
4082 if (CONSTANT_CLASS_P (t
))
4084 if (TREE_OVERFLOW (t
))
4087 permerror (input_location
, "overflow in constant expression");
4088 if (!flag_permissive
|| ctx
->quiet
)
4092 if (TREE_CODE (t
) == INTEGER_CST
4093 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
4094 && !integer_zerop (t
))
4097 error ("value %qE of type %qT is not a constant expression",
4099 *non_constant_p
= true;
4105 tree_code tcode
= TREE_CODE (t
);
4111 /* We ask for an rvalue for the RESULT_DECL when indirecting
4112 through an invisible reference, or in named return value
4114 return (*ctx
->values
->get (t
));
4117 if (DECL_HAS_VALUE_EXPR_P (t
))
4118 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4119 lval
, non_constant_p
, overflow_p
);
4122 /* We used to not check lval for CONST_DECL, but darwin.c uses
4123 CONST_DECL for aggregate constants. */
4126 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4127 && is_really_empty_class (TREE_TYPE (t
)))
4129 /* If the class is empty, we aren't actually loading anything. */
4130 r
= build_constructor (TREE_TYPE (t
), NULL
);
4131 TREE_CONSTANT (r
) = true;
4133 else if (ctx
->strict
)
4134 r
= decl_really_constant_value (t
);
4136 r
= decl_constant_value (t
);
4137 if (TREE_CODE (r
) == TARGET_EXPR
4138 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4139 r
= TARGET_EXPR_INITIAL (r
);
4141 if (tree
*p
= ctx
->values
->get (r
))
4142 if (*p
!= NULL_TREE
)
4147 non_const_var_error (r
);
4148 *non_constant_p
= true;
4152 case DEBUG_BEGIN_STMT
:
4153 /* ??? It might be nice to retain this information somehow, so
4154 as to be able to step into a constexpr function call. */
4161 case CASE_LABEL_EXPR
:
4166 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4168 else if (tree
*p
= ctx
->values
->get (r
))
4171 /* Defer in case this is only used for its type. */;
4172 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4173 /* Defer, there's no lvalue->rvalue conversion. */;
4174 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4175 && is_really_empty_class (TREE_TYPE (t
)))
4177 /* If the class is empty, we aren't actually loading anything. */
4178 r
= build_constructor (TREE_TYPE (t
), NULL
);
4179 TREE_CONSTANT (r
) = true;
4184 error ("%qE is not a constant expression", t
);
4185 *non_constant_p
= true;
4190 case AGGR_INIT_EXPR
:
4191 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4192 non_constant_p
, overflow_p
);
4197 r
= DECL_EXPR_DECL (t
);
4198 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4199 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4203 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4204 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4205 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4209 if (tree init
= DECL_INITIAL (r
))
4211 init
= cxx_eval_constant_expression (ctx
, init
,
4213 non_constant_p
, overflow_p
);
4214 /* Don't share a CONSTRUCTOR that might be changed. */
4215 init
= unshare_constructor (init
);
4216 ctx
->values
->put (r
, init
);
4218 else if (ctx
== &new_ctx
)
4219 /* We gave it a CONSTRUCTOR above. */;
4221 ctx
->values
->put (r
, NULL_TREE
);
4226 if (!literal_type_p (TREE_TYPE (t
)))
4230 error ("temporary of non-literal type %qT in a "
4231 "constant expression", TREE_TYPE (t
));
4232 explain_non_literal_class (TREE_TYPE (t
));
4234 *non_constant_p
= true;
4237 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4239 /* We're being expanded without an explicit target, so start
4240 initializing a new object; expansion with an explicit target
4241 strips the TARGET_EXPR before we get here. */
4243 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4244 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4245 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4246 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4249 /* Pass false for 'lval' because this indicates
4250 initialization of a temporary. */
4251 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4253 non_constant_p
, overflow_p
);
4254 if (!*non_constant_p
)
4255 /* Adjust the type of the result to the type of the temporary. */
4256 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4259 tree slot
= TARGET_EXPR_SLOT (t
);
4260 r
= unshare_constructor (r
);
4261 ctx
->values
->put (slot
, r
);
4268 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4269 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4270 non_constant_p
, overflow_p
);
4274 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4276 non_constant_p
, overflow_p
);
4280 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4281 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4283 non_constant_p
, overflow_p
);
4288 /* Can happen with ({ return true; }) && false; passed to
4289 maybe_constant_value. There is nothing to jump over in this
4290 case, and the bug will be diagnosed later. */
4291 gcc_assert (ctx
->quiet
);
4292 *non_constant_p
= true;
4297 /* Avoid evaluating a SAVE_EXPR more than once. */
4298 if (tree
*p
= ctx
->values
->get (t
))
4302 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4303 non_constant_p
, overflow_p
);
4304 ctx
->values
->put (t
, r
);
4305 if (ctx
->save_exprs
)
4306 ctx
->save_exprs
->add (t
);
4310 case NON_LVALUE_EXPR
:
4311 case TRY_CATCH_EXPR
:
4313 case CLEANUP_POINT_EXPR
:
4314 case MUST_NOT_THROW_EXPR
:
4317 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4319 non_constant_p
, overflow_p
,
4323 case TRY_FINALLY_EXPR
:
4324 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4325 non_constant_p
, overflow_p
,
4327 if (!*non_constant_p
)
4328 /* Also evaluate the cleanup. */
4329 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4330 non_constant_p
, overflow_p
,
4334 /* These differ from cxx_eval_unary_expression in that this doesn't
4335 check for a constant operand or result; an address can be
4336 constant without its operand being, and vice versa. */
4339 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4340 non_constant_p
, overflow_p
);
4345 tree oldop
= TREE_OPERAND (t
, 0);
4346 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4348 non_constant_p
, overflow_p
);
4349 /* Don't VERIFY_CONSTANT here. */
4350 if (*non_constant_p
)
4352 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4353 /* This function does more aggressive folding than fold itself. */
4354 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4355 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4364 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4365 non_constant_p
, overflow_p
);
4366 if (r
== error_mark_node
)
4368 else if (r
== TREE_OPERAND (t
, 0))
4371 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4376 case FIX_TRUNC_EXPR
:
4381 case TRUTH_NOT_EXPR
:
4382 case FIXED_CONVERT_EXPR
:
4383 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4384 non_constant_p
, overflow_p
);
4388 r
= fold_sizeof_expr (t
);
4389 VERIFY_CONSTANT (r
);
4394 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4395 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4396 introduced by build_call_a. */
4397 tree op0
= TREE_OPERAND (t
, 0);
4398 tree op1
= TREE_OPERAND (t
, 1);
4400 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4401 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4402 r
= cxx_eval_constant_expression (ctx
, op0
,
4403 lval
, non_constant_p
, overflow_p
,
4407 /* Check that the LHS is constant and then discard it. */
4408 cxx_eval_constant_expression (ctx
, op0
,
4409 true, non_constant_p
, overflow_p
,
4411 if (*non_constant_p
)
4413 op1
= TREE_OPERAND (t
, 1);
4414 r
= cxx_eval_constant_expression (ctx
, op1
,
4415 lval
, non_constant_p
, overflow_p
,
4421 case POINTER_PLUS_EXPR
:
4422 case POINTER_DIFF_EXPR
:
4426 case TRUNC_DIV_EXPR
:
4428 case FLOOR_DIV_EXPR
:
4429 case ROUND_DIV_EXPR
:
4430 case TRUNC_MOD_EXPR
:
4432 case ROUND_MOD_EXPR
:
4434 case EXACT_DIV_EXPR
:
4444 case TRUTH_XOR_EXPR
:
4451 case UNORDERED_EXPR
:
4461 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4462 non_constant_p
, overflow_p
);
4465 /* fold can introduce non-IF versions of these; still treat them as
4466 short-circuiting. */
4467 case TRUTH_AND_EXPR
:
4468 case TRUTH_ANDIF_EXPR
:
4469 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4472 non_constant_p
, overflow_p
);
4476 case TRUTH_ORIF_EXPR
:
4477 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4480 non_constant_p
, overflow_p
);
4484 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4485 non_constant_p
, overflow_p
);
4489 if (is_overloaded_fn (t
))
4491 /* We can only get here in checking mode via
4492 build_non_dependent_expr, because any expression that
4493 calls or takes the address of the function will have
4494 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4495 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4496 *non_constant_p
= true;
4499 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4500 non_constant_p
, overflow_p
);
4504 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4505 non_constant_p
, overflow_p
);
4509 if (jump_target
&& *jump_target
)
4511 /* When jumping to a label, the label might be either in the
4512 then or else blocks, so process then block first in skipping
4513 mode first, and if we are still in the skipping mode at its end,
4514 process the else block too. */
4515 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4516 lval
, non_constant_p
, overflow_p
,
4519 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4520 lval
, non_constant_p
, overflow_p
,
4524 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4525 non_constant_p
, overflow_p
,
4529 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4534 if (TREE_CONSTANT (t
))
4536 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4537 VECTOR_CST if applicable. */
4538 verify_constructor_flags (t
);
4539 if (TREE_CONSTANT (t
))
4542 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4543 non_constant_p
, overflow_p
);
4547 /* We can get this in a defaulted constructor for a class with a
4548 non-static data member of array type. Either the initializer will
4549 be NULL, meaning default-initialization, or it will be an lvalue
4550 or xvalue of the same type, meaning direct-initialization from the
4551 corresponding member. */
4552 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4553 non_constant_p
, overflow_p
);
4558 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4559 non_constant_p
, overflow_p
);
4563 case VIEW_CONVERT_EXPR
:
4565 case UNARY_PLUS_EXPR
:
4567 tree oldop
= TREE_OPERAND (t
, 0);
4569 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4571 non_constant_p
, overflow_p
);
4572 if (*non_constant_p
)
4574 tree type
= TREE_TYPE (t
);
4575 if (TREE_CODE (op
) == PTRMEM_CST
4576 && !TYPE_PTRMEM_P (type
))
4577 op
= cplus_expand_constant (op
);
4578 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4580 if (same_type_ignoring_top_level_qualifiers_p (type
,
4582 || can_convert_qual (type
, op
))
4583 return cp_fold_convert (type
, op
);
4587 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4588 "a reinterpret_cast is not a constant expression");
4589 *non_constant_p
= true;
4594 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4596 if (integer_zerop (op
))
4598 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4601 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4602 "dereferencing a null pointer");
4603 *non_constant_p
= true;
4606 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4608 tree from
= TREE_TYPE (op
);
4610 if (!can_convert (type
, from
, tf_none
))
4613 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4614 "conversion of %qT null pointer to %qT "
4615 "is not a constant expression",
4617 *non_constant_p
= true;
4624 /* This detects for example:
4625 reinterpret_cast<void*>(sizeof 0)
4628 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4629 "%<reinterpret_cast<%T>(%E)%> is not "
4630 "a constant expression",
4632 *non_constant_p
= true;
4636 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4637 /* We didn't fold at the top so we could check for ptr-int
4640 if (tcode
== UNARY_PLUS_EXPR
)
4641 r
= fold_convert (TREE_TYPE (t
), op
);
4643 r
= fold_build1 (tcode
, type
, op
);
4644 /* Conversion of an out-of-range value has implementation-defined
4645 behavior; the language considers it different from arithmetic
4646 overflow, which is undefined. */
4647 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4648 TREE_OVERFLOW (r
) = false;
4652 case EMPTY_CLASS_EXPR
:
4653 /* This is good enough for a function argument that might not get
4654 used, and they can't do anything with it, so just return it. */
4657 case STATEMENT_LIST
:
4659 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4660 return cxx_eval_statement_list (&new_ctx
, t
,
4661 non_constant_p
, overflow_p
, jump_target
);
4664 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4666 non_constant_p
, overflow_p
,
4669 case PREINCREMENT_EXPR
:
4670 case POSTINCREMENT_EXPR
:
4671 case PREDECREMENT_EXPR
:
4672 case POSTDECREMENT_EXPR
:
4673 return cxx_eval_increment_expression (ctx
, t
,
4674 lval
, non_constant_p
, overflow_p
);
4680 case VEC_DELETE_EXPR
:
4683 /* GCC internal stuff. */
4686 case NON_DEPENDENT_EXPR
:
4690 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4691 "expression %qE is not a constant expression", t
);
4692 *non_constant_p
= true;
4695 case PLACEHOLDER_EXPR
:
4696 /* Use of the value or address of the current object. */
4697 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4698 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4699 non_constant_p
, overflow_p
);
4700 /* A placeholder without a referent. We can get here when
4701 checking whether NSDMIs are noexcept, or in massage_init_elt;
4702 just say it's non-constant for now. */
4703 gcc_assert (ctx
->quiet
);
4704 *non_constant_p
= true;
4709 tree cond
= TREE_OPERAND (t
, 0);
4710 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4711 non_constant_p
, overflow_p
);
4712 VERIFY_CONSTANT (cond
);
4713 if (integer_nonzerop (cond
))
4719 *jump_target
= TREE_OPERAND (t
, 0);
4720 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4721 /* Allow for jumping to a cdtor_label. */
4722 || returns (jump_target
));
4726 cxx_eval_loop_expr (ctx
, t
,
4727 non_constant_p
, overflow_p
, jump_target
);
4731 cxx_eval_switch_expr (ctx
, t
,
4732 non_constant_p
, overflow_p
, jump_target
);
4736 /* It's possible to get a requires-expression in a constant
4737 expression. For example:
4739 template<typename T> concept bool C() {
4740 return requires (T t) { t; };
4743 template<typename T> requires !C<T>() void f(T);
4745 Normalization leaves f with the associated constraint
4746 '!requires (T t) { ... }' which is not transformed into
4748 if (!processing_template_decl
)
4749 return evaluate_constraint_expression (t
, NULL_TREE
);
4751 *non_constant_p
= true;
4755 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4757 non_constant_p
, overflow_p
,
4766 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4768 /* This function doesn't know how to deal with pre-genericize
4769 statements; this can only happen with statement-expressions,
4770 so for now just fail. */
4772 error_at (EXPR_LOCATION (t
),
4773 "statement is not a constant expression");
4776 internal_error ("unexpected expression %qE of kind %s", t
,
4777 get_tree_code_name (TREE_CODE (t
)));
4778 *non_constant_p
= true;
4782 if (r
== error_mark_node
)
4783 *non_constant_p
= true;
4785 if (*non_constant_p
)
4792 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4793 bool strict
= true, tree object
= NULL_TREE
)
4795 auto_timevar
time (TV_CONSTEXPR
);
4797 bool non_constant_p
= false;
4798 bool overflow_p
= false;
4799 hash_map
<tree
,tree
> map
;
4801 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4802 allow_non_constant
, strict
};
4804 tree type
= initialized_type (t
);
4806 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4808 /* In C++14 an NSDMI can participate in aggregate initialization,
4809 and can refer to the address of the object being initialized, so
4810 we need to pass in the relevant VAR_DECL if we want to do the
4811 evaluation in a single pass. The evaluation will dynamically
4812 update ctx.values for the VAR_DECL. We use the same strategy
4813 for C++11 constexpr constructors that refer to the object being
4815 ctx
.ctor
= build_constructor (type
, NULL
);
4816 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4819 if (TREE_CODE (t
) == TARGET_EXPR
)
4820 object
= TARGET_EXPR_SLOT (t
);
4821 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4822 object
= AGGR_INIT_EXPR_SLOT (t
);
4824 ctx
.object
= object
;
4826 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4827 (type
, TREE_TYPE (object
)));
4828 if (object
&& DECL_P (object
))
4829 map
.put (object
, ctx
.ctor
);
4830 if (TREE_CODE (r
) == TARGET_EXPR
)
4831 /* Avoid creating another CONSTRUCTOR when we expand the
4833 r
= TARGET_EXPR_INITIAL (r
);
4836 r
= cxx_eval_constant_expression (&ctx
, r
,
4837 false, &non_constant_p
, &overflow_p
);
4839 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4841 /* Mutable logic is a bit tricky: we want to allow initialization of
4842 constexpr variables with mutable members, but we can't copy those
4843 members to another constexpr variable. */
4844 if (TREE_CODE (r
) == CONSTRUCTOR
4845 && CONSTRUCTOR_MUTABLE_POISON (r
))
4847 if (!allow_non_constant
)
4848 error ("%qE is not a constant expression because it refers to "
4849 "mutable subobjects of %qT", t
, type
);
4850 non_constant_p
= true;
4853 if (TREE_CODE (r
) == CONSTRUCTOR
4854 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4856 if (!allow_non_constant
)
4857 error ("%qE is not a constant expression because it refers to "
4858 "an incompletely initialized variable", t
);
4859 TREE_CONSTANT (r
) = false;
4860 non_constant_p
= true;
4863 /* Technically we should check this for all subexpressions, but that
4864 runs into problems with our internal representation of pointer
4865 subtraction and the 5.19 rules are still in flux. */
4866 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4867 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4868 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4870 if (!allow_non_constant
)
4871 error ("conversion from pointer type %qT "
4872 "to arithmetic type %qT in a constant expression",
4873 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4874 non_constant_p
= true;
4877 if (!non_constant_p
&& overflow_p
)
4878 non_constant_p
= true;
4880 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4882 bool should_unshare
= true;
4883 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4884 should_unshare
= false;
4886 if (non_constant_p
&& !allow_non_constant
)
4887 return error_mark_node
;
4888 else if (non_constant_p
&& TREE_CONSTANT (r
))
4890 /* This isn't actually constant, so unset TREE_CONSTANT.
4891 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
4892 it to be set if it is invariant address, even when it is not
4893 a valid C++ constant expression. Wrap it with a NOP_EXPR
4895 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
4897 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4898 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4900 r
= build_nop (TREE_TYPE (r
), r
);
4901 TREE_CONSTANT (r
) = false;
4903 else if (non_constant_p
|| r
== t
)
4907 r
= unshare_expr (r
);
4909 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4911 if (TREE_CODE (t
) == TARGET_EXPR
4912 && TARGET_EXPR_INITIAL (t
) == r
)
4916 r
= get_target_expr (r
);
4917 TREE_CONSTANT (r
) = true;
4925 /* Returns true if T is a valid subexpression of a constant expression,
4926 even if it isn't itself a constant expression. */
4929 is_sub_constant_expr (tree t
)
4931 bool non_constant_p
= false;
4932 bool overflow_p
= false;
4933 hash_map
<tree
, tree
> map
;
4935 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4937 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4939 return !non_constant_p
&& !overflow_p
;
4942 /* If T represents a constant expression returns its reduced value.
4943 Otherwise return error_mark_node. If T is dependent, then
4947 cxx_constant_value (tree t
, tree decl
)
4949 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4952 /* Helper routine for fold_simple function. Either return simplified
4953 expression T, otherwise NULL_TREE.
4954 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4955 even if we are within template-declaration. So be careful on call, as in
4956 such case types can be undefined. */
4959 fold_simple_1 (tree t
)
4962 enum tree_code code
= TREE_CODE (t
);
4974 return fold_sizeof_expr (t
);
4982 case TRUTH_NOT_EXPR
:
4984 case VIEW_CONVERT_EXPR
:
4987 case FIX_TRUNC_EXPR
:
4988 case FIXED_CONVERT_EXPR
:
4989 case ADDR_SPACE_CONVERT_EXPR
:
4991 op1
= TREE_OPERAND (t
, 0);
4993 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4997 if (CONVERT_EXPR_CODE_P (code
)
4998 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4999 TREE_OVERFLOW (t
) = false;
5007 /* If T is a simple constant expression, returns its simplified value.
5008 Otherwise returns T. In contrast to maybe_constant_value we
5009 simplify only few operations on constant-expressions, and we don't
5010 try to simplify constexpressions. */
5013 fold_simple (tree t
)
5015 if (processing_template_decl
)
5018 tree r
= fold_simple_1 (t
);
5025 /* If T is a constant expression, returns its reduced value.
5026 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5027 Otherwise, returns a version of T without TREE_CONSTANT. */
5029 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5032 maybe_constant_value (tree t
, tree decl
)
5036 if (!is_nondependent_constant_expression (t
))
5038 if (TREE_OVERFLOW_P (t
))
5040 t
= build_nop (TREE_TYPE (t
), t
);
5041 TREE_CONSTANT (t
) = false;
5045 else if (CONSTANT_CLASS_P (t
))
5046 /* No caching or evaluation needed. */
5049 if (cv_cache
== NULL
)
5050 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5051 if (tree
*cached
= cv_cache
->get (t
))
5054 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
5055 gcc_checking_assert (r
== t
5056 || CONVERT_EXPR_P (t
)
5057 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5058 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5059 || !cp_tree_equal (r
, t
));
5060 cv_cache
->put (t
, r
);
5064 /* Dispose of the whole CV_CACHE. */
5067 clear_cv_cache (void)
5069 if (cv_cache
!= NULL
)
5073 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5076 clear_cv_and_fold_caches (void)
5079 clear_fold_cache ();
5082 /* Like maybe_constant_value but first fully instantiate the argument.
5084 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5085 (t, tf_none) followed by maybe_constant_value but is more efficient,
5086 because calls instantiation_dependent_expression_p and
5087 potential_constant_expression at most once. */
5090 fold_non_dependent_expr (tree t
)
5095 /* If we're in a template, but T isn't value dependent, simplify
5096 it. We're supposed to treat:
5098 template <typename T> void f(T[1 + 1]);
5099 template <typename T> void f(T[2]);
5101 as two declarations of the same function, for example. */
5102 if (processing_template_decl
)
5104 if (is_nondependent_constant_expression (t
))
5106 processing_template_decl_sentinel s
;
5107 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
5109 if (type_unknown_p (t
)
5110 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5112 if (TREE_OVERFLOW_P (t
))
5114 t
= build_nop (TREE_TYPE (t
), t
);
5115 TREE_CONSTANT (t
) = false;
5120 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
5121 /* cp_tree_equal looks through NOPs, so allow them. */
5122 gcc_checking_assert (r
== t
5123 || CONVERT_EXPR_P (t
)
5124 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5125 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5126 || !cp_tree_equal (r
, t
));
5129 else if (TREE_OVERFLOW_P (t
))
5131 t
= build_nop (TREE_TYPE (t
), t
);
5132 TREE_CONSTANT (t
) = false;
5137 return maybe_constant_value (t
);
5140 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5141 than wrapped in a TARGET_EXPR. */
5144 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
)
5148 if (TREE_CODE (t
) == EXPR_STMT
)
5149 t
= TREE_OPERAND (t
, 0);
5150 if (TREE_CODE (t
) == CONVERT_EXPR
5151 && VOID_TYPE_P (TREE_TYPE (t
)))
5152 t
= TREE_OPERAND (t
, 0);
5153 if (TREE_CODE (t
) == INIT_EXPR
)
5154 t
= TREE_OPERAND (t
, 1);
5155 if (TREE_CODE (t
) == TARGET_EXPR
)
5156 t
= TARGET_EXPR_INITIAL (t
);
5157 if (!is_nondependent_static_init_expression (t
))
5158 /* Don't try to evaluate it. */;
5159 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5160 /* No evaluation needed. */;
5162 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
, false, decl
);
5163 if (TREE_CODE (t
) == TARGET_EXPR
)
5165 tree init
= TARGET_EXPR_INITIAL (t
);
5166 if (TREE_CODE (init
) == CONSTRUCTOR
)
5172 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5175 maybe_constant_init (tree t
, tree decl
)
5177 return maybe_constant_init_1 (t
, decl
, true);
5180 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5183 cxx_constant_init (tree t
, tree decl
)
5185 return maybe_constant_init_1 (t
, decl
, false);
5189 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5190 /* Return true if the object referred to by REF has automatic or thread
5193 enum { ck_ok
, ck_bad
, ck_unknown
};
5195 check_automatic_or_tls (tree ref
)
5198 poly_int64 bitsize
, bitpos
;
5200 int volatilep
= 0, unsignedp
= 0;
5201 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5202 &mode
, &unsignedp
, &volatilep
, false);
5205 /* If there isn't a decl in the middle, we don't know the linkage here,
5206 and this isn't a constant expression anyway. */
5209 dk
= decl_storage_duration (decl
);
5210 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5214 /* Return true if T denotes a potentially constant expression. Issue
5215 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5216 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5217 consider the expression in the current context, independent of constexpr
5220 C++0x [expr.const] used to say
5222 6 An expression is a potential constant expression if it is
5223 a constant expression where all occurrences of function
5224 parameters are replaced by arbitrary constant expressions
5225 of the appropriate type.
5227 2 A conditional expression is a constant expression unless it
5228 involves one of the following as a potentially evaluated
5229 subexpression (3.2), but subexpressions of logical AND (5.14),
5230 logical OR (5.15), and conditional (5.16) operations that are
5231 not evaluated are not considered. */
5234 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5235 tsubst_flags_t flags
)
5237 #define RECUR(T,RV) \
5238 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5240 enum { any
= false, rval
= true };
5244 if (t
== error_mark_node
)
5248 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5249 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5251 if (flags
& tf_error
)
5252 error_at (loc
, "expression %qE has side-effects", t
);
5255 if (CONSTANT_CLASS_P (t
))
5257 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5258 && TREE_TYPE (t
) == error_mark_node
)
5261 switch (TREE_CODE (t
))
5267 case TEMPLATE_ID_EXPR
:
5270 case CASE_LABEL_EXPR
:
5276 case TEMPLATE_PARM_INDEX
:
5278 case IDENTIFIER_NODE
:
5279 case USERDEF_LITERAL
:
5280 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5285 case PLACEHOLDER_EXPR
:
5290 case DEBUG_BEGIN_STMT
:
5296 if (flags
& tf_error
)
5297 error ("%qE is not a constant expression", t
);
5302 case AGGR_INIT_EXPR
:
5304 /* -- an invocation of a function other than a constexpr function
5305 or a constexpr constructor. */
5307 tree fun
= get_function_named_in_call (t
);
5308 const int nargs
= call_expr_nargs (t
);
5311 if (fun
== NULL_TREE
)
5313 /* Reset to allow the function to continue past the end
5314 of the block below. Otherwise return early. */
5317 if (TREE_CODE (t
) == CALL_EXPR
5318 && CALL_EXPR_FN (t
) == NULL_TREE
)
5319 switch (CALL_EXPR_IFN (t
))
5321 /* These should be ignored, they are optimized away from
5322 constexpr functions. */
5323 case IFN_UBSAN_NULL
:
5324 case IFN_UBSAN_BOUNDS
:
5325 case IFN_UBSAN_VPTR
:
5326 case IFN_FALLTHROUGH
:
5329 case IFN_ADD_OVERFLOW
:
5330 case IFN_SUB_OVERFLOW
:
5331 case IFN_MUL_OVERFLOW
:
5341 /* fold_call_expr can't do anything with IFN calls. */
5342 if (flags
& tf_error
)
5343 error_at (loc
, "call to internal function %qE", t
);
5348 if (fun
&& is_overloaded_fn (fun
))
5350 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5352 if (builtin_valid_in_constant_expr_p (fun
))
5354 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5355 /* Allow any built-in function; if the expansion
5356 isn't constant, we'll deal with that then. */
5357 && !is_builtin_fn (fun
))
5359 if (flags
& tf_error
)
5361 error_at (loc
, "call to non-%<constexpr%> function %qD",
5363 explain_invalid_constexpr_fn (fun
);
5367 /* A call to a non-static member function takes the address
5368 of the object as the first argument. But in a constant
5369 expression the address will be folded away, so look
5371 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5372 && !DECL_CONSTRUCTOR_P (fun
))
5374 tree x
= get_nth_callarg (t
, 0);
5375 if (is_this_parameter (x
))
5377 /* Don't require an immediately constant value, as
5378 constexpr substitution might not use the value. */
5379 bool sub_now
= false;
5380 if (!potential_constant_expression_1 (x
, rval
, strict
,
5388 if (!RECUR (fun
, true))
5390 fun
= get_first_fn (fun
);
5392 /* Skip initial arguments to base constructors. */
5393 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5394 i
= num_artificial_parms_for (fun
);
5395 fun
= DECL_ORIGIN (fun
);
5399 if (RECUR (fun
, rval
))
5400 /* Might end up being a constant function pointer. */;
5404 for (; i
< nargs
; ++i
)
5406 tree x
= get_nth_callarg (t
, i
);
5407 /* In a template, reference arguments haven't been converted to
5408 REFERENCE_TYPE and we might not even know if the parameter
5409 is a reference, so accept lvalue constants too. */
5410 bool rv
= processing_template_decl
? any
: rval
;
5411 /* Don't require an immediately constant value, as constexpr
5412 substitution might not use the value of the argument. */
5413 bool sub_now
= false;
5414 if (!potential_constant_expression_1 (x
, rv
, strict
,
5421 case NON_LVALUE_EXPR
:
5422 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5423 -- an lvalue of integral type that refers to a non-volatile
5424 const variable or static data member initialized with
5425 constant expressions, or
5427 -- an lvalue of literal type that refers to non-volatile
5428 object defined with constexpr, or that refers to a
5429 sub-object of such an object; */
5430 return RECUR (TREE_OPERAND (t
, 0), rval
);
5433 if (DECL_HAS_VALUE_EXPR_P (t
))
5435 if (now
&& is_normal_capture_proxy (t
))
5437 /* -- in a lambda-expression, a reference to this or to a
5438 variable with automatic storage duration defined outside that
5439 lambda-expression, where the reference would be an
5441 if (flags
& tf_error
)
5443 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5444 error ("lambda capture of %qE is not a constant expression",
5446 if (!want_rval
&& decl_constant_var_p (cap
))
5447 inform (input_location
, "because it is used as a glvalue");
5451 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5454 && !var_in_maybe_constexpr_fn (t
)
5455 && !type_dependent_expression_p (t
)
5456 && !decl_maybe_constant_var_p (t
)
5458 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5459 || (DECL_INITIAL (t
)
5460 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5461 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5462 && !is_really_empty_class (TREE_TYPE (t
)))
5464 if (flags
& tf_error
)
5465 non_const_var_error (t
);
5472 case VIEW_CONVERT_EXPR
:
5473 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5474 may change to something more specific to type-punning (DR 1312). */
5476 tree from
= TREE_OPERAND (t
, 0);
5477 if (POINTER_TYPE_P (TREE_TYPE (t
))
5478 && TREE_CODE (from
) == INTEGER_CST
5479 && !integer_zerop (from
))
5481 if (flags
& tf_error
)
5482 error_at (loc
, "reinterpret_cast from integer to pointer");
5485 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5488 case ADDRESSOF_EXPR
:
5489 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5490 t
= TREE_OPERAND (t
, 0);
5491 goto handle_addr_expr
;
5494 /* -- a unary operator & that is applied to an lvalue that
5495 designates an object with thread or automatic storage
5497 t
= TREE_OPERAND (t
, 0);
5499 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5500 /* A pointer-to-member constant. */
5505 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5506 any checking here, as we might dereference the pointer later. If
5507 we remove this code, also remove check_automatic_or_tls. */
5508 i
= check_automatic_or_tls (t
);
5513 if (flags
& tf_error
)
5514 error ("address-of an object %qE with thread local or "
5515 "automatic storage is not a constant expression", t
);
5519 return RECUR (t
, any
);
5527 /* -- a class member access unless its postfix-expression is
5528 of literal type or of pointer to literal type. */
5529 /* This test would be redundant, as it follows from the
5530 postfix-expression being a potential constant expression. */
5531 if (type_unknown_p (t
))
5533 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5535 case EXPR_PACK_EXPANSION
:
5536 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5540 tree x
= TREE_OPERAND (t
, 0);
5542 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5544 if (!var_in_maybe_constexpr_fn (x
))
5546 if (flags
& tf_error
)
5547 error_at (loc
, "use of %<this%> in a constant expression");
5552 return RECUR (x
, rval
);
5555 case STATEMENT_LIST
:
5557 tree_stmt_iterator i
;
5558 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5560 if (!RECUR (tsi_stmt (i
), any
))
5568 if (cxx_dialect
< cxx14
)
5570 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5572 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5577 if (cxx_dialect
< cxx14
)
5579 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5581 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5586 if (!RECUR (DO_COND (t
), rval
))
5588 if (!RECUR (DO_BODY (t
), any
))
5593 if (!RECUR (FOR_INIT_STMT (t
), any
))
5595 if (!RECUR (FOR_COND (t
), rval
))
5597 if (!RECUR (FOR_EXPR (t
), any
))
5599 if (!RECUR (FOR_BODY (t
), any
))
5603 case RANGE_FOR_STMT
:
5604 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5606 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5611 if (!RECUR (WHILE_COND (t
), rval
))
5613 if (!RECUR (WHILE_BODY (t
), any
))
5618 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5620 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5621 unreachable labels would be checked. */
5625 return RECUR (STMT_EXPR_STMT (t
), rval
);
5628 if (cxx_dialect
>= cxx17
)
5629 /* In C++17 lambdas can be constexpr, don't give up yet. */
5631 else if (flags
& tf_error
)
5632 error_at (loc
, "lambda-expression is not a constant expression "
5636 case DYNAMIC_CAST_EXPR
:
5637 case PSEUDO_DTOR_EXPR
:
5641 case VEC_DELETE_EXPR
:
5647 case OMP_DISTRIBUTE
:
5650 case OMP_TARGET_DATA
:
5659 case OMP_TARGET_UPDATE
:
5660 case OMP_TARGET_ENTER_DATA
:
5661 case OMP_TARGET_EXIT_DATA
:
5663 case OMP_ATOMIC_READ
:
5664 case OMP_ATOMIC_CAPTURE_OLD
:
5665 case OMP_ATOMIC_CAPTURE_NEW
:
5669 case OACC_HOST_DATA
:
5673 case OACC_ENTER_DATA
:
5674 case OACC_EXIT_DATA
:
5676 /* GCC internal stuff. */
5679 case TRANSACTION_EXPR
:
5681 case AT_ENCODE_EXPR
:
5683 if (flags
& tf_error
)
5684 error_at (loc
, "expression %qE is not a constant expression", t
);
5688 /* -- a typeid expression whose operand is of polymorphic
5691 tree e
= TREE_OPERAND (t
, 0);
5692 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5693 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5695 if (flags
& tf_error
)
5696 error_at (loc
, "typeid-expression is not a constant expression "
5697 "because %qE is of polymorphic type", e
);
5703 case POINTER_DIFF_EXPR
:
5717 case PREINCREMENT_EXPR
:
5718 case POSTINCREMENT_EXPR
:
5719 case PREDECREMENT_EXPR
:
5720 case POSTDECREMENT_EXPR
:
5721 if (cxx_dialect
< cxx14
)
5727 if (TYPE_P (TREE_OPERAND (t
, 0)))
5733 case FIX_TRUNC_EXPR
:
5737 case TRUTH_NOT_EXPR
:
5738 case FIXED_CONVERT_EXPR
:
5739 case UNARY_PLUS_EXPR
:
5740 case UNARY_LEFT_FOLD_EXPR
:
5741 case UNARY_RIGHT_FOLD_EXPR
:
5743 return RECUR (TREE_OPERAND (t
, 0), rval
);
5746 case CONST_CAST_EXPR
:
5747 case STATIC_CAST_EXPR
:
5748 case REINTERPRET_CAST_EXPR
:
5749 case IMPLICIT_CONV_EXPR
:
5750 if (cxx_dialect
< cxx11
5751 && !dependent_type_p (TREE_TYPE (t
))
5752 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5753 /* In C++98, a conversion to non-integral type can't be part of a
5754 constant expression. */
5756 if (flags
& tf_error
)
5758 "cast to non-integral type %qT in a constant expression",
5763 return (RECUR (TREE_OPERAND (t
, 0),
5764 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5767 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5769 case CLEANUP_POINT_EXPR
:
5770 case MUST_NOT_THROW_EXPR
:
5771 case TRY_CATCH_EXPR
:
5776 case NON_DEPENDENT_EXPR
:
5777 /* For convenience. */
5781 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5784 tmp
= DECL_EXPR_DECL (t
);
5785 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5787 if (TREE_STATIC (tmp
))
5789 if (flags
& tf_error
)
5790 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5791 "%<static%> in %<constexpr%> context", tmp
);
5794 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5796 if (flags
& tf_error
)
5797 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5798 "%<thread_local%> in %<constexpr%> context", tmp
);
5801 else if (!check_for_uninitialized_const_var
5802 (tmp
, /*constexpr_context_p=*/true, flags
))
5805 return RECUR (tmp
, want_rval
);
5807 case TRY_FINALLY_EXPR
:
5808 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5809 && RECUR (TREE_OPERAND (t
, 1), any
));
5812 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5815 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
5816 && !literal_type_p (TREE_TYPE (t
)))
5818 if (flags
& tf_error
)
5820 error_at (loc
, "temporary of non-literal type %qT in a "
5821 "constant expression", TREE_TYPE (t
));
5822 explain_non_literal_class (TREE_TYPE (t
));
5828 return RECUR (TREE_OPERAND (t
, 1), rval
);
5832 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5833 constructor_elt
*ce
;
5834 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5835 if (!RECUR (ce
->value
, want_rval
))
5842 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5843 || DECL_P (TREE_PURPOSE (t
)));
5844 if (!RECUR (TREE_VALUE (t
), want_rval
))
5846 if (TREE_CHAIN (t
) == NULL_TREE
)
5848 return RECUR (TREE_CHAIN (t
), want_rval
);
5851 case TRUNC_DIV_EXPR
:
5853 case FLOOR_DIV_EXPR
:
5854 case ROUND_DIV_EXPR
:
5855 case TRUNC_MOD_EXPR
:
5857 case ROUND_MOD_EXPR
:
5859 tree denom
= TREE_OPERAND (t
, 1);
5860 if (!RECUR (denom
, rval
))
5862 /* We can't call cxx_eval_outermost_constant_expr on an expression
5863 that hasn't been through instantiate_non_dependent_expr yet. */
5864 if (!processing_template_decl
)
5865 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5866 if (integer_zerop (denom
))
5868 if (flags
& tf_error
)
5869 error ("division by zero is not a constant expression");
5875 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5881 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5882 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5883 introduced by build_call_a. */
5884 tree op0
= TREE_OPERAND (t
, 0);
5885 tree op1
= TREE_OPERAND (t
, 1);
5887 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5888 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5889 return RECUR (op0
, want_rval
);
5894 /* If the first operand is the non-short-circuit constant, look at
5895 the second operand; otherwise we only care about the first one for
5897 case TRUTH_AND_EXPR
:
5898 case TRUTH_ANDIF_EXPR
:
5899 tmp
= boolean_true_node
;
5902 case TRUTH_ORIF_EXPR
:
5903 tmp
= boolean_false_node
;
5906 tree op
= TREE_OPERAND (t
, 0);
5907 if (!RECUR (op
, rval
))
5909 if (!processing_template_decl
)
5910 op
= cxx_eval_outermost_constant_expr (op
, true);
5911 if (tree_int_cst_equal (op
, tmp
))
5912 return RECUR (TREE_OPERAND (t
, 1), rval
);
5919 case POINTER_PLUS_EXPR
:
5921 case EXACT_DIV_EXPR
:
5931 case TRUTH_XOR_EXPR
:
5932 case UNORDERED_EXPR
:
5945 case ARRAY_RANGE_REF
:
5949 case BINARY_LEFT_FOLD_EXPR
:
5950 case BINARY_RIGHT_FOLD_EXPR
:
5952 for (i
= 0; i
< 2; ++i
)
5953 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5959 for (i
= 0; i
< 3; ++i
)
5960 if (!RECUR (TREE_OPERAND (t
, i
), true))
5965 if (COND_EXPR_IS_VEC_DELETE (t
))
5967 if (flags
& tf_error
)
5968 error_at (loc
, "%<delete[]%> is not a constant expression");
5974 /* If the condition is a known constant, we know which of the legs we
5975 care about; otherwise we only require that the condition and
5976 either of the legs be potentially constant. */
5977 tmp
= TREE_OPERAND (t
, 0);
5978 if (!RECUR (tmp
, rval
))
5980 if (!processing_template_decl
)
5981 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5982 if (integer_zerop (tmp
))
5983 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5984 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5985 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5986 for (i
= 1; i
< 3; ++i
)
5987 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5988 want_rval
, strict
, now
, tf_none
))
5990 if (flags
& tf_error
)
5991 error_at (loc
, "expression %qE is not a constant expression", t
);
5995 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5997 if (flags
& tf_error
)
5999 error_at (loc
, "non-constant array initialization");
6000 diagnose_non_constexpr_vec_init (t
);
6006 /* We can see these in statement-expressions. */
6010 case EMPTY_CLASS_EXPR
:
6016 tree
*target
= &TREE_OPERAND (t
, 0);
6017 /* Gotos representing break and continue are OK. */
6018 if (breaks (target
) || continues (target
))
6020 if (flags
& tf_error
)
6021 error_at (loc
, "%<goto%> is not a constant expression");
6026 return RECUR (TREE_OPERAND (t
, 0), rval
);
6029 if (objc_is_property_ref (t
))
6032 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6039 /* The main entry point to the above. */
6042 potential_constant_expression (tree t
)
6044 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6047 /* As above, but require a constant rvalue. */
6050 potential_rvalue_constant_expression (tree t
)
6052 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6055 /* Like above, but complain about non-constant expressions. */
6058 require_potential_constant_expression (tree t
)
6060 return potential_constant_expression_1 (t
, false, true, false,
6061 tf_warning_or_error
);
6064 /* Cross product of the above. */
6067 require_potential_rvalue_constant_expression (tree t
)
6069 return potential_constant_expression_1 (t
, true, true, false,
6070 tf_warning_or_error
);
6073 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6076 require_rvalue_constant_expression (tree t
)
6078 return potential_constant_expression_1 (t
, true, true, true,
6079 tf_warning_or_error
);
6082 /* Like potential_constant_expression, but don't consider possible constexpr
6083 substitution of the current function. That is, PARM_DECL qualifies under
6084 potential_constant_expression, but not here.
6086 This is basically what you can check when any actual constant values might
6087 be value-dependent. */
6090 is_constant_expression (tree t
)
6092 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6095 /* Like above, but complain about non-constant expressions. */
6098 require_constant_expression (tree t
)
6100 return potential_constant_expression_1 (t
, false, true, true,
6101 tf_warning_or_error
);
6104 /* Like is_constant_expression, but allow const variables that are not allowed
6105 under constexpr rules. */
6108 is_static_init_expression (tree t
)
6110 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6113 /* Returns true if T is a potential constant expression that is not
6114 instantiation-dependent, and therefore a candidate for constant folding even
6118 is_nondependent_constant_expression (tree t
)
6120 return (!type_unknown_p (t
)
6121 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6122 && is_constant_expression (t
)
6123 && !instantiation_dependent_expression_p (t
));
6126 /* Returns true if T is a potential static initializer expression that is not
6127 instantiation-dependent. */
6130 is_nondependent_static_init_expression (tree t
)
6132 return (!type_unknown_p (t
)
6133 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6134 && is_static_init_expression (t
)
6135 && !instantiation_dependent_expression_p (t
));
6138 /* Finalize constexpr processing after parsing. */
6141 fini_constexpr (void)
6143 /* The contexpr call and fundef copies tables are no longer needed. */
6144 constexpr_call_table
= NULL
;
6145 fundef_copies_table
= NULL
;
6148 #include "gt-cp-constexpr.h"