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 /* Make sure the binding has the same type as the parm. But
1317 only for constant args. */
1318 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1319 arg
= adjust_temp_type (type
, arg
);
1320 if (!TREE_CONSTANT (arg
))
1321 *non_constant_args
= true;
1322 *p
= build_tree_list (parms
, arg
);
1323 p
= &TREE_CHAIN (*p
);
1325 parms
= TREE_CHAIN (parms
);
1329 /* Variables and functions to manage constexpr call expansion context.
1330 These do not need to be marked for PCH or GC. */
1332 /* FIXME remember and print actual constant arguments. */
1333 static vec
<tree
> call_stack
;
1334 static int call_stack_tick
;
1335 static int last_cx_error_tick
;
1338 push_cx_call_context (tree call
)
1341 if (!EXPR_HAS_LOCATION (call
))
1342 SET_EXPR_LOCATION (call
, input_location
);
1343 call_stack
.safe_push (call
);
1344 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1350 pop_cx_call_context (void)
1357 cx_error_context (void)
1359 vec
<tree
> r
= vNULL
;
1360 if (call_stack_tick
!= last_cx_error_tick
1361 && !call_stack
.is_empty ())
1363 last_cx_error_tick
= call_stack_tick
;
1367 /* Evaluate a call T to a GCC internal function when possible and return
1368 the evaluated result or, under the control of CTX, give an error, set
1369 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1372 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1374 bool *non_constant_p
, bool *overflow_p
)
1376 enum tree_code opcode
= ERROR_MARK
;
1378 switch (CALL_EXPR_IFN (t
))
1380 case IFN_UBSAN_NULL
:
1381 case IFN_UBSAN_BOUNDS
:
1382 case IFN_UBSAN_VPTR
:
1383 case IFN_FALLTHROUGH
:
1386 case IFN_ADD_OVERFLOW
:
1389 case IFN_SUB_OVERFLOW
:
1390 opcode
= MINUS_EXPR
;
1392 case IFN_MUL_OVERFLOW
:
1397 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1398 false, non_constant_p
, overflow_p
);
1402 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1403 "call to internal function %qE", t
);
1404 *non_constant_p
= true;
1408 /* Evaluate constant arguments using OPCODE and return a complex
1409 number containing the result and the overflow bit. */
1410 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1411 non_constant_p
, overflow_p
);
1412 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1413 non_constant_p
, overflow_p
);
1415 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1417 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1418 tree type
= TREE_TYPE (TREE_TYPE (t
));
1419 tree result
= fold_binary_loc (loc
, opcode
, type
,
1420 fold_convert_loc (loc
, type
, arg0
),
1421 fold_convert_loc (loc
, type
, arg1
));
1423 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1424 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1425 if (TREE_OVERFLOW (result
))
1426 TREE_OVERFLOW (result
) = 0;
1428 return build_complex (TREE_TYPE (t
), result
, ovf
);
1431 *non_constant_p
= true;
1435 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1438 clear_no_implicit_zero (tree ctor
)
1440 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1442 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1443 tree elt
; unsigned HOST_WIDE_INT idx
;
1444 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1445 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1446 clear_no_implicit_zero (elt
);
1450 /* Subroutine of cxx_eval_constant_expression.
1451 Evaluate the call expression tree T in the context of OLD_CALL expression
1455 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1457 bool *non_constant_p
, bool *overflow_p
)
1459 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1460 tree fun
= get_function_named_in_call (t
);
1461 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1464 if (fun
== NULL_TREE
)
1465 return cxx_eval_internal_function (ctx
, t
, lval
,
1466 non_constant_p
, overflow_p
);
1468 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1470 /* Might be a constexpr function pointer. */
1471 fun
= cxx_eval_constant_expression (ctx
, fun
,
1472 /*lval*/false, non_constant_p
,
1475 if (TREE_CODE (fun
) == ADDR_EXPR
)
1476 fun
= TREE_OPERAND (fun
, 0);
1478 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1480 if (!ctx
->quiet
&& !*non_constant_p
)
1481 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1483 *non_constant_p
= true;
1486 if (DECL_CLONED_FUNCTION_P (fun
))
1487 fun
= DECL_CLONED_FUNCTION (fun
);
1489 if (is_ubsan_builtin_p (fun
))
1492 if (is_builtin_fn (fun
))
1493 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1494 lval
, non_constant_p
, overflow_p
);
1495 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1499 if (!lambda_static_thunk_p (fun
))
1500 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1501 explain_invalid_constexpr_fn (fun
);
1503 *non_constant_p
= true;
1507 constexpr_ctx new_ctx
= *ctx
;
1508 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1509 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1511 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1512 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1513 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1514 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1515 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1516 ctx
->values
->put (new_ctx
.object
, ctor
);
1520 /* Shortcut trivial constructor/op=. */
1521 if (trivial_fn_p (fun
))
1523 tree init
= NULL_TREE
;
1524 if (call_expr_nargs (t
) == 2)
1525 init
= convert_from_reference (get_nth_callarg (t
, 1));
1526 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1527 && AGGR_INIT_ZERO_FIRST (t
))
1528 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1531 tree op
= get_nth_callarg (t
, 0);
1532 if (is_dummy_object (op
))
1535 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1536 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1537 new_ctx
.call
= &new_call
;
1538 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1539 non_constant_p
, overflow_p
);
1543 /* We can't defer instantiating the function any longer. */
1544 if (!DECL_INITIAL (fun
)
1545 && DECL_TEMPLOID_INSTANTIATION (fun
))
1547 location_t save_loc
= input_location
;
1548 input_location
= loc
;
1550 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1552 input_location
= save_loc
;
1555 /* If in direct recursive call, optimize definition search. */
1556 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1557 new_call
.fundef
= ctx
->call
->fundef
;
1560 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1561 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1562 || fun
== current_function_decl
)
1566 /* We need to check for current_function_decl here in case we're
1567 being called during cp_fold_function, because at that point
1568 DECL_INITIAL is set properly and we have a fundef but we
1569 haven't lowered invisirefs yet (c++/70344). */
1570 if (DECL_INITIAL (fun
) == error_mark_node
1571 || fun
== current_function_decl
)
1572 error_at (loc
, "%qD called in a constant expression before its "
1573 "definition is complete", fun
);
1574 else if (DECL_INITIAL (fun
))
1576 /* The definition of fun was somehow unsuitable. But pretend
1577 that lambda static thunks don't exist. */
1578 if (!lambda_static_thunk_p (fun
))
1579 error_at (loc
, "%qD called in a constant expression", fun
);
1580 explain_invalid_constexpr_fn (fun
);
1583 error_at (loc
, "%qD used before its definition", fun
);
1585 *non_constant_p
= true;
1590 bool non_constant_args
= false;
1591 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1592 non_constant_p
, overflow_p
, &non_constant_args
);
1593 if (*non_constant_p
)
1596 depth_ok
= push_cx_call_context (t
);
1598 tree result
= NULL_TREE
;
1600 constexpr_call
*entry
= NULL
;
1601 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1603 new_call
.hash
= iterative_hash_template_arg
1604 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1606 /* If we have seen this call before, we are done. */
1607 maybe_initialize_constexpr_call_table ();
1608 constexpr_call
**slot
1609 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1613 /* We need to keep a pointer to the entry, not just the slot, as the
1614 slot can move in the call to cxx_eval_builtin_function_call. */
1615 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1618 /* Calls that are in progress have their result set to NULL,
1619 so that we can detect circular dependencies. */
1620 else if (entry
->result
== NULL
)
1623 error ("call has circular dependency");
1624 *non_constant_p
= true;
1625 entry
->result
= result
= error_mark_node
;
1628 result
= entry
->result
;
1634 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1635 "-fconstexpr-depth= to increase the maximum)",
1636 max_constexpr_depth
);
1637 *non_constant_p
= true;
1638 result
= error_mark_node
;
1642 if (result
&& result
!= error_mark_node
)
1644 else if (!DECL_SAVED_TREE (fun
))
1646 /* When at_eof >= 2, cgraph has started throwing away
1647 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1648 late code generation for VEC_INIT_EXPR, which needs to be
1649 completely reconsidered. */
1650 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1651 *non_constant_p
= true;
1655 tree body
, parms
, res
;
1657 /* Reuse or create a new unshared copy of this function's body. */
1658 tree copy
= get_fundef_copy (fun
);
1659 body
= TREE_PURPOSE (copy
);
1660 parms
= TREE_VALUE (copy
);
1661 res
= TREE_TYPE (copy
);
1663 /* Associate the bindings with the remapped parms. */
1664 tree bound
= new_call
.bindings
;
1665 tree remapped
= parms
;
1668 tree oparm
= TREE_PURPOSE (bound
);
1669 tree arg
= TREE_VALUE (bound
);
1670 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1671 /* Don't share a CONSTRUCTOR that might be changed. */
1672 arg
= unshare_constructor (arg
);
1673 ctx
->values
->put (remapped
, arg
);
1674 bound
= TREE_CHAIN (bound
);
1675 remapped
= DECL_CHAIN (remapped
);
1677 /* Add the RESULT_DECL to the values map, too. */
1678 tree slot
= NULL_TREE
;
1679 if (DECL_BY_REFERENCE (res
))
1681 slot
= AGGR_INIT_EXPR_SLOT (t
);
1682 tree addr
= build_address (slot
);
1683 addr
= build_nop (TREE_TYPE (res
), addr
);
1684 ctx
->values
->put (res
, addr
);
1685 ctx
->values
->put (slot
, NULL_TREE
);
1688 ctx
->values
->put (res
, NULL_TREE
);
1690 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1691 their values after the call. */
1692 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1693 hash_set
<tree
> save_exprs
;
1694 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1695 ctx_with_save_exprs
.call
= &new_call
;
1697 tree jump_target
= NULL_TREE
;
1698 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1699 lval
, non_constant_p
, overflow_p
,
1702 if (DECL_CONSTRUCTOR_P (fun
))
1703 /* This can be null for a subobject constructor call, in
1704 which case what we care about is the initialization
1705 side-effects rather than the value. We could get at the
1706 value by evaluating *this, but we don't bother; there's
1707 no need to put such a call in the hash table. */
1708 result
= lval
? ctx
->object
: ctx
->ctor
;
1709 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1713 result
= *ctx
->values
->get (slot
? slot
: res
);
1714 if (result
== NULL_TREE
&& !*non_constant_p
)
1717 error ("%<constexpr%> call flows off the end "
1719 *non_constant_p
= true;
1723 /* Forget the saved values of the callee's SAVE_EXPRs. */
1724 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1725 iter
!= save_exprs
.end(); ++iter
)
1726 ctx_with_save_exprs
.values
->remove (*iter
);
1728 /* Remove the parms/result from the values map. Is it worth
1729 bothering to do this when the map itself is only live for
1730 one constexpr evaluation? If so, maybe also clear out
1731 other vars from call, maybe in BIND_EXPR handling? */
1732 ctx
->values
->remove (res
);
1734 ctx
->values
->remove (slot
);
1735 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1736 ctx
->values
->remove (parm
);
1738 /* Make the unshared function copy we used available for re-use. */
1739 save_fundef_copy (fun
, copy
);
1742 if (result
== error_mark_node
)
1743 *non_constant_p
= true;
1744 if (*non_constant_p
|| *overflow_p
)
1745 result
= error_mark_node
;
1749 entry
->result
= result
;
1752 /* The result of a constexpr function must be completely initialized. */
1753 if (TREE_CODE (result
) == CONSTRUCTOR
)
1754 clear_no_implicit_zero (result
);
1756 pop_cx_call_context ();
1757 return unshare_constructor (result
);
1760 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1763 reduced_constant_expression_p (tree t
)
1765 switch (TREE_CODE (t
))
1768 /* Even if we can't lower this yet, it's constant. */
1772 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1773 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1774 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1776 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1777 /* An initialized vector would have a VECTOR_CST. */
1780 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1784 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1787 /* We're in the middle of initializing this element. */
1789 if (!reduced_constant_expression_p (val
))
1795 field
= next_initializable_field (DECL_CHAIN (field
));
1800 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1801 /* All the fields are initialized. */
1802 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1806 /* FIXME are we calling this too much? */
1807 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1811 /* Some expressions may have constant operands but are not constant
1812 themselves, such as 1/0. Call this function (or rather, the macro
1813 following it) to check for that condition.
1815 We only call this in places that require an arithmetic constant, not in
1816 places where we might have a non-constant expression that can be a
1817 component of a constant expression, such as the address of a constexpr
1818 variable that might be dereferenced later. */
1821 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1824 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1826 if (!allow_non_constant
)
1827 error ("%q+E is not a constant expression", t
);
1828 *non_constant_p
= true;
1830 if (TREE_OVERFLOW_P (t
))
1832 if (!allow_non_constant
)
1834 permerror (input_location
, "overflow in constant expression");
1835 /* If we're being permissive (and are in an enforcing
1836 context), ignore the overflow. */
1837 if (flag_permissive
)
1838 return *non_constant_p
;
1842 return *non_constant_p
;
1845 /* Check whether the shift operation with code CODE and type TYPE on LHS
1846 and RHS is undefined. If it is, give an error with an explanation,
1847 and return true; return false otherwise. */
1850 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1851 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1853 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1854 || TREE_CODE (lhs
) != INTEGER_CST
1855 || TREE_CODE (rhs
) != INTEGER_CST
)
1858 tree lhstype
= TREE_TYPE (lhs
);
1859 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1861 /* [expr.shift] The behavior is undefined if the right operand
1862 is negative, or greater than or equal to the length in bits
1863 of the promoted left operand. */
1864 if (tree_int_cst_sgn (rhs
) == -1)
1867 permerror (loc
, "right operand of shift expression %q+E is negative",
1868 build2_loc (loc
, code
, type
, lhs
, rhs
));
1869 return (!flag_permissive
|| ctx
->quiet
);
1871 if (compare_tree_int (rhs
, uprec
) >= 0)
1874 permerror (loc
, "right operand of shift expression %q+E is >= than "
1875 "the precision of the left operand",
1876 build2_loc (loc
, code
, type
, lhs
, rhs
));
1877 return (!flag_permissive
|| ctx
->quiet
);
1880 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1881 if E1 has a signed type and non-negative value, and E1x2^E2 is
1882 representable in the corresponding unsigned type of the result type,
1883 then that value, converted to the result type, is the resulting value;
1884 otherwise, the behavior is undefined. */
1885 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1886 && (cxx_dialect
>= cxx11
))
1888 if (tree_int_cst_sgn (lhs
) == -1)
1892 "left operand of shift expression %q+E is negative",
1893 build2_loc (loc
, code
, type
, lhs
, rhs
));
1894 return (!flag_permissive
|| ctx
->quiet
);
1896 /* For signed x << y the following:
1897 (unsigned) x >> ((prec (lhs) - 1) - y)
1898 if > 1, is undefined. The right-hand side of this formula
1899 is the highest bit of the LHS that can be set (starting from 0),
1900 so that the shift doesn't overflow. We then right-shift the LHS
1901 to see whether any other bit is set making the original shift
1902 undefined -- the result is not representable in the corresponding
1904 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1905 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1906 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1907 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1908 if (tree_int_cst_lt (integer_one_node
, t
))
1911 permerror (loc
, "shift expression %q+E overflows",
1912 build2_loc (loc
, code
, type
, lhs
, rhs
));
1913 return (!flag_permissive
|| ctx
->quiet
);
1919 /* Subroutine of cxx_eval_constant_expression.
1920 Attempt to reduce the unary expression tree T to a compile time value.
1921 If successful, return the value. Otherwise issue a diagnostic
1922 and return error_mark_node. */
1925 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1927 bool *non_constant_p
, bool *overflow_p
)
1930 tree orig_arg
= TREE_OPERAND (t
, 0);
1931 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1932 non_constant_p
, overflow_p
);
1933 VERIFY_CONSTANT (arg
);
1934 location_t loc
= EXPR_LOCATION (t
);
1935 enum tree_code code
= TREE_CODE (t
);
1936 tree type
= TREE_TYPE (t
);
1937 r
= fold_unary_loc (loc
, code
, type
, arg
);
1940 if (arg
== orig_arg
)
1943 r
= build1_loc (loc
, code
, type
, arg
);
1945 VERIFY_CONSTANT (r
);
1949 /* Helper function for cxx_eval_binary_expression. Try to optimize
1950 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1951 generic folding should be used. */
1954 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1955 tree lhs
, tree rhs
, bool *non_constant_p
,
1959 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1962 lhs
= TREE_OPERAND (lhs
, 0);
1964 /* &A[i] p+ j => &A[i + j] */
1965 if (TREE_CODE (lhs
) == ARRAY_REF
1966 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1967 && TREE_CODE (rhs
) == INTEGER_CST
1968 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1969 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1971 tree orig_type
= TREE_TYPE (t
);
1972 location_t loc
= EXPR_LOCATION (t
);
1973 tree type
= TREE_TYPE (lhs
);
1975 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1976 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1977 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1979 if (*non_constant_p
)
1981 /* Don't fold an out-of-bound access. */
1982 if (!tree_int_cst_le (t
, nelts
))
1984 rhs
= cp_fold_convert (ssizetype
, rhs
);
1985 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1986 constexpr int A[1]; ... (char *)&A[0] + 1 */
1987 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1988 rhs
, TYPE_SIZE_UNIT (type
))))
1990 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1992 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1993 TYPE_SIZE_UNIT (type
));
1994 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1995 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1996 t
, NULL_TREE
, NULL_TREE
);
1997 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1998 t
= cp_fold_convert (orig_type
, t
);
1999 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2000 non_constant_p
, overflow_p
);
2006 /* Subroutine of cxx_eval_constant_expression.
2007 Like cxx_eval_unary_expression, except for binary expressions. */
2010 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2012 bool *non_constant_p
, bool *overflow_p
)
2015 tree orig_lhs
= TREE_OPERAND (t
, 0);
2016 tree orig_rhs
= TREE_OPERAND (t
, 1);
2018 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2019 non_constant_p
, overflow_p
);
2020 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2022 if (*non_constant_p
)
2024 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2025 non_constant_p
, overflow_p
);
2026 if (*non_constant_p
)
2029 location_t loc
= EXPR_LOCATION (t
);
2030 enum tree_code code
= TREE_CODE (t
);
2031 tree type
= TREE_TYPE (t
);
2033 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2035 bool is_code_eq
= (code
== EQ_EXPR
);
2037 if (TREE_CODE (lhs
) == PTRMEM_CST
2038 && TREE_CODE (rhs
) == PTRMEM_CST
)
2039 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2041 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2042 || TREE_CODE (rhs
) == PTRMEM_CST
)
2043 && (null_member_pointer_value_p (lhs
)
2044 || null_member_pointer_value_p (rhs
)))
2045 r
= constant_boolean_node (!is_code_eq
, type
);
2046 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2047 lhs
= cplus_expand_constant (lhs
);
2048 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2049 rhs
= cplus_expand_constant (rhs
);
2051 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2052 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2055 error ("arithmetic involving a null pointer in %qE", lhs
);
2058 else if (code
== POINTER_PLUS_EXPR
)
2059 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2063 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2067 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2070 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2072 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2073 *non_constant_p
= true;
2074 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2075 a local array in a constexpr function. */
2076 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2078 VERIFY_CONSTANT (r
);
2082 /* Subroutine of cxx_eval_constant_expression.
2083 Attempt to evaluate condition expressions. Dead branches are not
2087 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2089 bool *non_constant_p
, bool *overflow_p
,
2092 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2094 non_constant_p
, overflow_p
);
2095 VERIFY_CONSTANT (val
);
2096 /* Don't VERIFY_CONSTANT the other operands. */
2097 if (integer_zerop (val
))
2098 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2100 non_constant_p
, overflow_p
,
2102 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2104 non_constant_p
, overflow_p
,
2108 /* Subroutine of cxx_eval_constant_expression.
2109 Attempt to evaluate vector condition expressions. Unlike
2110 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2111 ternary arithmetics operation, where all 3 arguments have to be
2112 evaluated as constants and then folding computes the result from
2116 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2117 bool *non_constant_p
, bool *overflow_p
)
2119 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2121 non_constant_p
, overflow_p
);
2122 VERIFY_CONSTANT (arg1
);
2123 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2125 non_constant_p
, overflow_p
);
2126 VERIFY_CONSTANT (arg2
);
2127 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2129 non_constant_p
, overflow_p
);
2130 VERIFY_CONSTANT (arg3
);
2131 location_t loc
= EXPR_LOCATION (t
);
2132 tree type
= TREE_TYPE (t
);
2133 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2136 if (arg1
== TREE_OPERAND (t
, 0)
2137 && arg2
== TREE_OPERAND (t
, 1)
2138 && arg3
== TREE_OPERAND (t
, 2))
2141 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2143 VERIFY_CONSTANT (r
);
2147 /* Returns less than, equal to, or greater than zero if KEY is found to be
2148 less than, to match, or to be greater than the constructor_elt's INDEX. */
2151 array_index_cmp (tree key
, tree index
)
2153 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2155 switch (TREE_CODE (index
))
2158 return tree_int_cst_compare (key
, index
);
2161 tree lo
= TREE_OPERAND (index
, 0);
2162 tree hi
= TREE_OPERAND (index
, 1);
2163 if (tree_int_cst_lt (key
, lo
))
2165 else if (tree_int_cst_lt (hi
, key
))
2175 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2176 if none. If INSERT is true, insert a matching element rather than fail. */
2178 static HOST_WIDE_INT
2179 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2181 if (tree_int_cst_sgn (dindex
) < 0)
2184 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2185 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2186 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2188 unsigned HOST_WIDE_INT end
= len
;
2189 unsigned HOST_WIDE_INT begin
= 0;
2191 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2192 that the same is true of the other elements and index directly. */
2195 tree cindex
= (*elts
)[end
-1].index
;
2196 if (TREE_CODE (cindex
) == INTEGER_CST
2197 && compare_tree_int (cindex
, end
-1) == 0)
2206 /* Otherwise, find a matching index by means of a binary search. */
2207 while (begin
!= end
)
2209 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2210 constructor_elt
&elt
= (*elts
)[middle
];
2211 tree idx
= elt
.index
;
2213 int cmp
= array_index_cmp (dindex
, idx
);
2220 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2222 /* We need to split the range. */
2224 tree lo
= TREE_OPERAND (idx
, 0);
2225 tree hi
= TREE_OPERAND (idx
, 1);
2226 if (tree_int_cst_lt (lo
, dindex
))
2228 /* There are still some lower elts; shorten the range. */
2229 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2231 if (tree_int_cst_equal (lo
, new_hi
))
2232 /* Only one element left, no longer a range. */
2235 TREE_OPERAND (idx
, 1) = new_hi
;
2236 /* Append the element we want to insert. */
2239 e
.value
= unshare_constructor (elt
.value
);
2240 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2243 /* No lower elts, the range elt is now ours. */
2246 if (tree_int_cst_lt (dindex
, hi
))
2248 /* There are still some higher elts; append a range. */
2249 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2251 if (tree_int_cst_equal (new_lo
, hi
))
2254 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2255 e
.value
= unshare_constructor (elt
.value
);
2256 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2265 constructor_elt e
= { dindex
, NULL_TREE
};
2266 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2273 /* Under the control of CTX, issue a detailed diagnostic for
2274 an out-of-bounds subscript INDEX into the expression ARRAY. */
2277 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2281 tree arraytype
= TREE_TYPE (array
);
2283 /* Convert the unsigned array subscript to a signed integer to avoid
2284 printing huge numbers for small negative values. */
2285 tree sidx
= fold_convert (ssizetype
, index
);
2288 if (TYPE_DOMAIN (arraytype
))
2289 error ("array subscript value %qE is outside the bounds "
2290 "of array %qD of type %qT", sidx
, array
, arraytype
);
2292 error ("non-zero array subscript %qE is used with array %qD of "
2293 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2294 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2296 else if (TYPE_DOMAIN (arraytype
))
2297 error ("array subscript value %qE is outside the bounds "
2298 "of array type %qT", sidx
, arraytype
);
2300 error ("non-zero array subscript %qE is used with array of type %qT "
2301 "with unknown bounds", sidx
, arraytype
);
2305 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2309 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2310 bool *non_constant_p
, bool *overflow_p
)
2313 if (TREE_CODE (type
) == ARRAY_TYPE
)
2315 if (TYPE_DOMAIN (type
))
2316 nelts
= array_type_nelts_top (type
);
2318 nelts
= size_zero_node
;
2320 else if (VECTOR_TYPE_P (type
))
2321 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2325 /* For VLAs, the number of elements won't be an integer constant. */
2326 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2327 non_constant_p
, overflow_p
);
2331 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2332 STRING_CST STRING. */
2335 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2337 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2340 if (chars_per_elt
== 1)
2341 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2344 const unsigned char *ptr
2345 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2346 + index
* chars_per_elt
);
2347 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2352 /* Subroutine of cxx_eval_constant_expression.
2353 Attempt to reduce a reference to an array slot. */
2356 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2358 bool *non_constant_p
, bool *overflow_p
)
2360 tree oldary
= TREE_OPERAND (t
, 0);
2361 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2363 non_constant_p
, overflow_p
);
2365 HOST_WIDE_INT i
= 0;
2366 tree elem_type
= NULL_TREE
;
2367 unsigned len
= 0, elem_nchars
= 1;
2368 if (*non_constant_p
)
2370 oldidx
= TREE_OPERAND (t
, 1);
2371 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2373 non_constant_p
, overflow_p
);
2374 VERIFY_CONSTANT (index
);
2377 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2378 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2379 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2380 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2381 ary
= TREE_OPERAND (ary
, 0);
2382 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2383 len
= CONSTRUCTOR_NELTS (ary
);
2384 else if (TREE_CODE (ary
) == STRING_CST
)
2386 elem_nchars
= (TYPE_PRECISION (elem_type
)
2387 / TYPE_PRECISION (char_type_node
));
2388 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2390 else if (TREE_CODE (ary
) == VECTOR_CST
)
2391 /* We don't create variable-length VECTOR_CSTs. */
2392 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2395 /* We can't do anything with other tree codes, so use
2396 VERIFY_CONSTANT to complain and fail. */
2397 VERIFY_CONSTANT (ary
);
2401 if (!tree_fits_shwi_p (index
)
2402 || (i
= tree_to_shwi (index
)) < 0)
2404 diag_array_subscript (ctx
, ary
, index
);
2405 *non_constant_p
= true;
2410 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2412 VERIFY_CONSTANT (nelts
);
2414 ? !tree_int_cst_le (index
, nelts
)
2415 : !tree_int_cst_lt (index
, nelts
))
2416 || tree_int_cst_sgn (index
) < 0)
2418 diag_array_subscript (ctx
, ary
, index
);
2419 *non_constant_p
= true;
2423 if (lval
&& ary
== oldary
&& index
== oldidx
)
2426 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2429 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2431 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2442 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2443 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2444 else if (TREE_CODE (ary
) == VECTOR_CST
)
2445 r
= VECTOR_CST_ELT (ary
, i
);
2447 r
= extract_string_elt (ary
, elem_nchars
, i
);
2450 /* Don't VERIFY_CONSTANT here. */
2453 /* Otherwise the element doesn't have a value yet. */
2458 if (TREE_CODE (ary
) == CONSTRUCTOR
2459 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2461 /* 'ary' is part of the aggregate initializer we're currently
2462 building; if there's no initializer for this element yet,
2465 error ("accessing uninitialized array element");
2466 *non_constant_p
= true;
2470 /* If it's within the array bounds but doesn't have an explicit
2471 initializer, it's value-initialized. */
2472 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2473 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2477 /* Subroutine of cxx_eval_constant_expression.
2478 Attempt to reduce a field access of a value of class type. */
2481 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2483 bool *non_constant_p
, bool *overflow_p
)
2485 unsigned HOST_WIDE_INT i
;
2488 tree part
= TREE_OPERAND (t
, 1);
2489 tree orig_whole
= TREE_OPERAND (t
, 0);
2490 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2492 non_constant_p
, overflow_p
);
2493 if (INDIRECT_REF_P (whole
)
2494 && integer_zerop (TREE_OPERAND (whole
, 0))
2496 error ("dereferencing a null pointer in %qE", orig_whole
);
2498 if (TREE_CODE (whole
) == PTRMEM_CST
)
2499 whole
= cplus_expand_constant (whole
);
2500 if (whole
== orig_whole
)
2503 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2504 whole
, part
, NULL_TREE
);
2505 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2507 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2510 error ("%qE is not a constant expression", orig_whole
);
2511 *non_constant_p
= true;
2513 if (DECL_MUTABLE_P (part
))
2516 error ("mutable %qD is not usable in a constant expression", part
);
2517 *non_constant_p
= true;
2519 if (*non_constant_p
)
2521 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2522 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2524 /* Use name match for PMF fields, as a variant will have a
2525 different FIELD_DECL with a different type. */
2526 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2532 /* We're in the middle of initializing it. */
2536 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2537 && CONSTRUCTOR_NELTS (whole
) > 0)
2539 /* DR 1188 says we don't have to deal with this. */
2541 error ("accessing %qD member instead of initialized %qD member in "
2542 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2543 *non_constant_p
= true;
2547 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2548 classes never get represented; throw together a value now. */
2549 if (is_really_empty_class (TREE_TYPE (t
)))
2550 return build_constructor (TREE_TYPE (t
), NULL
);
2552 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2554 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2556 /* 'whole' is part of the aggregate initializer we're currently
2557 building; if there's no initializer for this member yet, that's an
2560 error ("accessing uninitialized member %qD", part
);
2561 *non_constant_p
= true;
2565 /* If there's no explicit init for this field, it's value-initialized. */
2566 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2567 return cxx_eval_constant_expression (ctx
, value
,
2569 non_constant_p
, overflow_p
);
2572 /* Subroutine of cxx_eval_constant_expression.
2573 Attempt to reduce a field access of a value of class type that is
2574 expressed as a BIT_FIELD_REF. */
2577 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2579 bool *non_constant_p
, bool *overflow_p
)
2581 tree orig_whole
= TREE_OPERAND (t
, 0);
2582 tree retval
, fldval
, utype
, mask
;
2583 bool fld_seen
= false;
2584 HOST_WIDE_INT istart
, isize
;
2585 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2587 non_constant_p
, overflow_p
);
2588 tree start
, field
, value
;
2589 unsigned HOST_WIDE_INT i
;
2591 if (whole
== orig_whole
)
2593 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2595 if (!*non_constant_p
2596 && TREE_CODE (whole
) != VECTOR_CST
2597 && TREE_CODE (whole
) != CONSTRUCTOR
)
2600 error ("%qE is not a constant expression", orig_whole
);
2601 *non_constant_p
= true;
2603 if (*non_constant_p
)
2606 if (TREE_CODE (whole
) == VECTOR_CST
)
2607 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2608 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2610 start
= TREE_OPERAND (t
, 2);
2611 istart
= tree_to_shwi (start
);
2612 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2613 utype
= TREE_TYPE (t
);
2614 if (!TYPE_UNSIGNED (utype
))
2615 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2616 retval
= build_int_cst (utype
, 0);
2617 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2619 tree bitpos
= bit_position (field
);
2620 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2622 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2623 && TREE_CODE (value
) == INTEGER_CST
2624 && tree_fits_shwi_p (bitpos
)
2625 && tree_fits_shwi_p (DECL_SIZE (field
)))
2627 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2628 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2629 HOST_WIDE_INT shift
;
2630 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2632 fldval
= fold_convert (utype
, value
);
2633 mask
= build_int_cst_type (utype
, -1);
2634 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2635 size_int (TYPE_PRECISION (utype
) - sz
));
2636 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2637 size_int (TYPE_PRECISION (utype
) - sz
));
2638 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2639 shift
= bit
- istart
;
2640 if (BYTES_BIG_ENDIAN
)
2641 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2642 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2644 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2650 return fold_convert (TREE_TYPE (t
), retval
);
2652 return error_mark_node
;
2655 /* Subroutine of cxx_eval_constant_expression.
2656 Evaluate a short-circuited logical expression T in the context
2657 of a given constexpr CALL. BAILOUT_VALUE is the value for
2658 early return. CONTINUE_VALUE is used here purely for
2659 sanity check purposes. */
2662 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2663 tree bailout_value
, tree continue_value
,
2665 bool *non_constant_p
, bool *overflow_p
)
2668 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2670 non_constant_p
, overflow_p
);
2671 VERIFY_CONSTANT (lhs
);
2672 if (tree_int_cst_equal (lhs
, bailout_value
))
2674 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2675 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2676 lval
, non_constant_p
,
2678 VERIFY_CONSTANT (r
);
2682 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2683 CONSTRUCTOR elements to initialize (part of) an object containing that
2684 field. Return a pointer to the constructor_elt corresponding to the
2685 initialization of the field. */
2687 static constructor_elt
*
2688 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2690 tree aggr
= TREE_OPERAND (ref
, 0);
2691 tree field
= TREE_OPERAND (ref
, 1);
2693 constructor_elt
*ce
;
2695 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2697 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2699 constructor_elt
*base_ce
2700 = base_field_constructor_elt (v
, aggr
);
2701 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2704 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2705 if (ce
->index
== field
)
2712 /* Some of the expressions fed to the constexpr mechanism are calls to
2713 constructors, which have type void. In that case, return the type being
2714 initialized by the constructor. */
2717 initialized_type (tree t
)
2721 tree type
= cv_unqualified (TREE_TYPE (t
));
2722 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2724 /* A constructor call has void type, so we need to look deeper. */
2725 tree fn
= get_function_named_in_call (t
);
2726 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2727 && DECL_CXX_CONSTRUCTOR_P (fn
))
2728 type
= DECL_CONTEXT (fn
);
2733 /* We're about to initialize element INDEX of an array or class from VALUE.
2734 Set up NEW_CTX appropriately by adjusting .object to refer to the
2735 subobject and creating a new CONSTRUCTOR if the element is itself
2736 a class or array. */
2739 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2740 tree index
, tree
&value
)
2744 if (index
&& TREE_CODE (index
) != INTEGER_CST
2745 && TREE_CODE (index
) != FIELD_DECL
)
2746 /* This won't have an element in the new CONSTRUCTOR. */
2749 tree type
= initialized_type (value
);
2750 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2751 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2754 /* The sub-aggregate initializer might contain a placeholder;
2755 update object to refer to the subobject and ctor to refer to
2756 the (newly created) sub-initializer. */
2758 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2759 tree elt
= build_constructor (type
, NULL
);
2760 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2763 if (TREE_CODE (value
) == TARGET_EXPR
)
2764 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2765 value
= TARGET_EXPR_INITIAL (value
);
2768 /* We're about to process an initializer for a class or array TYPE. Make
2769 sure that CTX is set up appropriately. */
2772 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2774 /* We don't bother building a ctor for an empty base subobject. */
2775 if (is_empty_class (type
))
2778 /* We're in the middle of an initializer that might involve placeholders;
2779 our caller should have created a CONSTRUCTOR for us to put the
2780 initializer into. We will either return that constructor or T. */
2781 gcc_assert (ctx
->ctor
);
2782 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2783 (type
, TREE_TYPE (ctx
->ctor
)));
2784 /* We used to check that ctx->ctor was empty, but that isn't the case when
2785 the object is zero-initialized before calling the constructor. */
2788 tree otype
= TREE_TYPE (ctx
->object
);
2789 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2790 /* Handle flexible array members. */
2791 || (TREE_CODE (otype
) == ARRAY_TYPE
2792 && TYPE_DOMAIN (otype
) == NULL_TREE
2793 && TREE_CODE (type
) == ARRAY_TYPE
2794 && (same_type_ignoring_top_level_qualifiers_p
2795 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2797 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2798 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2801 /* Subroutine of cxx_eval_constant_expression.
2802 The expression tree T denotes a C-style array or a C-style
2803 aggregate. Reduce it to a constant expression. */
2806 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2808 bool *non_constant_p
, bool *overflow_p
)
2810 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2811 bool changed
= false;
2812 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2813 tree type
= TREE_TYPE (t
);
2815 constexpr_ctx new_ctx
;
2816 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2818 /* We don't really need the ctx->ctor business for a PMF or
2819 vector, but it's simpler to use the same code. */
2821 new_ctx
.ctor
= build_constructor (type
, NULL
);
2822 new_ctx
.object
= NULL_TREE
;
2825 verify_ctor_sanity (ctx
, type
);
2826 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2827 vec_alloc (*p
, vec_safe_length (v
));
2831 bool constant_p
= true;
2832 bool side_effects_p
= false;
2833 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2835 tree orig_value
= value
;
2836 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2837 if (new_ctx
.ctor
!= ctx
->ctor
)
2838 /* If we built a new CONSTRUCTOR, attach it now so that other
2839 initializers can refer to it. */
2840 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2841 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2843 non_constant_p
, overflow_p
);
2844 /* Don't VERIFY_CONSTANT here. */
2845 if (ctx
->quiet
&& *non_constant_p
)
2847 if (elt
!= orig_value
)
2850 if (!TREE_CONSTANT (elt
))
2852 if (TREE_SIDE_EFFECTS (elt
))
2853 side_effects_p
= true;
2854 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2856 /* This is an initialization of a vfield inside a base
2857 subaggregate that we already initialized; push this
2858 initialization into the previous initialization. */
2859 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2864 && (TREE_CODE (index
) == NOP_EXPR
2865 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2867 /* This is an initializer for an empty base; now that we've
2868 checked that it's constant, we can ignore it. */
2869 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2872 else if (new_ctx
.ctor
!= ctx
->ctor
)
2874 /* We appended this element above; update the value. */
2875 gcc_assert ((*p
)->last().index
== index
);
2876 (*p
)->last().value
= elt
;
2879 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2881 if (*non_constant_p
|| !changed
)
2884 /* We're done building this CONSTRUCTOR, so now we can interpret an
2885 element without an explicit initializer as value-initialized. */
2886 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2887 TREE_CONSTANT (t
) = constant_p
;
2888 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2889 if (VECTOR_TYPE_P (type
))
2894 /* Subroutine of cxx_eval_constant_expression.
2895 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2896 initialization of a non-static data member of array type. Reduce it to a
2899 Note that apart from value-initialization (when VALUE_INIT is true),
2900 this is only intended to support value-initialization and the
2901 initializations done by defaulted constructors for classes with
2902 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2903 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2904 for the copy/move constructor. */
2907 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2908 bool value_init
, bool lval
,
2909 bool *non_constant_p
, bool *overflow_p
)
2911 tree elttype
= TREE_TYPE (atype
);
2912 verify_ctor_sanity (ctx
, atype
);
2913 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2914 bool pre_init
= false;
2915 unsigned HOST_WIDE_INT i
;
2917 /* For the default constructor, build up a call to the default
2918 constructor of the element type. We only need to handle class types
2919 here, as for a constructor to be constexpr, all members must be
2920 initialized, which for a defaulted default constructor means they must
2921 be of a class type with a constexpr default constructor. */
2922 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2923 /* We only do this at the lowest level. */;
2924 else if (value_init
)
2926 init
= build_value_init (elttype
, tf_warning_or_error
);
2931 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2932 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2933 &argvec
, elttype
, LOOKUP_NORMAL
,
2934 tf_warning_or_error
);
2935 release_tree_vector (argvec
);
2936 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2940 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
2942 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
2943 for (i
= 0; i
< max
; ++i
)
2945 tree idx
= build_int_cst (size_type_node
, i
);
2948 constexpr_ctx new_ctx
;
2949 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2950 if (new_ctx
.ctor
!= ctx
->ctor
)
2951 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2952 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2954 /* A multidimensional array; recurse. */
2955 if (value_init
|| init
== NULL_TREE
)
2957 eltinit
= NULL_TREE
;
2961 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2962 tf_warning_or_error
);
2963 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2965 non_constant_p
, overflow_p
);
2969 /* Initializing an element using value or default initialization
2970 we just pre-built above. */
2971 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2972 non_constant_p
, overflow_p
);
2977 /* Copying an element. */
2978 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2979 (atype
, TREE_TYPE (init
)));
2980 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2981 tf_warning_or_error
);
2982 if (!lvalue_p (init
))
2983 eltinit
= move (eltinit
);
2984 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2985 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
2986 non_constant_p
, overflow_p
);
2988 if (*non_constant_p
&& !ctx
->quiet
)
2990 if (new_ctx
.ctor
!= ctx
->ctor
)
2992 /* We appended this element above; update the value. */
2993 gcc_assert ((*p
)->last().index
== idx
);
2994 (*p
)->last().value
= eltinit
;
2997 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2998 /* Reuse the result of cxx_eval_constant_expression call
2999 from the first iteration to all others if it is a constant
3000 initializer that doesn't require relocations. */
3003 && (eltinit
== NULL_TREE
3004 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3005 == null_pointer_node
)))
3007 if (new_ctx
.ctor
!= ctx
->ctor
)
3008 eltinit
= new_ctx
.ctor
;
3009 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3010 build_int_cst (size_type_node
, 1),
3011 build_int_cst (size_type_node
, max
- 1));
3012 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3016 vec_safe_reserve (*p
, max
);
3019 if (!*non_constant_p
)
3022 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
3028 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3030 bool *non_constant_p
, bool *overflow_p
)
3032 tree atype
= TREE_TYPE (t
);
3033 tree init
= VEC_INIT_EXPR_INIT (t
);
3034 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3035 VEC_INIT_EXPR_VALUE_INIT (t
),
3036 lval
, non_constant_p
, overflow_p
);
3037 if (*non_constant_p
)
3043 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3044 match. We want to be less strict for simple *& folding; if we have a
3045 non-const temporary that we access through a const pointer, that should
3046 work. We handle this here rather than change fold_indirect_ref_1
3047 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3048 don't really make sense outside of constant expression evaluation. Also
3049 we want to allow folding to COMPONENT_REF, which could cause trouble
3050 with TBAA in fold_indirect_ref_1.
3052 Try to keep this function synced with fold_indirect_ref_1. */
3055 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3059 poly_uint64 const_op01
;
3062 subtype
= TREE_TYPE (sub
);
3063 if (!POINTER_TYPE_P (subtype
))
3066 if (TREE_CODE (sub
) == ADDR_EXPR
)
3068 tree op
= TREE_OPERAND (sub
, 0);
3069 tree optype
= TREE_TYPE (op
);
3071 /* *&CONST_DECL -> to the value of the const decl. */
3072 if (TREE_CODE (op
) == CONST_DECL
)
3073 return DECL_INITIAL (op
);
3074 /* *&p => p; make sure to handle *&"str"[cst] here. */
3075 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
3076 /* Also handle the case where the desired type is an array of unknown
3077 bounds because the variable has had its bounds deduced since the
3078 ADDR_EXPR was created. */
3079 || (TREE_CODE (type
) == ARRAY_TYPE
3080 && TREE_CODE (optype
) == ARRAY_TYPE
3081 && TYPE_DOMAIN (type
) == NULL_TREE
3082 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3085 tree fop
= fold_read_from_constant_string (op
);
3091 /* *(foo *)&fooarray => fooarray[0] */
3092 else if (TREE_CODE (optype
) == ARRAY_TYPE
3093 && (same_type_ignoring_top_level_qualifiers_p
3094 (type
, TREE_TYPE (optype
))))
3096 tree type_domain
= TYPE_DOMAIN (optype
);
3097 tree min_val
= size_zero_node
;
3098 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3099 min_val
= TYPE_MIN_VALUE (type_domain
);
3100 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3101 NULL_TREE
, NULL_TREE
);
3103 /* *(foo *)&complexfoo => __real__ complexfoo */
3104 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3105 && (same_type_ignoring_top_level_qualifiers_p
3106 (type
, TREE_TYPE (optype
))))
3107 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3108 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3109 else if (VECTOR_TYPE_P (optype
)
3110 && (same_type_ignoring_top_level_qualifiers_p
3111 (type
, TREE_TYPE (optype
))))
3113 tree part_width
= TYPE_SIZE (type
);
3114 tree index
= bitsize_int (0);
3115 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3118 /* Also handle conversion to an empty base class, which
3119 is represented with a NOP_EXPR. */
3120 else if (is_empty_class (type
)
3121 && CLASS_TYPE_P (optype
)
3122 && DERIVED_FROM_P (type
, optype
))
3127 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3128 else if (RECORD_OR_UNION_TYPE_P (optype
))
3130 tree field
= TYPE_FIELDS (optype
);
3131 for (; field
; field
= DECL_CHAIN (field
))
3132 if (TREE_CODE (field
) == FIELD_DECL
3133 && TREE_TYPE (field
) != error_mark_node
3134 && integer_zerop (byte_position (field
))
3135 && (same_type_ignoring_top_level_qualifiers_p
3136 (TREE_TYPE (field
), type
)))
3137 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3140 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3141 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3143 tree op00
= TREE_OPERAND (sub
, 0);
3144 tree op01
= TREE_OPERAND (sub
, 1);
3147 if (TREE_CODE (op00
) == ADDR_EXPR
)
3150 op00
= TREE_OPERAND (op00
, 0);
3151 op00type
= TREE_TYPE (op00
);
3153 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3154 if (VECTOR_TYPE_P (op00type
)
3155 && same_type_ignoring_top_level_qualifiers_p
3156 (type
, TREE_TYPE (op00type
))
3157 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3158 but we want to treat offsets with MSB set as negative.
3159 For the code below negative offsets are invalid and
3160 TYPE_SIZE of the element is something unsigned, so
3161 check whether op01 fits into poly_int64, which implies
3162 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3163 then just use poly_uint64 because we want to treat the
3164 value as unsigned. */
3165 && tree_fits_poly_int64_p (op01
))
3167 tree part_width
= TYPE_SIZE (type
);
3168 poly_uint64 max_offset
3169 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3170 * TYPE_VECTOR_SUBPARTS (op00type
));
3171 if (known_lt (const_op01
, max_offset
))
3173 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3174 return fold_build3_loc (loc
,
3175 BIT_FIELD_REF
, type
, op00
,
3179 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3180 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3181 && (same_type_ignoring_top_level_qualifiers_p
3182 (type
, TREE_TYPE (op00type
))))
3184 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3186 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3188 /* ((foo *)&fooarray)[1] => fooarray[1] */
3189 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3190 && (same_type_ignoring_top_level_qualifiers_p
3191 (type
, TREE_TYPE (op00type
))))
3193 tree type_domain
= TYPE_DOMAIN (op00type
);
3194 tree min_val
= size_zero_node
;
3195 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3196 min_val
= TYPE_MIN_VALUE (type_domain
);
3197 offset_int off
= wi::to_offset (op01
);
3198 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3199 offset_int remainder
;
3200 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3201 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3203 off
= off
+ wi::to_offset (min_val
);
3204 op01
= wide_int_to_tree (sizetype
, off
);
3205 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3206 NULL_TREE
, NULL_TREE
);
3209 /* Also handle conversion to an empty base class, which
3210 is represented with a NOP_EXPR. */
3211 else if (is_empty_class (type
)
3212 && CLASS_TYPE_P (op00type
)
3213 && DERIVED_FROM_P (type
, op00type
))
3218 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3219 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3221 tree field
= TYPE_FIELDS (op00type
);
3222 for (; field
; field
= DECL_CHAIN (field
))
3223 if (TREE_CODE (field
) == FIELD_DECL
3224 && TREE_TYPE (field
) != error_mark_node
3225 && tree_int_cst_equal (byte_position (field
), op01
)
3226 && (same_type_ignoring_top_level_qualifiers_p
3227 (TREE_TYPE (field
), type
)))
3228 return fold_build3 (COMPONENT_REF
, type
, op00
,
3233 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3234 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3235 && (same_type_ignoring_top_level_qualifiers_p
3236 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3239 tree min_val
= size_zero_node
;
3241 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3245 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3246 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3247 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3248 min_val
= TYPE_MIN_VALUE (type_domain
);
3249 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3257 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3259 bool *non_constant_p
, bool *overflow_p
)
3261 tree orig_op0
= TREE_OPERAND (t
, 0);
3262 bool empty_base
= false;
3264 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3265 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3267 if (TREE_CODE (t
) == MEM_REF
3268 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3270 gcc_assert (ctx
->quiet
);
3271 *non_constant_p
= true;
3275 /* First try to simplify it directly. */
3276 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3280 /* If that didn't work, evaluate the operand first. */
3281 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3282 /*lval*/false, non_constant_p
,
3284 /* Don't VERIFY_CONSTANT here. */
3285 if (*non_constant_p
)
3288 if (!lval
&& integer_zerop (op0
))
3291 error ("dereferencing a null pointer");
3292 *non_constant_p
= true;
3296 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3300 /* We couldn't fold to a constant value. Make sure it's not
3301 something we should have been able to fold. */
3304 if (TREE_CODE (sub
) == ADDR_EXPR
)
3306 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3307 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3308 /* DR 1188 says we don't have to deal with this. */
3310 error ("accessing value of %qE through a %qT glvalue in a "
3311 "constant expression", build_fold_indirect_ref (sub
),
3313 *non_constant_p
= true;
3317 if (lval
&& op0
!= orig_op0
)
3318 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3320 VERIFY_CONSTANT (t
);
3325 r
= cxx_eval_constant_expression (ctx
, r
,
3326 lval
, non_constant_p
, overflow_p
);
3327 if (*non_constant_p
)
3330 /* If we're pulling out the value of an empty base, just return an empty
3332 if (empty_base
&& !lval
)
3334 r
= build_constructor (TREE_TYPE (t
), NULL
);
3335 TREE_CONSTANT (r
) = true;
3341 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3342 Shared between potential_constant_expression and
3343 cxx_eval_constant_expression. */
3346 non_const_var_error (tree r
)
3348 tree type
= TREE_TYPE (r
);
3349 error ("the value of %qD is not usable in a constant "
3351 /* Avoid error cascade. */
3352 if (DECL_INITIAL (r
) == error_mark_node
)
3354 if (DECL_DECLARED_CONSTEXPR_P (r
))
3355 inform (DECL_SOURCE_LOCATION (r
),
3356 "%qD used in its own initializer", r
);
3357 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3359 if (!CP_TYPE_CONST_P (type
))
3360 inform (DECL_SOURCE_LOCATION (r
),
3361 "%q#D is not const", r
);
3362 else if (CP_TYPE_VOLATILE_P (type
))
3363 inform (DECL_SOURCE_LOCATION (r
),
3364 "%q#D is volatile", r
);
3365 else if (!DECL_INITIAL (r
)
3366 || !TREE_CONSTANT (DECL_INITIAL (r
))
3367 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3368 inform (DECL_SOURCE_LOCATION (r
),
3369 "%qD was not initialized with a constant "
3374 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3375 inform (DECL_SOURCE_LOCATION (r
),
3376 "%qD was not initialized with a constant "
3380 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3381 inform (DECL_SOURCE_LOCATION (r
),
3382 "%qD was not declared %<constexpr%>", r
);
3384 inform (DECL_SOURCE_LOCATION (r
),
3385 "%qD does not have integral or enumeration type",
3390 /* Subroutine of cxx_eval_constant_expression.
3391 Like cxx_eval_unary_expression, except for trinary expressions. */
3394 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3396 bool *non_constant_p
, bool *overflow_p
)
3402 for (i
= 0; i
< 3; i
++)
3404 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3406 non_constant_p
, overflow_p
);
3407 VERIFY_CONSTANT (args
[i
]);
3410 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3411 args
[0], args
[1], args
[2]);
3412 if (val
== NULL_TREE
)
3414 VERIFY_CONSTANT (val
);
3418 /* True if T was declared in a function declared to be constexpr, and
3419 therefore potentially constant in C++14. */
3422 var_in_constexpr_fn (tree t
)
3424 tree ctx
= DECL_CONTEXT (t
);
3425 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3426 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3429 /* True if T was declared in a function that might be constexpr: either a
3430 function that was declared constexpr, or a C++17 lambda op(). */
3433 var_in_maybe_constexpr_fn (tree t
)
3435 if (cxx_dialect
>= cxx17
3436 && DECL_FUNCTION_SCOPE_P (t
)
3437 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3439 return var_in_constexpr_fn (t
);
3442 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3443 build_over_call we implement trivial copy of a class with tail padding using
3444 assignment of character arrays, which is valid in normal code, but not in
3445 constexpr evaluation. We don't need to worry about clobbering tail padding
3446 in constexpr evaluation, so strip the type punning. */
3449 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3451 if (TREE_CODE (target
) == MEM_REF
3452 && TREE_CODE (init
) == MEM_REF
3453 && TREE_TYPE (target
) == TREE_TYPE (init
)
3454 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3455 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3457 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3458 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3462 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3465 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3467 bool *non_constant_p
, bool *overflow_p
)
3469 constexpr_ctx new_ctx
= *ctx
;
3471 tree init
= TREE_OPERAND (t
, 1);
3472 if (TREE_CLOBBER_P (init
))
3473 /* Just ignore clobbers. */
3476 /* First we figure out where we're storing to. */
3477 tree target
= TREE_OPERAND (t
, 0);
3479 maybe_simplify_trivial_copy (target
, init
);
3481 tree type
= TREE_TYPE (target
);
3482 target
= cxx_eval_constant_expression (ctx
, target
,
3484 non_constant_p
, overflow_p
);
3485 if (*non_constant_p
)
3488 /* cxx_eval_array_reference for lval = true allows references one past
3489 end of array, because it does not know if it is just taking address
3490 (which is valid), or actual dereference. Here we know it is
3491 a dereference, so diagnose it here. */
3492 for (tree probe
= target
; probe
; )
3494 switch (TREE_CODE (probe
))
3498 ary
= TREE_OPERAND (probe
, 0);
3499 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3500 non_constant_p
, overflow_p
);
3501 VERIFY_CONSTANT (nelts
);
3502 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3503 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3504 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3506 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3507 *non_constant_p
= true;
3514 probe
= TREE_OPERAND (probe
, 0);
3523 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3525 /* For initialization of an empty base, the original target will be
3526 *(base*)this, which the above evaluation resolves to the object
3527 argument, which has the derived type rather than the base type. In
3528 this situation, just evaluate the initializer and return, since
3529 there's no actual data to store. */
3530 gcc_assert (is_empty_class (type
));
3531 return cxx_eval_constant_expression (ctx
, init
, false,
3532 non_constant_p
, overflow_p
);
3535 /* And then find the underlying variable. */
3536 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3537 tree object
= NULL_TREE
;
3538 for (tree probe
= target
; object
== NULL_TREE
; )
3540 switch (TREE_CODE (probe
))
3545 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3546 vec_safe_push (refs
, TREE_TYPE (probe
));
3547 probe
= TREE_OPERAND (probe
, 0);
3555 /* And then find/build up our initializer for the path to the subobject
3556 we're initializing. */
3558 if (object
== ctx
->object
&& VAR_P (object
)
3559 && DECL_NAME (object
) && ctx
->call
== NULL
)
3560 /* The variable we're building up an aggregate initializer for is outside
3561 the constant-expression, so don't evaluate the store. We check
3562 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3564 else if (DECL_P (object
))
3565 valp
= ctx
->values
->get (object
);
3570 /* A constant-expression cannot modify objects from outside the
3571 constant-expression. */
3573 error ("modification of %qE is not a constant expression", object
);
3574 *non_constant_p
= true;
3577 type
= TREE_TYPE (object
);
3578 bool no_zero_init
= true;
3580 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3581 while (!refs
->is_empty())
3583 if (*valp
== NULL_TREE
)
3585 *valp
= build_constructor (type
, NULL
);
3586 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3588 else if (TREE_CODE (*valp
) == STRING_CST
)
3590 /* An array was initialized with a string constant, and now
3591 we're writing into one of its elements. Explode the
3592 single initialization into a set of element
3594 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3596 tree string
= *valp
;
3597 tree elt_type
= TREE_TYPE (type
);
3598 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3599 / TYPE_PRECISION (char_type_node
));
3600 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3601 tree ary_ctor
= build_constructor (type
, NULL
);
3603 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3604 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3606 constructor_elt elt
=
3608 build_int_cst (size_type_node
, ix
),
3609 extract_string_elt (string
, chars_per_elt
, ix
)
3611 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3617 /* If the value of object is already zero-initialized, any new ctors for
3618 subobjects will also be zero-initialized. */
3619 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3621 vec_safe_push (ctors
, *valp
);
3623 enum tree_code code
= TREE_CODE (type
);
3625 tree index
= refs
->pop();
3627 constructor_elt
*cep
= NULL
;
3628 if (code
== ARRAY_TYPE
)
3631 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3632 gcc_assert (i
>= 0);
3633 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3634 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3638 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3640 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3641 Usually we meet initializers in that order, but it is
3642 possible for base types to be placed not in program
3644 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3645 unsigned HOST_WIDE_INT idx
;
3647 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3648 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3649 /* Changing active member. */
3650 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3653 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3654 idx
++, fields
= DECL_CHAIN (fields
))
3656 if (index
== cep
->index
)
3659 /* The field we're initializing must be on the field
3660 list. Look to see if it is present before the
3661 field the current ELT initializes. */
3662 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3663 if (index
== fields
)
3667 /* We fell off the end of the CONSTRUCTOR, so insert a new
3668 entry at the end. */
3671 constructor_elt ce
= { index
, NULL_TREE
};
3673 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3674 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3680 release_tree_vector (refs
);
3682 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3684 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3685 wants to modify it. */
3686 if (*valp
== NULL_TREE
)
3688 *valp
= build_constructor (type
, NULL
);
3689 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3691 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3692 *valp
= cplus_expand_constant (*valp
);
3693 new_ctx
.ctor
= *valp
;
3694 new_ctx
.object
= target
;
3697 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3698 non_constant_p
, overflow_p
);
3699 /* Don't share a CONSTRUCTOR that might be changed later. */
3700 init
= unshare_constructor (init
);
3701 if (target
== object
)
3702 /* The hash table might have moved since the get earlier. */
3703 valp
= ctx
->values
->get (object
);
3705 if (TREE_CODE (init
) == CONSTRUCTOR
)
3707 /* An outer ctx->ctor might be pointing to *valp, so replace
3709 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3710 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3711 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3712 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3713 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3718 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3719 CONSTRUCTORs, if any. */
3722 bool c
= TREE_CONSTANT (init
);
3723 bool s
= TREE_SIDE_EFFECTS (init
);
3725 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3728 TREE_CONSTANT (elt
) = false;
3730 TREE_SIDE_EFFECTS (elt
) = true;
3732 release_tree_vector (ctors
);
3734 if (*non_constant_p
)
3742 /* Evaluate a ++ or -- expression. */
3745 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3747 bool *non_constant_p
, bool *overflow_p
)
3749 enum tree_code code
= TREE_CODE (t
);
3750 tree type
= TREE_TYPE (t
);
3751 tree op
= TREE_OPERAND (t
, 0);
3752 tree offset
= TREE_OPERAND (t
, 1);
3753 gcc_assert (TREE_CONSTANT (offset
));
3755 /* The operand as an lvalue. */
3756 op
= cxx_eval_constant_expression (ctx
, op
, true,
3757 non_constant_p
, overflow_p
);
3759 /* The operand as an rvalue. */
3761 = cxx_eval_constant_expression (ctx
, op
, false,
3762 non_constant_p
, overflow_p
);
3763 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3764 a local array in a constexpr function. */
3765 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3767 VERIFY_CONSTANT (val
);
3769 /* The modified value. */
3770 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3772 if (POINTER_TYPE_P (type
))
3774 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3775 offset
= convert_to_ptrofftype (offset
);
3777 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3778 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3781 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3783 VERIFY_CONSTANT (mod
);
3785 /* Storing the modified value. */
3786 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3787 cxx_eval_constant_expression (ctx
, store
,
3788 true, non_constant_p
, overflow_p
);
3790 /* And the value of the expression. */
3791 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3793 /* Prefix ops are lvalues. */
3797 /* But we optimize when the caller wants an rvalue. */
3801 /* Postfix ops are rvalues. */
3805 /* Predicates for the meaning of *jump_target. */
3808 returns (tree
*jump_target
)
3811 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3812 || (TREE_CODE (*jump_target
) == LABEL_DECL
3813 && LABEL_DECL_CDTOR (*jump_target
)));
3817 breaks (tree
*jump_target
)
3820 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3821 && LABEL_DECL_BREAK (*jump_target
))
3822 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3826 continues (tree
*jump_target
)
3829 && TREE_CODE (*jump_target
) == LABEL_DECL
3830 && LABEL_DECL_CONTINUE (*jump_target
);
3834 switches (tree
*jump_target
)
3837 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3840 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3841 STMT matches *jump_target. If we're looking for a case label and we see
3842 the default label, note it in ctx->css_state. */
3845 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3847 switch (TREE_CODE (*jump_target
))
3850 if (TREE_CODE (stmt
) == LABEL_EXPR
3851 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3856 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3858 gcc_assert (ctx
->css_state
!= NULL
);
3859 if (!CASE_LOW (stmt
))
3861 /* default: should appear just once in a SWITCH_EXPR
3862 body (excluding nested SWITCH_EXPR). */
3863 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3864 /* When evaluating SWITCH_EXPR body for the second time,
3865 return true for the default: label. */
3866 if (*ctx
->css_state
== css_default_processing
)
3868 *ctx
->css_state
= css_default_seen
;
3870 else if (CASE_HIGH (stmt
))
3872 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3873 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3876 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3887 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3888 semantics, for switch, break, continue, and return. */
3891 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3892 bool *non_constant_p
, bool *overflow_p
,
3895 tree_stmt_iterator i
;
3897 /* In a statement-expression we want to return the last value.
3898 For empty statement expression return void_node. */
3902 local_target
= NULL_TREE
;
3903 jump_target
= &local_target
;
3905 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3907 tree stmt
= tsi_stmt (i
);
3908 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
3910 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3911 non_constant_p
, overflow_p
,
3913 if (*non_constant_p
)
3915 if (returns (jump_target
) || breaks (jump_target
))
3921 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3922 semantics; continue semantics are covered by cxx_eval_statement_list. */
3925 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3926 bool *non_constant_p
, bool *overflow_p
,
3929 constexpr_ctx new_ctx
= *ctx
;
3931 tree body
= TREE_OPERAND (t
, 0);
3935 hash_set
<tree
> save_exprs
;
3936 new_ctx
.save_exprs
= &save_exprs
;
3938 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3939 non_constant_p
, overflow_p
, jump_target
);
3941 /* Forget saved values of SAVE_EXPRs. */
3942 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3943 iter
!= save_exprs
.end(); ++iter
)
3944 new_ctx
.values
->remove (*iter
);
3945 if (++count
>= constexpr_loop_limit
)
3948 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3949 "%<constexpr%> loop iteration count exceeds limit of %d "
3950 "(use -fconstexpr-loop-limit= to increase the limit)",
3951 constexpr_loop_limit
);
3952 *non_constant_p
= true;
3956 while (!returns (jump_target
)
3957 && !breaks (jump_target
)
3958 && !switches (jump_target
)
3959 && !*non_constant_p
);
3961 if (breaks (jump_target
))
3962 *jump_target
= NULL_TREE
;
3967 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3971 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3972 bool *non_constant_p
, bool *overflow_p
,
3975 tree cond
= TREE_OPERAND (t
, 0);
3976 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3977 non_constant_p
, overflow_p
);
3978 VERIFY_CONSTANT (cond
);
3979 *jump_target
= cond
;
3981 tree body
= TREE_OPERAND (t
, 1);
3982 constexpr_ctx new_ctx
= *ctx
;
3983 constexpr_switch_state css
= css_default_not_seen
;
3984 new_ctx
.css_state
= &css
;
3985 cxx_eval_constant_expression (&new_ctx
, body
, false,
3986 non_constant_p
, overflow_p
, jump_target
);
3987 if (switches (jump_target
) && css
== css_default_seen
)
3989 /* If the SWITCH_EXPR body has default: label, process it once again,
3990 this time instructing label_matches to return true for default:
3991 label on switches (jump_target). */
3992 css
= css_default_processing
;
3993 cxx_eval_constant_expression (&new_ctx
, body
, false,
3994 non_constant_p
, overflow_p
, jump_target
);
3996 if (breaks (jump_target
) || switches (jump_target
))
3997 *jump_target
= NULL_TREE
;
4001 /* Find the object of TYPE under initialization in CTX. */
4004 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4009 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4010 can is a minor optimization. */
4011 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4017 /* Since an object cannot have a field of its own type, we can search outward
4018 from ctx->object to find the unique containing object of TYPE. */
4019 tree ob
= ctx
->object
;
4022 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4024 if (handled_component_p (ob
))
4025 ob
= TREE_OPERAND (ob
, 0);
4033 /* Attempt to reduce the expression T to a constant value.
4034 On failure, issue diagnostic and return error_mark_node. */
4035 /* FIXME unify with c_fully_fold */
4036 /* FIXME overflow_p is too global */
4039 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4041 bool *non_constant_p
, bool *overflow_p
,
4044 constexpr_ctx new_ctx
;
4047 if (jump_target
&& *jump_target
)
4049 /* If we are jumping, ignore all statements/expressions except those
4050 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4051 switch (TREE_CODE (t
))
4054 case STATEMENT_LIST
:
4059 case CASE_LABEL_EXPR
:
4060 if (label_matches (ctx
, jump_target
, t
))
4062 *jump_target
= NULL_TREE
;
4068 if (t
== error_mark_node
)
4070 *non_constant_p
= true;
4073 if (CONSTANT_CLASS_P (t
))
4075 if (TREE_OVERFLOW (t
))
4078 permerror (input_location
, "overflow in constant expression");
4079 if (!flag_permissive
|| ctx
->quiet
)
4083 if (TREE_CODE (t
) == INTEGER_CST
4084 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
4085 && !integer_zerop (t
))
4088 error ("value %qE of type %qT is not a constant expression",
4090 *non_constant_p
= true;
4096 tree_code tcode
= TREE_CODE (t
);
4102 /* We ask for an rvalue for the RESULT_DECL when indirecting
4103 through an invisible reference, or in named return value
4105 return (*ctx
->values
->get (t
));
4108 if (DECL_HAS_VALUE_EXPR_P (t
))
4109 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4110 lval
, non_constant_p
, overflow_p
);
4113 /* We used to not check lval for CONST_DECL, but darwin.c uses
4114 CONST_DECL for aggregate constants. */
4117 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4118 && is_really_empty_class (TREE_TYPE (t
)))
4120 /* If the class is empty, we aren't actually loading anything. */
4121 r
= build_constructor (TREE_TYPE (t
), NULL
);
4122 TREE_CONSTANT (r
) = true;
4124 else if (ctx
->strict
)
4125 r
= decl_really_constant_value (t
);
4127 r
= decl_constant_value (t
);
4128 if (TREE_CODE (r
) == TARGET_EXPR
4129 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4130 r
= TARGET_EXPR_INITIAL (r
);
4132 if (tree
*p
= ctx
->values
->get (r
))
4133 if (*p
!= NULL_TREE
)
4138 non_const_var_error (r
);
4139 *non_constant_p
= true;
4143 case DEBUG_BEGIN_STMT
:
4144 /* ??? It might be nice to retain this information somehow, so
4145 as to be able to step into a constexpr function call. */
4152 case CASE_LABEL_EXPR
:
4157 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4159 else if (tree
*p
= ctx
->values
->get (r
))
4162 /* Defer in case this is only used for its type. */;
4163 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4164 /* Defer, there's no lvalue->rvalue conversion. */;
4165 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4166 && is_really_empty_class (TREE_TYPE (t
)))
4168 /* If the class is empty, we aren't actually loading anything. */
4169 r
= build_constructor (TREE_TYPE (t
), NULL
);
4170 TREE_CONSTANT (r
) = true;
4175 error ("%qE is not a constant expression", t
);
4176 *non_constant_p
= true;
4181 case AGGR_INIT_EXPR
:
4182 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4183 non_constant_p
, overflow_p
);
4188 r
= DECL_EXPR_DECL (t
);
4189 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4190 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4194 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4195 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4196 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4200 if (tree init
= DECL_INITIAL (r
))
4202 init
= cxx_eval_constant_expression (ctx
, init
,
4204 non_constant_p
, overflow_p
);
4205 /* Don't share a CONSTRUCTOR that might be changed. */
4206 init
= unshare_constructor (init
);
4207 ctx
->values
->put (r
, init
);
4209 else if (ctx
== &new_ctx
)
4210 /* We gave it a CONSTRUCTOR above. */;
4212 ctx
->values
->put (r
, NULL_TREE
);
4217 if (!literal_type_p (TREE_TYPE (t
)))
4221 error ("temporary of non-literal type %qT in a "
4222 "constant expression", TREE_TYPE (t
));
4223 explain_non_literal_class (TREE_TYPE (t
));
4225 *non_constant_p
= true;
4228 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4230 /* We're being expanded without an explicit target, so start
4231 initializing a new object; expansion with an explicit target
4232 strips the TARGET_EXPR before we get here. */
4234 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4235 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4236 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4237 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4240 /* Pass false for 'lval' because this indicates
4241 initialization of a temporary. */
4242 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4244 non_constant_p
, overflow_p
);
4245 if (!*non_constant_p
)
4246 /* Adjust the type of the result to the type of the temporary. */
4247 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4250 tree slot
= TARGET_EXPR_SLOT (t
);
4251 r
= unshare_constructor (r
);
4252 ctx
->values
->put (slot
, r
);
4259 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4260 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4261 non_constant_p
, overflow_p
);
4265 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4267 non_constant_p
, overflow_p
);
4271 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4272 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4274 non_constant_p
, overflow_p
);
4279 /* Can happen with ({ return true; }) && false; passed to
4280 maybe_constant_value. There is nothing to jump over in this
4281 case, and the bug will be diagnosed later. */
4282 gcc_assert (ctx
->quiet
);
4283 *non_constant_p
= true;
4288 /* Avoid evaluating a SAVE_EXPR more than once. */
4289 if (tree
*p
= ctx
->values
->get (t
))
4293 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4294 non_constant_p
, overflow_p
);
4295 ctx
->values
->put (t
, r
);
4296 if (ctx
->save_exprs
)
4297 ctx
->save_exprs
->add (t
);
4301 case NON_LVALUE_EXPR
:
4302 case TRY_CATCH_EXPR
:
4304 case CLEANUP_POINT_EXPR
:
4305 case MUST_NOT_THROW_EXPR
:
4308 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4310 non_constant_p
, overflow_p
,
4314 case TRY_FINALLY_EXPR
:
4315 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4316 non_constant_p
, overflow_p
,
4318 if (!*non_constant_p
)
4319 /* Also evaluate the cleanup. */
4320 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4321 non_constant_p
, overflow_p
,
4325 /* These differ from cxx_eval_unary_expression in that this doesn't
4326 check for a constant operand or result; an address can be
4327 constant without its operand being, and vice versa. */
4330 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4331 non_constant_p
, overflow_p
);
4336 tree oldop
= TREE_OPERAND (t
, 0);
4337 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4339 non_constant_p
, overflow_p
);
4340 /* Don't VERIFY_CONSTANT here. */
4341 if (*non_constant_p
)
4343 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4344 /* This function does more aggressive folding than fold itself. */
4345 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4346 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4355 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4356 non_constant_p
, overflow_p
);
4357 if (r
== error_mark_node
)
4359 else if (r
== TREE_OPERAND (t
, 0))
4362 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4367 case FIX_TRUNC_EXPR
:
4372 case TRUTH_NOT_EXPR
:
4373 case FIXED_CONVERT_EXPR
:
4374 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4375 non_constant_p
, overflow_p
);
4379 r
= fold_sizeof_expr (t
);
4380 VERIFY_CONSTANT (r
);
4385 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4386 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4387 introduced by build_call_a. */
4388 tree op0
= TREE_OPERAND (t
, 0);
4389 tree op1
= TREE_OPERAND (t
, 1);
4391 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4392 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4393 r
= cxx_eval_constant_expression (ctx
, op0
,
4394 lval
, non_constant_p
, overflow_p
,
4398 /* Check that the LHS is constant and then discard it. */
4399 cxx_eval_constant_expression (ctx
, op0
,
4400 true, non_constant_p
, overflow_p
,
4402 if (*non_constant_p
)
4404 op1
= TREE_OPERAND (t
, 1);
4405 r
= cxx_eval_constant_expression (ctx
, op1
,
4406 lval
, non_constant_p
, overflow_p
,
4412 case POINTER_PLUS_EXPR
:
4413 case POINTER_DIFF_EXPR
:
4417 case TRUNC_DIV_EXPR
:
4419 case FLOOR_DIV_EXPR
:
4420 case ROUND_DIV_EXPR
:
4421 case TRUNC_MOD_EXPR
:
4423 case ROUND_MOD_EXPR
:
4425 case EXACT_DIV_EXPR
:
4435 case TRUTH_XOR_EXPR
:
4442 case UNORDERED_EXPR
:
4452 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4453 non_constant_p
, overflow_p
);
4456 /* fold can introduce non-IF versions of these; still treat them as
4457 short-circuiting. */
4458 case TRUTH_AND_EXPR
:
4459 case TRUTH_ANDIF_EXPR
:
4460 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4463 non_constant_p
, overflow_p
);
4467 case TRUTH_ORIF_EXPR
:
4468 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4471 non_constant_p
, overflow_p
);
4475 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4476 non_constant_p
, overflow_p
);
4480 if (is_overloaded_fn (t
))
4482 /* We can only get here in checking mode via
4483 build_non_dependent_expr, because any expression that
4484 calls or takes the address of the function will have
4485 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4486 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4487 *non_constant_p
= true;
4490 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4491 non_constant_p
, overflow_p
);
4495 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4496 non_constant_p
, overflow_p
);
4500 if (jump_target
&& *jump_target
)
4502 /* When jumping to a label, the label might be either in the
4503 then or else blocks, so process then block first in skipping
4504 mode first, and if we are still in the skipping mode at its end,
4505 process the else block too. */
4506 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4507 lval
, non_constant_p
, overflow_p
,
4510 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4511 lval
, non_constant_p
, overflow_p
,
4515 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4516 non_constant_p
, overflow_p
,
4520 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4525 if (TREE_CONSTANT (t
))
4527 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4528 VECTOR_CST if applicable. */
4529 /* FIXME after GCC 6 branches, make the verify unconditional. */
4531 verify_constructor_flags (t
);
4533 recompute_constructor_flags (t
);
4534 if (TREE_CONSTANT (t
))
4537 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4538 non_constant_p
, overflow_p
);
4542 /* We can get this in a defaulted constructor for a class with a
4543 non-static data member of array type. Either the initializer will
4544 be NULL, meaning default-initialization, or it will be an lvalue
4545 or xvalue of the same type, meaning direct-initialization from the
4546 corresponding member. */
4547 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4548 non_constant_p
, overflow_p
);
4553 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4554 non_constant_p
, overflow_p
);
4558 case VIEW_CONVERT_EXPR
:
4560 case UNARY_PLUS_EXPR
:
4562 tree oldop
= TREE_OPERAND (t
, 0);
4564 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4566 non_constant_p
, overflow_p
);
4567 if (*non_constant_p
)
4569 tree type
= TREE_TYPE (t
);
4570 if (TREE_CODE (op
) == PTRMEM_CST
4571 && !TYPE_PTRMEM_P (type
))
4572 op
= cplus_expand_constant (op
);
4573 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4575 if (same_type_ignoring_top_level_qualifiers_p (type
,
4577 || can_convert_qual (type
, op
))
4578 return cp_fold_convert (type
, op
);
4582 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4583 "a reinterpret_cast is not a constant expression");
4584 *non_constant_p
= true;
4589 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4591 if (integer_zerop (op
))
4593 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4596 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4597 "dereferencing a null pointer");
4598 *non_constant_p
= true;
4601 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4603 tree from
= TREE_TYPE (op
);
4605 if (!can_convert (type
, from
, tf_none
))
4608 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4609 "conversion of %qT null pointer to %qT "
4610 "is not a constant expression",
4612 *non_constant_p
= true;
4619 /* This detects for example:
4620 reinterpret_cast<void*>(sizeof 0)
4623 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4624 "%<reinterpret_cast<%T>(%E)%> is not "
4625 "a constant expression",
4627 *non_constant_p
= true;
4631 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4632 /* We didn't fold at the top so we could check for ptr-int
4635 if (tcode
== UNARY_PLUS_EXPR
)
4636 r
= fold_convert (TREE_TYPE (t
), op
);
4638 r
= fold_build1 (tcode
, type
, op
);
4639 /* Conversion of an out-of-range value has implementation-defined
4640 behavior; the language considers it different from arithmetic
4641 overflow, which is undefined. */
4642 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4643 TREE_OVERFLOW (r
) = false;
4647 case EMPTY_CLASS_EXPR
:
4648 /* This is good enough for a function argument that might not get
4649 used, and they can't do anything with it, so just return it. */
4652 case STATEMENT_LIST
:
4654 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4655 return cxx_eval_statement_list (&new_ctx
, t
,
4656 non_constant_p
, overflow_p
, jump_target
);
4659 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4661 non_constant_p
, overflow_p
,
4664 case PREINCREMENT_EXPR
:
4665 case POSTINCREMENT_EXPR
:
4666 case PREDECREMENT_EXPR
:
4667 case POSTDECREMENT_EXPR
:
4668 return cxx_eval_increment_expression (ctx
, t
,
4669 lval
, non_constant_p
, overflow_p
);
4675 case VEC_DELETE_EXPR
:
4678 /* GCC internal stuff. */
4681 case NON_DEPENDENT_EXPR
:
4685 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4686 "expression %qE is not a constant expression", t
);
4687 *non_constant_p
= true;
4690 case PLACEHOLDER_EXPR
:
4691 /* Use of the value or address of the current object. */
4692 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4693 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4694 non_constant_p
, overflow_p
);
4695 /* A placeholder without a referent. We can get here when
4696 checking whether NSDMIs are noexcept, or in massage_init_elt;
4697 just say it's non-constant for now. */
4698 gcc_assert (ctx
->quiet
);
4699 *non_constant_p
= true;
4704 tree cond
= TREE_OPERAND (t
, 0);
4705 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4706 non_constant_p
, overflow_p
);
4707 VERIFY_CONSTANT (cond
);
4708 if (integer_nonzerop (cond
))
4714 *jump_target
= TREE_OPERAND (t
, 0);
4715 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4716 /* Allow for jumping to a cdtor_label. */
4717 || returns (jump_target
));
4721 cxx_eval_loop_expr (ctx
, t
,
4722 non_constant_p
, overflow_p
, jump_target
);
4726 cxx_eval_switch_expr (ctx
, t
,
4727 non_constant_p
, overflow_p
, jump_target
);
4731 /* It's possible to get a requires-expression in a constant
4732 expression. For example:
4734 template<typename T> concept bool C() {
4735 return requires (T t) { t; };
4738 template<typename T> requires !C<T>() void f(T);
4740 Normalization leaves f with the associated constraint
4741 '!requires (T t) { ... }' which is not transformed into
4743 if (!processing_template_decl
)
4744 return evaluate_constraint_expression (t
, NULL_TREE
);
4746 *non_constant_p
= true;
4750 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4752 non_constant_p
, overflow_p
,
4761 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4763 /* This function doesn't know how to deal with pre-genericize
4764 statements; this can only happen with statement-expressions,
4765 so for now just fail. */
4767 error_at (EXPR_LOCATION (t
),
4768 "statement is not a constant expression");
4771 internal_error ("unexpected expression %qE of kind %s", t
,
4772 get_tree_code_name (TREE_CODE (t
)));
4773 *non_constant_p
= true;
4777 if (r
== error_mark_node
)
4778 *non_constant_p
= true;
4780 if (*non_constant_p
)
4787 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4788 bool strict
= true, tree object
= NULL_TREE
)
4790 auto_timevar
time (TV_CONSTEXPR
);
4792 bool non_constant_p
= false;
4793 bool overflow_p
= false;
4794 hash_map
<tree
,tree
> map
;
4796 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4797 allow_non_constant
, strict
};
4799 tree type
= initialized_type (t
);
4801 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4803 /* In C++14 an NSDMI can participate in aggregate initialization,
4804 and can refer to the address of the object being initialized, so
4805 we need to pass in the relevant VAR_DECL if we want to do the
4806 evaluation in a single pass. The evaluation will dynamically
4807 update ctx.values for the VAR_DECL. We use the same strategy
4808 for C++11 constexpr constructors that refer to the object being
4810 ctx
.ctor
= build_constructor (type
, NULL
);
4811 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4814 if (TREE_CODE (t
) == TARGET_EXPR
)
4815 object
= TARGET_EXPR_SLOT (t
);
4816 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4817 object
= AGGR_INIT_EXPR_SLOT (t
);
4819 ctx
.object
= object
;
4821 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4822 (type
, TREE_TYPE (object
)));
4823 if (object
&& DECL_P (object
))
4824 map
.put (object
, ctx
.ctor
);
4825 if (TREE_CODE (r
) == TARGET_EXPR
)
4826 /* Avoid creating another CONSTRUCTOR when we expand the
4828 r
= TARGET_EXPR_INITIAL (r
);
4831 r
= cxx_eval_constant_expression (&ctx
, r
,
4832 false, &non_constant_p
, &overflow_p
);
4834 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4836 /* Mutable logic is a bit tricky: we want to allow initialization of
4837 constexpr variables with mutable members, but we can't copy those
4838 members to another constexpr variable. */
4839 if (TREE_CODE (r
) == CONSTRUCTOR
4840 && CONSTRUCTOR_MUTABLE_POISON (r
))
4842 if (!allow_non_constant
)
4843 error ("%qE is not a constant expression because it refers to "
4844 "mutable subobjects of %qT", t
, type
);
4845 non_constant_p
= true;
4848 if (TREE_CODE (r
) == CONSTRUCTOR
4849 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4851 if (!allow_non_constant
)
4852 error ("%qE is not a constant expression because it refers to "
4853 "an incompletely initialized variable", t
);
4854 TREE_CONSTANT (r
) = false;
4855 non_constant_p
= true;
4858 /* Technically we should check this for all subexpressions, but that
4859 runs into problems with our internal representation of pointer
4860 subtraction and the 5.19 rules are still in flux. */
4861 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4862 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4863 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4865 if (!allow_non_constant
)
4866 error ("conversion from pointer type %qT "
4867 "to arithmetic type %qT in a constant expression",
4868 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4869 non_constant_p
= true;
4872 if (!non_constant_p
&& overflow_p
)
4873 non_constant_p
= true;
4875 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4877 bool should_unshare
= true;
4878 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4879 should_unshare
= false;
4881 if (non_constant_p
&& !allow_non_constant
)
4882 return error_mark_node
;
4883 else if (non_constant_p
&& TREE_CONSTANT (r
))
4885 /* This isn't actually constant, so unset TREE_CONSTANT.
4886 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
4887 it to be set if it is invariant address, even when it is not
4888 a valid C++ constant expression. Wrap it with a NOP_EXPR
4890 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
4892 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4893 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4895 r
= build_nop (TREE_TYPE (r
), r
);
4896 TREE_CONSTANT (r
) = false;
4898 else if (non_constant_p
|| r
== t
)
4902 r
= unshare_expr (r
);
4904 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4906 if (TREE_CODE (t
) == TARGET_EXPR
4907 && TARGET_EXPR_INITIAL (t
) == r
)
4911 r
= get_target_expr (r
);
4912 TREE_CONSTANT (r
) = true;
4920 /* Returns true if T is a valid subexpression of a constant expression,
4921 even if it isn't itself a constant expression. */
4924 is_sub_constant_expr (tree t
)
4926 bool non_constant_p
= false;
4927 bool overflow_p
= false;
4928 hash_map
<tree
, tree
> map
;
4930 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4932 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4934 return !non_constant_p
&& !overflow_p
;
4937 /* If T represents a constant expression returns its reduced value.
4938 Otherwise return error_mark_node. If T is dependent, then
4942 cxx_constant_value (tree t
, tree decl
)
4944 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4947 /* Helper routine for fold_simple function. Either return simplified
4948 expression T, otherwise NULL_TREE.
4949 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4950 even if we are within template-declaration. So be careful on call, as in
4951 such case types can be undefined. */
4954 fold_simple_1 (tree t
)
4957 enum tree_code code
= TREE_CODE (t
);
4969 return fold_sizeof_expr (t
);
4977 case TRUTH_NOT_EXPR
:
4979 case VIEW_CONVERT_EXPR
:
4982 case FIX_TRUNC_EXPR
:
4983 case FIXED_CONVERT_EXPR
:
4984 case ADDR_SPACE_CONVERT_EXPR
:
4986 op1
= TREE_OPERAND (t
, 0);
4988 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4992 if (CONVERT_EXPR_CODE_P (code
)
4993 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4994 TREE_OVERFLOW (t
) = false;
5002 /* If T is a simple constant expression, returns its simplified value.
5003 Otherwise returns T. In contrast to maybe_constant_value we
5004 simplify only few operations on constant-expressions, and we don't
5005 try to simplify constexpressions. */
5008 fold_simple (tree t
)
5010 if (processing_template_decl
)
5013 tree r
= fold_simple_1 (t
);
5020 /* If T is a constant expression, returns its reduced value.
5021 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5022 Otherwise, returns a version of T without TREE_CONSTANT. */
5024 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5027 maybe_constant_value (tree t
, tree decl
)
5031 if (!is_nondependent_constant_expression (t
))
5033 if (TREE_OVERFLOW_P (t
))
5035 t
= build_nop (TREE_TYPE (t
), t
);
5036 TREE_CONSTANT (t
) = false;
5040 else if (CONSTANT_CLASS_P (t
))
5041 /* No caching or evaluation needed. */
5044 if (cv_cache
== NULL
)
5045 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5046 if (tree
*cached
= cv_cache
->get (t
))
5049 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
5050 gcc_checking_assert (r
== t
5051 || CONVERT_EXPR_P (t
)
5052 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5053 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5054 || !cp_tree_equal (r
, t
));
5055 cv_cache
->put (t
, r
);
5059 /* Dispose of the whole CV_CACHE. */
5062 clear_cv_cache (void)
5064 if (cv_cache
!= NULL
)
5068 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5071 clear_cv_and_fold_caches (void)
5074 clear_fold_cache ();
5077 /* Like maybe_constant_value but first fully instantiate the argument.
5079 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5080 (t, tf_none) followed by maybe_constant_value but is more efficient,
5081 because calls instantiation_dependent_expression_p and
5082 potential_constant_expression at most once. */
5085 fold_non_dependent_expr (tree t
)
5090 /* If we're in a template, but T isn't value dependent, simplify
5091 it. We're supposed to treat:
5093 template <typename T> void f(T[1 + 1]);
5094 template <typename T> void f(T[2]);
5096 as two declarations of the same function, for example. */
5097 if (processing_template_decl
)
5099 if (is_nondependent_constant_expression (t
))
5101 processing_template_decl_sentinel s
;
5102 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
5104 if (type_unknown_p (t
)
5105 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5107 if (TREE_OVERFLOW_P (t
))
5109 t
= build_nop (TREE_TYPE (t
), t
);
5110 TREE_CONSTANT (t
) = false;
5115 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
5116 /* cp_tree_equal looks through NOPs, so allow them. */
5117 gcc_checking_assert (r
== t
5118 || CONVERT_EXPR_P (t
)
5119 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5120 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5121 || !cp_tree_equal (r
, t
));
5124 else if (TREE_OVERFLOW_P (t
))
5126 t
= build_nop (TREE_TYPE (t
), t
);
5127 TREE_CONSTANT (t
) = false;
5132 return maybe_constant_value (t
);
5135 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5136 than wrapped in a TARGET_EXPR. */
5139 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
)
5143 if (TREE_CODE (t
) == EXPR_STMT
)
5144 t
= TREE_OPERAND (t
, 0);
5145 if (TREE_CODE (t
) == CONVERT_EXPR
5146 && VOID_TYPE_P (TREE_TYPE (t
)))
5147 t
= TREE_OPERAND (t
, 0);
5148 if (TREE_CODE (t
) == INIT_EXPR
)
5149 t
= TREE_OPERAND (t
, 1);
5150 if (TREE_CODE (t
) == TARGET_EXPR
)
5151 t
= TARGET_EXPR_INITIAL (t
);
5152 if (!is_nondependent_static_init_expression (t
))
5153 /* Don't try to evaluate it. */;
5154 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5155 /* No evaluation needed. */;
5157 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
, false, decl
);
5158 if (TREE_CODE (t
) == TARGET_EXPR
)
5160 tree init
= TARGET_EXPR_INITIAL (t
);
5161 if (TREE_CODE (init
) == CONSTRUCTOR
)
5167 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5170 maybe_constant_init (tree t
, tree decl
)
5172 return maybe_constant_init_1 (t
, decl
, true);
5175 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5178 cxx_constant_init (tree t
, tree decl
)
5180 return maybe_constant_init_1 (t
, decl
, false);
5184 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5185 /* Return true if the object referred to by REF has automatic or thread
5188 enum { ck_ok
, ck_bad
, ck_unknown
};
5190 check_automatic_or_tls (tree ref
)
5193 poly_int64 bitsize
, bitpos
;
5195 int volatilep
= 0, unsignedp
= 0;
5196 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5197 &mode
, &unsignedp
, &volatilep
, false);
5200 /* If there isn't a decl in the middle, we don't know the linkage here,
5201 and this isn't a constant expression anyway. */
5204 dk
= decl_storage_duration (decl
);
5205 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5209 /* Return true if T denotes a potentially constant expression. Issue
5210 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5211 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5212 consider the expression in the current context, independent of constexpr
5215 C++0x [expr.const] used to say
5217 6 An expression is a potential constant expression if it is
5218 a constant expression where all occurrences of function
5219 parameters are replaced by arbitrary constant expressions
5220 of the appropriate type.
5222 2 A conditional expression is a constant expression unless it
5223 involves one of the following as a potentially evaluated
5224 subexpression (3.2), but subexpressions of logical AND (5.14),
5225 logical OR (5.15), and conditional (5.16) operations that are
5226 not evaluated are not considered. */
5229 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5230 tsubst_flags_t flags
)
5232 #define RECUR(T,RV) \
5233 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5235 enum { any
= false, rval
= true };
5239 if (t
== error_mark_node
)
5243 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5244 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5246 if (flags
& tf_error
)
5247 error_at (loc
, "expression %qE has side-effects", t
);
5250 if (CONSTANT_CLASS_P (t
))
5252 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5253 && TREE_TYPE (t
) == error_mark_node
)
5256 switch (TREE_CODE (t
))
5262 case TEMPLATE_ID_EXPR
:
5265 case CASE_LABEL_EXPR
:
5271 case TEMPLATE_PARM_INDEX
:
5273 case IDENTIFIER_NODE
:
5274 case USERDEF_LITERAL
:
5275 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5280 case PLACEHOLDER_EXPR
:
5285 case DEBUG_BEGIN_STMT
:
5291 if (flags
& tf_error
)
5292 error ("%qE is not a constant expression", t
);
5297 case AGGR_INIT_EXPR
:
5299 /* -- an invocation of a function other than a constexpr function
5300 or a constexpr constructor. */
5302 tree fun
= get_function_named_in_call (t
);
5303 const int nargs
= call_expr_nargs (t
);
5306 if (fun
== NULL_TREE
)
5308 /* Reset to allow the function to continue past the end
5309 of the block below. Otherwise return early. */
5312 if (TREE_CODE (t
) == CALL_EXPR
5313 && CALL_EXPR_FN (t
) == NULL_TREE
)
5314 switch (CALL_EXPR_IFN (t
))
5316 /* These should be ignored, they are optimized away from
5317 constexpr functions. */
5318 case IFN_UBSAN_NULL
:
5319 case IFN_UBSAN_BOUNDS
:
5320 case IFN_UBSAN_VPTR
:
5321 case IFN_FALLTHROUGH
:
5324 case IFN_ADD_OVERFLOW
:
5325 case IFN_SUB_OVERFLOW
:
5326 case IFN_MUL_OVERFLOW
:
5336 /* fold_call_expr can't do anything with IFN calls. */
5337 if (flags
& tf_error
)
5338 error_at (loc
, "call to internal function %qE", t
);
5343 if (fun
&& is_overloaded_fn (fun
))
5345 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5347 if (builtin_valid_in_constant_expr_p (fun
))
5349 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5350 /* Allow any built-in function; if the expansion
5351 isn't constant, we'll deal with that then. */
5352 && !is_builtin_fn (fun
))
5354 if (flags
& tf_error
)
5356 error_at (loc
, "call to non-%<constexpr%> function %qD",
5358 explain_invalid_constexpr_fn (fun
);
5362 /* A call to a non-static member function takes the address
5363 of the object as the first argument. But in a constant
5364 expression the address will be folded away, so look
5366 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5367 && !DECL_CONSTRUCTOR_P (fun
))
5369 tree x
= get_nth_callarg (t
, 0);
5370 if (is_this_parameter (x
))
5372 /* Don't require an immediately constant value, as
5373 constexpr substitution might not use the value. */
5374 bool sub_now
= false;
5375 if (!potential_constant_expression_1 (x
, rval
, strict
,
5383 if (!RECUR (fun
, true))
5385 fun
= get_first_fn (fun
);
5387 /* Skip initial arguments to base constructors. */
5388 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5389 i
= num_artificial_parms_for (fun
);
5390 fun
= DECL_ORIGIN (fun
);
5394 if (RECUR (fun
, rval
))
5395 /* Might end up being a constant function pointer. */;
5399 for (; i
< nargs
; ++i
)
5401 tree x
= get_nth_callarg (t
, i
);
5402 /* In a template, reference arguments haven't been converted to
5403 REFERENCE_TYPE and we might not even know if the parameter
5404 is a reference, so accept lvalue constants too. */
5405 bool rv
= processing_template_decl
? any
: rval
;
5406 /* Don't require an immediately constant value, as constexpr
5407 substitution might not use the value of the argument. */
5408 bool sub_now
= false;
5409 if (!potential_constant_expression_1 (x
, rv
, strict
,
5416 case NON_LVALUE_EXPR
:
5417 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5418 -- an lvalue of integral type that refers to a non-volatile
5419 const variable or static data member initialized with
5420 constant expressions, or
5422 -- an lvalue of literal type that refers to non-volatile
5423 object defined with constexpr, or that refers to a
5424 sub-object of such an object; */
5425 return RECUR (TREE_OPERAND (t
, 0), rval
);
5428 if (DECL_HAS_VALUE_EXPR_P (t
))
5430 if (now
&& is_capture_proxy_with_ref (t
))
5432 /* -- in a lambda-expression, a reference to this or to a
5433 variable with automatic storage duration defined outside that
5434 lambda-expression, where the reference would be an
5436 if (flags
& tf_error
)
5438 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5439 error ("lambda capture of %qE is not a constant expression",
5441 if (!want_rval
&& decl_constant_var_p (cap
))
5442 inform (input_location
, "because it is used as a glvalue");
5446 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5449 && !var_in_maybe_constexpr_fn (t
)
5450 && !type_dependent_expression_p (t
)
5451 && !decl_maybe_constant_var_p (t
)
5453 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5454 || (DECL_INITIAL (t
)
5455 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5456 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5457 && !is_really_empty_class (TREE_TYPE (t
)))
5459 if (flags
& tf_error
)
5460 non_const_var_error (t
);
5467 case VIEW_CONVERT_EXPR
:
5468 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5469 may change to something more specific to type-punning (DR 1312). */
5471 tree from
= TREE_OPERAND (t
, 0);
5472 if (POINTER_TYPE_P (TREE_TYPE (t
))
5473 && TREE_CODE (from
) == INTEGER_CST
5474 && !integer_zerop (from
))
5476 if (flags
& tf_error
)
5477 error_at (loc
, "reinterpret_cast from integer to pointer");
5480 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5483 case ADDRESSOF_EXPR
:
5484 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5485 t
= TREE_OPERAND (t
, 0);
5486 goto handle_addr_expr
;
5489 /* -- a unary operator & that is applied to an lvalue that
5490 designates an object with thread or automatic storage
5492 t
= TREE_OPERAND (t
, 0);
5494 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5495 /* A pointer-to-member constant. */
5500 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5501 any checking here, as we might dereference the pointer later. If
5502 we remove this code, also remove check_automatic_or_tls. */
5503 i
= check_automatic_or_tls (t
);
5508 if (flags
& tf_error
)
5509 error ("address-of an object %qE with thread local or "
5510 "automatic storage is not a constant expression", t
);
5514 return RECUR (t
, any
);
5522 /* -- a class member access unless its postfix-expression is
5523 of literal type or of pointer to literal type. */
5524 /* This test would be redundant, as it follows from the
5525 postfix-expression being a potential constant expression. */
5526 if (type_unknown_p (t
))
5528 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5530 case EXPR_PACK_EXPANSION
:
5531 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5535 tree x
= TREE_OPERAND (t
, 0);
5537 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5539 if (!var_in_maybe_constexpr_fn (x
))
5541 if (flags
& tf_error
)
5542 error_at (loc
, "use of %<this%> in a constant expression");
5547 return RECUR (x
, rval
);
5550 case STATEMENT_LIST
:
5552 tree_stmt_iterator i
;
5553 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5555 if (!RECUR (tsi_stmt (i
), any
))
5563 if (cxx_dialect
< cxx14
)
5565 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5567 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5572 if (cxx_dialect
< cxx14
)
5574 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5576 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5581 if (!RECUR (DO_COND (t
), rval
))
5583 if (!RECUR (DO_BODY (t
), any
))
5588 if (!RECUR (FOR_INIT_STMT (t
), any
))
5590 if (!RECUR (FOR_COND (t
), rval
))
5592 if (!RECUR (FOR_EXPR (t
), any
))
5594 if (!RECUR (FOR_BODY (t
), any
))
5598 case RANGE_FOR_STMT
:
5599 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5601 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5606 if (!RECUR (WHILE_COND (t
), rval
))
5608 if (!RECUR (WHILE_BODY (t
), any
))
5613 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5615 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5616 unreachable labels would be checked. */
5620 return RECUR (STMT_EXPR_STMT (t
), rval
);
5623 if (cxx_dialect
>= cxx17
)
5624 /* In C++17 lambdas can be constexpr, don't give up yet. */
5626 else if (flags
& tf_error
)
5627 error_at (loc
, "lambda-expression is not a constant expression "
5631 case DYNAMIC_CAST_EXPR
:
5632 case PSEUDO_DTOR_EXPR
:
5636 case VEC_DELETE_EXPR
:
5642 case OMP_DISTRIBUTE
:
5645 case OMP_TARGET_DATA
:
5654 case OMP_TARGET_UPDATE
:
5655 case OMP_TARGET_ENTER_DATA
:
5656 case OMP_TARGET_EXIT_DATA
:
5658 case OMP_ATOMIC_READ
:
5659 case OMP_ATOMIC_CAPTURE_OLD
:
5660 case OMP_ATOMIC_CAPTURE_NEW
:
5664 case OACC_HOST_DATA
:
5668 case OACC_ENTER_DATA
:
5669 case OACC_EXIT_DATA
:
5671 /* GCC internal stuff. */
5674 case TRANSACTION_EXPR
:
5676 case AT_ENCODE_EXPR
:
5678 if (flags
& tf_error
)
5679 error_at (loc
, "expression %qE is not a constant expression", t
);
5683 /* -- a typeid expression whose operand is of polymorphic
5686 tree e
= TREE_OPERAND (t
, 0);
5687 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5688 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5690 if (flags
& tf_error
)
5691 error_at (loc
, "typeid-expression is not a constant expression "
5692 "because %qE is of polymorphic type", e
);
5698 case POINTER_DIFF_EXPR
:
5712 case PREINCREMENT_EXPR
:
5713 case POSTINCREMENT_EXPR
:
5714 case PREDECREMENT_EXPR
:
5715 case POSTDECREMENT_EXPR
:
5716 if (cxx_dialect
< cxx14
)
5722 if (TYPE_P (TREE_OPERAND (t
, 0)))
5728 case FIX_TRUNC_EXPR
:
5732 case TRUTH_NOT_EXPR
:
5733 case FIXED_CONVERT_EXPR
:
5734 case UNARY_PLUS_EXPR
:
5735 case UNARY_LEFT_FOLD_EXPR
:
5736 case UNARY_RIGHT_FOLD_EXPR
:
5738 return RECUR (TREE_OPERAND (t
, 0), rval
);
5741 case CONST_CAST_EXPR
:
5742 case STATIC_CAST_EXPR
:
5743 case REINTERPRET_CAST_EXPR
:
5744 case IMPLICIT_CONV_EXPR
:
5745 if (cxx_dialect
< cxx11
5746 && !dependent_type_p (TREE_TYPE (t
))
5747 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5748 /* In C++98, a conversion to non-integral type can't be part of a
5749 constant expression. */
5751 if (flags
& tf_error
)
5753 "cast to non-integral type %qT in a constant expression",
5758 return (RECUR (TREE_OPERAND (t
, 0),
5759 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5762 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5764 case CLEANUP_POINT_EXPR
:
5765 case MUST_NOT_THROW_EXPR
:
5766 case TRY_CATCH_EXPR
:
5771 case NON_DEPENDENT_EXPR
:
5772 /* For convenience. */
5776 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5779 tmp
= DECL_EXPR_DECL (t
);
5780 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5782 if (TREE_STATIC (tmp
))
5784 if (flags
& tf_error
)
5785 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5786 "%<static%> in %<constexpr%> context", tmp
);
5789 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5791 if (flags
& tf_error
)
5792 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5793 "%<thread_local%> in %<constexpr%> context", tmp
);
5796 else if (!check_for_uninitialized_const_var
5797 (tmp
, /*constexpr_context_p=*/true, flags
))
5800 return RECUR (tmp
, want_rval
);
5802 case TRY_FINALLY_EXPR
:
5803 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5804 && RECUR (TREE_OPERAND (t
, 1), any
));
5807 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5810 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
5811 && !literal_type_p (TREE_TYPE (t
)))
5813 if (flags
& tf_error
)
5815 error_at (loc
, "temporary of non-literal type %qT in a "
5816 "constant expression", TREE_TYPE (t
));
5817 explain_non_literal_class (TREE_TYPE (t
));
5823 return RECUR (TREE_OPERAND (t
, 1), rval
);
5827 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5828 constructor_elt
*ce
;
5829 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5830 if (!RECUR (ce
->value
, want_rval
))
5837 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5838 || DECL_P (TREE_PURPOSE (t
)));
5839 if (!RECUR (TREE_VALUE (t
), want_rval
))
5841 if (TREE_CHAIN (t
) == NULL_TREE
)
5843 return RECUR (TREE_CHAIN (t
), want_rval
);
5846 case TRUNC_DIV_EXPR
:
5848 case FLOOR_DIV_EXPR
:
5849 case ROUND_DIV_EXPR
:
5850 case TRUNC_MOD_EXPR
:
5852 case ROUND_MOD_EXPR
:
5854 tree denom
= TREE_OPERAND (t
, 1);
5855 if (!RECUR (denom
, rval
))
5857 /* We can't call cxx_eval_outermost_constant_expr on an expression
5858 that hasn't been through instantiate_non_dependent_expr yet. */
5859 if (!processing_template_decl
)
5860 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5861 if (integer_zerop (denom
))
5863 if (flags
& tf_error
)
5864 error ("division by zero is not a constant expression");
5870 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5876 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5877 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5878 introduced by build_call_a. */
5879 tree op0
= TREE_OPERAND (t
, 0);
5880 tree op1
= TREE_OPERAND (t
, 1);
5882 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5883 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5884 return RECUR (op0
, want_rval
);
5889 /* If the first operand is the non-short-circuit constant, look at
5890 the second operand; otherwise we only care about the first one for
5892 case TRUTH_AND_EXPR
:
5893 case TRUTH_ANDIF_EXPR
:
5894 tmp
= boolean_true_node
;
5897 case TRUTH_ORIF_EXPR
:
5898 tmp
= boolean_false_node
;
5901 tree op
= TREE_OPERAND (t
, 0);
5902 if (!RECUR (op
, rval
))
5904 if (!processing_template_decl
)
5905 op
= cxx_eval_outermost_constant_expr (op
, true);
5906 if (tree_int_cst_equal (op
, tmp
))
5907 return RECUR (TREE_OPERAND (t
, 1), rval
);
5914 case POINTER_PLUS_EXPR
:
5916 case EXACT_DIV_EXPR
:
5926 case TRUTH_XOR_EXPR
:
5927 case UNORDERED_EXPR
:
5940 case ARRAY_RANGE_REF
:
5944 case BINARY_LEFT_FOLD_EXPR
:
5945 case BINARY_RIGHT_FOLD_EXPR
:
5947 for (i
= 0; i
< 2; ++i
)
5948 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5954 for (i
= 0; i
< 3; ++i
)
5955 if (!RECUR (TREE_OPERAND (t
, i
), true))
5960 if (COND_EXPR_IS_VEC_DELETE (t
))
5962 if (flags
& tf_error
)
5963 error_at (loc
, "%<delete[]%> is not a constant expression");
5969 /* If the condition is a known constant, we know which of the legs we
5970 care about; otherwise we only require that the condition and
5971 either of the legs be potentially constant. */
5972 tmp
= TREE_OPERAND (t
, 0);
5973 if (!RECUR (tmp
, rval
))
5975 if (!processing_template_decl
)
5976 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5977 if (integer_zerop (tmp
))
5978 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5979 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5980 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5981 for (i
= 1; i
< 3; ++i
)
5982 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5983 want_rval
, strict
, now
, tf_none
))
5985 if (flags
& tf_error
)
5986 error_at (loc
, "expression %qE is not a constant expression", t
);
5990 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5992 if (flags
& tf_error
)
5994 error_at (loc
, "non-constant array initialization");
5995 diagnose_non_constexpr_vec_init (t
);
6001 /* We can see these in statement-expressions. */
6005 case EMPTY_CLASS_EXPR
:
6011 tree
*target
= &TREE_OPERAND (t
, 0);
6012 /* Gotos representing break and continue are OK. */
6013 if (breaks (target
) || continues (target
))
6015 if (flags
& tf_error
)
6016 error_at (loc
, "%<goto%> is not a constant expression");
6021 return RECUR (TREE_OPERAND (t
, 0), rval
);
6024 if (objc_is_property_ref (t
))
6027 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6034 /* The main entry point to the above. */
6037 potential_constant_expression (tree t
)
6039 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6042 /* As above, but require a constant rvalue. */
6045 potential_rvalue_constant_expression (tree t
)
6047 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6050 /* Like above, but complain about non-constant expressions. */
6053 require_potential_constant_expression (tree t
)
6055 return potential_constant_expression_1 (t
, false, true, false,
6056 tf_warning_or_error
);
6059 /* Cross product of the above. */
6062 require_potential_rvalue_constant_expression (tree t
)
6064 return potential_constant_expression_1 (t
, true, true, false,
6065 tf_warning_or_error
);
6068 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6071 require_rvalue_constant_expression (tree t
)
6073 return potential_constant_expression_1 (t
, true, true, true,
6074 tf_warning_or_error
);
6077 /* Like potential_constant_expression, but don't consider possible constexpr
6078 substitution of the current function. That is, PARM_DECL qualifies under
6079 potential_constant_expression, but not here.
6081 This is basically what you can check when any actual constant values might
6082 be value-dependent. */
6085 is_constant_expression (tree t
)
6087 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6090 /* Like above, but complain about non-constant expressions. */
6093 require_constant_expression (tree t
)
6095 return potential_constant_expression_1 (t
, false, true, true,
6096 tf_warning_or_error
);
6099 /* Like is_constant_expression, but allow const variables that are not allowed
6100 under constexpr rules. */
6103 is_static_init_expression (tree t
)
6105 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6108 /* Returns true if T is a potential constant expression that is not
6109 instantiation-dependent, and therefore a candidate for constant folding even
6113 is_nondependent_constant_expression (tree t
)
6115 return (!type_unknown_p (t
)
6116 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6117 && is_constant_expression (t
)
6118 && !instantiation_dependent_expression_p (t
));
6121 /* Returns true if T is a potential static initializer expression that is not
6122 instantiation-dependent. */
6125 is_nondependent_static_init_expression (tree t
)
6127 return (!type_unknown_p (t
)
6128 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6129 && is_static_init_expression (t
)
6130 && !instantiation_dependent_expression_p (t
));
6133 /* Finalize constexpr processing after parsing. */
6136 fini_constexpr (void)
6138 /* The contexpr call and fundef copies tables are no longer needed. */
6139 constexpr_call_table
= NULL
;
6140 fundef_copies_table
= NULL
;
6143 #include "gt-cp-constexpr.h"