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-2019 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"
36 #include "fold-const-call.h"
38 static bool verify_constant (tree
, bool, bool *, bool *);
39 #define VERIFY_CONSTANT(X) \
41 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
45 static HOST_WIDE_INT
find_array_ctor_elt (tree ary
, tree dindex
,
48 /* Returns true iff FUN is an instantiation of a constexpr function
49 template or a defaulted constexpr function. */
52 is_instantiation_of_constexpr (tree fun
)
54 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
55 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
56 || (DECL_DEFAULTED_FN (fun
)
57 && DECL_DECLARED_CONSTEXPR_P (fun
)));
60 /* Return true if T is a literal type. */
63 literal_type_p (tree t
)
68 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
72 t
= complete_type (t
);
73 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
74 return CLASSTYPE_LITERAL_P (t
);
76 if (TREE_CODE (t
) == ARRAY_TYPE
)
77 return literal_type_p (strip_array_types (t
));
81 /* If DECL is a variable declared `constexpr', require its type
82 be literal. Return error_mark_node if we give an error, the
86 ensure_literal_type_for_constexpr_object (tree decl
)
88 tree type
= TREE_TYPE (decl
);
90 && (DECL_DECLARED_CONSTEXPR_P (decl
)
91 || var_in_constexpr_fn (decl
))
92 && !processing_template_decl
)
94 tree stype
= strip_array_types (type
);
95 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
96 /* Don't complain here, we'll complain about incompleteness
97 when we try to initialize the variable. */;
98 else if (type_uses_auto (type
))
99 /* We don't know the actual type yet. */;
100 else if (!literal_type_p (type
))
102 if (DECL_DECLARED_CONSTEXPR_P (decl
))
104 auto_diagnostic_group d
;
105 error_at (DECL_SOURCE_LOCATION (decl
),
106 "the type %qT of %<constexpr%> variable %qD "
107 "is not literal", type
, decl
);
108 explain_non_literal_class (type
);
109 decl
= error_mark_node
;
113 if (!is_instantiation_of_constexpr (current_function_decl
))
115 auto_diagnostic_group d
;
116 error_at (DECL_SOURCE_LOCATION (decl
),
117 "variable %qD of non-literal type %qT in "
118 "%<constexpr%> function", decl
, type
);
119 explain_non_literal_class (type
);
120 decl
= error_mark_node
;
122 cp_function_chain
->invalid_constexpr
= true;
125 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
126 && variably_modified_type_p (type
, NULL_TREE
))
128 error_at (DECL_SOURCE_LOCATION (decl
),
129 "%<constexpr%> variable %qD has variably-modified "
130 "type %qT", decl
, type
);
131 decl
= error_mark_node
;
137 /* Representation of entries in the constexpr function definition table. */
139 struct GTY((for_user
)) constexpr_fundef
{
146 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
148 static hashval_t
hash (constexpr_fundef
*);
149 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
152 /* This table holds all constexpr function definitions seen in
153 the current translation unit. */
155 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
157 /* Utility function used for managing the constexpr function table.
158 Return true if the entries pointed to by P and Q are for the
159 same constexpr function. */
162 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
164 return lhs
->decl
== rhs
->decl
;
167 /* Utility function used for managing the constexpr function table.
168 Return a hash value for the entry pointed to by Q. */
171 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
173 return DECL_UID (fundef
->decl
);
176 /* Return a previously saved definition of function FUN. */
178 static constexpr_fundef
*
179 retrieve_constexpr_fundef (tree fun
)
181 if (constexpr_fundef_table
== NULL
)
184 constexpr_fundef fundef
= { fun
, NULL
, NULL
, NULL
};
185 return constexpr_fundef_table
->find (&fundef
);
188 /* Check whether the parameter and return types of FUN are valid for a
189 constexpr function, and complain if COMPLAIN. */
192 is_valid_constexpr_fn (tree fun
, bool complain
)
196 if (DECL_INHERITED_CTOR (fun
)
197 && TREE_CODE (fun
) == TEMPLATE_DECL
)
201 error ("inherited constructor %qD is not %<constexpr%>",
202 DECL_INHERITED_CTOR (fun
));
206 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
207 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
208 if (!literal_type_p (TREE_TYPE (parm
)))
213 auto_diagnostic_group d
;
214 error ("invalid type for parameter %d of %<constexpr%> "
215 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
216 explain_non_literal_class (TREE_TYPE (parm
));
221 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
225 inform (DECL_SOURCE_LOCATION (fun
),
226 "lambdas are implicitly %<constexpr%> only in C++17 and later");
228 else if (!DECL_CONSTRUCTOR_P (fun
))
230 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
231 if (!literal_type_p (rettype
))
236 auto_diagnostic_group d
;
237 error ("invalid return type %qT of %<constexpr%> function %q+D",
239 explain_non_literal_class (rettype
);
243 /* C++14 DR 1684 removed this restriction. */
244 if (cxx_dialect
< cxx14
245 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
246 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
251 auto_diagnostic_group d
;
252 if (pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
253 "enclosing class of %<constexpr%> non-static"
254 " member function %q+#D is not a literal type",
256 explain_non_literal_class (DECL_CONTEXT (fun
));
260 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
264 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
270 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
271 for a member of an anonymous aggregate, INIT is the initializer for that
272 member, and VEC_OUTER is the vector of constructor elements for the class
273 whose constructor we are processing. Add the initializer to the vector
274 and return true to indicate success. */
277 build_anon_member_initialization (tree member
, tree init
,
278 vec
<constructor_elt
, va_gc
> **vec_outer
)
280 /* MEMBER presents the relevant fields from the inside out, but we need
281 to build up the initializer from the outside in so that we can reuse
282 previously built CONSTRUCTORs if this is, say, the second field in an
283 anonymous struct. So we use a vec as a stack. */
284 auto_vec
<tree
, 2> fields
;
287 fields
.safe_push (TREE_OPERAND (member
, 1));
288 member
= TREE_OPERAND (member
, 0);
290 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
291 && TREE_CODE (member
) == COMPONENT_REF
);
293 /* VEC has the constructor elements vector for the context of FIELD.
294 If FIELD is an anonymous aggregate, we will push inside it. */
295 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
297 while (field
= fields
.pop(),
298 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
301 /* If there is already an outer constructor entry for the anonymous
302 aggregate FIELD, use it; otherwise, insert one. */
303 if (vec_safe_is_empty (*vec
)
304 || (*vec
)->last().index
!= field
)
306 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
307 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
310 ctor
= (*vec
)->last().value
;
311 vec
= &CONSTRUCTOR_ELTS (ctor
);
314 /* Now we're at the innermost field, the one that isn't an anonymous
315 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
316 gcc_assert (fields
.is_empty());
317 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
322 /* Subroutine of build_constexpr_constructor_member_initializers.
323 The expression tree T represents a data member initialization
324 in a (constexpr) constructor definition. Build a pairing of
325 the data member with its initializer, and prepend that pair
326 to the existing initialization pair INITS. */
329 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
332 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
333 t
= TREE_OPERAND (t
, 0);
334 if (TREE_CODE (t
) == EXPR_STMT
)
335 t
= TREE_OPERAND (t
, 0);
336 if (t
== error_mark_node
)
338 if (TREE_CODE (t
) == STATEMENT_LIST
)
340 tree_stmt_iterator i
;
341 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
343 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
348 if (TREE_CODE (t
) == CLEANUP_STMT
)
350 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
351 but we can in a constexpr constructor for a non-literal class. Just
352 ignore it; either all the initialization will be constant, in which
353 case the cleanup can't run, or it can't be constexpr.
354 Still recurse into CLEANUP_BODY. */
355 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
357 if (TREE_CODE (t
) == CONVERT_EXPR
)
358 t
= TREE_OPERAND (t
, 0);
359 if (TREE_CODE (t
) == INIT_EXPR
360 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
361 use what this function builds for cx_check_missing_mem_inits, and
362 assignment in the ctor body doesn't count. */
363 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
365 member
= TREE_OPERAND (t
, 0);
366 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
368 else if (TREE_CODE (t
) == CALL_EXPR
)
370 tree fn
= get_callee_fndecl (t
);
371 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
372 /* We're only interested in calls to subobject constructors. */
374 member
= CALL_EXPR_ARG (t
, 0);
375 /* We don't use build_cplus_new here because it complains about
376 abstract bases. Leaving the call unwrapped means that it has the
377 wrong type, but cxx_eval_constant_expression doesn't care. */
378 init
= break_out_target_exprs (t
);
380 else if (TREE_CODE (t
) == BIND_EXPR
)
381 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
383 /* Don't add anything else to the CONSTRUCTOR. */
385 if (INDIRECT_REF_P (member
))
386 member
= TREE_OPERAND (member
, 0);
387 if (TREE_CODE (member
) == NOP_EXPR
)
391 if (TREE_CODE (op
) == ADDR_EXPR
)
393 gcc_assert (same_type_ignoring_top_level_qualifiers_p
394 (TREE_TYPE (TREE_TYPE (op
)),
395 TREE_TYPE (TREE_TYPE (member
))));
396 /* Initializing a cv-qualified member; we need to look through
400 else if (op
== current_class_ptr
401 && (same_type_ignoring_top_level_qualifiers_p
402 (TREE_TYPE (TREE_TYPE (member
)),
403 current_class_type
)))
404 /* Delegating constructor. */
408 /* This is an initializer for an empty base; keep it for now so
409 we can check it in cxx_eval_bare_aggregate. */
410 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
413 if (TREE_CODE (member
) == ADDR_EXPR
)
414 member
= TREE_OPERAND (member
, 0);
415 if (TREE_CODE (member
) == COMPONENT_REF
)
417 tree aggr
= TREE_OPERAND (member
, 0);
418 if (TREE_CODE (aggr
) == VAR_DECL
)
419 /* Initializing a local variable, don't add anything. */
421 if (TREE_CODE (aggr
) != COMPONENT_REF
)
422 /* Normal member initialization. */
423 member
= TREE_OPERAND (member
, 1);
424 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
425 /* Initializing a member of an anonymous union. */
426 return build_anon_member_initialization (member
, init
, vec
);
428 /* We're initializing a vtable pointer in a base. Leave it as
429 COMPONENT_REF so we remember the path to get to the vfield. */
430 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
433 /* Value-initialization can produce multiple initializers for the
434 same field; use the last one. */
435 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
436 (*vec
)->last().value
= init
;
438 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
442 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
443 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
444 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
447 check_constexpr_bind_expr_vars (tree t
)
449 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
451 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
452 if (TREE_CODE (var
) == TYPE_DECL
453 && DECL_IMPLICIT_TYPEDEF_P (var
)
454 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
459 /* Subroutine of check_constexpr_ctor_body. */
462 check_constexpr_ctor_body_1 (tree last
, tree list
)
464 switch (TREE_CODE (list
))
467 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
468 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
472 case CLEANUP_POINT_EXPR
:
473 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
477 if (!check_constexpr_bind_expr_vars (list
)
478 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
485 case DEBUG_BEGIN_STMT
:
493 /* Make sure that there are no statements after LAST in the constructor
494 body represented by LIST. */
497 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
499 /* C++14 doesn't require a constexpr ctor to have an empty body. */
500 if (cxx_dialect
>= cxx14
)
504 if (TREE_CODE (list
) == STATEMENT_LIST
)
506 tree_stmt_iterator i
= tsi_last (list
);
507 for (; !tsi_end_p (i
); tsi_prev (&i
))
509 tree t
= tsi_stmt (i
);
512 if (!check_constexpr_ctor_body_1 (last
, t
))
519 else if (list
!= last
520 && !check_constexpr_ctor_body_1 (last
, list
))
525 error ("%<constexpr%> constructor does not have empty body");
526 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
531 /* V is a vector of constructor elements built up for the base and member
532 initializers of a constructor for TYPE. They need to be in increasing
533 offset order, which they might not be yet if TYPE has a primary base
534 which is not first in the base-clause or a vptr and at least one base
535 all of which are non-primary. */
537 static vec
<constructor_elt
, va_gc
> *
538 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
540 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
546 field_type
= BINFO_TYPE (pri
);
547 else if (TYPE_CONTAINS_VPTR_P (type
))
548 field_type
= vtbl_ptr_type_node
;
552 /* Find the element for the primary base or vptr and move it to the
553 beginning of the vec. */
554 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
555 if (TREE_TYPE (ce
->index
) == field_type
)
558 if (i
> 0 && i
< vec_safe_length (v
))
560 vec
<constructor_elt
, va_gc
> &vref
= *v
;
561 constructor_elt elt
= vref
[i
];
570 /* Build compile-time evalable representations of member-initializer list
571 for a constexpr constructor. */
574 build_constexpr_constructor_member_initializers (tree type
, tree body
)
576 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
579 switch (TREE_CODE (body
))
581 case MUST_NOT_THROW_EXPR
:
583 body
= TREE_OPERAND (body
, 0);
587 for (tree_stmt_iterator i
= tsi_start (body
);
588 !tsi_end_p (i
); tsi_next (&i
))
591 if (TREE_CODE (body
) == BIND_EXPR
)
597 body
= BIND_EXPR_BODY (body
);
604 if (TREE_CODE (body
) == TRY_BLOCK
)
606 body
= TREE_OPERAND (body
, 0);
607 if (TREE_CODE (body
) == BIND_EXPR
)
608 body
= BIND_EXPR_BODY (body
);
610 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
612 body
= TREE_OPERAND (body
, 0);
613 if (TREE_CODE (body
) == EXPR_STMT
)
614 body
= TREE_OPERAND (body
, 0);
615 if (TREE_CODE (body
) == INIT_EXPR
616 && (same_type_ignoring_top_level_qualifiers_p
617 (TREE_TYPE (TREE_OPERAND (body
, 0)),
618 current_class_type
)))
621 return TREE_OPERAND (body
, 1);
623 ok
= build_data_member_initialization (body
, &vec
);
625 else if (TREE_CODE (body
) == STATEMENT_LIST
)
627 tree_stmt_iterator i
;
628 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
630 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
635 else if (EXPR_P (body
))
636 ok
= build_data_member_initialization (body
, &vec
);
638 gcc_assert (errorcount
> 0);
641 if (vec_safe_length (vec
) > 0)
643 /* In a delegating constructor, return the target. */
644 constructor_elt
*ce
= &(*vec
)[0];
645 if (ce
->index
== current_class_ptr
)
652 vec
= sort_constexpr_mem_initializers (type
, vec
);
653 return build_constructor (type
, vec
);
656 return error_mark_node
;
659 /* We have an expression tree T that represents a call, either CALL_EXPR
660 or AGGR_INIT_EXPR. If the call is lexically to a named function,
661 retrun the _DECL for that function. */
664 get_function_named_in_call (tree t
)
666 tree fun
= cp_get_callee (t
);
667 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
668 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
669 fun
= TREE_OPERAND (fun
, 0);
673 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
674 declared to be constexpr, or a sub-statement thereof. Returns the
675 return value if suitable, error_mark_node for a statement not allowed in
676 a constexpr function, or NULL_TREE if no return value was found. */
679 constexpr_fn_retval (tree body
)
681 switch (TREE_CODE (body
))
685 tree_stmt_iterator i
;
686 tree expr
= NULL_TREE
;
687 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
689 tree s
= constexpr_fn_retval (tsi_stmt (i
));
690 if (s
== error_mark_node
)
691 return error_mark_node
;
692 else if (s
== NULL_TREE
)
693 /* Keep iterating. */;
695 /* Multiple return statements. */
696 return error_mark_node
;
704 return break_out_target_exprs (TREE_OPERAND (body
, 0));
708 tree decl
= DECL_EXPR_DECL (body
);
709 if (TREE_CODE (decl
) == USING_DECL
710 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
711 || DECL_ARTIFICIAL (decl
))
713 return error_mark_node
;
716 case CLEANUP_POINT_EXPR
:
717 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
720 if (!check_constexpr_bind_expr_vars (body
))
721 return error_mark_node
;
722 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
725 case DEBUG_BEGIN_STMT
:
730 tree fun
= get_function_named_in_call (body
);
732 && fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
))
738 return error_mark_node
;
742 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
743 FUN; do the necessary transformations to turn it into a single expression
744 that we can store in the hash table. */
747 massage_constexpr_body (tree fun
, tree body
)
749 if (DECL_CONSTRUCTOR_P (fun
))
750 body
= build_constexpr_constructor_member_initializers
751 (DECL_CONTEXT (fun
), body
);
752 else if (cxx_dialect
< cxx14
)
754 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
755 body
= EH_SPEC_STMTS (body
);
756 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
757 body
= TREE_OPERAND (body
, 0);
758 body
= constexpr_fn_retval (body
);
763 /* CTYPE is a type constructed from BODY. Return true if some
764 bases/fields are uninitialized, and complain if COMPLAIN. */
767 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
773 if (TREE_CODE (body
) != CONSTRUCTOR
)
775 nelts
= CONSTRUCTOR_NELTS (body
);
777 tree field
= TYPE_FIELDS (ctype
);
779 if (TREE_CODE (ctype
) == UNION_TYPE
)
781 if (nelts
== 0 && next_initializable_field (field
))
784 error ("%<constexpr%> constructor for union %qT must "
785 "initialize exactly one non-static data member", ctype
);
791 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
792 need an explicit initialization. */
794 for (unsigned i
= 0; i
<= nelts
; ++i
)
796 tree index
= NULL_TREE
;
799 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
800 /* Skip base and vtable inits. */
801 if (TREE_CODE (index
) != FIELD_DECL
802 || DECL_ARTIFICIAL (index
))
806 for (; field
!= index
; field
= DECL_CHAIN (field
))
809 if (TREE_CODE (field
) != FIELD_DECL
)
811 if (DECL_UNNAMED_BIT_FIELD (field
))
813 if (DECL_ARTIFICIAL (field
))
815 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
817 /* Recurse to check the anonummous aggregate member. */
818 bad
|= cx_check_missing_mem_inits
819 (TREE_TYPE (field
), NULL_TREE
, complain
);
820 if (bad
&& !complain
)
824 ftype
= strip_array_types (TREE_TYPE (field
));
825 if (type_has_constexpr_default_constructor (ftype
))
827 /* It's OK to skip a member with a trivial constexpr ctor.
828 A constexpr ctor that isn't trivial should have been
830 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
836 auto_diagnostic_group d
;
837 error ("member %qD must be initialized by mem-initializer "
838 "in %<constexpr%> constructor", field
);
839 inform (DECL_SOURCE_LOCATION (field
), "declared here");
842 if (field
== NULL_TREE
)
845 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
847 /* Check the anonymous aggregate initializer is valid. */
848 bad
|= cx_check_missing_mem_inits
849 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
850 if (bad
&& !complain
)
853 field
= DECL_CHAIN (field
);
859 /* We are processing the definition of the constexpr function FUN.
860 Check that its BODY fulfills the propriate requirements and
861 enter it in the constexpr function definition table.
862 For constructor BODY is actually the TREE_LIST of the
863 member-initializer list. */
866 register_constexpr_fundef (tree fun
, tree body
)
868 constexpr_fundef entry
;
869 constexpr_fundef
**slot
;
871 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
874 tree massaged
= massage_constexpr_body (fun
, body
);
875 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
877 if (!DECL_CONSTRUCTOR_P (fun
))
878 error ("body of %<constexpr%> function %qD not a return-statement",
883 if (!potential_rvalue_constant_expression (massaged
))
885 if (!DECL_GENERATED_P (fun
))
886 require_potential_rvalue_constant_expression (massaged
);
890 if (DECL_CONSTRUCTOR_P (fun
)
891 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
892 massaged
, !DECL_GENERATED_P (fun
)))
895 /* Create the constexpr function table if necessary. */
896 if (constexpr_fundef_table
== NULL
)
897 constexpr_fundef_table
898 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
901 tree saved_fn
= current_function_decl
;
902 bool clear_ctx
= false;
903 current_function_decl
= fun
;
904 if (DECL_RESULT (fun
) && DECL_CONTEXT (DECL_RESULT (fun
)) == NULL_TREE
)
907 DECL_CONTEXT (DECL_RESULT (fun
)) = fun
;
909 entry
.body
= copy_fn (fun
, entry
.parms
, entry
.result
);
910 current_function_decl
= saved_fn
;
911 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
913 DECL_CONTEXT (DECL_RESULT (fun
)) = NULL_TREE
;
915 gcc_assert (*slot
== NULL
);
916 *slot
= ggc_alloc
<constexpr_fundef
> ();
922 /* FUN is a non-constexpr function called in a context that requires a
923 constant expression. If it comes from a constexpr template, explain why
924 the instantiation isn't constexpr. */
927 explain_invalid_constexpr_fn (tree fun
)
929 static hash_set
<tree
> *diagnosed
;
932 /* Only diagnose defaulted functions, lambdas, or instantiations. */
933 if (!DECL_DEFAULTED_FN (fun
)
934 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
935 && !is_instantiation_of_constexpr (fun
))
937 if (diagnosed
== NULL
)
938 diagnosed
= new hash_set
<tree
>;
939 if (diagnosed
->add (fun
))
940 /* Already explained. */
943 save_loc
= input_location
;
944 if (!lambda_static_thunk_p (fun
))
946 /* Diagnostics should completely ignore the static thunk, so leave
947 input_location set to our caller's location. */
948 input_location
= DECL_SOURCE_LOCATION (fun
);
949 inform (input_location
,
950 "%qD is not usable as a %<constexpr%> function because:", fun
);
952 /* First check the declaration. */
953 if (is_valid_constexpr_fn (fun
, true))
955 /* Then if it's OK, the body. */
956 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
957 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
958 explain_implicit_non_constexpr (fun
);
961 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
962 require_potential_rvalue_constant_expression (body
);
963 if (DECL_CONSTRUCTOR_P (fun
))
964 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
967 input_location
= save_loc
;
970 /* Objects of this type represent calls to constexpr functions
971 along with the bindings of parameters to their arguments, for
972 the purpose of compile time evaluation. */
974 struct GTY((for_user
)) constexpr_call
{
975 /* Description of the constexpr function definition. */
976 constexpr_fundef
*fundef
;
977 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
978 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
979 Note: This arrangement is made to accommodate the use of
980 iterative_hash_template_arg (see pt.c). If you change this
981 representation, also change the hash calculation in
982 cxx_eval_call_expression. */
984 /* Result of the call.
985 NULL means the call is being evaluated.
986 error_mark_node means that the evaluation was erroneous;
987 otherwise, the actuall value of the call. */
989 /* The hash of this call; we remember it here to avoid having to
990 recalculate it when expanding the hash table. */
992 /* Whether __builtin_is_constant_evaluated() should evaluate to true. */
993 bool manifestly_const_eval
;
996 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
998 static hashval_t
hash (constexpr_call
*);
999 static bool equal (constexpr_call
*, constexpr_call
*);
1002 enum constexpr_switch_state
{
1003 /* Used when processing a switch for the first time by cxx_eval_switch_expr
1004 and default: label for that switch has not been seen yet. */
1005 css_default_not_seen
,
1006 /* Used when processing a switch for the first time by cxx_eval_switch_expr
1007 and default: label for that switch has been seen already. */
1009 /* Used when processing a switch for the second time by
1010 cxx_eval_switch_expr, where default: label should match. */
1011 css_default_processing
1014 /* The constexpr expansion context. CALL is the current function
1015 expansion, CTOR is the current aggregate initializer, OBJECT is the
1016 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
1017 is a map of values of variables initialized within the expression. */
1019 struct constexpr_ctx
{
1020 /* The innermost call we're evaluating. */
1021 constexpr_call
*call
;
1022 /* Values for any temporaries or local variables within the
1023 constant-expression. */
1024 hash_map
<tree
,tree
> *values
;
1025 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
1026 aren't inside a loop. */
1027 vec
<tree
> *save_exprs
;
1028 /* The CONSTRUCTOR we're currently building up for an aggregate
1031 /* The object we're building the CONSTRUCTOR for. */
1033 /* If inside SWITCH_EXPR. */
1034 constexpr_switch_state
*css_state
;
1035 /* Number of cxx_eval_constant_expression calls (except skipped ones,
1036 on simple constants or location wrappers) encountered during current
1037 cxx_eval_outermost_constant_expr call. */
1038 HOST_WIDE_INT
*constexpr_ops_count
;
1040 /* Whether we should error on a non-constant expression or fail quietly. */
1042 /* Whether we are strictly conforming to constant expression rules or
1043 trying harder to get a constant value. */
1045 /* Whether __builtin_is_constant_evaluated () should be true. */
1046 bool manifestly_const_eval
;
1049 /* A table of all constexpr calls that have been evaluated by the
1050 compiler in this translation unit. */
1052 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1054 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1055 bool, bool *, bool *, tree
* = NULL
);
1057 /* Compute a hash value for a constexpr call representation. */
1060 constexpr_call_hasher::hash (constexpr_call
*info
)
1065 /* Return true if the objects pointed to by P and Q represent calls
1066 to the same constexpr function with the same arguments.
1067 Otherwise, return false. */
1070 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1076 if (lhs
->hash
!= rhs
->hash
)
1078 if (lhs
->manifestly_const_eval
!= rhs
->manifestly_const_eval
)
1080 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1082 lhs_bindings
= lhs
->bindings
;
1083 rhs_bindings
= rhs
->bindings
;
1084 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1086 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1087 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1088 gcc_assert (same_type_p (TREE_TYPE (lhs_arg
), TREE_TYPE (rhs_arg
)));
1089 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1091 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1092 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1094 return lhs_bindings
== rhs_bindings
;
1097 /* Initialize the constexpr call table, if needed. */
1100 maybe_initialize_constexpr_call_table (void)
1102 if (constexpr_call_table
== NULL
)
1103 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1106 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1107 a function happens to get called recursively, we unshare the callee
1108 function's body and evaluate this unshared copy instead of evaluating the
1111 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1112 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1113 that's keyed off of the original FUNCTION_DECL and whose value is a
1114 TREE_LIST of this function's unused copies awaiting reuse.
1116 This is not GC-deletable to avoid GC affecting UID generation. */
1118 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1120 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1123 maybe_initialize_fundef_copies_table ()
1125 if (fundef_copies_table
== NULL
)
1126 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1129 /* Reuse a copy or create a new unshared copy of the function FUN.
1130 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1131 is parms, TYPE is result. */
1134 get_fundef_copy (constexpr_fundef
*fundef
)
1136 maybe_initialize_fundef_copies_table ();
1140 tree
*slot
= &fundef_copies_table
->get_or_insert (fundef
->decl
, &existed
);
1144 /* There is no cached function available, or in use. We can use
1145 the function directly. That the slot is now created records
1146 that this function is now in use. */
1147 copy
= build_tree_list (fundef
->body
, fundef
->parms
);
1148 TREE_TYPE (copy
) = fundef
->result
;
1150 else if (*slot
== NULL_TREE
)
1152 /* We've already used the function itself, so make a copy. */
1153 copy
= build_tree_list (NULL
, NULL
);
1154 tree saved_body
= DECL_SAVED_TREE (fundef
->decl
);
1155 tree saved_parms
= DECL_ARGUMENTS (fundef
->decl
);
1156 tree saved_result
= DECL_RESULT (fundef
->decl
);
1157 tree saved_fn
= current_function_decl
;
1158 DECL_SAVED_TREE (fundef
->decl
) = fundef
->body
;
1159 DECL_ARGUMENTS (fundef
->decl
) = fundef
->parms
;
1160 DECL_RESULT (fundef
->decl
) = fundef
->result
;
1161 current_function_decl
= fundef
->decl
;
1162 TREE_PURPOSE (copy
) = copy_fn (fundef
->decl
, TREE_VALUE (copy
),
1164 current_function_decl
= saved_fn
;
1165 DECL_RESULT (fundef
->decl
) = saved_result
;
1166 DECL_ARGUMENTS (fundef
->decl
) = saved_parms
;
1167 DECL_SAVED_TREE (fundef
->decl
) = saved_body
;
1171 /* We have a cached function available. */
1173 *slot
= TREE_CHAIN (copy
);
1179 /* Save the copy COPY of function FUN for later reuse by
1180 get_fundef_copy(). By construction, there will always be an entry
1184 save_fundef_copy (tree fun
, tree copy
)
1186 tree
*slot
= fundef_copies_table
->get (fun
);
1187 TREE_CHAIN (copy
) = *slot
;
1191 /* We have an expression tree T that represents a call, either CALL_EXPR
1192 or AGGR_INIT_EXPR. Return the Nth argument. */
1195 get_nth_callarg (tree t
, int n
)
1197 switch (TREE_CODE (t
))
1200 return CALL_EXPR_ARG (t
, n
);
1202 case AGGR_INIT_EXPR
:
1203 return AGGR_INIT_EXPR_ARG (t
, n
);
1211 /* Attempt to evaluate T which represents a call to a builtin function.
1212 We assume here that all builtin functions evaluate to scalar types
1213 represented by _CST nodes. */
1216 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1218 bool *non_constant_p
, bool *overflow_p
)
1220 const int nargs
= call_expr_nargs (t
);
1221 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1225 /* Don't fold __builtin_constant_p within a constexpr function. */
1226 bool bi_const_p
= DECL_IS_BUILTIN_CONSTANT_P (fun
);
1228 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1229 in a constexpr function until we have values for the parameters. */
1231 && !ctx
->manifestly_const_eval
1232 && current_function_decl
1233 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1235 *non_constant_p
= true;
1239 /* For __builtin_is_constant_evaluated, defer it if not
1240 ctx->manifestly_const_eval, otherwise fold it to true. */
1241 if (fndecl_built_in_p (fun
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
1244 if (!ctx
->manifestly_const_eval
)
1246 *non_constant_p
= true;
1249 return boolean_true_node
;
1252 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1253 return constant false for a non-constant argument. */
1254 constexpr_ctx new_ctx
= *ctx
;
1255 new_ctx
.quiet
= true;
1256 for (i
= 0; i
< nargs
; ++i
)
1258 args
[i
] = CALL_EXPR_ARG (t
, i
);
1259 /* If builtin_valid_in_constant_expr_p is true,
1260 potential_constant_expression_1 has not recursed into the arguments
1261 of the builtin, verify it here. */
1262 if (!builtin_valid_in_constant_expr_p (fun
)
1263 || potential_constant_expression (args
[i
]))
1265 bool dummy1
= false, dummy2
= false;
1266 args
[i
] = cxx_eval_constant_expression (&new_ctx
, args
[i
], false,
1271 /* For __builtin_constant_p, fold all expressions with constant values
1272 even if they aren't C++ constant-expressions. */
1273 args
[i
] = cp_fold_rvalue (args
[i
]);
1276 bool save_ffbcp
= force_folding_builtin_constant_p
;
1277 force_folding_builtin_constant_p
= true;
1278 tree save_cur_fn
= current_function_decl
;
1279 /* Return name of ctx->call->fundef->decl for __builtin_FUNCTION (). */
1280 if (fndecl_built_in_p (fun
, BUILT_IN_FUNCTION
)
1282 && ctx
->call
->fundef
)
1283 current_function_decl
= ctx
->call
->fundef
->decl
;
1284 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1285 CALL_EXPR_FN (t
), nargs
, args
);
1286 current_function_decl
= save_cur_fn
;
1287 force_folding_builtin_constant_p
= save_ffbcp
;
1288 if (new_call
== NULL
)
1290 if (!*non_constant_p
&& !ctx
->quiet
)
1292 /* Do not allow__builtin_unreachable in constexpr function.
1293 The __builtin_unreachable call with BUILTINS_LOCATION
1294 comes from cp_maybe_instrument_return. */
1295 if (fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
)
1296 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1297 error ("%<constexpr%> call flows off the end of the function");
1300 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1301 CALL_EXPR_FN (t
), nargs
, args
);
1302 error ("%q+E is not a constant expression", new_call
);
1305 *non_constant_p
= true;
1309 if (!potential_constant_expression (new_call
))
1311 if (!*non_constant_p
&& !ctx
->quiet
)
1312 error ("%q+E is not a constant expression", new_call
);
1313 *non_constant_p
= true;
1317 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1318 non_constant_p
, overflow_p
);
1321 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1322 the type of the value to match. */
1325 adjust_temp_type (tree type
, tree temp
)
1327 if (same_type_p (TREE_TYPE (temp
), type
))
1329 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1330 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1332 /* build_constructor wouldn't retain various CONSTRUCTOR flags. */
1333 tree t
= copy_node (temp
);
1334 TREE_TYPE (t
) = type
;
1337 if (TREE_CODE (temp
) == EMPTY_CLASS_EXPR
)
1338 return build0 (EMPTY_CLASS_EXPR
, type
);
1339 gcc_assert (scalarish_type_p (type
));
1340 return cp_fold_convert (type
, temp
);
1343 /* Callback for walk_tree used by unshare_constructor. */
1346 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1350 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1355 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1356 subexpression, return an unshared copy of T. Otherwise return T. */
1359 unshare_constructor (tree t
)
1361 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1362 if (ctor
!= NULL_TREE
)
1363 return unshare_expr (t
);
1367 /* Subroutine of cxx_eval_call_expression.
1368 We are processing a call expression (either CALL_EXPR or
1369 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1370 all arguments and bind their values to correspondings
1371 parameters, making up the NEW_CALL context. */
1374 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1375 constexpr_call
*new_call
,
1376 bool *non_constant_p
, bool *overflow_p
,
1377 bool *non_constant_args
)
1379 const int nargs
= call_expr_nargs (t
);
1380 tree fun
= new_call
->fundef
->decl
;
1381 tree parms
= new_call
->fundef
->parms
;
1383 tree
*p
= &new_call
->bindings
;
1384 for (i
= 0; i
< nargs
; ++i
)
1387 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1388 x
= get_nth_callarg (t
, i
);
1389 /* For member function, the first argument is a pointer to the implied
1390 object. For a constructor, it might still be a dummy object, in
1391 which case we get the real argument from ctx. */
1392 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1393 && is_dummy_object (x
))
1396 x
= build_address (x
);
1398 if (TREE_ADDRESSABLE (type
))
1399 /* Undo convert_for_arg_passing work here. */
1400 x
= convert_from_reference (x
);
1401 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1402 non_constant_p
, overflow_p
);
1403 /* Don't VERIFY_CONSTANT here. */
1404 if (*non_constant_p
&& ctx
->quiet
)
1406 /* Just discard ellipsis args after checking their constantitude. */
1410 if (!*non_constant_p
)
1412 /* Don't share a CONSTRUCTOR that might be changed. */
1413 arg
= unshare_constructor (arg
);
1414 /* Make sure the binding has the same type as the parm. But
1415 only for constant args. */
1416 if (!TYPE_REF_P (type
))
1417 arg
= adjust_temp_type (type
, arg
);
1418 if (!TREE_CONSTANT (arg
))
1419 *non_constant_args
= true;
1420 *p
= build_tree_list (parms
, arg
);
1421 p
= &TREE_CHAIN (*p
);
1423 parms
= TREE_CHAIN (parms
);
1427 /* Variables and functions to manage constexpr call expansion context.
1428 These do not need to be marked for PCH or GC. */
1430 /* FIXME remember and print actual constant arguments. */
1431 static vec
<tree
> call_stack
;
1432 static int call_stack_tick
;
1433 static int last_cx_error_tick
;
1436 push_cx_call_context (tree call
)
1439 if (!EXPR_HAS_LOCATION (call
))
1440 SET_EXPR_LOCATION (call
, input_location
);
1441 call_stack
.safe_push (call
);
1442 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1448 pop_cx_call_context (void)
1455 cx_error_context (void)
1457 vec
<tree
> r
= vNULL
;
1458 if (call_stack_tick
!= last_cx_error_tick
1459 && !call_stack
.is_empty ())
1461 last_cx_error_tick
= call_stack_tick
;
1465 /* Evaluate a call T to a GCC internal function when possible and return
1466 the evaluated result or, under the control of CTX, give an error, set
1467 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1470 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1472 bool *non_constant_p
, bool *overflow_p
)
1474 enum tree_code opcode
= ERROR_MARK
;
1476 switch (CALL_EXPR_IFN (t
))
1478 case IFN_UBSAN_NULL
:
1479 case IFN_UBSAN_BOUNDS
:
1480 case IFN_UBSAN_VPTR
:
1481 case IFN_FALLTHROUGH
:
1484 case IFN_ADD_OVERFLOW
:
1487 case IFN_SUB_OVERFLOW
:
1488 opcode
= MINUS_EXPR
;
1490 case IFN_MUL_OVERFLOW
:
1495 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1496 false, non_constant_p
, overflow_p
);
1498 case IFN_VEC_CONVERT
:
1500 tree arg
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1501 false, non_constant_p
,
1503 if (TREE_CODE (arg
) == VECTOR_CST
)
1504 return fold_const_call (CFN_VEC_CONVERT
, TREE_TYPE (t
), arg
);
1507 *non_constant_p
= true;
1514 error_at (cp_expr_loc_or_loc (t
, input_location
),
1515 "call to internal function %qE", t
);
1516 *non_constant_p
= true;
1520 /* Evaluate constant arguments using OPCODE and return a complex
1521 number containing the result and the overflow bit. */
1522 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1523 non_constant_p
, overflow_p
);
1524 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1525 non_constant_p
, overflow_p
);
1527 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1529 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1530 tree type
= TREE_TYPE (TREE_TYPE (t
));
1531 tree result
= fold_binary_loc (loc
, opcode
, type
,
1532 fold_convert_loc (loc
, type
, arg0
),
1533 fold_convert_loc (loc
, type
, arg1
));
1535 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1536 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1537 if (TREE_OVERFLOW (result
))
1538 TREE_OVERFLOW (result
) = 0;
1540 return build_complex (TREE_TYPE (t
), result
, ovf
);
1543 *non_constant_p
= true;
1547 /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */
1550 clear_no_implicit_zero (tree ctor
)
1552 if (CONSTRUCTOR_NO_CLEARING (ctor
))
1554 CONSTRUCTOR_NO_CLEARING (ctor
) = false;
1555 tree elt
; unsigned HOST_WIDE_INT idx
;
1556 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1557 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1558 clear_no_implicit_zero (elt
);
1562 /* Subroutine of cxx_eval_constant_expression.
1563 Evaluate the call expression tree T in the context of OLD_CALL expression
1567 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1569 bool *non_constant_p
, bool *overflow_p
)
1571 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1572 tree fun
= get_function_named_in_call (t
);
1573 constexpr_call new_call
1574 = { NULL
, NULL
, NULL
, 0, ctx
->manifestly_const_eval
};
1577 if (fun
== NULL_TREE
)
1578 return cxx_eval_internal_function (ctx
, t
, lval
,
1579 non_constant_p
, overflow_p
);
1581 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1583 /* Might be a constexpr function pointer. */
1584 fun
= cxx_eval_constant_expression (ctx
, fun
,
1585 /*lval*/false, non_constant_p
,
1588 if (TREE_CODE (fun
) == ADDR_EXPR
)
1589 fun
= TREE_OPERAND (fun
, 0);
1590 /* For TARGET_VTABLE_USES_DESCRIPTORS targets, there is no
1591 indirection, the called expression is a pointer into the
1592 virtual table which should contain FDESC_EXPR. Extract the
1593 FUNCTION_DECL from there. */
1594 else if (TARGET_VTABLE_USES_DESCRIPTORS
1595 && TREE_CODE (fun
) == POINTER_PLUS_EXPR
1596 && TREE_CODE (TREE_OPERAND (fun
, 0)) == ADDR_EXPR
1597 && TREE_CODE (TREE_OPERAND (fun
, 1)) == INTEGER_CST
)
1599 tree d
= TREE_OPERAND (TREE_OPERAND (fun
, 0), 0);
1601 && DECL_VTABLE_OR_VTT_P (d
)
1602 && TREE_CODE (TREE_TYPE (d
)) == ARRAY_TYPE
1603 && TREE_TYPE (TREE_TYPE (d
)) == vtable_entry_type
1605 && TREE_CODE (DECL_INITIAL (d
)) == CONSTRUCTOR
)
1607 tree i
= int_const_binop (TRUNC_DIV_EXPR
, TREE_OPERAND (fun
, 1),
1608 TYPE_SIZE_UNIT (vtable_entry_type
));
1609 HOST_WIDE_INT idx
= find_array_ctor_elt (DECL_INITIAL (d
), i
);
1613 = (*CONSTRUCTOR_ELTS (DECL_INITIAL (d
)))[idx
].value
;
1614 if (TREE_CODE (fdesc
) == FDESC_EXPR
1615 && integer_zerop (TREE_OPERAND (fdesc
, 1)))
1616 fun
= TREE_OPERAND (fdesc
, 0);
1621 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1623 if (!ctx
->quiet
&& !*non_constant_p
)
1624 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1626 *non_constant_p
= true;
1629 if (DECL_CLONED_FUNCTION_P (fun
))
1630 fun
= DECL_CLONED_FUNCTION (fun
);
1632 if (is_ubsan_builtin_p (fun
))
1635 if (fndecl_built_in_p (fun
))
1636 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1637 lval
, non_constant_p
, overflow_p
);
1638 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1642 if (!lambda_static_thunk_p (fun
))
1643 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1644 explain_invalid_constexpr_fn (fun
);
1646 *non_constant_p
= true;
1650 constexpr_ctx new_ctx
= *ctx
;
1651 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1652 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1654 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1655 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1656 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1657 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1658 CONSTRUCTOR_NO_CLEARING (ctor
) = true;
1659 ctx
->values
->put (new_ctx
.object
, ctor
);
1663 /* Shortcut trivial constructor/op=. */
1664 if (trivial_fn_p (fun
))
1666 tree init
= NULL_TREE
;
1667 if (call_expr_nargs (t
) == 2)
1668 init
= convert_from_reference (get_nth_callarg (t
, 1));
1669 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1670 && AGGR_INIT_ZERO_FIRST (t
))
1671 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1674 tree op
= get_nth_callarg (t
, 0);
1675 if (is_dummy_object (op
))
1678 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1679 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1680 new_ctx
.call
= &new_call
;
1681 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1682 non_constant_p
, overflow_p
);
1686 /* We can't defer instantiating the function any longer. */
1687 if (!DECL_INITIAL (fun
)
1688 && DECL_TEMPLOID_INSTANTIATION (fun
))
1690 location_t save_loc
= input_location
;
1691 input_location
= loc
;
1693 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1695 input_location
= save_loc
;
1698 /* If in direct recursive call, optimize definition search. */
1699 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1700 new_call
.fundef
= ctx
->call
->fundef
;
1703 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1704 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1705 || fun
== current_function_decl
)
1709 /* We need to check for current_function_decl here in case we're
1710 being called during cp_fold_function, because at that point
1711 DECL_INITIAL is set properly and we have a fundef but we
1712 haven't lowered invisirefs yet (c++/70344). */
1713 if (DECL_INITIAL (fun
) == error_mark_node
1714 || fun
== current_function_decl
)
1715 error_at (loc
, "%qD called in a constant expression before its "
1716 "definition is complete", fun
);
1717 else if (DECL_INITIAL (fun
))
1719 /* The definition of fun was somehow unsuitable. But pretend
1720 that lambda static thunks don't exist. */
1721 if (!lambda_static_thunk_p (fun
))
1722 error_at (loc
, "%qD called in a constant expression", fun
);
1723 explain_invalid_constexpr_fn (fun
);
1726 error_at (loc
, "%qD used before its definition", fun
);
1728 *non_constant_p
= true;
1733 bool non_constant_args
= false;
1734 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1735 non_constant_p
, overflow_p
, &non_constant_args
);
1736 if (*non_constant_p
)
1739 depth_ok
= push_cx_call_context (t
);
1741 tree result
= NULL_TREE
;
1743 constexpr_call
*entry
= NULL
;
1744 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1746 new_call
.hash
= constexpr_fundef_hasher::hash (new_call
.fundef
);
1748 = iterative_hash_template_arg (new_call
.bindings
, new_call
.hash
);
1750 = iterative_hash_object (ctx
->manifestly_const_eval
, new_call
.hash
);
1752 /* If we have seen this call before, we are done. */
1753 maybe_initialize_constexpr_call_table ();
1754 constexpr_call
**slot
1755 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1759 /* We need to keep a pointer to the entry, not just the slot, as the
1760 slot can move in the call to cxx_eval_builtin_function_call. */
1761 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1764 /* Calls that are in progress have their result set to NULL,
1765 so that we can detect circular dependencies. */
1766 else if (entry
->result
== NULL
)
1769 error ("call has circular dependency");
1770 *non_constant_p
= true;
1771 entry
->result
= result
= error_mark_node
;
1774 result
= entry
->result
;
1780 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1781 "%<-fconstexpr-depth=%> to increase the maximum)",
1782 max_constexpr_depth
);
1783 *non_constant_p
= true;
1784 result
= error_mark_node
;
1788 if (result
&& result
!= error_mark_node
)
1790 else if (!DECL_SAVED_TREE (fun
))
1792 /* When at_eof >= 2, cgraph has started throwing away
1793 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1794 late code generation for VEC_INIT_EXPR, which needs to be
1795 completely reconsidered. */
1796 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1797 *non_constant_p
= true;
1801 tree body
, parms
, res
;
1803 /* Reuse or create a new unshared copy of this function's body. */
1804 tree copy
= get_fundef_copy (new_call
.fundef
);
1805 body
= TREE_PURPOSE (copy
);
1806 parms
= TREE_VALUE (copy
);
1807 res
= TREE_TYPE (copy
);
1809 /* Associate the bindings with the remapped parms. */
1810 tree bound
= new_call
.bindings
;
1811 tree remapped
= parms
;
1814 tree oparm
= TREE_PURPOSE (bound
);
1815 tree arg
= TREE_VALUE (bound
);
1816 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1817 /* Don't share a CONSTRUCTOR that might be changed. */
1818 arg
= unshare_constructor (arg
);
1819 ctx
->values
->put (remapped
, arg
);
1820 bound
= TREE_CHAIN (bound
);
1821 remapped
= DECL_CHAIN (remapped
);
1823 /* Add the RESULT_DECL to the values map, too. */
1824 tree slot
= NULL_TREE
;
1825 if (DECL_BY_REFERENCE (res
))
1827 slot
= AGGR_INIT_EXPR_SLOT (t
);
1828 tree addr
= build_address (slot
);
1829 addr
= build_nop (TREE_TYPE (res
), addr
);
1830 ctx
->values
->put (res
, addr
);
1831 ctx
->values
->put (slot
, NULL_TREE
);
1834 ctx
->values
->put (res
, NULL_TREE
);
1836 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1837 their values after the call. */
1838 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1839 auto_vec
<tree
, 10> save_exprs
;
1840 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1841 ctx_with_save_exprs
.call
= &new_call
;
1843 tree jump_target
= NULL_TREE
;
1844 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1845 lval
, non_constant_p
, overflow_p
,
1848 if (DECL_CONSTRUCTOR_P (fun
))
1849 /* This can be null for a subobject constructor call, in
1850 which case what we care about is the initialization
1851 side-effects rather than the value. We could get at the
1852 value by evaluating *this, but we don't bother; there's
1853 no need to put such a call in the hash table. */
1854 result
= lval
? ctx
->object
: ctx
->ctor
;
1855 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1859 result
= *ctx
->values
->get (slot
? slot
: res
);
1860 if (result
== NULL_TREE
&& !*non_constant_p
)
1863 error ("%<constexpr%> call flows off the end "
1865 *non_constant_p
= true;
1869 /* Forget the saved values of the callee's SAVE_EXPRs. */
1872 FOR_EACH_VEC_ELT (save_exprs
, i
, save_expr
)
1873 ctx_with_save_exprs
.values
->remove (save_expr
);
1875 /* Remove the parms/result from the values map. Is it worth
1876 bothering to do this when the map itself is only live for
1877 one constexpr evaluation? If so, maybe also clear out
1878 other vars from call, maybe in BIND_EXPR handling? */
1879 ctx
->values
->remove (res
);
1881 ctx
->values
->remove (slot
);
1882 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1883 ctx
->values
->remove (parm
);
1885 /* Make the unshared function copy we used available for re-use. */
1886 save_fundef_copy (fun
, copy
);
1889 if (result
== error_mark_node
)
1890 *non_constant_p
= true;
1891 if (*non_constant_p
|| *overflow_p
)
1892 result
= error_mark_node
;
1896 entry
->result
= result
;
1899 /* The result of a constexpr function must be completely initialized. */
1900 if (TREE_CODE (result
) == CONSTRUCTOR
)
1901 clear_no_implicit_zero (result
);
1903 pop_cx_call_context ();
1904 return unshare_constructor (result
);
1907 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1910 reduced_constant_expression_p (tree t
)
1915 switch (TREE_CODE (t
))
1918 /* Even if we can't lower this yet, it's constant. */
1922 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1923 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1924 if (CONSTRUCTOR_NO_CLEARING (t
))
1926 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1927 /* An initialized vector would have a VECTOR_CST. */
1930 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1934 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1936 /* If VAL is null, we're in the middle of initializing this
1938 if (!reduced_constant_expression_p (val
))
1944 field
= next_initializable_field (DECL_CHAIN (field
));
1949 else if (CONSTRUCTOR_NO_CLEARING (t
))
1950 /* All the fields are initialized. */
1951 CONSTRUCTOR_NO_CLEARING (t
) = false;
1955 /* FIXME are we calling this too much? */
1956 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1960 /* Some expressions may have constant operands but are not constant
1961 themselves, such as 1/0. Call this function to check for that
1964 We only call this in places that require an arithmetic constant, not in
1965 places where we might have a non-constant expression that can be a
1966 component of a constant expression, such as the address of a constexpr
1967 variable that might be dereferenced later. */
1970 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1973 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1975 if (!allow_non_constant
)
1976 error ("%q+E is not a constant expression", t
);
1977 *non_constant_p
= true;
1979 if (TREE_OVERFLOW_P (t
))
1981 if (!allow_non_constant
)
1983 permerror (input_location
, "overflow in constant expression");
1984 /* If we're being permissive (and are in an enforcing
1985 context), ignore the overflow. */
1986 if (flag_permissive
)
1987 return *non_constant_p
;
1991 return *non_constant_p
;
1994 /* Check whether the shift operation with code CODE and type TYPE on LHS
1995 and RHS is undefined. If it is, give an error with an explanation,
1996 and return true; return false otherwise. */
1999 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
2000 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
2002 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
2003 || TREE_CODE (lhs
) != INTEGER_CST
2004 || TREE_CODE (rhs
) != INTEGER_CST
)
2007 tree lhstype
= TREE_TYPE (lhs
);
2008 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
2010 /* [expr.shift] The behavior is undefined if the right operand
2011 is negative, or greater than or equal to the length in bits
2012 of the promoted left operand. */
2013 if (tree_int_cst_sgn (rhs
) == -1)
2016 permerror (loc
, "right operand of shift expression %q+E is negative",
2017 build2_loc (loc
, code
, type
, lhs
, rhs
));
2018 return (!flag_permissive
|| ctx
->quiet
);
2020 if (compare_tree_int (rhs
, uprec
) >= 0)
2023 permerror (loc
, "right operand of shift expression %q+E is greater "
2024 "than or equal to the precision %wu of the left operand",
2025 build2_loc (loc
, code
, type
, lhs
, rhs
), uprec
);
2026 return (!flag_permissive
|| ctx
->quiet
);
2029 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
2030 if E1 has a signed type and non-negative value, and E1x2^E2 is
2031 representable in the corresponding unsigned type of the result type,
2032 then that value, converted to the result type, is the resulting value;
2033 otherwise, the behavior is undefined.
2035 The value of E1 << E2 is the unique value congruent to E1 x 2^E2 modulo
2036 2^N, where N is the range exponent of the type of the result. */
2037 if (code
== LSHIFT_EXPR
2038 && !TYPE_UNSIGNED (lhstype
)
2039 && cxx_dialect
>= cxx11
2040 && cxx_dialect
< cxx2a
)
2042 if (tree_int_cst_sgn (lhs
) == -1)
2046 "left operand of shift expression %q+E is negative",
2047 build2_loc (loc
, code
, type
, lhs
, rhs
));
2048 return (!flag_permissive
|| ctx
->quiet
);
2050 /* For signed x << y the following:
2051 (unsigned) x >> ((prec (lhs) - 1) - y)
2052 if > 1, is undefined. The right-hand side of this formula
2053 is the highest bit of the LHS that can be set (starting from 0),
2054 so that the shift doesn't overflow. We then right-shift the LHS
2055 to see whether any other bit is set making the original shift
2056 undefined -- the result is not representable in the corresponding
2058 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
2059 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
2060 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
2061 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
2062 if (tree_int_cst_lt (integer_one_node
, t
))
2065 permerror (loc
, "shift expression %q+E overflows",
2066 build2_loc (loc
, code
, type
, lhs
, rhs
));
2067 return (!flag_permissive
|| ctx
->quiet
);
2073 /* Subroutine of cxx_eval_constant_expression.
2074 Attempt to reduce the unary expression tree T to a compile time value.
2075 If successful, return the value. Otherwise issue a diagnostic
2076 and return error_mark_node. */
2079 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
2081 bool *non_constant_p
, bool *overflow_p
)
2084 tree orig_arg
= TREE_OPERAND (t
, 0);
2085 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
2086 non_constant_p
, overflow_p
);
2087 VERIFY_CONSTANT (arg
);
2088 location_t loc
= EXPR_LOCATION (t
);
2089 enum tree_code code
= TREE_CODE (t
);
2090 tree type
= TREE_TYPE (t
);
2091 r
= fold_unary_loc (loc
, code
, type
, arg
);
2094 if (arg
== orig_arg
)
2097 r
= build1_loc (loc
, code
, type
, arg
);
2099 VERIFY_CONSTANT (r
);
2103 /* Helper function for cxx_eval_binary_expression. Try to optimize
2104 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
2105 generic folding should be used. */
2108 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
2109 tree lhs
, tree rhs
, bool *non_constant_p
,
2113 if (TREE_CODE (lhs
) != ADDR_EXPR
)
2116 lhs
= TREE_OPERAND (lhs
, 0);
2118 /* &A[i] p+ j => &A[i + j] */
2119 if (TREE_CODE (lhs
) == ARRAY_REF
2120 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
2121 && TREE_CODE (rhs
) == INTEGER_CST
2122 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
2123 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
2125 tree orig_type
= TREE_TYPE (t
);
2126 location_t loc
= EXPR_LOCATION (t
);
2127 tree type
= TREE_TYPE (lhs
);
2129 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
2130 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
2131 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2133 if (*non_constant_p
)
2135 /* Don't fold an out-of-bound access. */
2136 if (!tree_int_cst_le (t
, nelts
))
2138 rhs
= cp_fold_convert (ssizetype
, rhs
);
2139 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
2140 constexpr int A[1]; ... (char *)&A[0] + 1 */
2141 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
2142 rhs
, TYPE_SIZE_UNIT (type
))))
2144 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2146 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
2147 TYPE_SIZE_UNIT (type
));
2148 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
2149 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
2150 t
, NULL_TREE
, NULL_TREE
);
2151 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2152 t
= cp_fold_convert (orig_type
, t
);
2153 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2154 non_constant_p
, overflow_p
);
2160 /* Subroutine of cxx_eval_constant_expression.
2161 Like cxx_eval_unary_expression, except for binary expressions. */
2164 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2166 bool *non_constant_p
, bool *overflow_p
)
2169 tree orig_lhs
= TREE_OPERAND (t
, 0);
2170 tree orig_rhs
= TREE_OPERAND (t
, 1);
2172 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2173 non_constant_p
, overflow_p
);
2174 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2176 if (*non_constant_p
)
2178 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2179 non_constant_p
, overflow_p
);
2180 if (*non_constant_p
)
2183 location_t loc
= EXPR_LOCATION (t
);
2184 enum tree_code code
= TREE_CODE (t
);
2185 tree type
= TREE_TYPE (t
);
2187 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2189 bool is_code_eq
= (code
== EQ_EXPR
);
2191 if (TREE_CODE (lhs
) == PTRMEM_CST
2192 && TREE_CODE (rhs
) == PTRMEM_CST
)
2194 tree lmem
= PTRMEM_CST_MEMBER (lhs
);
2195 tree rmem
= PTRMEM_CST_MEMBER (rhs
);
2197 if (TREE_CODE (lmem
) == TREE_CODE (rmem
)
2198 && TREE_CODE (lmem
) == FIELD_DECL
2199 && TREE_CODE (DECL_CONTEXT (lmem
)) == UNION_TYPE
2200 && same_type_p (DECL_CONTEXT (lmem
),
2201 DECL_CONTEXT (rmem
)))
2202 /* If both refer to (possibly different) members of the same union
2203 (12.3), they compare equal. */
2206 eq
= cp_tree_equal (lhs
, rhs
);
2207 r
= constant_boolean_node (eq
== is_code_eq
, type
);
2209 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2210 || TREE_CODE (rhs
) == PTRMEM_CST
)
2211 && (null_member_pointer_value_p (lhs
)
2212 || null_member_pointer_value_p (rhs
)))
2213 r
= constant_boolean_node (!is_code_eq
, type
);
2214 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2215 lhs
= cplus_expand_constant (lhs
);
2216 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2217 rhs
= cplus_expand_constant (rhs
);
2219 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2220 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2223 error ("arithmetic involving a null pointer in %qE", lhs
);
2224 *non_constant_p
= true;
2227 else if (code
== POINTER_PLUS_EXPR
)
2228 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2232 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2236 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2239 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2241 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2242 *non_constant_p
= true;
2243 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2244 a local array in a constexpr function. */
2245 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (lhs
));
2247 VERIFY_CONSTANT (r
);
2251 /* Subroutine of cxx_eval_constant_expression.
2252 Attempt to evaluate condition expressions. Dead branches are not
2256 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2258 bool *non_constant_p
, bool *overflow_p
,
2261 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2263 non_constant_p
, overflow_p
);
2264 VERIFY_CONSTANT (val
);
2265 /* Don't VERIFY_CONSTANT the other operands. */
2266 if (integer_zerop (val
))
2267 val
= TREE_OPERAND (t
, 2);
2269 val
= TREE_OPERAND (t
, 1);
2270 if (TREE_CODE (t
) == IF_STMT
&& !val
)
2272 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2273 overflow_p
, jump_target
);
2276 /* Subroutine of cxx_eval_constant_expression.
2277 Attempt to evaluate vector condition expressions. Unlike
2278 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2279 ternary arithmetics operation, where all 3 arguments have to be
2280 evaluated as constants and then folding computes the result from
2284 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2285 bool *non_constant_p
, bool *overflow_p
)
2287 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2289 non_constant_p
, overflow_p
);
2290 VERIFY_CONSTANT (arg1
);
2291 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2293 non_constant_p
, overflow_p
);
2294 VERIFY_CONSTANT (arg2
);
2295 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2297 non_constant_p
, overflow_p
);
2298 VERIFY_CONSTANT (arg3
);
2299 location_t loc
= EXPR_LOCATION (t
);
2300 tree type
= TREE_TYPE (t
);
2301 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2304 if (arg1
== TREE_OPERAND (t
, 0)
2305 && arg2
== TREE_OPERAND (t
, 1)
2306 && arg3
== TREE_OPERAND (t
, 2))
2309 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2311 VERIFY_CONSTANT (r
);
2315 /* Returns less than, equal to, or greater than zero if KEY is found to be
2316 less than, to match, or to be greater than the constructor_elt's INDEX. */
2319 array_index_cmp (tree key
, tree index
)
2321 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2323 switch (TREE_CODE (index
))
2326 return tree_int_cst_compare (key
, index
);
2329 tree lo
= TREE_OPERAND (index
, 0);
2330 tree hi
= TREE_OPERAND (index
, 1);
2331 if (tree_int_cst_lt (key
, lo
))
2333 else if (tree_int_cst_lt (hi
, key
))
2343 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2344 if none. If INSERT is true, insert a matching element rather than fail. */
2346 static HOST_WIDE_INT
2347 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
)
2349 if (tree_int_cst_sgn (dindex
) < 0)
2352 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2353 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2354 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2356 unsigned HOST_WIDE_INT end
= len
;
2357 unsigned HOST_WIDE_INT begin
= 0;
2359 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2360 that the same is true of the other elements and index directly. */
2363 tree cindex
= (*elts
)[end
- 1].index
;
2364 if (TREE_CODE (cindex
) == INTEGER_CST
2365 && compare_tree_int (cindex
, end
- 1) == 0)
2374 /* Otherwise, find a matching index by means of a binary search. */
2375 while (begin
!= end
)
2377 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2378 constructor_elt
&elt
= (*elts
)[middle
];
2379 tree idx
= elt
.index
;
2381 int cmp
= array_index_cmp (dindex
, idx
);
2388 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2390 /* We need to split the range. */
2392 tree lo
= TREE_OPERAND (idx
, 0);
2393 tree hi
= TREE_OPERAND (idx
, 1);
2394 tree value
= elt
.value
;
2395 dindex
= fold_convert (sizetype
, dindex
);
2396 if (tree_int_cst_lt (lo
, dindex
))
2398 /* There are still some lower elts; shorten the range. */
2399 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2401 if (tree_int_cst_equal (lo
, new_hi
))
2402 /* Only one element left, no longer a range. */
2405 TREE_OPERAND (idx
, 1) = new_hi
;
2406 /* Append the element we want to insert. */
2409 e
.value
= unshare_constructor (value
);
2410 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2413 /* No lower elts, the range elt is now ours. */
2416 if (tree_int_cst_lt (dindex
, hi
))
2418 /* There are still some higher elts; append a range. */
2419 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2421 if (tree_int_cst_equal (new_lo
, hi
))
2424 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2425 e
.value
= unshare_constructor (value
);
2426 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2435 constructor_elt e
= { dindex
, NULL_TREE
};
2436 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2443 /* Under the control of CTX, issue a detailed diagnostic for
2444 an out-of-bounds subscript INDEX into the expression ARRAY. */
2447 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2451 tree arraytype
= TREE_TYPE (array
);
2453 /* Convert the unsigned array subscript to a signed integer to avoid
2454 printing huge numbers for small negative values. */
2455 tree sidx
= fold_convert (ssizetype
, index
);
2458 if (TYPE_DOMAIN (arraytype
))
2459 error ("array subscript value %qE is outside the bounds "
2460 "of array %qD of type %qT", sidx
, array
, arraytype
);
2462 error ("non-zero array subscript %qE is used with array %qD of "
2463 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2464 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2466 else if (TYPE_DOMAIN (arraytype
))
2467 error ("array subscript value %qE is outside the bounds "
2468 "of array type %qT", sidx
, arraytype
);
2470 error ("non-zero array subscript %qE is used with array of type %qT "
2471 "with unknown bounds", sidx
, arraytype
);
2475 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2479 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2480 bool *non_constant_p
, bool *overflow_p
)
2483 if (TREE_CODE (type
) == ARRAY_TYPE
)
2485 if (TYPE_DOMAIN (type
))
2486 nelts
= array_type_nelts_top (type
);
2488 nelts
= size_zero_node
;
2490 else if (VECTOR_TYPE_P (type
))
2491 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2495 /* For VLAs, the number of elements won't be an integer constant. */
2496 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2497 non_constant_p
, overflow_p
);
2501 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2502 STRING_CST STRING. */
2505 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2507 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2510 if (chars_per_elt
== 1)
2511 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2514 const unsigned char *ptr
2515 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2516 + index
* chars_per_elt
);
2517 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2522 /* Subroutine of cxx_eval_constant_expression.
2523 Attempt to reduce a reference to an array slot. */
2526 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2528 bool *non_constant_p
, bool *overflow_p
)
2530 tree oldary
= TREE_OPERAND (t
, 0);
2531 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2533 non_constant_p
, overflow_p
);
2535 HOST_WIDE_INT i
= 0;
2536 tree elem_type
= NULL_TREE
;
2537 unsigned len
= 0, elem_nchars
= 1;
2538 if (*non_constant_p
)
2540 oldidx
= TREE_OPERAND (t
, 1);
2541 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2543 non_constant_p
, overflow_p
);
2544 VERIFY_CONSTANT (index
);
2547 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2548 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2549 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2550 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2551 ary
= TREE_OPERAND (ary
, 0);
2552 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2553 len
= CONSTRUCTOR_NELTS (ary
);
2554 else if (TREE_CODE (ary
) == STRING_CST
)
2556 elem_nchars
= (TYPE_PRECISION (elem_type
)
2557 / TYPE_PRECISION (char_type_node
));
2558 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2560 else if (TREE_CODE (ary
) == VECTOR_CST
)
2561 /* We don't create variable-length VECTOR_CSTs. */
2562 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2565 /* We can't do anything with other tree codes, so use
2566 VERIFY_CONSTANT to complain and fail. */
2567 VERIFY_CONSTANT (ary
);
2571 if (!tree_fits_shwi_p (index
)
2572 || (i
= tree_to_shwi (index
)) < 0)
2574 diag_array_subscript (ctx
, ary
, index
);
2575 *non_constant_p
= true;
2580 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2582 VERIFY_CONSTANT (nelts
);
2584 ? !tree_int_cst_le (index
, nelts
)
2585 : !tree_int_cst_lt (index
, nelts
))
2586 || tree_int_cst_sgn (index
) < 0)
2588 diag_array_subscript (ctx
, ary
, index
);
2589 *non_constant_p
= true;
2593 if (lval
&& ary
== oldary
&& index
== oldidx
)
2596 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2599 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2601 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2612 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2613 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2614 else if (TREE_CODE (ary
) == VECTOR_CST
)
2615 r
= VECTOR_CST_ELT (ary
, i
);
2617 r
= extract_string_elt (ary
, elem_nchars
, i
);
2620 /* Don't VERIFY_CONSTANT here. */
2623 /* Otherwise the element doesn't have a value yet. */
2628 if (TREE_CODE (ary
) == CONSTRUCTOR
2629 && CONSTRUCTOR_NO_CLEARING (ary
))
2631 /* 'ary' is part of the aggregate initializer we're currently
2632 building; if there's no initializer for this element yet,
2635 error ("accessing uninitialized array element");
2636 *non_constant_p
= true;
2640 /* If it's within the array bounds but doesn't have an explicit
2641 initializer, it's value-initialized. */
2642 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2643 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2647 /* Subroutine of cxx_eval_constant_expression.
2648 Attempt to reduce a field access of a value of class type. */
2651 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2653 bool *non_constant_p
, bool *overflow_p
)
2655 unsigned HOST_WIDE_INT i
;
2658 tree part
= TREE_OPERAND (t
, 1);
2659 tree orig_whole
= TREE_OPERAND (t
, 0);
2660 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2662 non_constant_p
, overflow_p
);
2663 if (INDIRECT_REF_P (whole
)
2664 && integer_zerop (TREE_OPERAND (whole
, 0)))
2667 error ("dereferencing a null pointer in %qE", orig_whole
);
2668 *non_constant_p
= true;
2672 if (TREE_CODE (whole
) == PTRMEM_CST
)
2673 whole
= cplus_expand_constant (whole
);
2674 if (whole
== orig_whole
)
2677 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2678 whole
, part
, NULL_TREE
);
2679 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2681 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2684 error ("%qE is not a constant expression", orig_whole
);
2685 *non_constant_p
= true;
2687 if (DECL_MUTABLE_P (part
))
2690 error ("mutable %qD is not usable in a constant expression", part
);
2691 *non_constant_p
= true;
2693 if (*non_constant_p
)
2695 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2696 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2698 /* Use name match for PMF fields, as a variant will have a
2699 different FIELD_DECL with a different type. */
2700 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2706 /* We're in the middle of initializing it. */
2710 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2711 && CONSTRUCTOR_NELTS (whole
) > 0)
2713 /* DR 1188 says we don't have to deal with this. */
2715 error ("accessing %qD member instead of initialized %qD member in "
2716 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2717 *non_constant_p
= true;
2721 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2722 classes never get represented; throw together a value now. */
2723 if (is_really_empty_class (TREE_TYPE (t
), /*ignore_vptr*/false))
2724 return build_constructor (TREE_TYPE (t
), NULL
);
2726 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2728 if (CONSTRUCTOR_NO_CLEARING (whole
))
2730 /* 'whole' is part of the aggregate initializer we're currently
2731 building; if there's no initializer for this member yet, that's an
2734 error ("accessing uninitialized member %qD", part
);
2735 *non_constant_p
= true;
2739 /* If there's no explicit init for this field, it's value-initialized. */
2740 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2741 return cxx_eval_constant_expression (ctx
, value
,
2743 non_constant_p
, overflow_p
);
2746 /* Subroutine of cxx_eval_constant_expression.
2747 Attempt to reduce a field access of a value of class type that is
2748 expressed as a BIT_FIELD_REF. */
2751 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2753 bool *non_constant_p
, bool *overflow_p
)
2755 tree orig_whole
= TREE_OPERAND (t
, 0);
2756 tree retval
, fldval
, utype
, mask
;
2757 bool fld_seen
= false;
2758 HOST_WIDE_INT istart
, isize
;
2759 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2761 non_constant_p
, overflow_p
);
2762 tree start
, field
, value
;
2763 unsigned HOST_WIDE_INT i
;
2765 if (whole
== orig_whole
)
2767 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2769 if (!*non_constant_p
2770 && TREE_CODE (whole
) != VECTOR_CST
2771 && TREE_CODE (whole
) != CONSTRUCTOR
)
2774 error ("%qE is not a constant expression", orig_whole
);
2775 *non_constant_p
= true;
2777 if (*non_constant_p
)
2780 if (TREE_CODE (whole
) == VECTOR_CST
)
2781 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2782 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2784 start
= TREE_OPERAND (t
, 2);
2785 istart
= tree_to_shwi (start
);
2786 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2787 utype
= TREE_TYPE (t
);
2788 if (!TYPE_UNSIGNED (utype
))
2789 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2790 retval
= build_int_cst (utype
, 0);
2791 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2793 tree bitpos
= bit_position (field
);
2794 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2796 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2797 && TREE_CODE (value
) == INTEGER_CST
2798 && tree_fits_shwi_p (bitpos
)
2799 && tree_fits_shwi_p (DECL_SIZE (field
)))
2801 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2802 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2803 HOST_WIDE_INT shift
;
2804 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2806 fldval
= fold_convert (utype
, value
);
2807 mask
= build_int_cst_type (utype
, -1);
2808 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2809 size_int (TYPE_PRECISION (utype
) - sz
));
2810 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2811 size_int (TYPE_PRECISION (utype
) - sz
));
2812 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2813 shift
= bit
- istart
;
2814 if (BYTES_BIG_ENDIAN
)
2815 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2816 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2818 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2824 return fold_convert (TREE_TYPE (t
), retval
);
2826 return error_mark_node
;
2829 /* Subroutine of cxx_eval_constant_expression.
2830 Evaluate a short-circuited logical expression T in the context
2831 of a given constexpr CALL. BAILOUT_VALUE is the value for
2832 early return. CONTINUE_VALUE is used here purely for
2833 sanity check purposes. */
2836 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2837 tree bailout_value
, tree continue_value
,
2839 bool *non_constant_p
, bool *overflow_p
)
2842 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2844 non_constant_p
, overflow_p
);
2845 VERIFY_CONSTANT (lhs
);
2846 if (tree_int_cst_equal (lhs
, bailout_value
))
2848 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2849 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2850 lval
, non_constant_p
,
2852 VERIFY_CONSTANT (r
);
2856 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2857 CONSTRUCTOR elements to initialize (part of) an object containing that
2858 field. Return a pointer to the constructor_elt corresponding to the
2859 initialization of the field. */
2861 static constructor_elt
*
2862 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2864 tree aggr
= TREE_OPERAND (ref
, 0);
2865 tree field
= TREE_OPERAND (ref
, 1);
2867 constructor_elt
*ce
;
2869 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2871 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2873 constructor_elt
*base_ce
2874 = base_field_constructor_elt (v
, aggr
);
2875 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2878 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2879 if (ce
->index
== field
)
2886 /* Some of the expressions fed to the constexpr mechanism are calls to
2887 constructors, which have type void. In that case, return the type being
2888 initialized by the constructor. */
2891 initialized_type (tree t
)
2895 tree type
= TREE_TYPE (t
);
2896 if (TREE_CODE (t
) == CALL_EXPR
)
2898 /* A constructor call has void type, so we need to look deeper. */
2899 tree fn
= get_function_named_in_call (t
);
2900 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2901 && DECL_CXX_CONSTRUCTOR_P (fn
))
2902 type
= DECL_CONTEXT (fn
);
2904 else if (TREE_CODE (t
) == COMPOUND_EXPR
)
2905 return initialized_type (TREE_OPERAND (t
, 1));
2906 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
2907 type
= TREE_TYPE (AGGR_INIT_EXPR_SLOT (t
));
2908 return cv_unqualified (type
);
2911 /* We're about to initialize element INDEX of an array or class from VALUE.
2912 Set up NEW_CTX appropriately by adjusting .object to refer to the
2913 subobject and creating a new CONSTRUCTOR if the element is itself
2914 a class or array. */
2917 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2918 tree index
, tree
&value
)
2922 if (index
&& TREE_CODE (index
) != INTEGER_CST
2923 && TREE_CODE (index
) != FIELD_DECL
)
2924 /* This won't have an element in the new CONSTRUCTOR. */
2927 tree type
= initialized_type (value
);
2928 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2929 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2932 /* The sub-aggregate initializer might contain a placeholder;
2933 update object to refer to the subobject and ctor to refer to
2934 the (newly created) sub-initializer. */
2936 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2937 tree elt
= build_constructor (type
, NULL
);
2938 CONSTRUCTOR_NO_CLEARING (elt
) = true;
2941 if (TREE_CODE (value
) == TARGET_EXPR
)
2942 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2943 value
= TARGET_EXPR_INITIAL (value
);
2946 /* We're about to process an initializer for a class or array TYPE. Make
2947 sure that CTX is set up appropriately. */
2950 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2952 /* We don't bother building a ctor for an empty base subobject. */
2953 if (is_empty_class (type
))
2956 /* We're in the middle of an initializer that might involve placeholders;
2957 our caller should have created a CONSTRUCTOR for us to put the
2958 initializer into. We will either return that constructor or T. */
2959 gcc_assert (ctx
->ctor
);
2960 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2961 (type
, TREE_TYPE (ctx
->ctor
)));
2962 /* We used to check that ctx->ctor was empty, but that isn't the case when
2963 the object is zero-initialized before calling the constructor. */
2966 tree otype
= TREE_TYPE (ctx
->object
);
2967 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2968 /* Handle flexible array members. */
2969 || (TREE_CODE (otype
) == ARRAY_TYPE
2970 && TYPE_DOMAIN (otype
) == NULL_TREE
2971 && TREE_CODE (type
) == ARRAY_TYPE
2972 && (same_type_ignoring_top_level_qualifiers_p
2973 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2975 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2976 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2979 /* Subroutine of cxx_eval_constant_expression.
2980 The expression tree T denotes a C-style array or a C-style
2981 aggregate. Reduce it to a constant expression. */
2984 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2986 bool *non_constant_p
, bool *overflow_p
)
2988 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2989 bool changed
= false;
2990 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2991 tree type
= TREE_TYPE (t
);
2993 constexpr_ctx new_ctx
;
2994 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2996 /* We don't really need the ctx->ctor business for a PMF or
2997 vector, but it's simpler to use the same code. */
2999 new_ctx
.ctor
= build_constructor (type
, NULL
);
3000 new_ctx
.object
= NULL_TREE
;
3003 verify_ctor_sanity (ctx
, type
);
3004 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
3005 vec_alloc (*p
, vec_safe_length (v
));
3009 bool constant_p
= true;
3010 bool side_effects_p
= false;
3011 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
3013 tree orig_value
= value
;
3014 init_subob_ctx (ctx
, new_ctx
, index
, value
);
3015 if (new_ctx
.ctor
!= ctx
->ctor
)
3016 /* If we built a new CONSTRUCTOR, attach it now so that other
3017 initializers can refer to it. */
3018 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
3019 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
3021 non_constant_p
, overflow_p
);
3022 /* Don't VERIFY_CONSTANT here. */
3023 if (ctx
->quiet
&& *non_constant_p
)
3025 if (elt
!= orig_value
)
3028 if (!TREE_CONSTANT (elt
))
3030 if (TREE_SIDE_EFFECTS (elt
))
3031 side_effects_p
= true;
3032 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
3034 /* This is an initialization of a vfield inside a base
3035 subaggregate that we already initialized; push this
3036 initialization into the previous initialization. */
3037 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
3042 && (TREE_CODE (index
) == NOP_EXPR
3043 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
3045 /* This is an initializer for an empty base; now that we've
3046 checked that it's constant, we can ignore it. */
3047 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
3052 if (new_ctx
.ctor
!= ctx
->ctor
)
3054 /* We appended this element above; update the value. */
3055 gcc_assert ((*p
)->last().index
== index
);
3056 (*p
)->last().value
= elt
;
3059 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
3060 /* Adding or replacing an element might change the ctor's flags. */
3061 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
3062 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
3065 if (*non_constant_p
|| !changed
)
3068 /* We're done building this CONSTRUCTOR, so now we can interpret an
3069 element without an explicit initializer as value-initialized. */
3070 CONSTRUCTOR_NO_CLEARING (t
) = false;
3071 TREE_CONSTANT (t
) = constant_p
;
3072 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
3073 if (VECTOR_TYPE_P (type
))
3078 /* Subroutine of cxx_eval_constant_expression.
3079 The expression tree T is a VEC_INIT_EXPR which denotes the desired
3080 initialization of a non-static data member of array type. Reduce it to a
3083 Note that apart from value-initialization (when VALUE_INIT is true),
3084 this is only intended to support value-initialization and the
3085 initializations done by defaulted constructors for classes with
3086 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
3087 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
3088 for the copy/move constructor. */
3091 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
3092 bool value_init
, bool lval
,
3093 bool *non_constant_p
, bool *overflow_p
)
3095 tree elttype
= TREE_TYPE (atype
);
3096 verify_ctor_sanity (ctx
, atype
);
3097 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
3098 bool pre_init
= false;
3099 unsigned HOST_WIDE_INT i
;
3100 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
3102 /* For the default constructor, build up a call to the default
3103 constructor of the element type. We only need to handle class types
3104 here, as for a constructor to be constexpr, all members must be
3105 initialized, which for a defaulted default constructor means they must
3106 be of a class type with a constexpr default constructor. */
3107 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3108 /* We only do this at the lowest level. */;
3109 else if (value_init
)
3111 init
= build_value_init (elttype
, complain
);
3116 releasing_vec argvec
;
3117 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
3118 &argvec
, elttype
, LOOKUP_NORMAL
,
3120 init
= build_aggr_init_expr (elttype
, init
);
3124 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
3126 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
3127 for (i
= 0; i
< max
; ++i
)
3129 tree idx
= build_int_cst (size_type_node
, i
);
3132 constexpr_ctx new_ctx
;
3133 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
3134 if (new_ctx
.ctor
!= ctx
->ctor
)
3135 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
3136 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3138 /* A multidimensional array; recurse. */
3139 if (value_init
|| init
== NULL_TREE
)
3141 eltinit
= NULL_TREE
;
3145 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3146 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
3148 non_constant_p
, overflow_p
);
3152 /* Initializing an element using value or default initialization
3153 we just pre-built above. */
3154 if (init
== void_node
)
3155 /* Trivial default-init, don't do anything to the CONSTRUCTOR. */
3157 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
3158 non_constant_p
, overflow_p
);
3163 /* Copying an element. */
3164 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3165 (atype
, TREE_TYPE (init
)));
3166 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3167 if (!lvalue_p (init
))
3168 eltinit
= move (eltinit
);
3169 eltinit
= force_rvalue (eltinit
, complain
);
3170 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
3171 non_constant_p
, overflow_p
);
3173 if (*non_constant_p
&& !ctx
->quiet
)
3175 if (new_ctx
.ctor
!= ctx
->ctor
)
3177 /* We appended this element above; update the value. */
3178 gcc_assert ((*p
)->last().index
== idx
);
3179 (*p
)->last().value
= eltinit
;
3182 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3183 /* Reuse the result of cxx_eval_constant_expression call
3184 from the first iteration to all others if it is a constant
3185 initializer that doesn't require relocations. */
3188 && (eltinit
== NULL_TREE
3189 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3190 == null_pointer_node
)))
3192 if (new_ctx
.ctor
!= ctx
->ctor
)
3193 eltinit
= new_ctx
.ctor
;
3194 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3195 build_int_cst (size_type_node
, 1),
3196 build_int_cst (size_type_node
, max
- 1));
3197 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3201 vec_safe_reserve (*p
, max
);
3204 if (!*non_constant_p
)
3207 CONSTRUCTOR_NO_CLEARING (init
) = false;
3213 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3215 bool *non_constant_p
, bool *overflow_p
)
3217 tree atype
= TREE_TYPE (t
);
3218 tree init
= VEC_INIT_EXPR_INIT (t
);
3219 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3220 VEC_INIT_EXPR_VALUE_INIT (t
),
3221 lval
, non_constant_p
, overflow_p
);
3222 if (*non_constant_p
)
3228 /* Like same_type_ignoring_top_level_qualifiers_p, but also handle the case
3229 where the desired type is an array of unknown bounds because the variable
3230 has had its bounds deduced since the wrapping expression was created. */
3233 same_type_ignoring_tlq_and_bounds_p (tree type1
, tree type2
)
3235 while (TREE_CODE (type1
) == ARRAY_TYPE
3236 && TREE_CODE (type2
) == ARRAY_TYPE
3237 && (!TYPE_DOMAIN (type1
) || !TYPE_DOMAIN (type2
)))
3239 type1
= TREE_TYPE (type1
);
3240 type2
= TREE_TYPE (type2
);
3242 return same_type_ignoring_top_level_qualifiers_p (type1
, type2
);
3245 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3246 match. We want to be less strict for simple *& folding; if we have a
3247 non-const temporary that we access through a const pointer, that should
3248 work. We handle this here rather than change fold_indirect_ref_1
3249 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3250 don't really make sense outside of constant expression evaluation. Also
3251 we want to allow folding to COMPONENT_REF, which could cause trouble
3252 with TBAA in fold_indirect_ref_1.
3254 Try to keep this function synced with fold_indirect_ref_1. */
3257 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3261 poly_uint64 const_op01
;
3264 subtype
= TREE_TYPE (sub
);
3265 if (!INDIRECT_TYPE_P (subtype
))
3268 if (TREE_CODE (sub
) == ADDR_EXPR
)
3270 tree op
= TREE_OPERAND (sub
, 0);
3271 tree optype
= TREE_TYPE (op
);
3273 /* *&CONST_DECL -> to the value of the const decl. */
3274 if (TREE_CODE (op
) == CONST_DECL
)
3275 return DECL_INITIAL (op
);
3276 /* *&p => p; make sure to handle *&"str"[cst] here. */
3277 if (same_type_ignoring_tlq_and_bounds_p (optype
, type
))
3279 tree fop
= fold_read_from_constant_string (op
);
3285 /* *(foo *)&fooarray => fooarray[0] */
3286 else if (TREE_CODE (optype
) == ARRAY_TYPE
3287 && (same_type_ignoring_top_level_qualifiers_p
3288 (type
, TREE_TYPE (optype
))))
3290 tree type_domain
= TYPE_DOMAIN (optype
);
3291 tree min_val
= size_zero_node
;
3292 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3293 min_val
= TYPE_MIN_VALUE (type_domain
);
3294 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3295 NULL_TREE
, NULL_TREE
);
3297 /* *(foo *)&complexfoo => __real__ complexfoo */
3298 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3299 && (same_type_ignoring_top_level_qualifiers_p
3300 (type
, TREE_TYPE (optype
))))
3301 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3302 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3303 else if (VECTOR_TYPE_P (optype
)
3304 && (same_type_ignoring_top_level_qualifiers_p
3305 (type
, TREE_TYPE (optype
))))
3307 tree part_width
= TYPE_SIZE (type
);
3308 tree index
= bitsize_int (0);
3309 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3312 /* Also handle conversion to an empty base class, which
3313 is represented with a NOP_EXPR. */
3314 else if (is_empty_class (type
)
3315 && CLASS_TYPE_P (optype
)
3316 && DERIVED_FROM_P (type
, optype
))
3321 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3322 else if (RECORD_OR_UNION_TYPE_P (optype
))
3324 tree field
= TYPE_FIELDS (optype
);
3325 for (; field
; field
= DECL_CHAIN (field
))
3326 if (TREE_CODE (field
) == FIELD_DECL
3327 && TREE_TYPE (field
) != error_mark_node
3328 && integer_zerop (byte_position (field
))
3329 && (same_type_ignoring_top_level_qualifiers_p
3330 (TREE_TYPE (field
), type
)))
3331 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3334 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3335 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3337 tree op00
= TREE_OPERAND (sub
, 0);
3338 tree op01
= TREE_OPERAND (sub
, 1);
3341 if (TREE_CODE (op00
) == ADDR_EXPR
)
3344 op00
= TREE_OPERAND (op00
, 0);
3345 op00type
= TREE_TYPE (op00
);
3347 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3348 if (VECTOR_TYPE_P (op00type
)
3349 && same_type_ignoring_top_level_qualifiers_p
3350 (type
, TREE_TYPE (op00type
))
3351 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3352 but we want to treat offsets with MSB set as negative.
3353 For the code below negative offsets are invalid and
3354 TYPE_SIZE of the element is something unsigned, so
3355 check whether op01 fits into poly_int64, which implies
3356 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3357 then just use poly_uint64 because we want to treat the
3358 value as unsigned. */
3359 && tree_fits_poly_int64_p (op01
))
3361 tree part_width
= TYPE_SIZE (type
);
3362 poly_uint64 max_offset
3363 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3364 * TYPE_VECTOR_SUBPARTS (op00type
));
3365 if (known_lt (const_op01
, max_offset
))
3367 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3368 return fold_build3_loc (loc
,
3369 BIT_FIELD_REF
, type
, op00
,
3373 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3374 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3375 && (same_type_ignoring_top_level_qualifiers_p
3376 (type
, TREE_TYPE (op00type
))))
3378 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3380 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3382 /* ((foo *)&fooarray)[1] => fooarray[1] */
3383 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3384 && (same_type_ignoring_top_level_qualifiers_p
3385 (type
, TREE_TYPE (op00type
))))
3387 tree type_domain
= TYPE_DOMAIN (op00type
);
3388 tree min_val
= size_zero_node
;
3389 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3390 min_val
= TYPE_MIN_VALUE (type_domain
);
3391 offset_int off
= wi::to_offset (op01
);
3392 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3393 offset_int remainder
;
3394 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3395 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3397 off
= off
+ wi::to_offset (min_val
);
3398 op01
= wide_int_to_tree (sizetype
, off
);
3399 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3400 NULL_TREE
, NULL_TREE
);
3403 /* Also handle conversion to an empty base class, which
3404 is represented with a NOP_EXPR. */
3405 else if (is_empty_class (type
)
3406 && CLASS_TYPE_P (op00type
)
3407 && DERIVED_FROM_P (type
, op00type
))
3412 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3413 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3415 tree field
= TYPE_FIELDS (op00type
);
3416 for (; field
; field
= DECL_CHAIN (field
))
3417 if (TREE_CODE (field
) == FIELD_DECL
3418 && TREE_TYPE (field
) != error_mark_node
3419 && tree_int_cst_equal (byte_position (field
), op01
)
3420 && (same_type_ignoring_top_level_qualifiers_p
3421 (TREE_TYPE (field
), type
)))
3422 return fold_build3 (COMPONENT_REF
, type
, op00
,
3427 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3428 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3429 && (same_type_ignoring_top_level_qualifiers_p
3430 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3433 tree min_val
= size_zero_node
;
3435 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3439 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3440 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3441 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3442 min_val
= TYPE_MIN_VALUE (type_domain
);
3443 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3451 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3453 bool *non_constant_p
, bool *overflow_p
)
3455 tree orig_op0
= TREE_OPERAND (t
, 0);
3456 bool empty_base
= false;
3458 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3459 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3461 if (TREE_CODE (t
) == MEM_REF
3462 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3464 gcc_assert (ctx
->quiet
);
3465 *non_constant_p
= true;
3469 /* First try to simplify it directly. */
3470 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3474 /* If that didn't work, evaluate the operand first. */
3475 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3476 /*lval*/false, non_constant_p
,
3478 /* Don't VERIFY_CONSTANT here. */
3479 if (*non_constant_p
)
3482 if (!lval
&& integer_zerop (op0
))
3485 error ("dereferencing a null pointer");
3486 *non_constant_p
= true;
3490 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3494 /* We couldn't fold to a constant value. Make sure it's not
3495 something we should have been able to fold. */
3498 if (TREE_CODE (sub
) == ADDR_EXPR
)
3500 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3501 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3502 /* DR 1188 says we don't have to deal with this. */
3504 error ("accessing value of %qE through a %qT glvalue in a "
3505 "constant expression", build_fold_indirect_ref (sub
),
3507 *non_constant_p
= true;
3511 if (lval
&& op0
!= orig_op0
)
3512 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3514 VERIFY_CONSTANT (t
);
3519 r
= cxx_eval_constant_expression (ctx
, r
,
3520 lval
, non_constant_p
, overflow_p
);
3521 if (*non_constant_p
)
3524 /* If we're pulling out the value of an empty base, just return an empty
3526 if (empty_base
&& !lval
)
3528 r
= build_constructor (TREE_TYPE (t
), NULL
);
3529 TREE_CONSTANT (r
) = true;
3535 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3536 Shared between potential_constant_expression and
3537 cxx_eval_constant_expression. */
3540 non_const_var_error (tree r
)
3542 tree type
= TREE_TYPE (r
);
3543 error ("the value of %qD is not usable in a constant "
3545 /* Avoid error cascade. */
3546 if (DECL_INITIAL (r
) == error_mark_node
)
3548 if (DECL_DECLARED_CONSTEXPR_P (r
))
3549 inform (DECL_SOURCE_LOCATION (r
),
3550 "%qD used in its own initializer", r
);
3551 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3553 if (!CP_TYPE_CONST_P (type
))
3554 inform (DECL_SOURCE_LOCATION (r
),
3555 "%q#D is not const", r
);
3556 else if (CP_TYPE_VOLATILE_P (type
))
3557 inform (DECL_SOURCE_LOCATION (r
),
3558 "%q#D is volatile", r
);
3559 else if (!DECL_INITIAL (r
)
3560 || !TREE_CONSTANT (DECL_INITIAL (r
))
3561 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3562 inform (DECL_SOURCE_LOCATION (r
),
3563 "%qD was not initialized with a constant "
3568 else if (TYPE_REF_P (type
))
3569 inform (DECL_SOURCE_LOCATION (r
),
3570 "%qD was not initialized with a constant "
3574 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3575 inform (DECL_SOURCE_LOCATION (r
),
3576 "%qD was not declared %<constexpr%>", r
);
3578 inform (DECL_SOURCE_LOCATION (r
),
3579 "%qD does not have integral or enumeration type",
3584 /* Subroutine of cxx_eval_constant_expression.
3585 Like cxx_eval_unary_expression, except for trinary expressions. */
3588 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3590 bool *non_constant_p
, bool *overflow_p
)
3596 for (i
= 0; i
< 3; i
++)
3598 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3600 non_constant_p
, overflow_p
);
3601 VERIFY_CONSTANT (args
[i
]);
3604 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3605 args
[0], args
[1], args
[2]);
3606 if (val
== NULL_TREE
)
3608 VERIFY_CONSTANT (val
);
3612 /* True if T was declared in a function declared to be constexpr, and
3613 therefore potentially constant in C++14. */
3616 var_in_constexpr_fn (tree t
)
3618 tree ctx
= DECL_CONTEXT (t
);
3619 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3620 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3623 /* True if T was declared in a function that might be constexpr: either a
3624 function that was declared constexpr, or a C++17 lambda op(). */
3627 var_in_maybe_constexpr_fn (tree t
)
3629 if (cxx_dialect
>= cxx17
3630 && DECL_FUNCTION_SCOPE_P (t
)
3631 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3633 return var_in_constexpr_fn (t
);
3636 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3637 build_over_call we implement trivial copy of a class with tail padding using
3638 assignment of character arrays, which is valid in normal code, but not in
3639 constexpr evaluation. We don't need to worry about clobbering tail padding
3640 in constexpr evaluation, so strip the type punning. */
3643 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3645 if (TREE_CODE (target
) == MEM_REF
3646 && TREE_CODE (init
) == MEM_REF
3647 && TREE_TYPE (target
) == TREE_TYPE (init
)
3648 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3649 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3651 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3652 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3656 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3659 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3661 bool *non_constant_p
, bool *overflow_p
)
3663 constexpr_ctx new_ctx
= *ctx
;
3665 tree init
= TREE_OPERAND (t
, 1);
3666 if (TREE_CLOBBER_P (init
))
3667 /* Just ignore clobbers. */
3670 /* First we figure out where we're storing to. */
3671 tree target
= TREE_OPERAND (t
, 0);
3673 maybe_simplify_trivial_copy (target
, init
);
3675 tree type
= TREE_TYPE (target
);
3676 bool preeval
= SCALAR_TYPE_P (type
) || TREE_CODE (t
) == MODIFY_EXPR
;
3679 /* Evaluate the value to be stored without knowing what object it will be
3680 stored in, so that any side-effects happen first. */
3681 if (!SCALAR_TYPE_P (type
))
3682 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3683 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3684 non_constant_p
, overflow_p
);
3685 if (*non_constant_p
)
3688 target
= cxx_eval_constant_expression (ctx
, target
,
3690 non_constant_p
, overflow_p
);
3691 if (*non_constant_p
)
3694 /* cxx_eval_array_reference for lval = true allows references one past
3695 end of array, because it does not know if it is just taking address
3696 (which is valid), or actual dereference. Here we know it is
3697 a dereference, so diagnose it here. */
3698 for (tree probe
= target
; probe
; )
3700 switch (TREE_CODE (probe
))
3704 ary
= TREE_OPERAND (probe
, 0);
3705 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3706 non_constant_p
, overflow_p
);
3707 VERIFY_CONSTANT (nelts
);
3708 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3709 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3710 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3712 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3713 *non_constant_p
= true;
3720 probe
= TREE_OPERAND (probe
, 0);
3729 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3731 /* For initialization of an empty base, the original target will be
3732 *(base*)this, which the above evaluation resolves to the object
3733 argument, which has the derived type rather than the base type. In
3734 this situation, just evaluate the initializer and return, since
3735 there's no actual data to store. */
3736 gcc_assert (is_empty_class (type
));
3737 return cxx_eval_constant_expression (ctx
, init
, false,
3738 non_constant_p
, overflow_p
);
3741 /* And then find the underlying variable. */
3743 tree object
= NULL_TREE
;
3744 for (tree probe
= target
; object
== NULL_TREE
; )
3746 switch (TREE_CODE (probe
))
3751 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3752 vec_safe_push (refs
, TREE_TYPE (probe
));
3753 probe
= TREE_OPERAND (probe
, 0);
3761 /* And then find/build up our initializer for the path to the subobject
3762 we're initializing. */
3764 if (object
== ctx
->object
&& VAR_P (object
)
3765 && DECL_NAME (object
) && ctx
->call
== NULL
)
3766 /* The variable we're building up an aggregate initializer for is outside
3767 the constant-expression, so don't evaluate the store. We check
3768 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3770 else if (DECL_P (object
))
3771 valp
= ctx
->values
->get (object
);
3776 /* A constant-expression cannot modify objects from outside the
3777 constant-expression. */
3779 error ("modification of %qE is not a constant expression", object
);
3780 *non_constant_p
= true;
3783 type
= TREE_TYPE (object
);
3784 bool no_zero_init
= true;
3786 releasing_vec ctors
;
3787 while (!refs
->is_empty())
3789 if (*valp
== NULL_TREE
)
3791 *valp
= build_constructor (type
, NULL
);
3792 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3794 else if (TREE_CODE (*valp
) == STRING_CST
)
3796 /* An array was initialized with a string constant, and now
3797 we're writing into one of its elements. Explode the
3798 single initialization into a set of element
3800 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3802 tree string
= *valp
;
3803 tree elt_type
= TREE_TYPE (type
);
3804 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3805 / TYPE_PRECISION (char_type_node
));
3806 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3807 tree ary_ctor
= build_constructor (type
, NULL
);
3809 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3810 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3812 constructor_elt elt
=
3814 build_int_cst (size_type_node
, ix
),
3815 extract_string_elt (string
, chars_per_elt
, ix
)
3817 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3823 /* If the value of object is already zero-initialized, any new ctors for
3824 subobjects will also be zero-initialized. */
3825 no_zero_init
= CONSTRUCTOR_NO_CLEARING (*valp
);
3827 vec_safe_push (ctors
, *valp
);
3829 enum tree_code code
= TREE_CODE (type
);
3831 tree index
= refs
->pop();
3833 constructor_elt
*cep
= NULL
;
3834 if (code
== ARRAY_TYPE
)
3837 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3838 gcc_assert (i
>= 0);
3839 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3840 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3844 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3846 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3847 Usually we meet initializers in that order, but it is
3848 possible for base types to be placed not in program
3850 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3851 unsigned HOST_WIDE_INT idx
;
3853 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3854 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3856 if (cxx_dialect
< cxx2a
)
3859 error_at (cp_expr_loc_or_loc (t
, input_location
),
3860 "change of the active member of a union "
3862 CONSTRUCTOR_ELT (*valp
, 0)->index
,
3864 *non_constant_p
= true;
3866 /* Changing active member. */
3867 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3868 no_zero_init
= true;
3872 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3873 idx
++, fields
= DECL_CHAIN (fields
))
3875 if (index
== cep
->index
)
3878 /* The field we're initializing must be on the field
3879 list. Look to see if it is present before the
3880 field the current ELT initializes. */
3881 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3882 if (index
== fields
)
3886 /* We fell off the end of the CONSTRUCTOR, so insert a new
3887 entry at the end. */
3890 constructor_elt ce
= { index
, NULL_TREE
};
3892 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3893 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3902 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3903 wants to modify it. */
3904 if (*valp
== NULL_TREE
)
3906 *valp
= build_constructor (type
, NULL
);
3907 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3909 new_ctx
.ctor
= *valp
;
3910 new_ctx
.object
= target
;
3911 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3912 non_constant_p
, overflow_p
);
3913 if (target
== object
)
3914 /* The hash table might have moved since the get earlier. */
3915 valp
= ctx
->values
->get (object
);
3918 /* Don't share a CONSTRUCTOR that might be changed later. */
3919 init
= unshare_constructor (init
);
3921 if (*valp
&& TREE_CODE (*valp
) == CONSTRUCTOR
3922 && TREE_CODE (init
) == CONSTRUCTOR
)
3924 /* An outer ctx->ctor might be pointing to *valp, so replace
3926 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3927 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3928 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3929 CONSTRUCTOR_NO_CLEARING (*valp
)
3930 = CONSTRUCTOR_NO_CLEARING (init
);
3935 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3936 CONSTRUCTORs, if any. */
3939 bool c
= TREE_CONSTANT (init
);
3940 bool s
= TREE_SIDE_EFFECTS (init
);
3942 FOR_EACH_VEC_ELT (*ctors
, i
, elt
)
3945 TREE_CONSTANT (elt
) = false;
3947 TREE_SIDE_EFFECTS (elt
) = true;
3950 if (*non_constant_p
)
3958 /* Evaluate a ++ or -- expression. */
3961 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3963 bool *non_constant_p
, bool *overflow_p
)
3965 enum tree_code code
= TREE_CODE (t
);
3966 tree type
= TREE_TYPE (t
);
3967 tree op
= TREE_OPERAND (t
, 0);
3968 tree offset
= TREE_OPERAND (t
, 1);
3969 gcc_assert (TREE_CONSTANT (offset
));
3971 /* The operand as an lvalue. */
3972 op
= cxx_eval_constant_expression (ctx
, op
, true,
3973 non_constant_p
, overflow_p
);
3975 /* The operand as an rvalue. */
3977 = cxx_eval_constant_expression (ctx
, op
, false,
3978 non_constant_p
, overflow_p
);
3979 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3980 a local array in a constexpr function. */
3981 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (val
));
3983 VERIFY_CONSTANT (val
);
3985 /* The modified value. */
3986 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3988 if (INDIRECT_TYPE_P (type
))
3990 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3991 offset
= convert_to_ptrofftype (offset
);
3993 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3994 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3997 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3999 VERIFY_CONSTANT (mod
);
4001 /* Storing the modified value. */
4002 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
4003 cxx_eval_constant_expression (ctx
, store
,
4004 true, non_constant_p
, overflow_p
);
4006 /* And the value of the expression. */
4007 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4009 /* Prefix ops are lvalues. */
4013 /* But we optimize when the caller wants an rvalue. */
4017 /* Postfix ops are rvalues. */
4021 /* Predicates for the meaning of *jump_target. */
4024 returns (tree
*jump_target
)
4027 && (TREE_CODE (*jump_target
) == RETURN_EXPR
4028 || (TREE_CODE (*jump_target
) == LABEL_DECL
4029 && LABEL_DECL_CDTOR (*jump_target
)));
4033 breaks (tree
*jump_target
)
4036 && ((TREE_CODE (*jump_target
) == LABEL_DECL
4037 && LABEL_DECL_BREAK (*jump_target
))
4038 || TREE_CODE (*jump_target
) == BREAK_STMT
4039 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
4043 continues (tree
*jump_target
)
4046 && ((TREE_CODE (*jump_target
) == LABEL_DECL
4047 && LABEL_DECL_CONTINUE (*jump_target
))
4048 || TREE_CODE (*jump_target
) == CONTINUE_STMT
);
4053 switches (tree
*jump_target
)
4056 && TREE_CODE (*jump_target
) == INTEGER_CST
;
4059 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
4060 STMT matches *jump_target. If we're looking for a case label and we see
4061 the default label, note it in ctx->css_state. */
4064 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
4066 switch (TREE_CODE (*jump_target
))
4069 if (TREE_CODE (stmt
) == LABEL_EXPR
4070 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
4075 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
4077 gcc_assert (ctx
->css_state
!= NULL
);
4078 if (!CASE_LOW (stmt
))
4080 /* default: should appear just once in a SWITCH_EXPR
4081 body (excluding nested SWITCH_EXPR). */
4082 gcc_assert (*ctx
->css_state
!= css_default_seen
);
4083 /* When evaluating SWITCH_EXPR body for the second time,
4084 return true for the default: label. */
4085 if (*ctx
->css_state
== css_default_processing
)
4087 *ctx
->css_state
= css_default_seen
;
4089 else if (CASE_HIGH (stmt
))
4091 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
4092 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
4095 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
4102 /* These two are handled directly in cxx_eval_loop_expr by testing
4103 breaks (jump_target) or continues (jump_target). */
4112 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
4113 semantics, for switch, break, continue, and return. */
4116 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
4117 bool *non_constant_p
, bool *overflow_p
,
4120 tree_stmt_iterator i
;
4122 /* In a statement-expression we want to return the last value.
4123 For empty statement expression return void_node. */
4127 local_target
= NULL_TREE
;
4128 jump_target
= &local_target
;
4130 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4132 tree stmt
= tsi_stmt (i
);
4133 /* We've found a continue, so skip everything until we reach
4134 the label its jumping to. */
4135 if (continues (jump_target
))
4137 if (label_matches (ctx
, jump_target
, stmt
))
4139 *jump_target
= NULL_TREE
;
4143 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
4145 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
4146 non_constant_p
, overflow_p
,
4148 if (*non_constant_p
)
4150 if (returns (jump_target
) || breaks (jump_target
))
4153 if (*jump_target
&& jump_target
== &local_target
)
4155 /* We aren't communicating the jump to our caller, so give up. We don't
4156 need to support evaluation of jumps out of statement-exprs. */
4158 error_at (cp_expr_loc_or_loc (r
, input_location
),
4159 "statement is not a constant expression");
4160 *non_constant_p
= true;
4165 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
4166 semantics; continue semantics are covered by cxx_eval_statement_list. */
4169 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
4170 bool *non_constant_p
, bool *overflow_p
,
4173 constexpr_ctx new_ctx
= *ctx
;
4175 tree body
, cond
= NULL_TREE
, expr
= NULL_TREE
;
4177 switch (TREE_CODE (t
))
4180 body
= LOOP_EXPR_BODY (t
);
4187 body
= WHILE_BODY (t
);
4188 cond
= WHILE_COND (t
);
4192 if (FOR_INIT_STMT (t
))
4193 cxx_eval_constant_expression (ctx
, FOR_INIT_STMT (t
), /*lval*/false,
4194 non_constant_p
, overflow_p
, jump_target
);
4195 if (*non_constant_p
)
4197 body
= FOR_BODY (t
);
4198 cond
= FOR_COND (t
);
4199 expr
= FOR_EXPR (t
);
4205 auto_vec
<tree
, 10> save_exprs
;
4206 new_ctx
.save_exprs
= &save_exprs
;
4212 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
4213 non_constant_p
, overflow_p
,
4215 if (breaks (jump_target
))
4217 *jump_target
= NULL_TREE
;
4221 if (TREE_CODE (t
) != LOOP_EXPR
&& continues (jump_target
))
4222 *jump_target
= NULL_TREE
;
4225 cxx_eval_constant_expression (&new_ctx
, expr
, /*lval*/false,
4226 non_constant_p
, overflow_p
,
4233 = cxx_eval_constant_expression (&new_ctx
, cond
, /*lval*/false,
4234 non_constant_p
, overflow_p
,
4238 if (verify_constant (res
, ctx
->quiet
, non_constant_p
,
4241 if (integer_zerop (res
))
4245 gcc_assert (*jump_target
);
4248 /* Forget saved values of SAVE_EXPRs. */
4251 FOR_EACH_VEC_ELT (save_exprs
, i
, save_expr
)
4252 new_ctx
.values
->remove (save_expr
);
4253 save_exprs
.truncate (0);
4255 if (++count
>= constexpr_loop_limit
)
4258 error_at (cp_expr_loc_or_loc (t
, input_location
),
4259 "%<constexpr%> loop iteration count exceeds limit of %d "
4260 "(use %<-fconstexpr-loop-limit=%> to increase the limit)",
4261 constexpr_loop_limit
);
4262 *non_constant_p
= true;
4266 while (!returns (jump_target
)
4267 && !breaks (jump_target
)
4268 && !continues (jump_target
)
4269 && (!switches (jump_target
) || count
== 0)
4270 && !*non_constant_p
);
4272 /* Forget saved values of SAVE_EXPRs. */
4275 FOR_EACH_VEC_ELT (save_exprs
, i
, save_expr
)
4276 new_ctx
.values
->remove (save_expr
);
4281 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
4285 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
4286 bool *non_constant_p
, bool *overflow_p
,
4290 = TREE_CODE (t
) == SWITCH_STMT
? SWITCH_STMT_COND (t
) : SWITCH_COND (t
);
4291 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
4292 non_constant_p
, overflow_p
);
4293 VERIFY_CONSTANT (cond
);
4294 *jump_target
= cond
;
4297 = TREE_CODE (t
) == SWITCH_STMT
? SWITCH_STMT_BODY (t
) : SWITCH_BODY (t
);
4298 constexpr_ctx new_ctx
= *ctx
;
4299 constexpr_switch_state css
= css_default_not_seen
;
4300 new_ctx
.css_state
= &css
;
4301 cxx_eval_constant_expression (&new_ctx
, body
, false,
4302 non_constant_p
, overflow_p
, jump_target
);
4303 if (switches (jump_target
) && css
== css_default_seen
)
4305 /* If the SWITCH_EXPR body has default: label, process it once again,
4306 this time instructing label_matches to return true for default:
4307 label on switches (jump_target). */
4308 css
= css_default_processing
;
4309 cxx_eval_constant_expression (&new_ctx
, body
, false,
4310 non_constant_p
, overflow_p
, jump_target
);
4312 if (breaks (jump_target
) || switches (jump_target
))
4313 *jump_target
= NULL_TREE
;
4317 /* Find the object of TYPE under initialization in CTX. */
4320 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4325 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4326 can is a minor optimization. */
4327 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4333 /* Since an object cannot have a field of its own type, we can search outward
4334 from ctx->object to find the unique containing object of TYPE. */
4335 tree ob
= ctx
->object
;
4338 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4340 if (handled_component_p (ob
))
4341 ob
= TREE_OPERAND (ob
, 0);
4349 /* Attempt to reduce the expression T to a constant value.
4350 On failure, issue diagnostic and return error_mark_node. */
4351 /* FIXME unify with c_fully_fold */
4352 /* FIXME overflow_p is too global */
4355 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4357 bool *non_constant_p
, bool *overflow_p
,
4358 tree
*jump_target
/* = NULL */)
4360 constexpr_ctx new_ctx
;
4363 if (jump_target
&& *jump_target
)
4365 /* If we are jumping, ignore all statements/expressions except those
4366 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4367 switch (TREE_CODE (t
))
4370 case STATEMENT_LIST
:
4379 case CASE_LABEL_EXPR
:
4380 if (label_matches (ctx
, jump_target
, t
))
4382 *jump_target
= NULL_TREE
;
4388 if (error_operand_p (t
))
4390 *non_constant_p
= true;
4393 if (CONSTANT_CLASS_P (t
))
4395 if (TREE_OVERFLOW (t
))
4398 permerror (input_location
, "overflow in constant expression");
4399 if (!flag_permissive
|| ctx
->quiet
)
4403 if (TREE_CODE (t
) == INTEGER_CST
4404 && TYPE_PTR_P (TREE_TYPE (t
))
4405 && !integer_zerop (t
))
4408 error ("value %qE of type %qT is not a constant expression",
4410 *non_constant_p
= true;
4416 /* Avoid excessively long constexpr evaluations. */
4417 if (!location_wrapper_p (t
)
4418 && ++*ctx
->constexpr_ops_count
>= constexpr_ops_limit
)
4421 error_at (cp_expr_loc_or_loc (t
, input_location
),
4422 "%<constexpr%> evaluation operation count exceeds limit of "
4423 "%wd (use %<-fconstexpr-ops-limit=%> to increase the limit)",
4424 constexpr_ops_limit
);
4425 *ctx
->constexpr_ops_count
= INTTYPE_MINIMUM (HOST_WIDE_INT
);
4426 *non_constant_p
= true;
4430 tree_code tcode
= TREE_CODE (t
);
4436 /* We ask for an rvalue for the RESULT_DECL when indirecting
4437 through an invisible reference, or in named return value
4439 if (tree
*p
= ctx
->values
->get (t
))
4444 error ("%qE is not a constant expression", t
);
4445 *non_constant_p
= true;
4450 if (DECL_HAS_VALUE_EXPR_P (t
))
4452 if (is_normal_capture_proxy (t
)
4453 && current_function_decl
== DECL_CONTEXT (t
))
4455 /* Function parms aren't constexpr within the function
4456 definition, so don't try to look at the closure. But if the
4457 captured variable is constant, try to evaluate it directly. */
4458 r
= DECL_CAPTURED_VARIABLE (t
);
4459 tree type
= TREE_TYPE (t
);
4460 if (TYPE_REF_P (type
) != TYPE_REF_P (TREE_TYPE (r
)))
4462 /* Adjust r to match the reference-ness of t. */
4463 if (TYPE_REF_P (type
))
4464 r
= build_address (r
);
4466 r
= convert_from_reference (r
);
4470 r
= DECL_VALUE_EXPR (t
);
4471 return cxx_eval_constant_expression (ctx
, r
, lval
, non_constant_p
,
4476 /* We used to not check lval for CONST_DECL, but darwin.c uses
4477 CONST_DECL for aggregate constants. */
4480 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4481 && is_really_empty_class (TREE_TYPE (t
), /*ignore_vptr*/false))
4483 /* If the class is empty, we aren't actually loading anything. */
4484 r
= build_constructor (TREE_TYPE (t
), NULL
);
4485 TREE_CONSTANT (r
) = true;
4487 else if (ctx
->strict
)
4488 r
= decl_really_constant_value (t
);
4490 r
= decl_constant_value (t
);
4491 if (TREE_CODE (r
) == TARGET_EXPR
4492 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4493 r
= TARGET_EXPR_INITIAL (r
);
4495 if (tree
*p
= ctx
->values
->get (r
))
4496 if (*p
!= NULL_TREE
)
4501 non_const_var_error (r
);
4502 *non_constant_p
= true;
4506 case DEBUG_BEGIN_STMT
:
4507 /* ??? It might be nice to retain this information somehow, so
4508 as to be able to step into a constexpr function call. */
4515 case CASE_LABEL_EXPR
:
4520 if (lval
&& !TYPE_REF_P (TREE_TYPE (t
)))
4522 else if (tree
*p
= ctx
->values
->get (r
))
4525 /* Defer in case this is only used for its type. */;
4526 else if (TYPE_REF_P (TREE_TYPE (t
)))
4527 /* Defer, there's no lvalue->rvalue conversion. */;
4528 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4529 && is_really_empty_class (TREE_TYPE (t
), /*ignore_vptr*/false))
4531 /* If the class is empty, we aren't actually loading anything. */
4532 r
= build_constructor (TREE_TYPE (t
), NULL
);
4533 TREE_CONSTANT (r
) = true;
4538 error ("%qE is not a constant expression", t
);
4539 *non_constant_p
= true;
4544 case AGGR_INIT_EXPR
:
4545 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4546 non_constant_p
, overflow_p
);
4551 r
= DECL_EXPR_DECL (t
);
4552 if (TREE_CODE (r
) == USING_DECL
)
4557 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4558 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4562 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4563 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4564 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4568 if (tree init
= DECL_INITIAL (r
))
4570 init
= cxx_eval_constant_expression (ctx
, init
,
4572 non_constant_p
, overflow_p
);
4573 /* Don't share a CONSTRUCTOR that might be changed. */
4574 init
= unshare_constructor (init
);
4575 ctx
->values
->put (r
, init
);
4577 else if (ctx
== &new_ctx
)
4578 /* We gave it a CONSTRUCTOR above. */;
4580 ctx
->values
->put (r
, NULL_TREE
);
4585 if (!literal_type_p (TREE_TYPE (t
)))
4589 auto_diagnostic_group d
;
4590 error ("temporary of non-literal type %qT in a "
4591 "constant expression", TREE_TYPE (t
));
4592 explain_non_literal_class (TREE_TYPE (t
));
4594 *non_constant_p
= true;
4597 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4599 /* We're being expanded without an explicit target, so start
4600 initializing a new object; expansion with an explicit target
4601 strips the TARGET_EXPR before we get here. */
4603 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4604 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4605 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4606 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4609 /* Pass false for 'lval' because this indicates
4610 initialization of a temporary. */
4611 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4613 non_constant_p
, overflow_p
);
4614 if (!*non_constant_p
)
4615 /* Adjust the type of the result to the type of the temporary. */
4616 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4619 tree slot
= TARGET_EXPR_SLOT (t
);
4620 r
= unshare_constructor (r
);
4621 ctx
->values
->put (slot
, r
);
4628 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4629 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4630 non_constant_p
, overflow_p
);
4634 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4636 non_constant_p
, overflow_p
);
4640 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4641 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4643 non_constant_p
, overflow_p
);
4651 /* Can happen with ({ return true; }) && false; passed to
4652 maybe_constant_value. There is nothing to jump over in this
4653 case, and the bug will be diagnosed later. */
4654 gcc_assert (ctx
->quiet
);
4655 *non_constant_p
= true;
4660 /* Avoid evaluating a SAVE_EXPR more than once. */
4661 if (tree
*p
= ctx
->values
->get (t
))
4665 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4666 non_constant_p
, overflow_p
);
4667 ctx
->values
->put (t
, r
);
4668 if (ctx
->save_exprs
)
4669 ctx
->save_exprs
->safe_push (t
);
4673 case NON_LVALUE_EXPR
:
4674 case TRY_CATCH_EXPR
:
4676 case CLEANUP_POINT_EXPR
:
4677 case MUST_NOT_THROW_EXPR
:
4680 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4682 non_constant_p
, overflow_p
,
4686 case TRY_FINALLY_EXPR
:
4687 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4688 non_constant_p
, overflow_p
,
4690 if (!*non_constant_p
)
4691 /* Also evaluate the cleanup. */
4692 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4693 non_constant_p
, overflow_p
,
4698 r
= cxx_eval_constant_expression (ctx
, CLEANUP_BODY (t
), lval
,
4699 non_constant_p
, overflow_p
,
4701 if (!CLEANUP_EH_ONLY (t
) && !*non_constant_p
)
4702 /* Also evaluate the cleanup. */
4703 cxx_eval_constant_expression (ctx
, CLEANUP_EXPR (t
), true,
4704 non_constant_p
, overflow_p
,
4708 /* These differ from cxx_eval_unary_expression in that this doesn't
4709 check for a constant operand or result; an address can be
4710 constant without its operand being, and vice versa. */
4713 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4714 non_constant_p
, overflow_p
);
4719 tree oldop
= TREE_OPERAND (t
, 0);
4720 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4722 non_constant_p
, overflow_p
);
4723 /* Don't VERIFY_CONSTANT here. */
4724 if (*non_constant_p
)
4726 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4727 /* This function does more aggressive folding than fold itself. */
4728 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4729 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4738 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4739 non_constant_p
, overflow_p
);
4740 if (r
== error_mark_node
)
4742 else if (r
== TREE_OPERAND (t
, 0))
4745 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4750 case FIX_TRUNC_EXPR
:
4756 case TRUTH_NOT_EXPR
:
4757 case FIXED_CONVERT_EXPR
:
4758 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4759 non_constant_p
, overflow_p
);
4763 r
= cxx_eval_constant_expression (ctx
, fold_sizeof_expr (t
), lval
,
4764 non_constant_p
, overflow_p
,
4770 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4771 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4772 introduced by build_call_a. */
4773 tree op0
= TREE_OPERAND (t
, 0);
4774 tree op1
= TREE_OPERAND (t
, 1);
4776 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4777 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4778 r
= cxx_eval_constant_expression (ctx
, op0
,
4779 lval
, non_constant_p
, overflow_p
,
4783 /* Check that the LHS is constant and then discard it. */
4784 cxx_eval_constant_expression (ctx
, op0
,
4785 true, non_constant_p
, overflow_p
,
4787 if (*non_constant_p
)
4789 op1
= TREE_OPERAND (t
, 1);
4790 r
= cxx_eval_constant_expression (ctx
, op1
,
4791 lval
, non_constant_p
, overflow_p
,
4797 case POINTER_PLUS_EXPR
:
4798 case POINTER_DIFF_EXPR
:
4802 case TRUNC_DIV_EXPR
:
4804 case FLOOR_DIV_EXPR
:
4805 case ROUND_DIV_EXPR
:
4806 case TRUNC_MOD_EXPR
:
4808 case ROUND_MOD_EXPR
:
4810 case EXACT_DIV_EXPR
:
4820 case TRUTH_XOR_EXPR
:
4827 case UNORDERED_EXPR
:
4837 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4838 non_constant_p
, overflow_p
);
4841 /* fold can introduce non-IF versions of these; still treat them as
4842 short-circuiting. */
4843 case TRUTH_AND_EXPR
:
4844 case TRUTH_ANDIF_EXPR
:
4845 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4848 non_constant_p
, overflow_p
);
4852 case TRUTH_ORIF_EXPR
:
4853 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4856 non_constant_p
, overflow_p
);
4860 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4861 non_constant_p
, overflow_p
);
4865 if (is_overloaded_fn (t
))
4867 /* We can only get here in checking mode via
4868 build_non_dependent_expr, because any expression that
4869 calls or takes the address of the function will have
4870 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4871 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4872 *non_constant_p
= true;
4875 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4876 non_constant_p
, overflow_p
);
4880 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4881 non_constant_p
, overflow_p
);
4886 if (jump_target
&& *jump_target
)
4888 tree orig_jump
= *jump_target
;
4889 tree arg
= ((TREE_CODE (t
) != IF_STMT
|| TREE_OPERAND (t
, 1))
4890 ? TREE_OPERAND (t
, 1) : void_node
);
4891 /* When jumping to a label, the label might be either in the
4892 then or else blocks, so process then block first in skipping
4893 mode first, and if we are still in the skipping mode at its end,
4894 process the else block too. */
4895 r
= cxx_eval_constant_expression (ctx
, arg
, lval
, non_constant_p
,
4896 overflow_p
, jump_target
);
4897 /* It's possible that we found the label in the then block. But
4898 it could have been followed by another jumping statement, e.g.
4899 say we're looking for case 1:
4902 // skipped statements
4903 case 1:; // clears up *jump_target
4904 return 1; // and sets it to a RETURN_EXPR
4907 in which case we need not go looking to the else block.
4908 (goto is not allowed in a constexpr function.) */
4909 if (*jump_target
== orig_jump
)
4911 arg
= ((TREE_CODE (t
) != IF_STMT
|| TREE_OPERAND (t
, 2))
4912 ? TREE_OPERAND (t
, 2) : void_node
);
4913 r
= cxx_eval_constant_expression (ctx
, arg
, lval
, non_constant_p
,
4914 overflow_p
, jump_target
);
4918 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4919 non_constant_p
, overflow_p
,
4923 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4928 if (TREE_CONSTANT (t
) && reduced_constant_expression_p (t
))
4930 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4931 VECTOR_CST if applicable. */
4932 verify_constructor_flags (t
);
4933 if (TREE_CONSTANT (t
))
4936 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4937 non_constant_p
, overflow_p
);
4941 /* We can get this in a defaulted constructor for a class with a
4942 non-static data member of array type. Either the initializer will
4943 be NULL, meaning default-initialization, or it will be an lvalue
4944 or xvalue of the same type, meaning direct-initialization from the
4945 corresponding member. */
4946 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4947 non_constant_p
, overflow_p
);
4951 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4952 non_constant_p
, overflow_p
);
4956 if (REINTERPRET_CAST_P (t
))
4959 error_at (cp_expr_loc_or_loc (t
, input_location
),
4960 "%<reinterpret_cast%> is not a constant expression");
4961 *non_constant_p
= true;
4966 case VIEW_CONVERT_EXPR
:
4967 case UNARY_PLUS_EXPR
:
4969 tree oldop
= TREE_OPERAND (t
, 0);
4971 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4973 non_constant_p
, overflow_p
);
4974 if (*non_constant_p
)
4976 tree type
= TREE_TYPE (t
);
4977 if (TREE_CODE (op
) == PTRMEM_CST
4978 && !TYPE_PTRMEM_P (type
))
4979 op
= cplus_expand_constant (op
);
4981 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4983 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (op
))
4984 && !can_convert_qual (type
, op
))
4985 op
= cplus_expand_constant (op
);
4986 return cp_fold_convert (type
, op
);
4989 if (INDIRECT_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4991 if (integer_zerop (op
))
4993 if (TYPE_REF_P (type
))
4996 error_at (cp_expr_loc_or_loc (t
, input_location
),
4997 "dereferencing a null pointer");
4998 *non_constant_p
= true;
5001 else if (TYPE_PTR_P (TREE_TYPE (op
)))
5003 tree from
= TREE_TYPE (op
);
5005 if (!can_convert (type
, from
, tf_none
))
5008 error_at (cp_expr_loc_or_loc (t
, input_location
),
5009 "conversion of %qT null pointer to %qT "
5010 "is not a constant expression",
5012 *non_constant_p
= true;
5019 /* This detects for example:
5020 reinterpret_cast<void*>(sizeof 0)
5023 error_at (cp_expr_loc_or_loc (t
, input_location
),
5024 "%<reinterpret_cast<%T>(%E)%> is not "
5025 "a constant expression",
5027 *non_constant_p
= true;
5032 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
5033 /* We didn't fold at the top so we could check for ptr-int
5037 /* Handle an array's bounds having been deduced after we built
5038 the wrapping expression. */
5039 if (same_type_ignoring_tlq_and_bounds_p (type
, TREE_TYPE (op
)))
5041 else if (tcode
== UNARY_PLUS_EXPR
)
5042 r
= fold_convert (TREE_TYPE (t
), op
);
5044 r
= fold_build1 (tcode
, type
, op
);
5046 /* Conversion of an out-of-range value has implementation-defined
5047 behavior; the language considers it different from arithmetic
5048 overflow, which is undefined. */
5049 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
5050 TREE_OVERFLOW (r
) = false;
5054 case EMPTY_CLASS_EXPR
:
5055 /* This is good enough for a function argument that might not get
5056 used, and they can't do anything with it, so just return it. */
5059 case STATEMENT_LIST
:
5061 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
5062 return cxx_eval_statement_list (&new_ctx
, t
,
5063 non_constant_p
, overflow_p
, jump_target
);
5066 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
5068 non_constant_p
, overflow_p
,
5071 case PREINCREMENT_EXPR
:
5072 case POSTINCREMENT_EXPR
:
5073 case PREDECREMENT_EXPR
:
5074 case POSTDECREMENT_EXPR
:
5075 return cxx_eval_increment_expression (ctx
, t
,
5076 lval
, non_constant_p
, overflow_p
);
5082 case VEC_DELETE_EXPR
:
5085 /* GCC internal stuff. */
5087 case NON_DEPENDENT_EXPR
:
5091 error_at (cp_expr_loc_or_loc (t
, input_location
),
5092 "expression %qE is not a constant expression", t
);
5093 *non_constant_p
= true;
5098 /* Virtual function call. Let the constexpr machinery figure out
5099 the dynamic type. */
5100 int token
= tree_to_shwi (OBJ_TYPE_REF_TOKEN (t
));
5101 tree obj
= OBJ_TYPE_REF_OBJECT (t
);
5102 obj
= cxx_eval_constant_expression (ctx
, obj
, lval
, non_constant_p
,
5104 /* We expect something in the form of &x.D.2103.D.2094; get x. */
5105 if (TREE_CODE (obj
) != ADDR_EXPR
5106 || !DECL_P (get_base_address (TREE_OPERAND (obj
, 0))))
5109 error_at (cp_expr_loc_or_loc (t
, input_location
),
5110 "expression %qE is not a constant expression", t
);
5111 *non_constant_p
= true;
5114 obj
= TREE_OPERAND (obj
, 0);
5115 while (TREE_CODE (obj
) == COMPONENT_REF
5116 && DECL_FIELD_IS_BASE (TREE_OPERAND (obj
, 1)))
5117 obj
= TREE_OPERAND (obj
, 0);
5118 tree objtype
= TREE_TYPE (obj
);
5119 /* Find the function decl in the virtual functions list. TOKEN is
5120 the DECL_VINDEX that says which function we're looking for. */
5121 tree virtuals
= BINFO_VIRTUALS (TYPE_BINFO (objtype
));
5122 if (TARGET_VTABLE_USES_DESCRIPTORS
)
5123 token
/= MAX (TARGET_VTABLE_USES_DESCRIPTORS
, 1);
5124 r
= TREE_VALUE (chain_index (token
, virtuals
));
5128 case PLACEHOLDER_EXPR
:
5129 /* Use of the value or address of the current object. */
5130 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
5131 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
5132 non_constant_p
, overflow_p
);
5133 /* A placeholder without a referent. We can get here when
5134 checking whether NSDMIs are noexcept, or in massage_init_elt;
5135 just say it's non-constant for now. */
5136 gcc_assert (ctx
->quiet
);
5137 *non_constant_p
= true;
5142 tree cond
= TREE_OPERAND (t
, 0);
5143 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
5144 non_constant_p
, overflow_p
);
5145 VERIFY_CONSTANT (cond
);
5146 if (integer_nonzerop (cond
))
5152 *jump_target
= TREE_OPERAND (t
, 0);
5153 gcc_assert (breaks (jump_target
) || continues (jump_target
)
5154 /* Allow for jumping to a cdtor_label. */
5155 || returns (jump_target
));
5162 cxx_eval_loop_expr (ctx
, t
,
5163 non_constant_p
, overflow_p
, jump_target
);
5168 cxx_eval_switch_expr (ctx
, t
,
5169 non_constant_p
, overflow_p
, jump_target
);
5173 /* It's possible to get a requires-expression in a constant
5174 expression. For example:
5176 template<typename T> concept bool C() {
5177 return requires (T t) { t; };
5180 template<typename T> requires !C<T>() void f(T);
5182 Normalization leaves f with the associated constraint
5183 '!requires (T t) { ... }' which is not transformed into
5185 if (!processing_template_decl
)
5186 return evaluate_constraint_expression (t
, NULL_TREE
);
5188 *non_constant_p
= true;
5192 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
5194 non_constant_p
, overflow_p
,
5203 if (STATEMENT_CODE_P (TREE_CODE (t
)))
5205 /* This function doesn't know how to deal with pre-genericize
5206 statements; this can only happen with statement-expressions,
5207 so for now just fail. */
5209 error_at (EXPR_LOCATION (t
),
5210 "statement is not a constant expression");
5213 internal_error ("unexpected expression %qE of kind %s", t
,
5214 get_tree_code_name (TREE_CODE (t
)));
5215 *non_constant_p
= true;
5219 if (r
== error_mark_node
)
5220 *non_constant_p
= true;
5222 if (*non_constant_p
)
5228 /* P0859: A function is needed for constant evaluation if it is a constexpr
5229 function that is named by an expression ([basic.def.odr]) that is
5230 potentially constant evaluated.
5232 So we need to instantiate any constexpr functions mentioned by the
5233 expression even if the definition isn't needed for evaluating the
5237 instantiate_cx_fn_r (tree
*tp
, int *walk_subtrees
, void */
*data*/
)
5239 if (TREE_CODE (*tp
) == FUNCTION_DECL
5240 && DECL_DECLARED_CONSTEXPR_P (*tp
)
5241 && !DECL_INITIAL (*tp
)
5242 && !trivial_fn_p (*tp
)
5243 && DECL_TEMPLOID_INSTANTIATION (*tp
))
5246 instantiate_decl (*tp
, /*defer_ok*/false, /*expl_inst*/false);
5249 else if (TREE_CODE (*tp
) == CALL_EXPR
5250 || TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
5252 if (EXPR_HAS_LOCATION (*tp
))
5253 input_location
= EXPR_LOCATION (*tp
);
5262 instantiate_constexpr_fns (tree t
)
5264 location_t loc
= input_location
;
5265 cp_walk_tree_without_duplicates (&t
, instantiate_cx_fn_r
, NULL
);
5266 input_location
= loc
;
5269 /* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5270 STRICT has the same sense as for constant_value_1: true if we only allow
5271 conforming C++ constant expressions, or false if we want a constant value
5272 even if it doesn't conform.
5273 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
5274 per P0595 even when ALLOW_NON_CONSTANT is true. */
5277 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
5279 bool manifestly_const_eval
= false,
5280 tree object
= NULL_TREE
)
5282 auto_timevar
time (TV_CONSTEXPR
);
5284 bool non_constant_p
= false;
5285 bool overflow_p
= false;
5286 hash_map
<tree
,tree
> map
;
5287 HOST_WIDE_INT constexpr_ctx_count
= 0;
5289 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
5290 &constexpr_ctx_count
, allow_non_constant
, strict
,
5291 manifestly_const_eval
|| !allow_non_constant
};
5293 tree type
= initialized_type (t
);
5295 if (VOID_TYPE_P (type
))
5297 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5299 /* In C++14 an NSDMI can participate in aggregate initialization,
5300 and can refer to the address of the object being initialized, so
5301 we need to pass in the relevant VAR_DECL if we want to do the
5302 evaluation in a single pass. The evaluation will dynamically
5303 update ctx.values for the VAR_DECL. We use the same strategy
5304 for C++11 constexpr constructors that refer to the object being
5306 ctx
.ctor
= build_constructor (type
, NULL
);
5307 CONSTRUCTOR_NO_CLEARING (ctx
.ctor
) = true;
5310 if (TREE_CODE (t
) == TARGET_EXPR
)
5311 object
= TARGET_EXPR_SLOT (t
);
5312 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5313 object
= AGGR_INIT_EXPR_SLOT (t
);
5315 ctx
.object
= object
;
5317 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5318 (type
, TREE_TYPE (object
)));
5319 if (object
&& DECL_P (object
))
5320 map
.put (object
, ctx
.ctor
);
5321 if (TREE_CODE (r
) == TARGET_EXPR
)
5322 /* Avoid creating another CONSTRUCTOR when we expand the
5324 r
= TARGET_EXPR_INITIAL (r
);
5327 instantiate_constexpr_fns (r
);
5328 r
= cxx_eval_constant_expression (&ctx
, r
,
5329 false, &non_constant_p
, &overflow_p
);
5331 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
5333 /* Mutable logic is a bit tricky: we want to allow initialization of
5334 constexpr variables with mutable members, but we can't copy those
5335 members to another constexpr variable. */
5336 if (TREE_CODE (r
) == CONSTRUCTOR
5337 && CONSTRUCTOR_MUTABLE_POISON (r
))
5339 if (!allow_non_constant
)
5340 error ("%qE is not a constant expression because it refers to "
5341 "mutable subobjects of %qT", t
, type
);
5342 non_constant_p
= true;
5345 if (TREE_CODE (r
) == CONSTRUCTOR
5346 && CONSTRUCTOR_NO_CLEARING (r
))
5348 if (!allow_non_constant
)
5349 error ("%qE is not a constant expression because it refers to "
5350 "an incompletely initialized variable", t
);
5351 TREE_CONSTANT (r
) = false;
5352 non_constant_p
= true;
5355 /* Technically we should check this for all subexpressions, but that
5356 runs into problems with our internal representation of pointer
5357 subtraction and the 5.19 rules are still in flux. */
5358 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
5359 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
5360 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
5362 if (!allow_non_constant
)
5363 error ("conversion from pointer type %qT "
5364 "to arithmetic type %qT in a constant expression",
5365 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
5366 non_constant_p
= true;
5369 if (!non_constant_p
&& overflow_p
)
5370 non_constant_p
= true;
5372 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
5374 bool should_unshare
= true;
5375 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
5376 should_unshare
= false;
5378 if (non_constant_p
&& !allow_non_constant
)
5379 return error_mark_node
;
5380 else if (non_constant_p
&& TREE_CONSTANT (r
))
5382 /* If __builtin_is_constant_evaluated () was evaluated to true
5383 and the result is not a valid constant expression, we need to
5385 if (manifestly_const_eval
)
5386 return cxx_eval_outermost_constant_expr (t
, true, strict
,
5388 /* This isn't actually constant, so unset TREE_CONSTANT.
5389 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
5390 it to be set if it is invariant address, even when it is not
5391 a valid C++ constant expression. Wrap it with a NOP_EXPR
5393 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
5395 else if (TREE_CODE (r
) == CONSTRUCTOR
)
5396 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
5398 r
= build_nop (TREE_TYPE (r
), r
);
5399 TREE_CONSTANT (r
) = false;
5401 else if (non_constant_p
)
5405 r
= unshare_expr (r
);
5407 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
5409 r
= adjust_temp_type (type
, r
);
5410 if (TREE_CODE (t
) == TARGET_EXPR
5411 && TARGET_EXPR_INITIAL (t
) == r
)
5413 else if (TREE_CODE (t
) != CONSTRUCTOR
)
5415 r
= get_target_expr (r
);
5416 TREE_CONSTANT (r
) = true;
5423 /* If T represents a constant expression returns its reduced value.
5424 Otherwise return error_mark_node. If T is dependent, then
5428 cxx_constant_value (tree t
, tree decl
)
5430 return cxx_eval_outermost_constant_expr (t
, false, true, true, decl
);
5433 /* Helper routine for fold_simple function. Either return simplified
5434 expression T, otherwise NULL_TREE.
5435 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
5436 even if we are within template-declaration. So be careful on call, as in
5437 such case types can be undefined. */
5440 fold_simple_1 (tree t
)
5443 enum tree_code code
= TREE_CODE (t
);
5455 return fold_sizeof_expr (t
);
5464 case TRUTH_NOT_EXPR
:
5466 case VIEW_CONVERT_EXPR
:
5469 case FIX_TRUNC_EXPR
:
5470 case FIXED_CONVERT_EXPR
:
5471 case ADDR_SPACE_CONVERT_EXPR
:
5473 op1
= TREE_OPERAND (t
, 0);
5475 t
= const_unop (code
, TREE_TYPE (t
), op1
);
5479 if (CONVERT_EXPR_CODE_P (code
)
5480 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
5481 TREE_OVERFLOW (t
) = false;
5489 /* If T is a simple constant expression, returns its simplified value.
5490 Otherwise returns T. In contrast to maybe_constant_value we
5491 simplify only few operations on constant-expressions, and we don't
5492 try to simplify constexpressions. */
5495 fold_simple (tree t
)
5497 if (processing_template_decl
)
5500 tree r
= fold_simple_1 (t
);
5507 /* If T is a constant expression, returns its reduced value.
5508 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5509 Otherwise, returns a version of T without TREE_CONSTANT.
5510 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated
5513 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5516 maybe_constant_value (tree t
, tree decl
, bool manifestly_const_eval
)
5520 if (!is_nondependent_constant_expression (t
))
5522 if (TREE_OVERFLOW_P (t
))
5524 t
= build_nop (TREE_TYPE (t
), t
);
5525 TREE_CONSTANT (t
) = false;
5529 else if (CONSTANT_CLASS_P (t
))
5530 /* No caching or evaluation needed. */
5533 if (manifestly_const_eval
)
5534 return cxx_eval_outermost_constant_expr (t
, true, true, true, decl
);
5536 if (cv_cache
== NULL
)
5537 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5538 if (tree
*cached
= cv_cache
->get (t
))
5541 r
= cxx_eval_outermost_constant_expr (t
, true, true, false, decl
);
5542 gcc_checking_assert (r
== t
5543 || CONVERT_EXPR_P (t
)
5544 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5545 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5546 || !cp_tree_equal (r
, t
));
5547 cv_cache
->put (t
, r
);
5551 /* Dispose of the whole CV_CACHE. */
5554 clear_cv_cache (void)
5556 if (cv_cache
!= NULL
)
5560 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5563 clear_cv_and_fold_caches (void)
5566 clear_fold_cache ();
5569 /* Internal function handling expressions in templates for
5570 fold_non_dependent_expr and fold_non_dependent_init.
5572 If we're in a template, but T isn't value dependent, simplify
5573 it. We're supposed to treat:
5575 template <typename T> void f(T[1 + 1]);
5576 template <typename T> void f(T[2]);
5578 as two declarations of the same function, for example. */
5581 fold_non_dependent_expr_template (tree t
, tsubst_flags_t complain
,
5582 bool manifestly_const_eval
)
5584 gcc_assert (processing_template_decl
);
5586 if (is_nondependent_constant_expression (t
))
5588 processing_template_decl_sentinel s
;
5589 t
= instantiate_non_dependent_expr_internal (t
, complain
);
5591 if (type_unknown_p (t
) || BRACE_ENCLOSED_INITIALIZER_P (t
))
5593 if (TREE_OVERFLOW_P (t
))
5595 t
= build_nop (TREE_TYPE (t
), t
);
5596 TREE_CONSTANT (t
) = false;
5601 tree r
= cxx_eval_outermost_constant_expr (t
, true, true,
5602 manifestly_const_eval
,
5604 /* cp_tree_equal looks through NOPs, so allow them. */
5605 gcc_checking_assert (r
== t
5606 || CONVERT_EXPR_P (t
)
5607 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5608 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5609 || !cp_tree_equal (r
, t
));
5612 else if (TREE_OVERFLOW_P (t
))
5614 t
= build_nop (TREE_TYPE (t
), t
);
5615 TREE_CONSTANT (t
) = false;
5621 /* Like maybe_constant_value but first fully instantiate the argument.
5623 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5624 (t, complain) followed by maybe_constant_value but is more efficient,
5625 because it calls instantiation_dependent_expression_p and
5626 potential_constant_expression at most once.
5627 The manifestly_const_eval argument is passed to maybe_constant_value.
5629 Callers should generally pass their active complain, or if they are in a
5630 non-template, diagnosing context, they can use the default of
5631 tf_warning_or_error. Callers that might be within a template context, don't
5632 have a complain parameter, and aren't going to remember the result for long
5633 (e.g. null_ptr_cst_p), can pass tf_none and deal with error_mark_node
5637 fold_non_dependent_expr (tree t
,
5638 tsubst_flags_t complain
/* = tf_warning_or_error */,
5639 bool manifestly_const_eval
/* = false */)
5644 if (processing_template_decl
)
5645 return fold_non_dependent_expr_template (t
, complain
,
5646 manifestly_const_eval
);
5648 return maybe_constant_value (t
, NULL_TREE
, manifestly_const_eval
);
5652 /* Like maybe_constant_init but first fully instantiate the argument. */
5655 fold_non_dependent_init (tree t
,
5656 tsubst_flags_t complain
/*=tf_warning_or_error*/,
5657 bool manifestly_const_eval
/*=false*/)
5662 if (processing_template_decl
)
5664 t
= fold_non_dependent_expr_template (t
, complain
,
5665 manifestly_const_eval
);
5666 /* maybe_constant_init does this stripping, so do it here too. */
5667 if (TREE_CODE (t
) == TARGET_EXPR
)
5669 tree init
= TARGET_EXPR_INITIAL (t
);
5670 if (TREE_CODE (init
) == CONSTRUCTOR
)
5676 return maybe_constant_init (t
, NULL_TREE
, manifestly_const_eval
);
5679 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5680 than wrapped in a TARGET_EXPR.
5681 ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5682 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
5683 per P0595 even when ALLOW_NON_CONSTANT is true. */
5686 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
,
5687 bool manifestly_const_eval
)
5691 if (TREE_CODE (t
) == EXPR_STMT
)
5692 t
= TREE_OPERAND (t
, 0);
5693 if (TREE_CODE (t
) == CONVERT_EXPR
5694 && VOID_TYPE_P (TREE_TYPE (t
)))
5695 t
= TREE_OPERAND (t
, 0);
5696 if (TREE_CODE (t
) == INIT_EXPR
)
5697 t
= TREE_OPERAND (t
, 1);
5698 if (TREE_CODE (t
) == TARGET_EXPR
)
5699 t
= TARGET_EXPR_INITIAL (t
);
5700 if (!is_nondependent_static_init_expression (t
))
5701 /* Don't try to evaluate it. */;
5702 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5703 /* No evaluation needed. */;
5705 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
,
5707 manifestly_const_eval
, decl
);
5708 if (TREE_CODE (t
) == TARGET_EXPR
)
5710 tree init
= TARGET_EXPR_INITIAL (t
);
5711 if (TREE_CODE (init
) == CONSTRUCTOR
)
5717 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5720 maybe_constant_init (tree t
, tree decl
, bool manifestly_const_eval
)
5722 return maybe_constant_init_1 (t
, decl
, true, manifestly_const_eval
);
5725 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5728 cxx_constant_init (tree t
, tree decl
)
5730 return maybe_constant_init_1 (t
, decl
, false, true);
5734 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5735 /* Return true if the object referred to by REF has automatic or thread
5738 enum { ck_ok
, ck_bad
, ck_unknown
};
5740 check_automatic_or_tls (tree ref
)
5743 poly_int64 bitsize
, bitpos
;
5745 int volatilep
= 0, unsignedp
= 0;
5746 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5747 &mode
, &unsignedp
, &volatilep
, false);
5750 /* If there isn't a decl in the middle, we don't know the linkage here,
5751 and this isn't a constant expression anyway. */
5754 dk
= decl_storage_duration (decl
);
5755 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5759 /* Data structure for passing data from potential_constant_expression_1
5760 to check_for_return_continue via cp_walk_tree. */
5761 struct check_for_return_continue_data
{
5762 hash_set
<tree
> *pset
;
5766 /* Helper function for potential_constant_expression_1 SWITCH_STMT handling,
5767 called through cp_walk_tree. Return the first RETURN_EXPR found, or note
5768 the first CONTINUE_STMT if RETURN_EXPR is not found. */
5770 check_for_return_continue (tree
*tp
, int *walk_subtrees
, void *data
)
5773 check_for_return_continue_data
*d
= (check_for_return_continue_data
*) data
;
5774 switch (TREE_CODE (t
))
5780 if (d
->continue_stmt
== NULL_TREE
)
5781 d
->continue_stmt
= t
;
5785 if (tree r = cp_walk_tree (&x, check_for_return_continue, data, \
5789 /* For loops, walk subtrees manually, so that continue stmts found
5790 inside of the bodies of the loops are ignored. */
5793 RECUR (DO_COND (t
));
5794 s
= d
->continue_stmt
;
5795 RECUR (DO_BODY (t
));
5796 d
->continue_stmt
= s
;
5801 RECUR (WHILE_COND (t
));
5802 s
= d
->continue_stmt
;
5803 RECUR (WHILE_BODY (t
));
5804 d
->continue_stmt
= s
;
5809 RECUR (FOR_INIT_STMT (t
));
5810 RECUR (FOR_COND (t
));
5811 RECUR (FOR_EXPR (t
));
5812 s
= d
->continue_stmt
;
5813 RECUR (FOR_BODY (t
));
5814 d
->continue_stmt
= s
;
5817 case RANGE_FOR_STMT
:
5819 RECUR (RANGE_FOR_EXPR (t
));
5820 s
= d
->continue_stmt
;
5821 RECUR (RANGE_FOR_BODY (t
));
5822 d
->continue_stmt
= s
;
5826 case STATEMENT_LIST
:
5839 /* Return true if T denotes a potentially constant expression. Issue
5840 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5841 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5842 consider the expression in the current context, independent of constexpr
5845 C++0x [expr.const] used to say
5847 6 An expression is a potential constant expression if it is
5848 a constant expression where all occurrences of function
5849 parameters are replaced by arbitrary constant expressions
5850 of the appropriate type.
5852 2 A conditional expression is a constant expression unless it
5853 involves one of the following as a potentially evaluated
5854 subexpression (3.2), but subexpressions of logical AND (5.14),
5855 logical OR (5.15), and conditional (5.16) operations that are
5856 not evaluated are not considered. */
5859 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5860 tsubst_flags_t flags
, tree
*jump_target
)
5862 #define RECUR(T,RV) \
5863 potential_constant_expression_1 ((T), (RV), strict, now, flags, jump_target)
5865 enum { any
= false, rval
= true };
5869 if (t
== error_mark_node
)
5873 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
5876 /* If we are jumping, ignore everything. This is simpler than the
5877 cxx_eval_constant_expression handling because we only need to be
5878 conservatively correct, and we don't necessarily have a constant value
5879 available, so we don't bother with switch tracking. */
5882 if (TREE_THIS_VOLATILE (t
) && want_rval
)
5884 if (flags
& tf_error
)
5885 error_at (loc
, "lvalue-to-rvalue conversion of a volatile lvalue "
5886 "%qE with type %qT", t
, TREE_TYPE (t
));
5889 if (CONSTANT_CLASS_P (t
))
5891 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5892 && TREE_TYPE (t
) == error_mark_node
)
5895 switch (TREE_CODE (t
))
5901 case TEMPLATE_ID_EXPR
:
5904 case CASE_LABEL_EXPR
:
5910 case TEMPLATE_PARM_INDEX
:
5912 case IDENTIFIER_NODE
:
5913 case USERDEF_LITERAL
:
5914 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5919 case PLACEHOLDER_EXPR
:
5922 case DEBUG_BEGIN_STMT
:
5926 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5938 if (flags
& tf_error
)
5939 error ("%qE is not a constant expression", t
);
5944 case AGGR_INIT_EXPR
:
5946 /* -- an invocation of a function other than a constexpr function
5947 or a constexpr constructor. */
5949 tree fun
= get_function_named_in_call (t
);
5950 const int nargs
= call_expr_nargs (t
);
5953 if (fun
== NULL_TREE
)
5955 /* Reset to allow the function to continue past the end
5956 of the block below. Otherwise return early. */
5959 if (TREE_CODE (t
) == CALL_EXPR
5960 && CALL_EXPR_FN (t
) == NULL_TREE
)
5961 switch (CALL_EXPR_IFN (t
))
5963 /* These should be ignored, they are optimized away from
5964 constexpr functions. */
5965 case IFN_UBSAN_NULL
:
5966 case IFN_UBSAN_BOUNDS
:
5967 case IFN_UBSAN_VPTR
:
5968 case IFN_FALLTHROUGH
:
5971 case IFN_ADD_OVERFLOW
:
5972 case IFN_SUB_OVERFLOW
:
5973 case IFN_MUL_OVERFLOW
:
5975 case IFN_VEC_CONVERT
:
5985 /* fold_call_expr can't do anything with IFN calls. */
5986 if (flags
& tf_error
)
5987 error_at (loc
, "call to internal function %qE", t
);
5992 if (fun
&& is_overloaded_fn (fun
))
5994 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5996 if (builtin_valid_in_constant_expr_p (fun
))
5998 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5999 /* Allow any built-in function; if the expansion
6000 isn't constant, we'll deal with that then. */
6001 && !fndecl_built_in_p (fun
))
6003 if (flags
& tf_error
)
6005 error_at (loc
, "call to non-%<constexpr%> function %qD",
6007 explain_invalid_constexpr_fn (fun
);
6011 /* A call to a non-static member function takes the address
6012 of the object as the first argument. But in a constant
6013 expression the address will be folded away, so look
6015 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
6016 && !DECL_CONSTRUCTOR_P (fun
))
6018 tree x
= get_nth_callarg (t
, 0);
6019 if (is_this_parameter (x
))
6021 /* Don't require an immediately constant value, as
6022 constexpr substitution might not use the value. */
6023 bool sub_now
= false;
6024 if (!potential_constant_expression_1 (x
, rval
, strict
,
6033 if (!RECUR (fun
, true))
6035 fun
= get_first_fn (fun
);
6037 /* Skip initial arguments to base constructors. */
6038 if (DECL_BASE_CONSTRUCTOR_P (fun
))
6039 i
= num_artificial_parms_for (fun
);
6040 fun
= DECL_ORIGIN (fun
);
6044 if (RECUR (fun
, rval
))
6045 /* Might end up being a constant function pointer. */;
6049 for (; i
< nargs
; ++i
)
6051 tree x
= get_nth_callarg (t
, i
);
6052 /* In a template, reference arguments haven't been converted to
6053 REFERENCE_TYPE and we might not even know if the parameter
6054 is a reference, so accept lvalue constants too. */
6055 bool rv
= processing_template_decl
? any
: rval
;
6056 /* Don't require an immediately constant value, as constexpr
6057 substitution might not use the value of the argument. */
6058 bool sub_now
= false;
6059 if (!potential_constant_expression_1 (x
, rv
, strict
,
6060 sub_now
, flags
, jump_target
))
6066 case NON_LVALUE_EXPR
:
6067 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
6068 -- an lvalue of integral type that refers to a non-volatile
6069 const variable or static data member initialized with
6070 constant expressions, or
6072 -- an lvalue of literal type that refers to non-volatile
6073 object defined with constexpr, or that refers to a
6074 sub-object of such an object; */
6075 return RECUR (TREE_OPERAND (t
, 0), rval
);
6078 if (DECL_HAS_VALUE_EXPR_P (t
))
6080 if (now
&& is_normal_capture_proxy (t
))
6082 /* -- in a lambda-expression, a reference to this or to a
6083 variable with automatic storage duration defined outside that
6084 lambda-expression, where the reference would be an
6086 if (flags
& tf_error
)
6088 tree cap
= DECL_CAPTURED_VARIABLE (t
);
6089 error ("lambda capture of %qE is not a constant expression",
6091 if (!want_rval
&& decl_constant_var_p (cap
))
6092 inform (input_location
, "because it is used as a glvalue");
6096 return RECUR (DECL_VALUE_EXPR (t
), rval
);
6099 && !var_in_maybe_constexpr_fn (t
)
6100 && !type_dependent_expression_p (t
)
6101 && !decl_maybe_constant_var_p (t
)
6103 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
6104 || (DECL_INITIAL (t
)
6105 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
6106 && COMPLETE_TYPE_P (TREE_TYPE (t
))
6107 && !is_really_empty_class (TREE_TYPE (t
), /*ignore_vptr*/false))
6109 if (flags
& tf_error
)
6110 non_const_var_error (t
);
6116 if (REINTERPRET_CAST_P (t
))
6118 if (flags
& tf_error
)
6119 error_at (loc
, "%<reinterpret_cast%> is not a constant expression");
6124 case VIEW_CONVERT_EXPR
:
6125 /* -- a reinterpret_cast. FIXME not implemented, and this rule
6126 may change to something more specific to type-punning (DR 1312). */
6128 tree from
= TREE_OPERAND (t
, 0);
6129 if (location_wrapper_p (t
))
6130 return (RECUR (from
, want_rval
));
6131 if (INDIRECT_TYPE_P (TREE_TYPE (t
)))
6133 STRIP_ANY_LOCATION_WRAPPER (from
);
6134 if (TREE_CODE (from
) == INTEGER_CST
6135 && !integer_zerop (from
))
6137 if (flags
& tf_error
)
6139 "%<reinterpret_cast%> from integer to pointer");
6143 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
6146 case ADDRESSOF_EXPR
:
6147 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
6148 t
= TREE_OPERAND (t
, 0);
6149 goto handle_addr_expr
;
6152 /* -- a unary operator & that is applied to an lvalue that
6153 designates an object with thread or automatic storage
6155 t
= TREE_OPERAND (t
, 0);
6157 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
6158 /* A pointer-to-member constant. */
6163 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
6164 any checking here, as we might dereference the pointer later. If
6165 we remove this code, also remove check_automatic_or_tls. */
6166 i
= check_automatic_or_tls (t
);
6171 if (flags
& tf_error
)
6172 error ("address-of an object %qE with thread local or "
6173 "automatic storage is not a constant expression", t
);
6177 return RECUR (t
, any
);
6185 /* -- a class member access unless its postfix-expression is
6186 of literal type or of pointer to literal type. */
6187 /* This test would be redundant, as it follows from the
6188 postfix-expression being a potential constant expression. */
6189 if (type_unknown_p (t
))
6191 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6193 case EXPR_PACK_EXPANSION
:
6194 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
6198 tree x
= TREE_OPERAND (t
, 0);
6200 if (is_this_parameter (x
) && !is_capture_proxy (x
))
6202 if (!var_in_maybe_constexpr_fn (x
))
6204 if (flags
& tf_error
)
6205 error_at (loc
, "use of %<this%> in a constant expression");
6210 return RECUR (x
, rval
);
6213 case STATEMENT_LIST
:
6215 tree_stmt_iterator i
;
6216 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
6218 if (!RECUR (tsi_stmt (i
), any
))
6226 if (cxx_dialect
< cxx14
)
6228 if (!RECUR (TREE_OPERAND (t
, 0), any
))
6230 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
6235 if (cxx_dialect
< cxx14
)
6237 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
6239 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
6244 if (!RECUR (DO_COND (t
), rval
))
6246 if (!RECUR (DO_BODY (t
), any
))
6248 if (breaks (jump_target
) || continues (jump_target
))
6249 *jump_target
= NULL_TREE
;
6253 if (!RECUR (FOR_INIT_STMT (t
), any
))
6256 if (!RECUR (tmp
, rval
))
6260 if (!processing_template_decl
)
6261 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6262 /* If we couldn't evaluate the condition, it might not ever be
6264 if (!integer_onep (tmp
))
6267 if (!RECUR (FOR_EXPR (t
), any
))
6269 if (!RECUR (FOR_BODY (t
), any
))
6271 if (breaks (jump_target
) || continues (jump_target
))
6272 *jump_target
= NULL_TREE
;
6275 case RANGE_FOR_STMT
:
6276 if (!RECUR (RANGE_FOR_INIT_STMT (t
), any
))
6278 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
6280 if (!RECUR (RANGE_FOR_BODY (t
), any
))
6282 if (breaks (jump_target
) || continues (jump_target
))
6283 *jump_target
= NULL_TREE
;
6287 tmp
= WHILE_COND (t
);
6288 if (!RECUR (tmp
, rval
))
6290 if (!processing_template_decl
)
6291 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6292 /* If we couldn't evaluate the condition, it might not ever be true. */
6293 if (!integer_onep (tmp
))
6295 if (!RECUR (WHILE_BODY (t
), any
))
6297 if (breaks (jump_target
) || continues (jump_target
))
6298 *jump_target
= NULL_TREE
;
6302 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
6304 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
6305 unreachable labels would be checked and it is enough if there is
6306 a single switch cond value for which it is a valid constant
6307 expression. We need to check if there are any RETURN_EXPRs
6308 or CONTINUE_STMTs inside of the body though, as in that case
6309 we need to set *jump_target. */
6312 hash_set
<tree
> pset
;
6313 check_for_return_continue_data data
= { &pset
, NULL_TREE
};
6315 = cp_walk_tree (&SWITCH_STMT_BODY (t
), check_for_return_continue
,
6317 /* The switch might return. */
6318 *jump_target
= ret_expr
;
6319 else if (data
.continue_stmt
)
6320 /* The switch can't return, but might continue. */
6321 *jump_target
= data
.continue_stmt
;
6326 return RECUR (STMT_EXPR_STMT (t
), rval
);
6329 if (cxx_dialect
>= cxx17
)
6330 /* In C++17 lambdas can be constexpr, don't give up yet. */
6332 else if (flags
& tf_error
)
6333 error_at (loc
, "lambda-expression is not a constant expression "
6337 case DYNAMIC_CAST_EXPR
:
6338 case PSEUDO_DTOR_EXPR
:
6342 case VEC_DELETE_EXPR
:
6348 case OMP_DISTRIBUTE
:
6351 case OMP_TARGET_DATA
:
6360 case OMP_TARGET_UPDATE
:
6361 case OMP_TARGET_ENTER_DATA
:
6362 case OMP_TARGET_EXIT_DATA
:
6364 case OMP_ATOMIC_READ
:
6365 case OMP_ATOMIC_CAPTURE_OLD
:
6366 case OMP_ATOMIC_CAPTURE_NEW
:
6371 case OACC_HOST_DATA
:
6375 case OACC_ENTER_DATA
:
6376 case OACC_EXIT_DATA
:
6378 /* GCC internal stuff. */
6380 case TRANSACTION_EXPR
:
6382 case AT_ENCODE_EXPR
:
6384 if (flags
& tf_error
)
6385 error_at (loc
, "expression %qE is not a constant expression", t
);
6389 if (cxx_dialect
>= cxx2a
)
6390 /* In C++2a virtual calls can be constexpr, don't give up yet. */
6392 else if (flags
& tf_error
)
6394 "virtual functions cannot be %<constexpr%> before C++2a");
6398 /* -- a typeid expression whose operand is of polymorphic
6401 tree e
= TREE_OPERAND (t
, 0);
6402 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
6403 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
6405 if (flags
& tf_error
)
6406 error_at (loc
, "%<typeid%> is not a constant expression "
6407 "because %qE is of polymorphic type", e
);
6413 case POINTER_DIFF_EXPR
:
6427 case PREINCREMENT_EXPR
:
6428 case POSTINCREMENT_EXPR
:
6429 case PREDECREMENT_EXPR
:
6430 case POSTDECREMENT_EXPR
:
6431 if (cxx_dialect
< cxx14
)
6437 if (TYPE_P (TREE_OPERAND (t
, 0)))
6443 case FIX_TRUNC_EXPR
:
6448 case TRUTH_NOT_EXPR
:
6449 case FIXED_CONVERT_EXPR
:
6450 case UNARY_PLUS_EXPR
:
6451 case UNARY_LEFT_FOLD_EXPR
:
6452 case UNARY_RIGHT_FOLD_EXPR
:
6454 return RECUR (TREE_OPERAND (t
, 0), rval
);
6457 case CONST_CAST_EXPR
:
6458 case STATIC_CAST_EXPR
:
6459 case REINTERPRET_CAST_EXPR
:
6460 case IMPLICIT_CONV_EXPR
:
6461 if (cxx_dialect
< cxx11
6462 && !dependent_type_p (TREE_TYPE (t
))
6463 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
6464 /* In C++98, a conversion to non-integral type can't be part of a
6465 constant expression. */
6467 if (flags
& tf_error
)
6469 "cast to non-integral type %qT in a constant expression",
6473 /* This might be a conversion from a class to a (potentially) literal
6474 type. Let's consider it potentially constant since the conversion
6475 might be a constexpr user-defined conversion. */
6476 else if (cxx_dialect
>= cxx11
6477 && (dependent_type_p (TREE_TYPE (t
))
6478 || !COMPLETE_TYPE_P (TREE_TYPE (t
))
6479 || literal_type_p (TREE_TYPE (t
)))
6480 && TREE_OPERAND (t
, 0))
6482 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6483 /* If this is a dependent type, it could end up being a class
6484 with conversions. */
6485 if (type
== NULL_TREE
|| WILDCARD_TYPE_P (type
))
6487 /* Or a non-dependent class which has conversions. */
6488 else if (CLASS_TYPE_P (type
)
6489 && (TYPE_HAS_CONVERSION (type
) || dependent_scope_p (type
)))
6493 return (RECUR (TREE_OPERAND (t
, 0),
6494 !TYPE_REF_P (TREE_TYPE (t
))));
6497 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
6499 case CLEANUP_POINT_EXPR
:
6500 case MUST_NOT_THROW_EXPR
:
6501 case TRY_CATCH_EXPR
:
6506 case NON_DEPENDENT_EXPR
:
6507 /* For convenience. */
6510 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6513 tmp
= DECL_EXPR_DECL (t
);
6514 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
6516 if (TREE_STATIC (tmp
))
6518 if (flags
& tf_error
)
6519 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6520 "%<static%> in %<constexpr%> context", tmp
);
6523 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
6525 if (flags
& tf_error
)
6526 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6527 "%<thread_local%> in %<constexpr%> context", tmp
);
6530 else if (!check_for_uninitialized_const_var
6531 (tmp
, /*constexpr_context_p=*/true, flags
))
6534 return RECUR (tmp
, want_rval
);
6536 case TRY_FINALLY_EXPR
:
6537 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
6538 && RECUR (TREE_OPERAND (t
, 1), any
));
6541 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6544 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
6545 && !literal_type_p (TREE_TYPE (t
)))
6547 if (flags
& tf_error
)
6549 auto_diagnostic_group d
;
6550 error_at (loc
, "temporary of non-literal type %qT in a "
6551 "constant expression", TREE_TYPE (t
));
6552 explain_non_literal_class (TREE_TYPE (t
));
6558 return RECUR (TREE_OPERAND (t
, 1), rval
);
6562 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
6563 constructor_elt
*ce
;
6564 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
6565 if (!RECUR (ce
->value
, want_rval
))
6572 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
6573 || DECL_P (TREE_PURPOSE (t
)));
6574 if (!RECUR (TREE_VALUE (t
), want_rval
))
6576 if (TREE_CHAIN (t
) == NULL_TREE
)
6578 return RECUR (TREE_CHAIN (t
), want_rval
);
6581 case TRUNC_DIV_EXPR
:
6583 case FLOOR_DIV_EXPR
:
6584 case ROUND_DIV_EXPR
:
6585 case TRUNC_MOD_EXPR
:
6587 case ROUND_MOD_EXPR
:
6589 tree denom
= TREE_OPERAND (t
, 1);
6590 if (!RECUR (denom
, rval
))
6592 /* We can't call cxx_eval_outermost_constant_expr on an expression
6593 that hasn't been through instantiate_non_dependent_expr yet. */
6594 if (!processing_template_decl
)
6595 denom
= cxx_eval_outermost_constant_expr (denom
, true);
6596 if (integer_zerop (denom
))
6598 if (flags
& tf_error
)
6599 error ("division by zero is not a constant expression");
6605 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6611 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6612 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6613 introduced by build_call_a. */
6614 tree op0
= TREE_OPERAND (t
, 0);
6615 tree op1
= TREE_OPERAND (t
, 1);
6617 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
6618 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
6619 return RECUR (op0
, want_rval
);
6624 /* If the first operand is the non-short-circuit constant, look at
6625 the second operand; otherwise we only care about the first one for
6627 case TRUTH_AND_EXPR
:
6628 case TRUTH_ANDIF_EXPR
:
6629 tmp
= boolean_true_node
;
6632 case TRUTH_ORIF_EXPR
:
6633 tmp
= boolean_false_node
;
6636 tree op
= TREE_OPERAND (t
, 0);
6637 if (!RECUR (op
, rval
))
6639 if (!processing_template_decl
)
6640 op
= cxx_eval_outermost_constant_expr (op
, true);
6641 if (tree_int_cst_equal (op
, tmp
))
6642 return RECUR (TREE_OPERAND (t
, 1), rval
);
6649 case POINTER_PLUS_EXPR
:
6651 case EXACT_DIV_EXPR
:
6661 case TRUTH_XOR_EXPR
:
6662 case UNORDERED_EXPR
:
6675 case ARRAY_RANGE_REF
:
6679 case BINARY_LEFT_FOLD_EXPR
:
6680 case BINARY_RIGHT_FOLD_EXPR
:
6682 for (i
= 0; i
< 2; ++i
)
6683 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
6688 for (i
= 0; i
< 3; ++i
)
6689 if (!RECUR (TREE_OPERAND (t
, i
), true))
6694 if (COND_EXPR_IS_VEC_DELETE (t
))
6696 if (flags
& tf_error
)
6697 error_at (loc
, "%<delete[]%> is not a constant expression");
6703 /* If the condition is a known constant, we know which of the legs we
6704 care about; otherwise we only require that the condition and
6705 either of the legs be potentially constant. */
6706 tmp
= TREE_OPERAND (t
, 0);
6707 if (!RECUR (tmp
, rval
))
6709 if (!processing_template_decl
)
6710 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6711 if (integer_zerop (tmp
))
6712 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
6713 else if (TREE_CODE (tmp
) == INTEGER_CST
)
6714 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6715 for (i
= 1; i
< 3; ++i
)
6716 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
6717 want_rval
, strict
, now
,
6718 tf_none
, jump_target
))
6720 if (flags
& tf_error
)
6721 error_at (loc
, "expression %qE is not a constant expression", t
);
6725 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
6727 if (flags
& tf_error
)
6729 error_at (loc
, "non-constant array initialization");
6730 diagnose_non_constexpr_vec_init (t
);
6736 /* We can see these in statement-expressions. */
6740 case EMPTY_CLASS_EXPR
:
6746 tree
*target
= &TREE_OPERAND (t
, 0);
6747 /* Gotos representing break and continue are OK. */
6748 if (breaks (target
) || continues (target
))
6750 *jump_target
= *target
;
6753 if (flags
& tf_error
)
6754 error_at (loc
, "%<goto%> is not a constant expression");
6759 return RECUR (TREE_OPERAND (t
, 0), rval
);
6762 if (objc_is_property_ref (t
))
6765 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6773 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
6774 tsubst_flags_t flags
)
6776 tree target
= NULL_TREE
;
6777 return potential_constant_expression_1 (t
, want_rval
, strict
, now
,
6781 /* The main entry point to the above. */
6784 potential_constant_expression (tree t
)
6786 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6789 /* As above, but require a constant rvalue. */
6792 potential_rvalue_constant_expression (tree t
)
6794 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6797 /* Like above, but complain about non-constant expressions. */
6800 require_potential_constant_expression (tree t
)
6802 return potential_constant_expression_1 (t
, false, true, false,
6803 tf_warning_or_error
);
6806 /* Cross product of the above. */
6809 require_potential_rvalue_constant_expression (tree t
)
6811 return potential_constant_expression_1 (t
, true, true, false,
6812 tf_warning_or_error
);
6815 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6818 require_rvalue_constant_expression (tree t
)
6820 return potential_constant_expression_1 (t
, true, true, true,
6821 tf_warning_or_error
);
6824 /* Like potential_constant_expression, but don't consider possible constexpr
6825 substitution of the current function. That is, PARM_DECL qualifies under
6826 potential_constant_expression, but not here.
6828 This is basically what you can check when any actual constant values might
6829 be value-dependent. */
6832 is_constant_expression (tree t
)
6834 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6837 /* Like above, but complain about non-constant expressions. */
6840 require_constant_expression (tree t
)
6842 return potential_constant_expression_1 (t
, false, true, true,
6843 tf_warning_or_error
);
6846 /* Like is_constant_expression, but allow const variables that are not allowed
6847 under constexpr rules. */
6850 is_static_init_expression (tree t
)
6852 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6855 /* Returns true if T is a potential constant expression that is not
6856 instantiation-dependent, and therefore a candidate for constant folding even
6860 is_nondependent_constant_expression (tree t
)
6862 return (!type_unknown_p (t
)
6863 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6864 && is_constant_expression (t
)
6865 && !instantiation_dependent_expression_p (t
));
6868 /* Returns true if T is a potential static initializer expression that is not
6869 instantiation-dependent. */
6872 is_nondependent_static_init_expression (tree t
)
6874 return (!type_unknown_p (t
)
6875 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6876 && is_static_init_expression (t
)
6877 && !instantiation_dependent_expression_p (t
));
6880 /* Finalize constexpr processing after parsing. */
6883 fini_constexpr (void)
6885 /* The contexpr call and fundef copies tables are no longer needed. */
6886 constexpr_call_table
= NULL
;
6887 fundef_copies_table
= NULL
;
6890 #include "gt-cp-constexpr.h"