1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2018 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
34 #include "gimple-fold.h"
37 static bool verify_constant (tree
, bool, bool *, bool *);
38 #define VERIFY_CONSTANT(X) \
40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
44 /* Returns true iff FUN is an instantiation of a constexpr function
45 template or a defaulted constexpr function. */
48 is_instantiation_of_constexpr (tree fun
)
50 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
52 || (DECL_DEFAULTED_FN (fun
)
53 && DECL_DECLARED_CONSTEXPR_P (fun
)));
56 /* Return true if T is a literal type. */
59 literal_type_p (tree t
)
63 || TREE_CODE (t
) == REFERENCE_TYPE
64 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
68 t
= complete_type (t
);
69 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
70 return CLASSTYPE_LITERAL_P (t
);
72 if (TREE_CODE (t
) == ARRAY_TYPE
)
73 return literal_type_p (strip_array_types (t
));
77 /* If DECL is a variable declared `constexpr', require its type
78 be literal. Return error_mark_node if we give an error, the
82 ensure_literal_type_for_constexpr_object (tree decl
)
84 tree type
= TREE_TYPE (decl
);
86 && (DECL_DECLARED_CONSTEXPR_P (decl
)
87 || var_in_constexpr_fn (decl
))
88 && !processing_template_decl
)
90 tree stype
= strip_array_types (type
);
91 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
92 /* Don't complain here, we'll complain about incompleteness
93 when we try to initialize the variable. */;
94 else if (!literal_type_p (type
))
96 if (DECL_DECLARED_CONSTEXPR_P (decl
))
98 error ("the type %qT of %<constexpr%> variable %qD "
99 "is not literal", type
, decl
);
100 explain_non_literal_class (type
);
101 decl
= error_mark_node
;
105 if (!is_instantiation_of_constexpr (current_function_decl
))
107 error ("variable %qD of non-literal type %qT in %<constexpr%> "
108 "function", decl
, type
);
109 explain_non_literal_class (type
);
110 decl
= error_mark_node
;
112 cp_function_chain
->invalid_constexpr
= true;
115 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
116 && variably_modified_type_p (type
, NULL_TREE
))
118 error ("%<constexpr%> variable %qD has variably-modified type %qT",
120 decl
= error_mark_node
;
126 /* Representation of entries in the constexpr function definition table. */
128 struct GTY((for_user
)) constexpr_fundef
{
133 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
135 static hashval_t
hash (constexpr_fundef
*);
136 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
139 /* This table holds all constexpr function definitions seen in
140 the current translation unit. */
142 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
144 /* Utility function used for managing the constexpr function table.
145 Return true if the entries pointed to by P and Q are for the
146 same constexpr function. */
149 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
151 return lhs
->decl
== rhs
->decl
;
154 /* Utility function used for managing the constexpr function table.
155 Return a hash value for the entry pointed to by Q. */
158 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
160 return DECL_UID (fundef
->decl
);
163 /* Return a previously saved definition of function FUN. */
165 static constexpr_fundef
*
166 retrieve_constexpr_fundef (tree fun
)
168 constexpr_fundef fundef
= { NULL
, NULL
};
169 if (constexpr_fundef_table
== NULL
)
173 return constexpr_fundef_table
->find (&fundef
);
176 /* Check whether the parameter and return types of FUN are valid for a
177 constexpr function, and complain if COMPLAIN. */
180 is_valid_constexpr_fn (tree fun
, bool complain
)
184 if (DECL_INHERITED_CTOR (fun
)
185 && TREE_CODE (fun
) == TEMPLATE_DECL
)
189 error ("inherited constructor %qD is not %<constexpr%>",
190 DECL_INHERITED_CTOR (fun
));
194 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
195 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
196 if (!literal_type_p (TREE_TYPE (parm
)))
201 error ("invalid type for parameter %d of %<constexpr%> "
202 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
203 explain_non_literal_class (TREE_TYPE (parm
));
208 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
212 inform (DECL_SOURCE_LOCATION (fun
),
213 "lambdas are implicitly %<constexpr%> only in C++17 and later");
215 else if (!DECL_CONSTRUCTOR_P (fun
))
217 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
218 if (!literal_type_p (rettype
))
223 error ("invalid return type %qT of %<constexpr%> function %q+D",
225 explain_non_literal_class (rettype
);
229 /* C++14 DR 1684 removed this restriction. */
230 if (cxx_dialect
< cxx14
231 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
232 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
236 && pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
237 "enclosing class of %<constexpr%> non-static member "
238 "function %q+#D is not a literal type", fun
))
239 explain_non_literal_class (DECL_CONTEXT (fun
));
242 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
246 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
252 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
253 for a member of an anonymous aggregate, INIT is the initializer for that
254 member, and VEC_OUTER is the vector of constructor elements for the class
255 whose constructor we are processing. Add the initializer to the vector
256 and return true to indicate success. */
259 build_anon_member_initialization (tree member
, tree init
,
260 vec
<constructor_elt
, va_gc
> **vec_outer
)
262 /* MEMBER presents the relevant fields from the inside out, but we need
263 to build up the initializer from the outside in so that we can reuse
264 previously built CONSTRUCTORs if this is, say, the second field in an
265 anonymous struct. So we use a vec as a stack. */
266 auto_vec
<tree
, 2> fields
;
269 fields
.safe_push (TREE_OPERAND (member
, 1));
270 member
= TREE_OPERAND (member
, 0);
272 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
273 && TREE_CODE (member
) == COMPONENT_REF
);
275 /* VEC has the constructor elements vector for the context of FIELD.
276 If FIELD is an anonymous aggregate, we will push inside it. */
277 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
279 while (field
= fields
.pop(),
280 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
283 /* If there is already an outer constructor entry for the anonymous
284 aggregate FIELD, use it; otherwise, insert one. */
285 if (vec_safe_is_empty (*vec
)
286 || (*vec
)->last().index
!= field
)
288 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
289 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
292 ctor
= (*vec
)->last().value
;
293 vec
= &CONSTRUCTOR_ELTS (ctor
);
296 /* Now we're at the innermost field, the one that isn't an anonymous
297 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
298 gcc_assert (fields
.is_empty());
299 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
304 /* Subroutine of build_constexpr_constructor_member_initializers.
305 The expression tree T represents a data member initialization
306 in a (constexpr) constructor definition. Build a pairing of
307 the data member with its initializer, and prepend that pair
308 to the existing initialization pair INITS. */
311 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
314 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
315 t
= TREE_OPERAND (t
, 0);
316 if (TREE_CODE (t
) == EXPR_STMT
)
317 t
= TREE_OPERAND (t
, 0);
318 if (t
== error_mark_node
)
320 if (TREE_CODE (t
) == STATEMENT_LIST
)
322 tree_stmt_iterator i
;
323 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
325 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
330 if (TREE_CODE (t
) == CLEANUP_STMT
)
332 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
333 but we can in a constexpr constructor for a non-literal class. Just
334 ignore it; either all the initialization will be constant, in which
335 case the cleanup can't run, or it can't be constexpr.
336 Still recurse into CLEANUP_BODY. */
337 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
339 if (TREE_CODE (t
) == CONVERT_EXPR
)
340 t
= TREE_OPERAND (t
, 0);
341 if (TREE_CODE (t
) == INIT_EXPR
342 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
343 use what this function builds for cx_check_missing_mem_inits, and
344 assignment in the ctor body doesn't count. */
345 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
347 member
= TREE_OPERAND (t
, 0);
348 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
350 else if (TREE_CODE (t
) == CALL_EXPR
)
352 tree fn
= get_callee_fndecl (t
);
353 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
354 /* We're only interested in calls to subobject constructors. */
356 member
= CALL_EXPR_ARG (t
, 0);
357 /* We don't use build_cplus_new here because it complains about
358 abstract bases. Leaving the call unwrapped means that it has the
359 wrong type, but cxx_eval_constant_expression doesn't care. */
360 init
= break_out_target_exprs (t
);
362 else if (TREE_CODE (t
) == BIND_EXPR
)
363 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
365 /* Don't add anything else to the CONSTRUCTOR. */
367 if (INDIRECT_REF_P (member
))
368 member
= TREE_OPERAND (member
, 0);
369 if (TREE_CODE (member
) == NOP_EXPR
)
373 if (TREE_CODE (op
) == ADDR_EXPR
)
375 gcc_assert (same_type_ignoring_top_level_qualifiers_p
376 (TREE_TYPE (TREE_TYPE (op
)),
377 TREE_TYPE (TREE_TYPE (member
))));
378 /* Initializing a cv-qualified member; we need to look through
382 else if (op
== current_class_ptr
383 && (same_type_ignoring_top_level_qualifiers_p
384 (TREE_TYPE (TREE_TYPE (member
)),
385 current_class_type
)))
386 /* Delegating constructor. */
390 /* This is an initializer for an empty base; keep it for now so
391 we can check it in cxx_eval_bare_aggregate. */
392 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
395 if (TREE_CODE (member
) == ADDR_EXPR
)
396 member
= TREE_OPERAND (member
, 0);
397 if (TREE_CODE (member
) == COMPONENT_REF
)
399 tree aggr
= TREE_OPERAND (member
, 0);
400 if (TREE_CODE (aggr
) == VAR_DECL
)
401 /* Initializing a local variable, don't add anything. */
403 if (TREE_CODE (aggr
) != COMPONENT_REF
)
404 /* Normal member initialization. */
405 member
= TREE_OPERAND (member
, 1);
406 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
407 /* Initializing a member of an anonymous union. */
408 return build_anon_member_initialization (member
, init
, vec
);
410 /* We're initializing a vtable pointer in a base. Leave it as
411 COMPONENT_REF so we remember the path to get to the vfield. */
412 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
415 /* Value-initialization can produce multiple initializers for the
416 same field; use the last one. */
417 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
418 (*vec
)->last().value
= init
;
420 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
424 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
425 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
426 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
429 check_constexpr_bind_expr_vars (tree t
)
431 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
433 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
434 if (TREE_CODE (var
) == TYPE_DECL
435 && DECL_IMPLICIT_TYPEDEF_P (var
)
436 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
441 /* Subroutine of check_constexpr_ctor_body. */
444 check_constexpr_ctor_body_1 (tree last
, tree list
)
446 switch (TREE_CODE (list
))
449 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
450 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
454 case CLEANUP_POINT_EXPR
:
455 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
459 if (!check_constexpr_bind_expr_vars (list
)
460 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
467 case DEBUG_BEGIN_STMT
:
475 /* Make sure that there are no statements after LAST in the constructor
476 body represented by LIST. */
479 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
481 /* C++14 doesn't require a constexpr ctor to have an empty body. */
482 if (cxx_dialect
>= cxx14
)
486 if (TREE_CODE (list
) == STATEMENT_LIST
)
488 tree_stmt_iterator i
= tsi_last (list
);
489 for (; !tsi_end_p (i
); tsi_prev (&i
))
491 tree t
= tsi_stmt (i
);
494 if (!check_constexpr_ctor_body_1 (last
, t
))
501 else if (list
!= last
502 && !check_constexpr_ctor_body_1 (last
, list
))
507 error ("%<constexpr%> constructor does not have empty body");
508 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
513 /* V is a vector of constructor elements built up for the base and member
514 initializers of a constructor for TYPE. They need to be in increasing
515 offset order, which they might not be yet if TYPE has a primary base
516 which is not first in the base-clause or a vptr and at least one base
517 all of which are non-primary. */
519 static vec
<constructor_elt
, va_gc
> *
520 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
522 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
528 field_type
= BINFO_TYPE (pri
);
529 else if (TYPE_CONTAINS_VPTR_P (type
))
530 field_type
= vtbl_ptr_type_node
;
534 /* Find the element for the primary base or vptr and move it to the
535 beginning of the vec. */
536 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
537 if (TREE_TYPE (ce
->index
) == field_type
)
540 if (i
> 0 && i
< vec_safe_length (v
))
542 vec
<constructor_elt
, va_gc
> &vref
= *v
;
543 constructor_elt elt
= vref
[i
];
552 /* Build compile-time evalable representations of member-initializer list
553 for a constexpr constructor. */
556 build_constexpr_constructor_member_initializers (tree type
, tree body
)
558 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
561 switch (TREE_CODE (body
))
563 case MUST_NOT_THROW_EXPR
:
565 body
= TREE_OPERAND (body
, 0);
569 for (tree_stmt_iterator i
= tsi_start (body
);
570 !tsi_end_p (i
); tsi_next (&i
))
573 if (TREE_CODE (body
) == BIND_EXPR
)
579 body
= BIND_EXPR_BODY (body
);
586 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
588 body
= TREE_OPERAND (body
, 0);
589 if (TREE_CODE (body
) == EXPR_STMT
)
590 body
= TREE_OPERAND (body
, 0);
591 if (TREE_CODE (body
) == INIT_EXPR
592 && (same_type_ignoring_top_level_qualifiers_p
593 (TREE_TYPE (TREE_OPERAND (body
, 0)),
594 current_class_type
)))
597 return TREE_OPERAND (body
, 1);
599 ok
= build_data_member_initialization (body
, &vec
);
601 else if (TREE_CODE (body
) == STATEMENT_LIST
)
603 tree_stmt_iterator i
;
604 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
606 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
611 else if (TREE_CODE (body
) == TRY_BLOCK
)
613 error ("body of %<constexpr%> constructor cannot be "
614 "a function-try-block");
615 return error_mark_node
;
617 else if (EXPR_P (body
))
618 ok
= build_data_member_initialization (body
, &vec
);
620 gcc_assert (errorcount
> 0);
623 if (vec_safe_length (vec
) > 0)
625 /* In a delegating constructor, return the target. */
626 constructor_elt
*ce
= &(*vec
)[0];
627 if (ce
->index
== current_class_ptr
)
634 vec
= sort_constexpr_mem_initializers (type
, vec
);
635 return build_constructor (type
, vec
);
638 return error_mark_node
;
641 /* We have an expression tree T that represents a call, either CALL_EXPR
642 or AGGR_INIT_EXPR. If the call is lexically to a named function,
643 retrun the _DECL for that function. */
646 get_function_named_in_call (tree t
)
648 tree fun
= cp_get_callee (t
);
649 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
650 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
651 fun
= TREE_OPERAND (fun
, 0);
655 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
656 declared to be constexpr, or a sub-statement thereof. Returns the
657 return value if suitable, error_mark_node for a statement not allowed in
658 a constexpr function, or NULL_TREE if no return value was found. */
661 constexpr_fn_retval (tree body
)
663 switch (TREE_CODE (body
))
667 tree_stmt_iterator i
;
668 tree expr
= NULL_TREE
;
669 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
671 tree s
= constexpr_fn_retval (tsi_stmt (i
));
672 if (s
== error_mark_node
)
673 return error_mark_node
;
674 else if (s
== NULL_TREE
)
675 /* Keep iterating. */;
677 /* Multiple return statements. */
678 return error_mark_node
;
686 return break_out_target_exprs (TREE_OPERAND (body
, 0));
690 tree decl
= DECL_EXPR_DECL (body
);
691 if (TREE_CODE (decl
) == USING_DECL
692 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
693 || DECL_ARTIFICIAL (decl
))
695 return error_mark_node
;
698 case CLEANUP_POINT_EXPR
:
699 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
702 if (!check_constexpr_bind_expr_vars (body
))
703 return error_mark_node
;
704 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
707 case DEBUG_BEGIN_STMT
:
712 tree fun
= get_function_named_in_call (body
);
714 && DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
)
720 return error_mark_node
;
724 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
725 FUN; do the necessary transformations to turn it into a single expression
726 that we can store in the hash table. */
729 massage_constexpr_body (tree fun
, tree body
)
731 if (DECL_CONSTRUCTOR_P (fun
))
732 body
= build_constexpr_constructor_member_initializers
733 (DECL_CONTEXT (fun
), body
);
734 else if (cxx_dialect
< cxx14
)
736 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
737 body
= EH_SPEC_STMTS (body
);
738 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
739 body
= TREE_OPERAND (body
, 0);
740 body
= constexpr_fn_retval (body
);
745 /* CTYPE is a type constructed from BODY. Return true if some
746 bases/fields are uninitialized, and complain if COMPLAIN. */
749 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
755 if (TREE_CODE (body
) != CONSTRUCTOR
)
757 nelts
= CONSTRUCTOR_NELTS (body
);
759 tree field
= TYPE_FIELDS (ctype
);
761 if (TREE_CODE (ctype
) == UNION_TYPE
)
763 if (nelts
== 0 && next_initializable_field (field
))
766 error ("%<constexpr%> constructor for union %qT must "
767 "initialize exactly one non-static data member", ctype
);
773 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
774 need an explicit initialization. */
776 for (unsigned i
= 0; i
<= nelts
; ++i
)
778 tree index
= NULL_TREE
;
781 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
782 /* Skip base and vtable inits. */
783 if (TREE_CODE (index
) != FIELD_DECL
784 || DECL_ARTIFICIAL (index
))
788 for (; field
!= index
; field
= DECL_CHAIN (field
))
791 if (TREE_CODE (field
) != FIELD_DECL
)
793 if (DECL_UNNAMED_BIT_FIELD (field
))
795 if (DECL_ARTIFICIAL (field
))
797 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
799 /* Recurse to check the anonummous aggregate member. */
800 bad
|= cx_check_missing_mem_inits
801 (TREE_TYPE (field
), NULL_TREE
, complain
);
802 if (bad
&& !complain
)
806 ftype
= strip_array_types (TREE_TYPE (field
));
807 if (type_has_constexpr_default_constructor (ftype
))
809 /* It's OK to skip a member with a trivial constexpr ctor.
810 A constexpr ctor that isn't trivial should have been
812 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
818 error ("member %qD must be initialized by mem-initializer "
819 "in %<constexpr%> constructor", field
);
820 inform (DECL_SOURCE_LOCATION (field
), "declared here");
823 if (field
== NULL_TREE
)
826 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
828 /* Check the anonymous aggregate initializer is valid. */
829 bad
|= cx_check_missing_mem_inits
830 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
831 if (bad
&& !complain
)
834 field
= DECL_CHAIN (field
);
840 /* We are processing the definition of the constexpr function FUN.
841 Check that its BODY fulfills the propriate requirements and
842 enter it in the constexpr function definition table.
843 For constructor BODY is actually the TREE_LIST of the
844 member-initializer list. */
847 register_constexpr_fundef (tree fun
, tree body
)
849 constexpr_fundef entry
;
850 constexpr_fundef
**slot
;
852 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
855 tree massaged
= massage_constexpr_body (fun
, body
);
856 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
858 if (!DECL_CONSTRUCTOR_P (fun
))
859 error ("body of %<constexpr%> function %qD not a return-statement",
864 if (!potential_rvalue_constant_expression (massaged
))
866 if (!DECL_GENERATED_P (fun
))
867 require_potential_rvalue_constant_expression (massaged
);
871 if (DECL_CONSTRUCTOR_P (fun
)
872 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
873 massaged
, !DECL_GENERATED_P (fun
)))
876 /* Create the constexpr function table if necessary. */
877 if (constexpr_fundef_table
== NULL
)
878 constexpr_fundef_table
879 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
883 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
885 gcc_assert (*slot
== NULL
);
886 *slot
= ggc_alloc
<constexpr_fundef
> ();
892 /* FUN is a non-constexpr function called in a context that requires a
893 constant expression. If it comes from a constexpr template, explain why
894 the instantiation isn't constexpr. */
897 explain_invalid_constexpr_fn (tree fun
)
899 static hash_set
<tree
> *diagnosed
;
902 /* Only diagnose defaulted functions, lambdas, or instantiations. */
903 if (!DECL_DEFAULTED_FN (fun
)
904 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
905 && !is_instantiation_of_constexpr (fun
))
907 if (diagnosed
== NULL
)
908 diagnosed
= new hash_set
<tree
>;
909 if (diagnosed
->add (fun
))
910 /* Already explained. */
913 save_loc
= input_location
;
914 if (!lambda_static_thunk_p (fun
))
916 /* Diagnostics should completely ignore the static thunk, so leave
917 input_location set to our caller's location. */
918 input_location
= DECL_SOURCE_LOCATION (fun
);
919 inform (input_location
,
920 "%qD is not usable as a %<constexpr%> function because:", fun
);
922 /* First check the declaration. */
923 if (is_valid_constexpr_fn (fun
, true))
925 /* Then if it's OK, the body. */
926 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
927 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
928 explain_implicit_non_constexpr (fun
);
931 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
932 require_potential_rvalue_constant_expression (body
);
933 if (DECL_CONSTRUCTOR_P (fun
))
934 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
937 input_location
= save_loc
;
940 /* Objects of this type represent calls to constexpr functions
941 along with the bindings of parameters to their arguments, for
942 the purpose of compile time evaluation. */
944 struct GTY((for_user
)) constexpr_call
{
945 /* Description of the constexpr function definition. */
946 constexpr_fundef
*fundef
;
947 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
948 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
949 Note: This arrangement is made to accommodate the use of
950 iterative_hash_template_arg (see pt.c). If you change this
951 representation, also change the hash calculation in
952 cxx_eval_call_expression. */
954 /* Result of the call.
955 NULL means the call is being evaluated.
956 error_mark_node means that the evaluation was erroneous;
957 otherwise, the actuall value of the call. */
959 /* The hash of this call; we remember it here to avoid having to
960 recalculate it when expanding the hash table. */
964 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
966 static hashval_t
hash (constexpr_call
*);
967 static bool equal (constexpr_call
*, constexpr_call
*);
970 enum constexpr_switch_state
{
971 /* Used when processing a switch for the first time by cxx_eval_switch_expr
972 and default: label for that switch has not been seen yet. */
973 css_default_not_seen
,
974 /* Used when processing a switch for the first time by cxx_eval_switch_expr
975 and default: label for that switch has been seen already. */
977 /* Used when processing a switch for the second time by
978 cxx_eval_switch_expr, where default: label should match. */
979 css_default_processing
982 /* The constexpr expansion context. CALL is the current function
983 expansion, CTOR is the current aggregate initializer, OBJECT is the
984 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
985 is a map of values of variables initialized within the expression. */
987 struct constexpr_ctx
{
988 /* The innermost call we're evaluating. */
989 constexpr_call
*call
;
990 /* Values for any temporaries or local variables within the
991 constant-expression. */
992 hash_map
<tree
,tree
> *values
;
993 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
994 aren't inside a loop. */
995 hash_set
<tree
> *save_exprs
;
996 /* The CONSTRUCTOR we're currently building up for an aggregate
999 /* The object we're building the CONSTRUCTOR for. */
1001 /* If inside SWITCH_EXPR. */
1002 constexpr_switch_state
*css_state
;
1003 /* Whether we should error on a non-constant expression or fail quietly. */
1005 /* Whether we are strictly conforming to constant expression rules or
1006 trying harder to get a constant value. */
1010 /* A table of all constexpr calls that have been evaluated by the
1011 compiler in this translation unit. */
1013 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1015 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1016 bool, bool *, bool *, tree
* = NULL
);
1018 /* Compute a hash value for a constexpr call representation. */
1021 constexpr_call_hasher::hash (constexpr_call
*info
)
1026 /* Return true if the objects pointed to by P and Q represent calls
1027 to the same constexpr function with the same arguments.
1028 Otherwise, return false. */
1031 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1037 if (lhs
->hash
!= rhs
->hash
)
1039 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1041 lhs_bindings
= lhs
->bindings
;
1042 rhs_bindings
= rhs
->bindings
;
1043 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1045 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1046 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1047 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1048 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1050 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1051 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1053 return lhs_bindings
== rhs_bindings
;
1056 /* Initialize the constexpr call table, if needed. */
1059 maybe_initialize_constexpr_call_table (void)
1061 if (constexpr_call_table
== NULL
)
1062 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1065 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1066 a function happens to get called recursively, we unshare the callee
1067 function's body and evaluate this unshared copy instead of evaluating the
1070 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1071 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1072 that's keyed off of the original FUNCTION_DECL and whose value is a
1073 TREE_LIST of this function's unused copies awaiting reuse.
1075 This is not GC-deletable to avoid GC affecting UID generation. */
1077 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1079 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1082 maybe_initialize_fundef_copies_table ()
1084 if (fundef_copies_table
== NULL
)
1085 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1088 /* Reuse a copy or create a new unshared copy of the function FUN.
1089 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1090 is parms, TYPE is result. */
1093 get_fundef_copy (tree fun
)
1095 maybe_initialize_fundef_copies_table ();
1099 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1103 /* There is no cached function available, or in use. We can use
1104 the function directly. That the slot is now created records
1105 that this function is now in use. */
1106 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1107 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1109 else if (*slot
== NULL_TREE
)
1111 /* We've already used the function itself, so make a copy. */
1112 copy
= build_tree_list (NULL
, NULL
);
1113 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1117 /* We have a cached function available. */
1119 *slot
= TREE_CHAIN (copy
);
1125 /* Save the copy COPY of function FUN for later reuse by
1126 get_fundef_copy(). By construction, there will always be an entry
1130 save_fundef_copy (tree fun
, tree copy
)
1132 tree
*slot
= fundef_copies_table
->get (fun
);
1133 TREE_CHAIN (copy
) = *slot
;
1137 /* We have an expression tree T that represents a call, either CALL_EXPR
1138 or AGGR_INIT_EXPR. Return the Nth argument. */
1141 get_nth_callarg (tree t
, int n
)
1143 switch (TREE_CODE (t
))
1146 return CALL_EXPR_ARG (t
, n
);
1148 case AGGR_INIT_EXPR
:
1149 return AGGR_INIT_EXPR_ARG (t
, n
);
1157 /* Attempt to evaluate T which represents a call to a builtin function.
1158 We assume here that all builtin functions evaluate to scalar types
1159 represented by _CST nodes. */
1162 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1164 bool *non_constant_p
, bool *overflow_p
)
1166 const int nargs
= call_expr_nargs (t
);
1167 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1171 /* Don't fold __builtin_constant_p within a constexpr function. */
1172 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1174 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1175 in a constexpr function until we have values for the parameters. */
1178 && current_function_decl
1179 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1181 *non_constant_p
= true;
1185 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1186 return constant false for a non-constant argument. */
1187 constexpr_ctx new_ctx
= *ctx
;
1188 new_ctx
.quiet
= true;
1189 bool dummy1
= false, dummy2
= false;
1190 for (i
= 0; i
< nargs
; ++i
)
1192 args
[i
] = CALL_EXPR_ARG (t
, i
);
1193 /* If builtin_valid_in_constant_expr_p is true,
1194 potential_constant_expression_1 has not recursed into the arguments
1195 of the builtin, verify it here. */
1196 if (!builtin_valid_in_constant_expr_p (fun
)
1197 || potential_constant_expression (args
[i
]))
1198 args
[i
] = cxx_eval_constant_expression (&new_ctx
, args
[i
], false,
1201 /* For __built_in_constant_p, fold all expressions with constant values
1202 even if they aren't C++ constant-expressions. */
1203 args
[i
] = cp_fully_fold (args
[i
]);
1206 bool save_ffbcp
= force_folding_builtin_constant_p
;
1207 force_folding_builtin_constant_p
= true;
1208 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1209 CALL_EXPR_FN (t
), nargs
, args
);
1210 force_folding_builtin_constant_p
= save_ffbcp
;
1211 if (new_call
== NULL
)
1213 if (!*non_constant_p
&& !ctx
->quiet
)
1215 /* Do not allow__builtin_unreachable in constexpr function.
1216 The __builtin_unreachable call with BUILTINS_LOCATION
1217 comes from cp_maybe_instrument_return. */
1218 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
1219 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1220 error ("%<constexpr%> call flows off the end of the function");
1223 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1224 CALL_EXPR_FN (t
), nargs
, args
);
1225 error ("%q+E is not a constant expression", new_call
);
1228 *non_constant_p
= true;
1232 if (!is_constant_expression (new_call
))
1234 if (!*non_constant_p
&& !ctx
->quiet
)
1235 error ("%q+E is not a constant expression", new_call
);
1236 *non_constant_p
= true;
1240 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1241 non_constant_p
, overflow_p
);
1244 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1245 the type of the value to match. */
1248 adjust_temp_type (tree type
, tree temp
)
1250 if (TREE_TYPE (temp
) == type
)
1252 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1253 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1254 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1255 gcc_assert (scalarish_type_p (type
));
1256 return cp_fold_convert (type
, temp
);
1259 /* Callback for walk_tree used by unshare_constructor. */
1262 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1266 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1271 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1272 subexpression, return an unshared copy of T. Otherwise return T. */
1275 unshare_constructor (tree t
)
1277 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1278 if (ctor
!= NULL_TREE
)
1279 return unshare_expr (t
);
1283 /* Subroutine of cxx_eval_call_expression.
1284 We are processing a call expression (either CALL_EXPR or
1285 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1286 all arguments and bind their values to correspondings
1287 parameters, making up the NEW_CALL context. */
1290 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1291 constexpr_call
*new_call
,
1292 bool *non_constant_p
, bool *overflow_p
,
1293 bool *non_constant_args
)
1295 const int nargs
= call_expr_nargs (t
);
1296 tree fun
= new_call
->fundef
->decl
;
1297 tree parms
= DECL_ARGUMENTS (fun
);
1299 tree
*p
= &new_call
->bindings
;
1300 for (i
= 0; i
< nargs
; ++i
)
1303 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1304 x
= get_nth_callarg (t
, i
);
1305 /* For member function, the first argument is a pointer to the implied
1306 object. For a constructor, it might still be a dummy object, in
1307 which case we get the real argument from ctx. */
1308 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1309 && is_dummy_object (x
))
1312 x
= build_address (x
);
1314 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1315 non_constant_p
, overflow_p
);
1316 /* Don't VERIFY_CONSTANT here. */
1317 if (*non_constant_p
&& ctx
->quiet
)
1319 /* Just discard ellipsis args after checking their constantitude. */
1323 if (!*non_constant_p
)
1325 /* Don't share a CONSTRUCTOR that might be changed. */
1326 arg
= unshare_constructor (arg
);
1327 /* Make sure the binding has the same type as the parm. But
1328 only for constant args. */
1329 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1330 arg
= adjust_temp_type (type
, arg
);
1331 if (!TREE_CONSTANT (arg
))
1332 *non_constant_args
= true;
1333 *p
= build_tree_list (parms
, arg
);
1334 p
= &TREE_CHAIN (*p
);
1336 parms
= TREE_CHAIN (parms
);
1340 /* Variables and functions to manage constexpr call expansion context.
1341 These do not need to be marked for PCH or GC. */
1343 /* FIXME remember and print actual constant arguments. */
1344 static vec
<tree
> call_stack
;
1345 static int call_stack_tick
;
1346 static int last_cx_error_tick
;
1349 push_cx_call_context (tree call
)
1352 if (!EXPR_HAS_LOCATION (call
))
1353 SET_EXPR_LOCATION (call
, input_location
);
1354 call_stack
.safe_push (call
);
1355 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1361 pop_cx_call_context (void)
1368 cx_error_context (void)
1370 vec
<tree
> r
= vNULL
;
1371 if (call_stack_tick
!= last_cx_error_tick
1372 && !call_stack
.is_empty ())
1374 last_cx_error_tick
= call_stack_tick
;
1378 /* Evaluate a call T to a GCC internal function when possible and return
1379 the evaluated result or, under the control of CTX, give an error, set
1380 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1383 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1385 bool *non_constant_p
, bool *overflow_p
)
1387 enum tree_code opcode
= ERROR_MARK
;
1389 switch (CALL_EXPR_IFN (t
))
1391 case IFN_UBSAN_NULL
:
1392 case IFN_UBSAN_BOUNDS
:
1393 case IFN_UBSAN_VPTR
:
1394 case IFN_FALLTHROUGH
:
1397 case IFN_ADD_OVERFLOW
:
1400 case IFN_SUB_OVERFLOW
:
1401 opcode
= MINUS_EXPR
;
1403 case IFN_MUL_OVERFLOW
:
1408 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1409 false, non_constant_p
, overflow_p
);
1413 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1414 "call to internal function %qE", t
);
1415 *non_constant_p
= true;
1419 /* Evaluate constant arguments using OPCODE and return a complex
1420 number containing the result and the overflow bit. */
1421 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1422 non_constant_p
, overflow_p
);
1423 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1424 non_constant_p
, overflow_p
);
1426 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1428 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1429 tree type
= TREE_TYPE (TREE_TYPE (t
));
1430 tree result
= fold_binary_loc (loc
, opcode
, type
,
1431 fold_convert_loc (loc
, type
, arg0
),
1432 fold_convert_loc (loc
, type
, arg1
));
1434 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1435 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1436 if (TREE_OVERFLOW (result
))
1437 TREE_OVERFLOW (result
) = 0;
1439 return build_complex (TREE_TYPE (t
), result
, ovf
);
1442 *non_constant_p
= true;
1446 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1449 clear_no_implicit_zero (tree ctor
)
1451 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1453 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1454 tree elt
; unsigned HOST_WIDE_INT idx
;
1455 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1456 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1457 clear_no_implicit_zero (elt
);
1461 /* Subroutine of cxx_eval_constant_expression.
1462 Evaluate the call expression tree T in the context of OLD_CALL expression
1466 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1468 bool *non_constant_p
, bool *overflow_p
)
1470 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1471 tree fun
= get_function_named_in_call (t
);
1472 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1475 if (fun
== NULL_TREE
)
1476 return cxx_eval_internal_function (ctx
, t
, lval
,
1477 non_constant_p
, overflow_p
);
1479 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1481 /* Might be a constexpr function pointer. */
1482 fun
= cxx_eval_constant_expression (ctx
, fun
,
1483 /*lval*/false, non_constant_p
,
1486 if (TREE_CODE (fun
) == ADDR_EXPR
)
1487 fun
= TREE_OPERAND (fun
, 0);
1489 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1491 if (!ctx
->quiet
&& !*non_constant_p
)
1492 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1494 *non_constant_p
= true;
1497 if (DECL_CLONED_FUNCTION_P (fun
))
1498 fun
= DECL_CLONED_FUNCTION (fun
);
1500 if (is_ubsan_builtin_p (fun
))
1503 if (is_builtin_fn (fun
))
1504 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1505 lval
, non_constant_p
, overflow_p
);
1506 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1510 if (!lambda_static_thunk_p (fun
))
1511 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1512 explain_invalid_constexpr_fn (fun
);
1514 *non_constant_p
= true;
1518 constexpr_ctx new_ctx
= *ctx
;
1519 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1520 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1522 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1523 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1524 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1525 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1526 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1527 ctx
->values
->put (new_ctx
.object
, ctor
);
1531 /* Shortcut trivial constructor/op=. */
1532 if (trivial_fn_p (fun
))
1534 tree init
= NULL_TREE
;
1535 if (call_expr_nargs (t
) == 2)
1536 init
= convert_from_reference (get_nth_callarg (t
, 1));
1537 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1538 && AGGR_INIT_ZERO_FIRST (t
))
1539 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1542 tree op
= get_nth_callarg (t
, 0);
1543 if (is_dummy_object (op
))
1546 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1547 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1548 new_ctx
.call
= &new_call
;
1549 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1550 non_constant_p
, overflow_p
);
1554 /* We can't defer instantiating the function any longer. */
1555 if (!DECL_INITIAL (fun
)
1556 && DECL_TEMPLOID_INSTANTIATION (fun
))
1558 location_t save_loc
= input_location
;
1559 input_location
= loc
;
1561 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1563 input_location
= save_loc
;
1566 /* If in direct recursive call, optimize definition search. */
1567 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1568 new_call
.fundef
= ctx
->call
->fundef
;
1571 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1572 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1573 || fun
== current_function_decl
)
1577 /* We need to check for current_function_decl here in case we're
1578 being called during cp_fold_function, because at that point
1579 DECL_INITIAL is set properly and we have a fundef but we
1580 haven't lowered invisirefs yet (c++/70344). */
1581 if (DECL_INITIAL (fun
) == error_mark_node
1582 || fun
== current_function_decl
)
1583 error_at (loc
, "%qD called in a constant expression before its "
1584 "definition is complete", fun
);
1585 else if (DECL_INITIAL (fun
))
1587 /* The definition of fun was somehow unsuitable. But pretend
1588 that lambda static thunks don't exist. */
1589 if (!lambda_static_thunk_p (fun
))
1590 error_at (loc
, "%qD called in a constant expression", fun
);
1591 explain_invalid_constexpr_fn (fun
);
1594 error_at (loc
, "%qD used before its definition", fun
);
1596 *non_constant_p
= true;
1601 bool non_constant_args
= false;
1602 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1603 non_constant_p
, overflow_p
, &non_constant_args
);
1604 if (*non_constant_p
)
1607 depth_ok
= push_cx_call_context (t
);
1609 tree result
= NULL_TREE
;
1611 constexpr_call
*entry
= NULL
;
1612 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1614 new_call
.hash
= iterative_hash_template_arg
1615 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1617 /* If we have seen this call before, we are done. */
1618 maybe_initialize_constexpr_call_table ();
1619 constexpr_call
**slot
1620 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1624 /* We need to keep a pointer to the entry, not just the slot, as the
1625 slot can move in the call to cxx_eval_builtin_function_call. */
1626 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1629 /* Calls that are in progress have their result set to NULL,
1630 so that we can detect circular dependencies. */
1631 else if (entry
->result
== NULL
)
1634 error ("call has circular dependency");
1635 *non_constant_p
= true;
1636 entry
->result
= result
= error_mark_node
;
1639 result
= entry
->result
;
1645 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1646 "-fconstexpr-depth= to increase the maximum)",
1647 max_constexpr_depth
);
1648 *non_constant_p
= true;
1649 result
= error_mark_node
;
1653 if (result
&& result
!= error_mark_node
)
1655 else if (!DECL_SAVED_TREE (fun
))
1657 /* When at_eof >= 2, cgraph has started throwing away
1658 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1659 late code generation for VEC_INIT_EXPR, which needs to be
1660 completely reconsidered. */
1661 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1662 *non_constant_p
= true;
1666 tree body
, parms
, res
;
1668 /* Reuse or create a new unshared copy of this function's body. */
1669 tree copy
= get_fundef_copy (fun
);
1670 body
= TREE_PURPOSE (copy
);
1671 parms
= TREE_VALUE (copy
);
1672 res
= TREE_TYPE (copy
);
1674 /* Associate the bindings with the remapped parms. */
1675 tree bound
= new_call
.bindings
;
1676 tree remapped
= parms
;
1679 tree oparm
= TREE_PURPOSE (bound
);
1680 tree arg
= TREE_VALUE (bound
);
1681 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1682 /* Don't share a CONSTRUCTOR that might be changed. */
1683 arg
= unshare_constructor (arg
);
1684 ctx
->values
->put (remapped
, arg
);
1685 bound
= TREE_CHAIN (bound
);
1686 remapped
= DECL_CHAIN (remapped
);
1688 /* Add the RESULT_DECL to the values map, too. */
1689 tree slot
= NULL_TREE
;
1690 if (DECL_BY_REFERENCE (res
))
1692 slot
= AGGR_INIT_EXPR_SLOT (t
);
1693 tree addr
= build_address (slot
);
1694 addr
= build_nop (TREE_TYPE (res
), addr
);
1695 ctx
->values
->put (res
, addr
);
1696 ctx
->values
->put (slot
, NULL_TREE
);
1699 ctx
->values
->put (res
, NULL_TREE
);
1701 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1702 their values after the call. */
1703 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1704 hash_set
<tree
> save_exprs
;
1705 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1706 ctx_with_save_exprs
.call
= &new_call
;
1708 tree jump_target
= NULL_TREE
;
1709 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1710 lval
, non_constant_p
, overflow_p
,
1713 if (DECL_CONSTRUCTOR_P (fun
))
1714 /* This can be null for a subobject constructor call, in
1715 which case what we care about is the initialization
1716 side-effects rather than the value. We could get at the
1717 value by evaluating *this, but we don't bother; there's
1718 no need to put such a call in the hash table. */
1719 result
= lval
? ctx
->object
: ctx
->ctor
;
1720 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1724 result
= *ctx
->values
->get (slot
? slot
: res
);
1725 if (result
== NULL_TREE
&& !*non_constant_p
)
1728 error ("%<constexpr%> call flows off the end "
1730 *non_constant_p
= true;
1734 /* Forget the saved values of the callee's SAVE_EXPRs. */
1735 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1736 iter
!= save_exprs
.end(); ++iter
)
1737 ctx_with_save_exprs
.values
->remove (*iter
);
1739 /* Remove the parms/result from the values map. Is it worth
1740 bothering to do this when the map itself is only live for
1741 one constexpr evaluation? If so, maybe also clear out
1742 other vars from call, maybe in BIND_EXPR handling? */
1743 ctx
->values
->remove (res
);
1745 ctx
->values
->remove (slot
);
1746 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1747 ctx
->values
->remove (parm
);
1749 /* Make the unshared function copy we used available for re-use. */
1750 save_fundef_copy (fun
, copy
);
1753 if (result
== error_mark_node
)
1754 *non_constant_p
= true;
1755 if (*non_constant_p
|| *overflow_p
)
1756 result
= error_mark_node
;
1760 entry
->result
= result
;
1763 /* The result of a constexpr function must be completely initialized. */
1764 if (TREE_CODE (result
) == CONSTRUCTOR
)
1765 clear_no_implicit_zero (result
);
1767 pop_cx_call_context ();
1768 return unshare_constructor (result
);
1771 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1774 reduced_constant_expression_p (tree t
)
1776 switch (TREE_CODE (t
))
1779 /* Even if we can't lower this yet, it's constant. */
1783 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1784 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1785 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1787 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1788 /* An initialized vector would have a VECTOR_CST. */
1791 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1795 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1798 /* We're in the middle of initializing this element. */
1800 if (!reduced_constant_expression_p (val
))
1806 field
= next_initializable_field (DECL_CHAIN (field
));
1811 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1812 /* All the fields are initialized. */
1813 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1817 /* FIXME are we calling this too much? */
1818 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1822 /* Some expressions may have constant operands but are not constant
1823 themselves, such as 1/0. Call this function (or rather, the macro
1824 following it) to check for that condition.
1826 We only call this in places that require an arithmetic constant, not in
1827 places where we might have a non-constant expression that can be a
1828 component of a constant expression, such as the address of a constexpr
1829 variable that might be dereferenced later. */
1832 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1835 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1837 if (!allow_non_constant
)
1838 error ("%q+E is not a constant expression", t
);
1839 *non_constant_p
= true;
1841 if (TREE_OVERFLOW_P (t
))
1843 if (!allow_non_constant
)
1845 permerror (input_location
, "overflow in constant expression");
1846 /* If we're being permissive (and are in an enforcing
1847 context), ignore the overflow. */
1848 if (flag_permissive
)
1849 return *non_constant_p
;
1853 return *non_constant_p
;
1856 /* Check whether the shift operation with code CODE and type TYPE on LHS
1857 and RHS is undefined. If it is, give an error with an explanation,
1858 and return true; return false otherwise. */
1861 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1862 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1864 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1865 || TREE_CODE (lhs
) != INTEGER_CST
1866 || TREE_CODE (rhs
) != INTEGER_CST
)
1869 tree lhstype
= TREE_TYPE (lhs
);
1870 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1872 /* [expr.shift] The behavior is undefined if the right operand
1873 is negative, or greater than or equal to the length in bits
1874 of the promoted left operand. */
1875 if (tree_int_cst_sgn (rhs
) == -1)
1878 permerror (loc
, "right operand of shift expression %q+E is negative",
1879 build2_loc (loc
, code
, type
, lhs
, rhs
));
1880 return (!flag_permissive
|| ctx
->quiet
);
1882 if (compare_tree_int (rhs
, uprec
) >= 0)
1885 permerror (loc
, "right operand of shift expression %q+E is >= than "
1886 "the precision of the left operand",
1887 build2_loc (loc
, code
, type
, lhs
, rhs
));
1888 return (!flag_permissive
|| ctx
->quiet
);
1891 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1892 if E1 has a signed type and non-negative value, and E1x2^E2 is
1893 representable in the corresponding unsigned type of the result type,
1894 then that value, converted to the result type, is the resulting value;
1895 otherwise, the behavior is undefined. */
1896 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1897 && (cxx_dialect
>= cxx11
))
1899 if (tree_int_cst_sgn (lhs
) == -1)
1903 "left operand of shift expression %q+E is negative",
1904 build2_loc (loc
, code
, type
, lhs
, rhs
));
1905 return (!flag_permissive
|| ctx
->quiet
);
1907 /* For signed x << y the following:
1908 (unsigned) x >> ((prec (lhs) - 1) - y)
1909 if > 1, is undefined. The right-hand side of this formula
1910 is the highest bit of the LHS that can be set (starting from 0),
1911 so that the shift doesn't overflow. We then right-shift the LHS
1912 to see whether any other bit is set making the original shift
1913 undefined -- the result is not representable in the corresponding
1915 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1916 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1917 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1918 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1919 if (tree_int_cst_lt (integer_one_node
, t
))
1922 permerror (loc
, "shift expression %q+E overflows",
1923 build2_loc (loc
, code
, type
, lhs
, rhs
));
1924 return (!flag_permissive
|| ctx
->quiet
);
1930 /* Subroutine of cxx_eval_constant_expression.
1931 Attempt to reduce the unary expression tree T to a compile time value.
1932 If successful, return the value. Otherwise issue a diagnostic
1933 and return error_mark_node. */
1936 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1938 bool *non_constant_p
, bool *overflow_p
)
1941 tree orig_arg
= TREE_OPERAND (t
, 0);
1942 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1943 non_constant_p
, overflow_p
);
1944 VERIFY_CONSTANT (arg
);
1945 location_t loc
= EXPR_LOCATION (t
);
1946 enum tree_code code
= TREE_CODE (t
);
1947 tree type
= TREE_TYPE (t
);
1948 r
= fold_unary_loc (loc
, code
, type
, arg
);
1951 if (arg
== orig_arg
)
1954 r
= build1_loc (loc
, code
, type
, arg
);
1956 VERIFY_CONSTANT (r
);
1960 /* Helper function for cxx_eval_binary_expression. Try to optimize
1961 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1962 generic folding should be used. */
1965 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1966 tree lhs
, tree rhs
, bool *non_constant_p
,
1970 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1973 lhs
= TREE_OPERAND (lhs
, 0);
1975 /* &A[i] p+ j => &A[i + j] */
1976 if (TREE_CODE (lhs
) == ARRAY_REF
1977 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1978 && TREE_CODE (rhs
) == INTEGER_CST
1979 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1980 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1982 tree orig_type
= TREE_TYPE (t
);
1983 location_t loc
= EXPR_LOCATION (t
);
1984 tree type
= TREE_TYPE (lhs
);
1986 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1987 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1988 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1990 if (*non_constant_p
)
1992 /* Don't fold an out-of-bound access. */
1993 if (!tree_int_cst_le (t
, nelts
))
1995 rhs
= cp_fold_convert (ssizetype
, rhs
);
1996 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1997 constexpr int A[1]; ... (char *)&A[0] + 1 */
1998 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1999 rhs
, TYPE_SIZE_UNIT (type
))))
2001 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2003 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
2004 TYPE_SIZE_UNIT (type
));
2005 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
2006 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
2007 t
, NULL_TREE
, NULL_TREE
);
2008 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2009 t
= cp_fold_convert (orig_type
, t
);
2010 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2011 non_constant_p
, overflow_p
);
2017 /* Subroutine of cxx_eval_constant_expression.
2018 Like cxx_eval_unary_expression, except for binary expressions. */
2021 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2023 bool *non_constant_p
, bool *overflow_p
)
2026 tree orig_lhs
= TREE_OPERAND (t
, 0);
2027 tree orig_rhs
= TREE_OPERAND (t
, 1);
2029 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2030 non_constant_p
, overflow_p
);
2031 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2033 if (*non_constant_p
)
2035 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2036 non_constant_p
, overflow_p
);
2037 if (*non_constant_p
)
2040 location_t loc
= EXPR_LOCATION (t
);
2041 enum tree_code code
= TREE_CODE (t
);
2042 tree type
= TREE_TYPE (t
);
2044 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2046 bool is_code_eq
= (code
== EQ_EXPR
);
2048 if (TREE_CODE (lhs
) == PTRMEM_CST
2049 && TREE_CODE (rhs
) == PTRMEM_CST
)
2050 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2052 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2053 || TREE_CODE (rhs
) == PTRMEM_CST
)
2054 && (null_member_pointer_value_p (lhs
)
2055 || null_member_pointer_value_p (rhs
)))
2056 r
= constant_boolean_node (!is_code_eq
, type
);
2057 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2058 lhs
= cplus_expand_constant (lhs
);
2059 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2060 rhs
= cplus_expand_constant (rhs
);
2062 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2063 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2066 error ("arithmetic involving a null pointer in %qE", lhs
);
2069 else if (code
== POINTER_PLUS_EXPR
)
2070 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2074 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2078 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2081 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2083 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2084 *non_constant_p
= true;
2085 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2086 a local array in a constexpr function. */
2087 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2089 VERIFY_CONSTANT (r
);
2093 /* Subroutine of cxx_eval_constant_expression.
2094 Attempt to evaluate condition expressions. Dead branches are not
2098 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2100 bool *non_constant_p
, bool *overflow_p
,
2103 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2105 non_constant_p
, overflow_p
);
2106 VERIFY_CONSTANT (val
);
2107 /* Don't VERIFY_CONSTANT the other operands. */
2108 if (integer_zerop (val
))
2109 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2111 non_constant_p
, overflow_p
,
2113 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2115 non_constant_p
, overflow_p
,
2119 /* Subroutine of cxx_eval_constant_expression.
2120 Attempt to evaluate vector condition expressions. Unlike
2121 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2122 ternary arithmetics operation, where all 3 arguments have to be
2123 evaluated as constants and then folding computes the result from
2127 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2128 bool *non_constant_p
, bool *overflow_p
)
2130 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2132 non_constant_p
, overflow_p
);
2133 VERIFY_CONSTANT (arg1
);
2134 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2136 non_constant_p
, overflow_p
);
2137 VERIFY_CONSTANT (arg2
);
2138 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2140 non_constant_p
, overflow_p
);
2141 VERIFY_CONSTANT (arg3
);
2142 location_t loc
= EXPR_LOCATION (t
);
2143 tree type
= TREE_TYPE (t
);
2144 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2147 if (arg1
== TREE_OPERAND (t
, 0)
2148 && arg2
== TREE_OPERAND (t
, 1)
2149 && arg3
== TREE_OPERAND (t
, 2))
2152 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2154 VERIFY_CONSTANT (r
);
2158 /* Returns less than, equal to, or greater than zero if KEY is found to be
2159 less than, to match, or to be greater than the constructor_elt's INDEX. */
2162 array_index_cmp (tree key
, tree index
)
2164 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2166 switch (TREE_CODE (index
))
2169 return tree_int_cst_compare (key
, index
);
2172 tree lo
= TREE_OPERAND (index
, 0);
2173 tree hi
= TREE_OPERAND (index
, 1);
2174 if (tree_int_cst_lt (key
, lo
))
2176 else if (tree_int_cst_lt (hi
, key
))
2186 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2187 if none. If INSERT is true, insert a matching element rather than fail. */
2189 static HOST_WIDE_INT
2190 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2192 if (tree_int_cst_sgn (dindex
) < 0)
2195 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2196 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2197 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2199 unsigned HOST_WIDE_INT end
= len
;
2200 unsigned HOST_WIDE_INT begin
= 0;
2202 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2203 that the same is true of the other elements and index directly. */
2206 tree cindex
= (*elts
)[end
- 1].index
;
2207 if (TREE_CODE (cindex
) == INTEGER_CST
2208 && compare_tree_int (cindex
, end
- 1) == 0)
2217 /* Otherwise, find a matching index by means of a binary search. */
2218 while (begin
!= end
)
2220 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2221 constructor_elt
&elt
= (*elts
)[middle
];
2222 tree idx
= elt
.index
;
2224 int cmp
= array_index_cmp (dindex
, idx
);
2231 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2233 /* We need to split the range. */
2235 tree lo
= TREE_OPERAND (idx
, 0);
2236 tree hi
= TREE_OPERAND (idx
, 1);
2237 tree value
= elt
.value
;
2238 dindex
= fold_convert (sizetype
, dindex
);
2239 if (tree_int_cst_lt (lo
, dindex
))
2241 /* There are still some lower elts; shorten the range. */
2242 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2244 if (tree_int_cst_equal (lo
, new_hi
))
2245 /* Only one element left, no longer a range. */
2248 TREE_OPERAND (idx
, 1) = new_hi
;
2249 /* Append the element we want to insert. */
2252 e
.value
= unshare_constructor (value
);
2253 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2256 /* No lower elts, the range elt is now ours. */
2259 if (tree_int_cst_lt (dindex
, hi
))
2261 /* There are still some higher elts; append a range. */
2262 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2264 if (tree_int_cst_equal (new_lo
, hi
))
2267 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2268 e
.value
= unshare_constructor (value
);
2269 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2278 constructor_elt e
= { dindex
, NULL_TREE
};
2279 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2286 /* Under the control of CTX, issue a detailed diagnostic for
2287 an out-of-bounds subscript INDEX into the expression ARRAY. */
2290 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2294 tree arraytype
= TREE_TYPE (array
);
2296 /* Convert the unsigned array subscript to a signed integer to avoid
2297 printing huge numbers for small negative values. */
2298 tree sidx
= fold_convert (ssizetype
, index
);
2301 if (TYPE_DOMAIN (arraytype
))
2302 error ("array subscript value %qE is outside the bounds "
2303 "of array %qD of type %qT", sidx
, array
, arraytype
);
2305 error ("non-zero array subscript %qE is used with array %qD of "
2306 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2307 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2309 else if (TYPE_DOMAIN (arraytype
))
2310 error ("array subscript value %qE is outside the bounds "
2311 "of array type %qT", sidx
, arraytype
);
2313 error ("non-zero array subscript %qE is used with array of type %qT "
2314 "with unknown bounds", sidx
, arraytype
);
2318 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2322 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2323 bool *non_constant_p
, bool *overflow_p
)
2326 if (TREE_CODE (type
) == ARRAY_TYPE
)
2328 if (TYPE_DOMAIN (type
))
2329 nelts
= array_type_nelts_top (type
);
2331 nelts
= size_zero_node
;
2333 else if (VECTOR_TYPE_P (type
))
2334 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2338 /* For VLAs, the number of elements won't be an integer constant. */
2339 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2340 non_constant_p
, overflow_p
);
2344 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2345 STRING_CST STRING. */
2348 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2350 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2353 if (chars_per_elt
== 1)
2354 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2357 const unsigned char *ptr
2358 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2359 + index
* chars_per_elt
);
2360 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2365 /* Subroutine of cxx_eval_constant_expression.
2366 Attempt to reduce a reference to an array slot. */
2369 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2371 bool *non_constant_p
, bool *overflow_p
)
2373 tree oldary
= TREE_OPERAND (t
, 0);
2374 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2376 non_constant_p
, overflow_p
);
2378 HOST_WIDE_INT i
= 0;
2379 tree elem_type
= NULL_TREE
;
2380 unsigned len
= 0, elem_nchars
= 1;
2381 if (*non_constant_p
)
2383 oldidx
= TREE_OPERAND (t
, 1);
2384 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2386 non_constant_p
, overflow_p
);
2387 VERIFY_CONSTANT (index
);
2390 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2391 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2392 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2393 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2394 ary
= TREE_OPERAND (ary
, 0);
2395 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2396 len
= CONSTRUCTOR_NELTS (ary
);
2397 else if (TREE_CODE (ary
) == STRING_CST
)
2399 elem_nchars
= (TYPE_PRECISION (elem_type
)
2400 / TYPE_PRECISION (char_type_node
));
2401 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2403 else if (TREE_CODE (ary
) == VECTOR_CST
)
2404 /* We don't create variable-length VECTOR_CSTs. */
2405 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2408 /* We can't do anything with other tree codes, so use
2409 VERIFY_CONSTANT to complain and fail. */
2410 VERIFY_CONSTANT (ary
);
2414 if (!tree_fits_shwi_p (index
)
2415 || (i
= tree_to_shwi (index
)) < 0)
2417 diag_array_subscript (ctx
, ary
, index
);
2418 *non_constant_p
= true;
2423 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2425 VERIFY_CONSTANT (nelts
);
2427 ? !tree_int_cst_le (index
, nelts
)
2428 : !tree_int_cst_lt (index
, nelts
))
2429 || tree_int_cst_sgn (index
) < 0)
2431 diag_array_subscript (ctx
, ary
, index
);
2432 *non_constant_p
= true;
2436 if (lval
&& ary
== oldary
&& index
== oldidx
)
2439 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2442 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2444 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2455 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2456 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2457 else if (TREE_CODE (ary
) == VECTOR_CST
)
2458 r
= VECTOR_CST_ELT (ary
, i
);
2460 r
= extract_string_elt (ary
, elem_nchars
, i
);
2463 /* Don't VERIFY_CONSTANT here. */
2466 /* Otherwise the element doesn't have a value yet. */
2471 if (TREE_CODE (ary
) == CONSTRUCTOR
2472 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2474 /* 'ary' is part of the aggregate initializer we're currently
2475 building; if there's no initializer for this element yet,
2478 error ("accessing uninitialized array element");
2479 *non_constant_p
= true;
2483 /* If it's within the array bounds but doesn't have an explicit
2484 initializer, it's value-initialized. */
2485 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2486 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2490 /* Subroutine of cxx_eval_constant_expression.
2491 Attempt to reduce a field access of a value of class type. */
2494 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2496 bool *non_constant_p
, bool *overflow_p
)
2498 unsigned HOST_WIDE_INT i
;
2501 tree part
= TREE_OPERAND (t
, 1);
2502 tree orig_whole
= TREE_OPERAND (t
, 0);
2503 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2505 non_constant_p
, overflow_p
);
2506 if (INDIRECT_REF_P (whole
)
2507 && integer_zerop (TREE_OPERAND (whole
, 0))
2509 error ("dereferencing a null pointer in %qE", orig_whole
);
2511 if (TREE_CODE (whole
) == PTRMEM_CST
)
2512 whole
= cplus_expand_constant (whole
);
2513 if (whole
== orig_whole
)
2516 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2517 whole
, part
, NULL_TREE
);
2518 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2520 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2523 error ("%qE is not a constant expression", orig_whole
);
2524 *non_constant_p
= true;
2526 if (DECL_MUTABLE_P (part
))
2529 error ("mutable %qD is not usable in a constant expression", part
);
2530 *non_constant_p
= true;
2532 if (*non_constant_p
)
2534 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2535 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2537 /* Use name match for PMF fields, as a variant will have a
2538 different FIELD_DECL with a different type. */
2539 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2545 /* We're in the middle of initializing it. */
2549 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2550 && CONSTRUCTOR_NELTS (whole
) > 0)
2552 /* DR 1188 says we don't have to deal with this. */
2554 error ("accessing %qD member instead of initialized %qD member in "
2555 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2556 *non_constant_p
= true;
2560 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2561 classes never get represented; throw together a value now. */
2562 if (is_really_empty_class (TREE_TYPE (t
)))
2563 return build_constructor (TREE_TYPE (t
), NULL
);
2565 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2567 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2569 /* 'whole' is part of the aggregate initializer we're currently
2570 building; if there's no initializer for this member yet, that's an
2573 error ("accessing uninitialized member %qD", part
);
2574 *non_constant_p
= true;
2578 /* If there's no explicit init for this field, it's value-initialized. */
2579 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2580 return cxx_eval_constant_expression (ctx
, value
,
2582 non_constant_p
, overflow_p
);
2585 /* Subroutine of cxx_eval_constant_expression.
2586 Attempt to reduce a field access of a value of class type that is
2587 expressed as a BIT_FIELD_REF. */
2590 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2592 bool *non_constant_p
, bool *overflow_p
)
2594 tree orig_whole
= TREE_OPERAND (t
, 0);
2595 tree retval
, fldval
, utype
, mask
;
2596 bool fld_seen
= false;
2597 HOST_WIDE_INT istart
, isize
;
2598 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2600 non_constant_p
, overflow_p
);
2601 tree start
, field
, value
;
2602 unsigned HOST_WIDE_INT i
;
2604 if (whole
== orig_whole
)
2606 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2608 if (!*non_constant_p
2609 && TREE_CODE (whole
) != VECTOR_CST
2610 && TREE_CODE (whole
) != CONSTRUCTOR
)
2613 error ("%qE is not a constant expression", orig_whole
);
2614 *non_constant_p
= true;
2616 if (*non_constant_p
)
2619 if (TREE_CODE (whole
) == VECTOR_CST
)
2620 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2621 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2623 start
= TREE_OPERAND (t
, 2);
2624 istart
= tree_to_shwi (start
);
2625 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2626 utype
= TREE_TYPE (t
);
2627 if (!TYPE_UNSIGNED (utype
))
2628 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2629 retval
= build_int_cst (utype
, 0);
2630 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2632 tree bitpos
= bit_position (field
);
2633 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2635 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2636 && TREE_CODE (value
) == INTEGER_CST
2637 && tree_fits_shwi_p (bitpos
)
2638 && tree_fits_shwi_p (DECL_SIZE (field
)))
2640 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2641 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2642 HOST_WIDE_INT shift
;
2643 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2645 fldval
= fold_convert (utype
, value
);
2646 mask
= build_int_cst_type (utype
, -1);
2647 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2648 size_int (TYPE_PRECISION (utype
) - sz
));
2649 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2650 size_int (TYPE_PRECISION (utype
) - sz
));
2651 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2652 shift
= bit
- istart
;
2653 if (BYTES_BIG_ENDIAN
)
2654 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2655 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2657 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2663 return fold_convert (TREE_TYPE (t
), retval
);
2665 return error_mark_node
;
2668 /* Subroutine of cxx_eval_constant_expression.
2669 Evaluate a short-circuited logical expression T in the context
2670 of a given constexpr CALL. BAILOUT_VALUE is the value for
2671 early return. CONTINUE_VALUE is used here purely for
2672 sanity check purposes. */
2675 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2676 tree bailout_value
, tree continue_value
,
2678 bool *non_constant_p
, bool *overflow_p
)
2681 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2683 non_constant_p
, overflow_p
);
2684 VERIFY_CONSTANT (lhs
);
2685 if (tree_int_cst_equal (lhs
, bailout_value
))
2687 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2688 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2689 lval
, non_constant_p
,
2691 VERIFY_CONSTANT (r
);
2695 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2696 CONSTRUCTOR elements to initialize (part of) an object containing that
2697 field. Return a pointer to the constructor_elt corresponding to the
2698 initialization of the field. */
2700 static constructor_elt
*
2701 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2703 tree aggr
= TREE_OPERAND (ref
, 0);
2704 tree field
= TREE_OPERAND (ref
, 1);
2706 constructor_elt
*ce
;
2708 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2710 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2712 constructor_elt
*base_ce
2713 = base_field_constructor_elt (v
, aggr
);
2714 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2717 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2718 if (ce
->index
== field
)
2725 /* Some of the expressions fed to the constexpr mechanism are calls to
2726 constructors, which have type void. In that case, return the type being
2727 initialized by the constructor. */
2730 initialized_type (tree t
)
2734 tree type
= cv_unqualified (TREE_TYPE (t
));
2735 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2737 /* A constructor call has void type, so we need to look deeper. */
2738 tree fn
= get_function_named_in_call (t
);
2739 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2740 && DECL_CXX_CONSTRUCTOR_P (fn
))
2741 type
= DECL_CONTEXT (fn
);
2746 /* We're about to initialize element INDEX of an array or class from VALUE.
2747 Set up NEW_CTX appropriately by adjusting .object to refer to the
2748 subobject and creating a new CONSTRUCTOR if the element is itself
2749 a class or array. */
2752 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2753 tree index
, tree
&value
)
2757 if (index
&& TREE_CODE (index
) != INTEGER_CST
2758 && TREE_CODE (index
) != FIELD_DECL
)
2759 /* This won't have an element in the new CONSTRUCTOR. */
2762 tree type
= initialized_type (value
);
2763 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2764 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2767 /* The sub-aggregate initializer might contain a placeholder;
2768 update object to refer to the subobject and ctor to refer to
2769 the (newly created) sub-initializer. */
2771 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2772 tree elt
= build_constructor (type
, NULL
);
2773 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2776 if (TREE_CODE (value
) == TARGET_EXPR
)
2777 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2778 value
= TARGET_EXPR_INITIAL (value
);
2781 /* We're about to process an initializer for a class or array TYPE. Make
2782 sure that CTX is set up appropriately. */
2785 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2787 /* We don't bother building a ctor for an empty base subobject. */
2788 if (is_empty_class (type
))
2791 /* We're in the middle of an initializer that might involve placeholders;
2792 our caller should have created a CONSTRUCTOR for us to put the
2793 initializer into. We will either return that constructor or T. */
2794 gcc_assert (ctx
->ctor
);
2795 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2796 (type
, TREE_TYPE (ctx
->ctor
)));
2797 /* We used to check that ctx->ctor was empty, but that isn't the case when
2798 the object is zero-initialized before calling the constructor. */
2801 tree otype
= TREE_TYPE (ctx
->object
);
2802 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2803 /* Handle flexible array members. */
2804 || (TREE_CODE (otype
) == ARRAY_TYPE
2805 && TYPE_DOMAIN (otype
) == NULL_TREE
2806 && TREE_CODE (type
) == ARRAY_TYPE
2807 && (same_type_ignoring_top_level_qualifiers_p
2808 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2810 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2811 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2814 /* Subroutine of cxx_eval_constant_expression.
2815 The expression tree T denotes a C-style array or a C-style
2816 aggregate. Reduce it to a constant expression. */
2819 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2821 bool *non_constant_p
, bool *overflow_p
)
2823 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2824 bool changed
= false;
2825 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2826 tree type
= TREE_TYPE (t
);
2828 constexpr_ctx new_ctx
;
2829 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2831 /* We don't really need the ctx->ctor business for a PMF or
2832 vector, but it's simpler to use the same code. */
2834 new_ctx
.ctor
= build_constructor (type
, NULL
);
2835 new_ctx
.object
= NULL_TREE
;
2838 verify_ctor_sanity (ctx
, type
);
2839 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2840 vec_alloc (*p
, vec_safe_length (v
));
2844 bool constant_p
= true;
2845 bool side_effects_p
= false;
2846 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2848 tree orig_value
= value
;
2849 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2850 if (new_ctx
.ctor
!= ctx
->ctor
)
2851 /* If we built a new CONSTRUCTOR, attach it now so that other
2852 initializers can refer to it. */
2853 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2854 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2856 non_constant_p
, overflow_p
);
2857 /* Don't VERIFY_CONSTANT here. */
2858 if (ctx
->quiet
&& *non_constant_p
)
2860 if (elt
!= orig_value
)
2863 if (!TREE_CONSTANT (elt
))
2865 if (TREE_SIDE_EFFECTS (elt
))
2866 side_effects_p
= true;
2867 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2869 /* This is an initialization of a vfield inside a base
2870 subaggregate that we already initialized; push this
2871 initialization into the previous initialization. */
2872 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2877 && (TREE_CODE (index
) == NOP_EXPR
2878 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2880 /* This is an initializer for an empty base; now that we've
2881 checked that it's constant, we can ignore it. */
2882 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2887 if (new_ctx
.ctor
!= ctx
->ctor
)
2889 /* We appended this element above; update the value. */
2890 gcc_assert ((*p
)->last().index
== index
);
2891 (*p
)->last().value
= elt
;
2894 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2895 /* Adding or replacing an element might change the ctor's flags. */
2896 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
2897 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
2900 if (*non_constant_p
|| !changed
)
2903 /* We're done building this CONSTRUCTOR, so now we can interpret an
2904 element without an explicit initializer as value-initialized. */
2905 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2906 TREE_CONSTANT (t
) = constant_p
;
2907 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2908 if (VECTOR_TYPE_P (type
))
2913 /* Subroutine of cxx_eval_constant_expression.
2914 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2915 initialization of a non-static data member of array type. Reduce it to a
2918 Note that apart from value-initialization (when VALUE_INIT is true),
2919 this is only intended to support value-initialization and the
2920 initializations done by defaulted constructors for classes with
2921 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2922 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2923 for the copy/move constructor. */
2926 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2927 bool value_init
, bool lval
,
2928 bool *non_constant_p
, bool *overflow_p
)
2930 tree elttype
= TREE_TYPE (atype
);
2931 verify_ctor_sanity (ctx
, atype
);
2932 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2933 bool pre_init
= false;
2934 unsigned HOST_WIDE_INT i
;
2936 /* For the default constructor, build up a call to the default
2937 constructor of the element type. We only need to handle class types
2938 here, as for a constructor to be constexpr, all members must be
2939 initialized, which for a defaulted default constructor means they must
2940 be of a class type with a constexpr default constructor. */
2941 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2942 /* We only do this at the lowest level. */;
2943 else if (value_init
)
2945 init
= build_value_init (elttype
, tf_warning_or_error
);
2950 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2951 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2952 &argvec
, elttype
, LOOKUP_NORMAL
,
2953 tf_warning_or_error
);
2954 release_tree_vector (argvec
);
2955 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2959 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
2961 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
2962 for (i
= 0; i
< max
; ++i
)
2964 tree idx
= build_int_cst (size_type_node
, i
);
2967 constexpr_ctx new_ctx
;
2968 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2969 if (new_ctx
.ctor
!= ctx
->ctor
)
2970 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2971 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2973 /* A multidimensional array; recurse. */
2974 if (value_init
|| init
== NULL_TREE
)
2976 eltinit
= NULL_TREE
;
2980 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2981 tf_warning_or_error
);
2982 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2984 non_constant_p
, overflow_p
);
2988 /* Initializing an element using value or default initialization
2989 we just pre-built above. */
2990 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2991 non_constant_p
, overflow_p
);
2996 /* Copying an element. */
2997 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2998 (atype
, TREE_TYPE (init
)));
2999 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
3000 tf_warning_or_error
);
3001 if (!lvalue_p (init
))
3002 eltinit
= move (eltinit
);
3003 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
3004 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
3005 non_constant_p
, overflow_p
);
3007 if (*non_constant_p
&& !ctx
->quiet
)
3009 if (new_ctx
.ctor
!= ctx
->ctor
)
3011 /* We appended this element above; update the value. */
3012 gcc_assert ((*p
)->last().index
== idx
);
3013 (*p
)->last().value
= eltinit
;
3016 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3017 /* Reuse the result of cxx_eval_constant_expression call
3018 from the first iteration to all others if it is a constant
3019 initializer that doesn't require relocations. */
3022 && (eltinit
== NULL_TREE
3023 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3024 == null_pointer_node
)))
3026 if (new_ctx
.ctor
!= ctx
->ctor
)
3027 eltinit
= new_ctx
.ctor
;
3028 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3029 build_int_cst (size_type_node
, 1),
3030 build_int_cst (size_type_node
, max
- 1));
3031 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3035 vec_safe_reserve (*p
, max
);
3038 if (!*non_constant_p
)
3041 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
3047 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3049 bool *non_constant_p
, bool *overflow_p
)
3051 tree atype
= TREE_TYPE (t
);
3052 tree init
= VEC_INIT_EXPR_INIT (t
);
3053 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3054 VEC_INIT_EXPR_VALUE_INIT (t
),
3055 lval
, non_constant_p
, overflow_p
);
3056 if (*non_constant_p
)
3062 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3063 match. We want to be less strict for simple *& folding; if we have a
3064 non-const temporary that we access through a const pointer, that should
3065 work. We handle this here rather than change fold_indirect_ref_1
3066 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3067 don't really make sense outside of constant expression evaluation. Also
3068 we want to allow folding to COMPONENT_REF, which could cause trouble
3069 with TBAA in fold_indirect_ref_1.
3071 Try to keep this function synced with fold_indirect_ref_1. */
3074 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3078 poly_uint64 const_op01
;
3081 subtype
= TREE_TYPE (sub
);
3082 if (!POINTER_TYPE_P (subtype
))
3085 if (TREE_CODE (sub
) == ADDR_EXPR
)
3087 tree op
= TREE_OPERAND (sub
, 0);
3088 tree optype
= TREE_TYPE (op
);
3090 /* *&CONST_DECL -> to the value of the const decl. */
3091 if (TREE_CODE (op
) == CONST_DECL
)
3092 return DECL_INITIAL (op
);
3093 /* *&p => p; make sure to handle *&"str"[cst] here. */
3094 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
3095 /* Also handle the case where the desired type is an array of unknown
3096 bounds because the variable has had its bounds deduced since the
3097 ADDR_EXPR was created. */
3098 || (TREE_CODE (type
) == ARRAY_TYPE
3099 && TREE_CODE (optype
) == ARRAY_TYPE
3100 && TYPE_DOMAIN (type
) == NULL_TREE
3101 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3104 tree fop
= fold_read_from_constant_string (op
);
3110 /* *(foo *)&fooarray => fooarray[0] */
3111 else if (TREE_CODE (optype
) == ARRAY_TYPE
3112 && (same_type_ignoring_top_level_qualifiers_p
3113 (type
, TREE_TYPE (optype
))))
3115 tree type_domain
= TYPE_DOMAIN (optype
);
3116 tree min_val
= size_zero_node
;
3117 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3118 min_val
= TYPE_MIN_VALUE (type_domain
);
3119 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3120 NULL_TREE
, NULL_TREE
);
3122 /* *(foo *)&complexfoo => __real__ complexfoo */
3123 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3124 && (same_type_ignoring_top_level_qualifiers_p
3125 (type
, TREE_TYPE (optype
))))
3126 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3127 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3128 else if (VECTOR_TYPE_P (optype
)
3129 && (same_type_ignoring_top_level_qualifiers_p
3130 (type
, TREE_TYPE (optype
))))
3132 tree part_width
= TYPE_SIZE (type
);
3133 tree index
= bitsize_int (0);
3134 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3137 /* Also handle conversion to an empty base class, which
3138 is represented with a NOP_EXPR. */
3139 else if (is_empty_class (type
)
3140 && CLASS_TYPE_P (optype
)
3141 && DERIVED_FROM_P (type
, optype
))
3146 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3147 else if (RECORD_OR_UNION_TYPE_P (optype
))
3149 tree field
= TYPE_FIELDS (optype
);
3150 for (; field
; field
= DECL_CHAIN (field
))
3151 if (TREE_CODE (field
) == FIELD_DECL
3152 && TREE_TYPE (field
) != error_mark_node
3153 && integer_zerop (byte_position (field
))
3154 && (same_type_ignoring_top_level_qualifiers_p
3155 (TREE_TYPE (field
), type
)))
3156 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3159 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3160 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3162 tree op00
= TREE_OPERAND (sub
, 0);
3163 tree op01
= TREE_OPERAND (sub
, 1);
3166 if (TREE_CODE (op00
) == ADDR_EXPR
)
3169 op00
= TREE_OPERAND (op00
, 0);
3170 op00type
= TREE_TYPE (op00
);
3172 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3173 if (VECTOR_TYPE_P (op00type
)
3174 && same_type_ignoring_top_level_qualifiers_p
3175 (type
, TREE_TYPE (op00type
))
3176 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3177 but we want to treat offsets with MSB set as negative.
3178 For the code below negative offsets are invalid and
3179 TYPE_SIZE of the element is something unsigned, so
3180 check whether op01 fits into poly_int64, which implies
3181 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3182 then just use poly_uint64 because we want to treat the
3183 value as unsigned. */
3184 && tree_fits_poly_int64_p (op01
))
3186 tree part_width
= TYPE_SIZE (type
);
3187 poly_uint64 max_offset
3188 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3189 * TYPE_VECTOR_SUBPARTS (op00type
));
3190 if (known_lt (const_op01
, max_offset
))
3192 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3193 return fold_build3_loc (loc
,
3194 BIT_FIELD_REF
, type
, op00
,
3198 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3199 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3200 && (same_type_ignoring_top_level_qualifiers_p
3201 (type
, TREE_TYPE (op00type
))))
3203 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3205 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3207 /* ((foo *)&fooarray)[1] => fooarray[1] */
3208 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3209 && (same_type_ignoring_top_level_qualifiers_p
3210 (type
, TREE_TYPE (op00type
))))
3212 tree type_domain
= TYPE_DOMAIN (op00type
);
3213 tree min_val
= size_zero_node
;
3214 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3215 min_val
= TYPE_MIN_VALUE (type_domain
);
3216 offset_int off
= wi::to_offset (op01
);
3217 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3218 offset_int remainder
;
3219 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3220 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3222 off
= off
+ wi::to_offset (min_val
);
3223 op01
= wide_int_to_tree (sizetype
, off
);
3224 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3225 NULL_TREE
, NULL_TREE
);
3228 /* Also handle conversion to an empty base class, which
3229 is represented with a NOP_EXPR. */
3230 else if (is_empty_class (type
)
3231 && CLASS_TYPE_P (op00type
)
3232 && DERIVED_FROM_P (type
, op00type
))
3237 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3238 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3240 tree field
= TYPE_FIELDS (op00type
);
3241 for (; field
; field
= DECL_CHAIN (field
))
3242 if (TREE_CODE (field
) == FIELD_DECL
3243 && TREE_TYPE (field
) != error_mark_node
3244 && tree_int_cst_equal (byte_position (field
), op01
)
3245 && (same_type_ignoring_top_level_qualifiers_p
3246 (TREE_TYPE (field
), type
)))
3247 return fold_build3 (COMPONENT_REF
, type
, op00
,
3252 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3253 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3254 && (same_type_ignoring_top_level_qualifiers_p
3255 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3258 tree min_val
= size_zero_node
;
3260 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3264 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3265 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3266 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3267 min_val
= TYPE_MIN_VALUE (type_domain
);
3268 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3276 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3278 bool *non_constant_p
, bool *overflow_p
)
3280 tree orig_op0
= TREE_OPERAND (t
, 0);
3281 bool empty_base
= false;
3283 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3284 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3286 if (TREE_CODE (t
) == MEM_REF
3287 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3289 gcc_assert (ctx
->quiet
);
3290 *non_constant_p
= true;
3294 /* First try to simplify it directly. */
3295 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3299 /* If that didn't work, evaluate the operand first. */
3300 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3301 /*lval*/false, non_constant_p
,
3303 /* Don't VERIFY_CONSTANT here. */
3304 if (*non_constant_p
)
3307 if (!lval
&& integer_zerop (op0
))
3310 error ("dereferencing a null pointer");
3311 *non_constant_p
= true;
3315 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3319 /* We couldn't fold to a constant value. Make sure it's not
3320 something we should have been able to fold. */
3323 if (TREE_CODE (sub
) == ADDR_EXPR
)
3325 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3326 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3327 /* DR 1188 says we don't have to deal with this. */
3329 error ("accessing value of %qE through a %qT glvalue in a "
3330 "constant expression", build_fold_indirect_ref (sub
),
3332 *non_constant_p
= true;
3336 if (lval
&& op0
!= orig_op0
)
3337 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3339 VERIFY_CONSTANT (t
);
3344 r
= cxx_eval_constant_expression (ctx
, r
,
3345 lval
, non_constant_p
, overflow_p
);
3346 if (*non_constant_p
)
3349 /* If we're pulling out the value of an empty base, just return an empty
3351 if (empty_base
&& !lval
)
3353 r
= build_constructor (TREE_TYPE (t
), NULL
);
3354 TREE_CONSTANT (r
) = true;
3360 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3361 Shared between potential_constant_expression and
3362 cxx_eval_constant_expression. */
3365 non_const_var_error (tree r
)
3367 tree type
= TREE_TYPE (r
);
3368 error ("the value of %qD is not usable in a constant "
3370 /* Avoid error cascade. */
3371 if (DECL_INITIAL (r
) == error_mark_node
)
3373 if (DECL_DECLARED_CONSTEXPR_P (r
))
3374 inform (DECL_SOURCE_LOCATION (r
),
3375 "%qD used in its own initializer", r
);
3376 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3378 if (!CP_TYPE_CONST_P (type
))
3379 inform (DECL_SOURCE_LOCATION (r
),
3380 "%q#D is not const", r
);
3381 else if (CP_TYPE_VOLATILE_P (type
))
3382 inform (DECL_SOURCE_LOCATION (r
),
3383 "%q#D is volatile", r
);
3384 else if (!DECL_INITIAL (r
)
3385 || !TREE_CONSTANT (DECL_INITIAL (r
))
3386 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3387 inform (DECL_SOURCE_LOCATION (r
),
3388 "%qD was not initialized with a constant "
3393 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3394 inform (DECL_SOURCE_LOCATION (r
),
3395 "%qD was not initialized with a constant "
3399 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3400 inform (DECL_SOURCE_LOCATION (r
),
3401 "%qD was not declared %<constexpr%>", r
);
3403 inform (DECL_SOURCE_LOCATION (r
),
3404 "%qD does not have integral or enumeration type",
3409 /* Subroutine of cxx_eval_constant_expression.
3410 Like cxx_eval_unary_expression, except for trinary expressions. */
3413 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3415 bool *non_constant_p
, bool *overflow_p
)
3421 for (i
= 0; i
< 3; i
++)
3423 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3425 non_constant_p
, overflow_p
);
3426 VERIFY_CONSTANT (args
[i
]);
3429 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3430 args
[0], args
[1], args
[2]);
3431 if (val
== NULL_TREE
)
3433 VERIFY_CONSTANT (val
);
3437 /* True if T was declared in a function declared to be constexpr, and
3438 therefore potentially constant in C++14. */
3441 var_in_constexpr_fn (tree t
)
3443 tree ctx
= DECL_CONTEXT (t
);
3444 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3445 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3448 /* True if T was declared in a function that might be constexpr: either a
3449 function that was declared constexpr, or a C++17 lambda op(). */
3452 var_in_maybe_constexpr_fn (tree t
)
3454 if (cxx_dialect
>= cxx17
3455 && DECL_FUNCTION_SCOPE_P (t
)
3456 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3458 return var_in_constexpr_fn (t
);
3461 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3462 build_over_call we implement trivial copy of a class with tail padding using
3463 assignment of character arrays, which is valid in normal code, but not in
3464 constexpr evaluation. We don't need to worry about clobbering tail padding
3465 in constexpr evaluation, so strip the type punning. */
3468 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3470 if (TREE_CODE (target
) == MEM_REF
3471 && TREE_CODE (init
) == MEM_REF
3472 && TREE_TYPE (target
) == TREE_TYPE (init
)
3473 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3474 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3476 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3477 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3481 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3484 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3486 bool *non_constant_p
, bool *overflow_p
)
3488 constexpr_ctx new_ctx
= *ctx
;
3490 tree init
= TREE_OPERAND (t
, 1);
3491 if (TREE_CLOBBER_P (init
))
3492 /* Just ignore clobbers. */
3495 /* First we figure out where we're storing to. */
3496 tree target
= TREE_OPERAND (t
, 0);
3498 maybe_simplify_trivial_copy (target
, init
);
3500 tree type
= TREE_TYPE (target
);
3501 target
= cxx_eval_constant_expression (ctx
, target
,
3503 non_constant_p
, overflow_p
);
3504 if (*non_constant_p
)
3507 /* cxx_eval_array_reference for lval = true allows references one past
3508 end of array, because it does not know if it is just taking address
3509 (which is valid), or actual dereference. Here we know it is
3510 a dereference, so diagnose it here. */
3511 for (tree probe
= target
; probe
; )
3513 switch (TREE_CODE (probe
))
3517 ary
= TREE_OPERAND (probe
, 0);
3518 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3519 non_constant_p
, overflow_p
);
3520 VERIFY_CONSTANT (nelts
);
3521 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3522 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3523 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3525 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3526 *non_constant_p
= true;
3533 probe
= TREE_OPERAND (probe
, 0);
3542 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3544 /* For initialization of an empty base, the original target will be
3545 *(base*)this, which the above evaluation resolves to the object
3546 argument, which has the derived type rather than the base type. In
3547 this situation, just evaluate the initializer and return, since
3548 there's no actual data to store. */
3549 gcc_assert (is_empty_class (type
));
3550 return cxx_eval_constant_expression (ctx
, init
, false,
3551 non_constant_p
, overflow_p
);
3554 /* And then find the underlying variable. */
3555 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3556 tree object
= NULL_TREE
;
3557 for (tree probe
= target
; object
== NULL_TREE
; )
3559 switch (TREE_CODE (probe
))
3564 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3565 vec_safe_push (refs
, TREE_TYPE (probe
));
3566 probe
= TREE_OPERAND (probe
, 0);
3574 /* And then find/build up our initializer for the path to the subobject
3575 we're initializing. */
3577 if (object
== ctx
->object
&& VAR_P (object
)
3578 && DECL_NAME (object
) && ctx
->call
== NULL
)
3579 /* The variable we're building up an aggregate initializer for is outside
3580 the constant-expression, so don't evaluate the store. We check
3581 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3583 else if (DECL_P (object
))
3584 valp
= ctx
->values
->get (object
);
3589 /* A constant-expression cannot modify objects from outside the
3590 constant-expression. */
3592 error ("modification of %qE is not a constant expression", object
);
3593 *non_constant_p
= true;
3596 type
= TREE_TYPE (object
);
3597 bool no_zero_init
= true;
3599 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3600 while (!refs
->is_empty())
3602 if (*valp
== NULL_TREE
)
3604 *valp
= build_constructor (type
, NULL
);
3605 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3607 else if (TREE_CODE (*valp
) == STRING_CST
)
3609 /* An array was initialized with a string constant, and now
3610 we're writing into one of its elements. Explode the
3611 single initialization into a set of element
3613 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3615 tree string
= *valp
;
3616 tree elt_type
= TREE_TYPE (type
);
3617 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3618 / TYPE_PRECISION (char_type_node
));
3619 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3620 tree ary_ctor
= build_constructor (type
, NULL
);
3622 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3623 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3625 constructor_elt elt
=
3627 build_int_cst (size_type_node
, ix
),
3628 extract_string_elt (string
, chars_per_elt
, ix
)
3630 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3636 /* If the value of object is already zero-initialized, any new ctors for
3637 subobjects will also be zero-initialized. */
3638 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3640 vec_safe_push (ctors
, *valp
);
3642 enum tree_code code
= TREE_CODE (type
);
3644 tree index
= refs
->pop();
3646 constructor_elt
*cep
= NULL
;
3647 if (code
== ARRAY_TYPE
)
3650 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3651 gcc_assert (i
>= 0);
3652 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3653 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3657 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3659 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3660 Usually we meet initializers in that order, but it is
3661 possible for base types to be placed not in program
3663 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3664 unsigned HOST_WIDE_INT idx
;
3666 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3667 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3668 /* Changing active member. */
3669 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3672 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3673 idx
++, fields
= DECL_CHAIN (fields
))
3675 if (index
== cep
->index
)
3678 /* The field we're initializing must be on the field
3679 list. Look to see if it is present before the
3680 field the current ELT initializes. */
3681 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3682 if (index
== fields
)
3686 /* We fell off the end of the CONSTRUCTOR, so insert a new
3687 entry at the end. */
3690 constructor_elt ce
= { index
, NULL_TREE
};
3692 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3693 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3699 release_tree_vector (refs
);
3701 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3703 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3704 wants to modify it. */
3705 if (*valp
== NULL_TREE
)
3707 *valp
= build_constructor (type
, NULL
);
3708 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3710 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3711 *valp
= cplus_expand_constant (*valp
);
3712 new_ctx
.ctor
= *valp
;
3713 new_ctx
.object
= target
;
3716 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3717 non_constant_p
, overflow_p
);
3718 /* Don't share a CONSTRUCTOR that might be changed later. */
3719 init
= unshare_constructor (init
);
3720 if (target
== object
)
3721 /* The hash table might have moved since the get earlier. */
3722 valp
= ctx
->values
->get (object
);
3724 if (TREE_CODE (init
) == CONSTRUCTOR
)
3726 /* An outer ctx->ctor might be pointing to *valp, so replace
3728 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3729 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3730 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3731 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3732 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3737 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3738 CONSTRUCTORs, if any. */
3741 bool c
= TREE_CONSTANT (init
);
3742 bool s
= TREE_SIDE_EFFECTS (init
);
3744 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3747 TREE_CONSTANT (elt
) = false;
3749 TREE_SIDE_EFFECTS (elt
) = true;
3751 release_tree_vector (ctors
);
3753 if (*non_constant_p
)
3761 /* Evaluate a ++ or -- expression. */
3764 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3766 bool *non_constant_p
, bool *overflow_p
)
3768 enum tree_code code
= TREE_CODE (t
);
3769 tree type
= TREE_TYPE (t
);
3770 tree op
= TREE_OPERAND (t
, 0);
3771 tree offset
= TREE_OPERAND (t
, 1);
3772 gcc_assert (TREE_CONSTANT (offset
));
3774 /* The operand as an lvalue. */
3775 op
= cxx_eval_constant_expression (ctx
, op
, true,
3776 non_constant_p
, overflow_p
);
3778 /* The operand as an rvalue. */
3780 = cxx_eval_constant_expression (ctx
, op
, false,
3781 non_constant_p
, overflow_p
);
3782 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3783 a local array in a constexpr function. */
3784 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3786 VERIFY_CONSTANT (val
);
3788 /* The modified value. */
3789 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3791 if (POINTER_TYPE_P (type
))
3793 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3794 offset
= convert_to_ptrofftype (offset
);
3796 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3797 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3800 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3802 VERIFY_CONSTANT (mod
);
3804 /* Storing the modified value. */
3805 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3806 cxx_eval_constant_expression (ctx
, store
,
3807 true, non_constant_p
, overflow_p
);
3809 /* And the value of the expression. */
3810 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3812 /* Prefix ops are lvalues. */
3816 /* But we optimize when the caller wants an rvalue. */
3820 /* Postfix ops are rvalues. */
3824 /* Predicates for the meaning of *jump_target. */
3827 returns (tree
*jump_target
)
3830 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3831 || (TREE_CODE (*jump_target
) == LABEL_DECL
3832 && LABEL_DECL_CDTOR (*jump_target
)));
3836 breaks (tree
*jump_target
)
3839 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3840 && LABEL_DECL_BREAK (*jump_target
))
3841 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3845 continues (tree
*jump_target
)
3848 && TREE_CODE (*jump_target
) == LABEL_DECL
3849 && LABEL_DECL_CONTINUE (*jump_target
);
3853 switches (tree
*jump_target
)
3856 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3859 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3860 STMT matches *jump_target. If we're looking for a case label and we see
3861 the default label, note it in ctx->css_state. */
3864 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3866 switch (TREE_CODE (*jump_target
))
3869 if (TREE_CODE (stmt
) == LABEL_EXPR
3870 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3875 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3877 gcc_assert (ctx
->css_state
!= NULL
);
3878 if (!CASE_LOW (stmt
))
3880 /* default: should appear just once in a SWITCH_EXPR
3881 body (excluding nested SWITCH_EXPR). */
3882 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3883 /* When evaluating SWITCH_EXPR body for the second time,
3884 return true for the default: label. */
3885 if (*ctx
->css_state
== css_default_processing
)
3887 *ctx
->css_state
= css_default_seen
;
3889 else if (CASE_HIGH (stmt
))
3891 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3892 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3895 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3906 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3907 semantics, for switch, break, continue, and return. */
3910 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3911 bool *non_constant_p
, bool *overflow_p
,
3914 tree_stmt_iterator i
;
3916 /* In a statement-expression we want to return the last value.
3917 For empty statement expression return void_node. */
3921 local_target
= NULL_TREE
;
3922 jump_target
= &local_target
;
3924 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3926 tree stmt
= tsi_stmt (i
);
3927 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
3929 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3930 non_constant_p
, overflow_p
,
3932 if (*non_constant_p
)
3934 if (returns (jump_target
) || breaks (jump_target
))
3940 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3941 semantics; continue semantics are covered by cxx_eval_statement_list. */
3944 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3945 bool *non_constant_p
, bool *overflow_p
,
3948 constexpr_ctx new_ctx
= *ctx
;
3950 tree body
= TREE_OPERAND (t
, 0);
3954 hash_set
<tree
> save_exprs
;
3955 new_ctx
.save_exprs
= &save_exprs
;
3957 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3958 non_constant_p
, overflow_p
, jump_target
);
3960 /* Forget saved values of SAVE_EXPRs. */
3961 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3962 iter
!= save_exprs
.end(); ++iter
)
3963 new_ctx
.values
->remove (*iter
);
3964 if (++count
>= constexpr_loop_limit
)
3967 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3968 "%<constexpr%> loop iteration count exceeds limit of %d "
3969 "(use -fconstexpr-loop-limit= to increase the limit)",
3970 constexpr_loop_limit
);
3971 *non_constant_p
= true;
3975 while (!returns (jump_target
)
3976 && !breaks (jump_target
)
3977 && !switches (jump_target
)
3978 && !*non_constant_p
);
3980 if (breaks (jump_target
))
3981 *jump_target
= NULL_TREE
;
3986 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3990 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3991 bool *non_constant_p
, bool *overflow_p
,
3994 tree cond
= TREE_OPERAND (t
, 0);
3995 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3996 non_constant_p
, overflow_p
);
3997 VERIFY_CONSTANT (cond
);
3998 *jump_target
= cond
;
4000 tree body
= TREE_OPERAND (t
, 1);
4001 constexpr_ctx new_ctx
= *ctx
;
4002 constexpr_switch_state css
= css_default_not_seen
;
4003 new_ctx
.css_state
= &css
;
4004 cxx_eval_constant_expression (&new_ctx
, body
, false,
4005 non_constant_p
, overflow_p
, jump_target
);
4006 if (switches (jump_target
) && css
== css_default_seen
)
4008 /* If the SWITCH_EXPR body has default: label, process it once again,
4009 this time instructing label_matches to return true for default:
4010 label on switches (jump_target). */
4011 css
= css_default_processing
;
4012 cxx_eval_constant_expression (&new_ctx
, body
, false,
4013 non_constant_p
, overflow_p
, jump_target
);
4015 if (breaks (jump_target
) || switches (jump_target
))
4016 *jump_target
= NULL_TREE
;
4020 /* Find the object of TYPE under initialization in CTX. */
4023 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4028 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4029 can is a minor optimization. */
4030 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4036 /* Since an object cannot have a field of its own type, we can search outward
4037 from ctx->object to find the unique containing object of TYPE. */
4038 tree ob
= ctx
->object
;
4041 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4043 if (handled_component_p (ob
))
4044 ob
= TREE_OPERAND (ob
, 0);
4052 /* Attempt to reduce the expression T to a constant value.
4053 On failure, issue diagnostic and return error_mark_node. */
4054 /* FIXME unify with c_fully_fold */
4055 /* FIXME overflow_p is too global */
4058 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4060 bool *non_constant_p
, bool *overflow_p
,
4063 constexpr_ctx new_ctx
;
4066 if (jump_target
&& *jump_target
)
4068 /* If we are jumping, ignore all statements/expressions except those
4069 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4070 switch (TREE_CODE (t
))
4073 case STATEMENT_LIST
:
4078 case CASE_LABEL_EXPR
:
4079 if (label_matches (ctx
, jump_target
, t
))
4081 *jump_target
= NULL_TREE
;
4087 if (t
== error_mark_node
)
4089 *non_constant_p
= true;
4092 if (CONSTANT_CLASS_P (t
))
4094 if (TREE_OVERFLOW (t
))
4097 permerror (input_location
, "overflow in constant expression");
4098 if (!flag_permissive
|| ctx
->quiet
)
4102 if (TREE_CODE (t
) == INTEGER_CST
4103 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
4104 && !integer_zerop (t
))
4107 error ("value %qE of type %qT is not a constant expression",
4109 *non_constant_p
= true;
4115 tree_code tcode
= TREE_CODE (t
);
4121 /* We ask for an rvalue for the RESULT_DECL when indirecting
4122 through an invisible reference, or in named return value
4124 if (tree
*p
= ctx
->values
->get (t
))
4129 error ("%qE is not a constant expression", t
);
4130 *non_constant_p
= true;
4135 if (DECL_HAS_VALUE_EXPR_P (t
))
4136 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4137 lval
, non_constant_p
, overflow_p
);
4140 /* We used to not check lval for CONST_DECL, but darwin.c uses
4141 CONST_DECL for aggregate constants. */
4144 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4145 && is_really_empty_class (TREE_TYPE (t
)))
4147 /* If the class is empty, we aren't actually loading anything. */
4148 r
= build_constructor (TREE_TYPE (t
), NULL
);
4149 TREE_CONSTANT (r
) = true;
4151 else if (ctx
->strict
)
4152 r
= decl_really_constant_value (t
);
4154 r
= decl_constant_value (t
);
4155 if (TREE_CODE (r
) == TARGET_EXPR
4156 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4157 r
= TARGET_EXPR_INITIAL (r
);
4159 if (tree
*p
= ctx
->values
->get (r
))
4160 if (*p
!= NULL_TREE
)
4165 non_const_var_error (r
);
4166 *non_constant_p
= true;
4170 case DEBUG_BEGIN_STMT
:
4171 /* ??? It might be nice to retain this information somehow, so
4172 as to be able to step into a constexpr function call. */
4179 case CASE_LABEL_EXPR
:
4184 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4186 else if (tree
*p
= ctx
->values
->get (r
))
4189 /* Defer in case this is only used for its type. */;
4190 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4191 /* Defer, there's no lvalue->rvalue conversion. */;
4192 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4193 && is_really_empty_class (TREE_TYPE (t
)))
4195 /* If the class is empty, we aren't actually loading anything. */
4196 r
= build_constructor (TREE_TYPE (t
), NULL
);
4197 TREE_CONSTANT (r
) = true;
4202 error ("%qE is not a constant expression", t
);
4203 *non_constant_p
= true;
4208 case AGGR_INIT_EXPR
:
4209 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4210 non_constant_p
, overflow_p
);
4215 r
= DECL_EXPR_DECL (t
);
4216 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4217 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4221 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4222 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4223 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4227 if (tree init
= DECL_INITIAL (r
))
4229 init
= cxx_eval_constant_expression (ctx
, init
,
4231 non_constant_p
, overflow_p
);
4232 /* Don't share a CONSTRUCTOR that might be changed. */
4233 init
= unshare_constructor (init
);
4234 ctx
->values
->put (r
, init
);
4236 else if (ctx
== &new_ctx
)
4237 /* We gave it a CONSTRUCTOR above. */;
4239 ctx
->values
->put (r
, NULL_TREE
);
4244 if (!literal_type_p (TREE_TYPE (t
)))
4248 error ("temporary of non-literal type %qT in a "
4249 "constant expression", TREE_TYPE (t
));
4250 explain_non_literal_class (TREE_TYPE (t
));
4252 *non_constant_p
= true;
4255 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4257 /* We're being expanded without an explicit target, so start
4258 initializing a new object; expansion with an explicit target
4259 strips the TARGET_EXPR before we get here. */
4261 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4262 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4263 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4264 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4267 /* Pass false for 'lval' because this indicates
4268 initialization of a temporary. */
4269 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4271 non_constant_p
, overflow_p
);
4272 if (!*non_constant_p
)
4273 /* Adjust the type of the result to the type of the temporary. */
4274 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4277 tree slot
= TARGET_EXPR_SLOT (t
);
4278 r
= unshare_constructor (r
);
4279 ctx
->values
->put (slot
, r
);
4286 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4287 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4288 non_constant_p
, overflow_p
);
4292 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4294 non_constant_p
, overflow_p
);
4298 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4299 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4301 non_constant_p
, overflow_p
);
4306 /* Can happen with ({ return true; }) && false; passed to
4307 maybe_constant_value. There is nothing to jump over in this
4308 case, and the bug will be diagnosed later. */
4309 gcc_assert (ctx
->quiet
);
4310 *non_constant_p
= true;
4315 /* Avoid evaluating a SAVE_EXPR more than once. */
4316 if (tree
*p
= ctx
->values
->get (t
))
4320 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4321 non_constant_p
, overflow_p
);
4322 ctx
->values
->put (t
, r
);
4323 if (ctx
->save_exprs
)
4324 ctx
->save_exprs
->add (t
);
4328 case NON_LVALUE_EXPR
:
4329 case TRY_CATCH_EXPR
:
4331 case CLEANUP_POINT_EXPR
:
4332 case MUST_NOT_THROW_EXPR
:
4335 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4337 non_constant_p
, overflow_p
,
4341 case TRY_FINALLY_EXPR
:
4342 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4343 non_constant_p
, overflow_p
,
4345 if (!*non_constant_p
)
4346 /* Also evaluate the cleanup. */
4347 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4348 non_constant_p
, overflow_p
,
4352 /* These differ from cxx_eval_unary_expression in that this doesn't
4353 check for a constant operand or result; an address can be
4354 constant without its operand being, and vice versa. */
4357 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4358 non_constant_p
, overflow_p
);
4363 tree oldop
= TREE_OPERAND (t
, 0);
4364 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4366 non_constant_p
, overflow_p
);
4367 /* Don't VERIFY_CONSTANT here. */
4368 if (*non_constant_p
)
4370 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4371 /* This function does more aggressive folding than fold itself. */
4372 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4373 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4382 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4383 non_constant_p
, overflow_p
);
4384 if (r
== error_mark_node
)
4386 else if (r
== TREE_OPERAND (t
, 0))
4389 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4394 case FIX_TRUNC_EXPR
:
4399 case TRUTH_NOT_EXPR
:
4400 case FIXED_CONVERT_EXPR
:
4401 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4402 non_constant_p
, overflow_p
);
4406 r
= fold_sizeof_expr (t
);
4407 VERIFY_CONSTANT (r
);
4412 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4413 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4414 introduced by build_call_a. */
4415 tree op0
= TREE_OPERAND (t
, 0);
4416 tree op1
= TREE_OPERAND (t
, 1);
4418 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4419 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4420 r
= cxx_eval_constant_expression (ctx
, op0
,
4421 lval
, non_constant_p
, overflow_p
,
4425 /* Check that the LHS is constant and then discard it. */
4426 cxx_eval_constant_expression (ctx
, op0
,
4427 true, non_constant_p
, overflow_p
,
4429 if (*non_constant_p
)
4431 op1
= TREE_OPERAND (t
, 1);
4432 r
= cxx_eval_constant_expression (ctx
, op1
,
4433 lval
, non_constant_p
, overflow_p
,
4439 case POINTER_PLUS_EXPR
:
4440 case POINTER_DIFF_EXPR
:
4444 case TRUNC_DIV_EXPR
:
4446 case FLOOR_DIV_EXPR
:
4447 case ROUND_DIV_EXPR
:
4448 case TRUNC_MOD_EXPR
:
4450 case ROUND_MOD_EXPR
:
4452 case EXACT_DIV_EXPR
:
4462 case TRUTH_XOR_EXPR
:
4469 case UNORDERED_EXPR
:
4479 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4480 non_constant_p
, overflow_p
);
4483 /* fold can introduce non-IF versions of these; still treat them as
4484 short-circuiting. */
4485 case TRUTH_AND_EXPR
:
4486 case TRUTH_ANDIF_EXPR
:
4487 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4490 non_constant_p
, overflow_p
);
4494 case TRUTH_ORIF_EXPR
:
4495 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4498 non_constant_p
, overflow_p
);
4502 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4503 non_constant_p
, overflow_p
);
4507 if (is_overloaded_fn (t
))
4509 /* We can only get here in checking mode via
4510 build_non_dependent_expr, because any expression that
4511 calls or takes the address of the function will have
4512 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4513 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4514 *non_constant_p
= true;
4517 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4518 non_constant_p
, overflow_p
);
4522 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4523 non_constant_p
, overflow_p
);
4527 if (jump_target
&& *jump_target
)
4529 /* When jumping to a label, the label might be either in the
4530 then or else blocks, so process then block first in skipping
4531 mode first, and if we are still in the skipping mode at its end,
4532 process the else block too. */
4533 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4534 lval
, non_constant_p
, overflow_p
,
4537 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4538 lval
, non_constant_p
, overflow_p
,
4542 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4543 non_constant_p
, overflow_p
,
4547 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4552 if (TREE_CONSTANT (t
))
4554 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4555 VECTOR_CST if applicable. */
4556 verify_constructor_flags (t
);
4557 if (TREE_CONSTANT (t
))
4560 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4561 non_constant_p
, overflow_p
);
4565 /* We can get this in a defaulted constructor for a class with a
4566 non-static data member of array type. Either the initializer will
4567 be NULL, meaning default-initialization, or it will be an lvalue
4568 or xvalue of the same type, meaning direct-initialization from the
4569 corresponding member. */
4570 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4571 non_constant_p
, overflow_p
);
4576 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4577 non_constant_p
, overflow_p
);
4581 case VIEW_CONVERT_EXPR
:
4583 case UNARY_PLUS_EXPR
:
4585 tree oldop
= TREE_OPERAND (t
, 0);
4587 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4589 non_constant_p
, overflow_p
);
4590 if (*non_constant_p
)
4592 tree type
= TREE_TYPE (t
);
4593 if (TREE_CODE (op
) == PTRMEM_CST
4594 && !TYPE_PTRMEM_P (type
))
4595 op
= cplus_expand_constant (op
);
4596 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4598 if (same_type_ignoring_top_level_qualifiers_p (type
,
4600 || can_convert_qual (type
, op
))
4601 return cp_fold_convert (type
, op
);
4605 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4606 "a reinterpret_cast is not a constant expression");
4607 *non_constant_p
= true;
4612 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4614 if (integer_zerop (op
))
4616 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4619 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4620 "dereferencing a null pointer");
4621 *non_constant_p
= true;
4624 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4626 tree from
= TREE_TYPE (op
);
4628 if (!can_convert (type
, from
, tf_none
))
4631 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4632 "conversion of %qT null pointer to %qT "
4633 "is not a constant expression",
4635 *non_constant_p
= true;
4642 /* This detects for example:
4643 reinterpret_cast<void*>(sizeof 0)
4646 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4647 "%<reinterpret_cast<%T>(%E)%> is not "
4648 "a constant expression",
4650 *non_constant_p
= true;
4654 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4655 /* We didn't fold at the top so we could check for ptr-int
4658 if (tcode
== UNARY_PLUS_EXPR
)
4659 r
= fold_convert (TREE_TYPE (t
), op
);
4661 r
= fold_build1 (tcode
, type
, op
);
4662 /* Conversion of an out-of-range value has implementation-defined
4663 behavior; the language considers it different from arithmetic
4664 overflow, which is undefined. */
4665 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4666 TREE_OVERFLOW (r
) = false;
4670 case EMPTY_CLASS_EXPR
:
4671 /* This is good enough for a function argument that might not get
4672 used, and they can't do anything with it, so just return it. */
4675 case STATEMENT_LIST
:
4677 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4678 return cxx_eval_statement_list (&new_ctx
, t
,
4679 non_constant_p
, overflow_p
, jump_target
);
4682 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4684 non_constant_p
, overflow_p
,
4687 case PREINCREMENT_EXPR
:
4688 case POSTINCREMENT_EXPR
:
4689 case PREDECREMENT_EXPR
:
4690 case POSTDECREMENT_EXPR
:
4691 return cxx_eval_increment_expression (ctx
, t
,
4692 lval
, non_constant_p
, overflow_p
);
4698 case VEC_DELETE_EXPR
:
4701 /* GCC internal stuff. */
4704 case NON_DEPENDENT_EXPR
:
4708 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4709 "expression %qE is not a constant expression", t
);
4710 *non_constant_p
= true;
4713 case PLACEHOLDER_EXPR
:
4714 /* Use of the value or address of the current object. */
4715 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4716 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4717 non_constant_p
, overflow_p
);
4718 /* A placeholder without a referent. We can get here when
4719 checking whether NSDMIs are noexcept, or in massage_init_elt;
4720 just say it's non-constant for now. */
4721 gcc_assert (ctx
->quiet
);
4722 *non_constant_p
= true;
4727 tree cond
= TREE_OPERAND (t
, 0);
4728 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4729 non_constant_p
, overflow_p
);
4730 VERIFY_CONSTANT (cond
);
4731 if (integer_nonzerop (cond
))
4737 *jump_target
= TREE_OPERAND (t
, 0);
4738 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4739 /* Allow for jumping to a cdtor_label. */
4740 || returns (jump_target
));
4744 cxx_eval_loop_expr (ctx
, t
,
4745 non_constant_p
, overflow_p
, jump_target
);
4749 cxx_eval_switch_expr (ctx
, t
,
4750 non_constant_p
, overflow_p
, jump_target
);
4754 /* It's possible to get a requires-expression in a constant
4755 expression. For example:
4757 template<typename T> concept bool C() {
4758 return requires (T t) { t; };
4761 template<typename T> requires !C<T>() void f(T);
4763 Normalization leaves f with the associated constraint
4764 '!requires (T t) { ... }' which is not transformed into
4766 if (!processing_template_decl
)
4767 return evaluate_constraint_expression (t
, NULL_TREE
);
4769 *non_constant_p
= true;
4773 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4775 non_constant_p
, overflow_p
,
4784 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4786 /* This function doesn't know how to deal with pre-genericize
4787 statements; this can only happen with statement-expressions,
4788 so for now just fail. */
4790 error_at (EXPR_LOCATION (t
),
4791 "statement is not a constant expression");
4794 internal_error ("unexpected expression %qE of kind %s", t
,
4795 get_tree_code_name (TREE_CODE (t
)));
4796 *non_constant_p
= true;
4800 if (r
== error_mark_node
)
4801 *non_constant_p
= true;
4803 if (*non_constant_p
)
4810 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4811 bool strict
= true, tree object
= NULL_TREE
)
4813 auto_timevar
time (TV_CONSTEXPR
);
4815 bool non_constant_p
= false;
4816 bool overflow_p
= false;
4817 hash_map
<tree
,tree
> map
;
4819 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4820 allow_non_constant
, strict
};
4822 tree type
= initialized_type (t
);
4824 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4826 /* In C++14 an NSDMI can participate in aggregate initialization,
4827 and can refer to the address of the object being initialized, so
4828 we need to pass in the relevant VAR_DECL if we want to do the
4829 evaluation in a single pass. The evaluation will dynamically
4830 update ctx.values for the VAR_DECL. We use the same strategy
4831 for C++11 constexpr constructors that refer to the object being
4833 ctx
.ctor
= build_constructor (type
, NULL
);
4834 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4837 if (TREE_CODE (t
) == TARGET_EXPR
)
4838 object
= TARGET_EXPR_SLOT (t
);
4839 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4840 object
= AGGR_INIT_EXPR_SLOT (t
);
4842 ctx
.object
= object
;
4844 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4845 (type
, TREE_TYPE (object
)));
4846 if (object
&& DECL_P (object
))
4847 map
.put (object
, ctx
.ctor
);
4848 if (TREE_CODE (r
) == TARGET_EXPR
)
4849 /* Avoid creating another CONSTRUCTOR when we expand the
4851 r
= TARGET_EXPR_INITIAL (r
);
4854 r
= cxx_eval_constant_expression (&ctx
, r
,
4855 false, &non_constant_p
, &overflow_p
);
4857 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4859 /* Mutable logic is a bit tricky: we want to allow initialization of
4860 constexpr variables with mutable members, but we can't copy those
4861 members to another constexpr variable. */
4862 if (TREE_CODE (r
) == CONSTRUCTOR
4863 && CONSTRUCTOR_MUTABLE_POISON (r
))
4865 if (!allow_non_constant
)
4866 error ("%qE is not a constant expression because it refers to "
4867 "mutable subobjects of %qT", t
, type
);
4868 non_constant_p
= true;
4871 if (TREE_CODE (r
) == CONSTRUCTOR
4872 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4874 if (!allow_non_constant
)
4875 error ("%qE is not a constant expression because it refers to "
4876 "an incompletely initialized variable", t
);
4877 TREE_CONSTANT (r
) = false;
4878 non_constant_p
= true;
4881 /* Technically we should check this for all subexpressions, but that
4882 runs into problems with our internal representation of pointer
4883 subtraction and the 5.19 rules are still in flux. */
4884 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4885 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4886 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4888 if (!allow_non_constant
)
4889 error ("conversion from pointer type %qT "
4890 "to arithmetic type %qT in a constant expression",
4891 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4892 non_constant_p
= true;
4895 if (!non_constant_p
&& overflow_p
)
4896 non_constant_p
= true;
4898 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4900 bool should_unshare
= true;
4901 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4902 should_unshare
= false;
4904 if (non_constant_p
&& !allow_non_constant
)
4905 return error_mark_node
;
4906 else if (non_constant_p
&& TREE_CONSTANT (r
))
4908 /* This isn't actually constant, so unset TREE_CONSTANT.
4909 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
4910 it to be set if it is invariant address, even when it is not
4911 a valid C++ constant expression. Wrap it with a NOP_EXPR
4913 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
4915 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4916 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4918 r
= build_nop (TREE_TYPE (r
), r
);
4919 TREE_CONSTANT (r
) = false;
4921 else if (non_constant_p
|| r
== t
)
4925 r
= unshare_expr (r
);
4927 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4929 if (TREE_CODE (t
) == TARGET_EXPR
4930 && TARGET_EXPR_INITIAL (t
) == r
)
4934 r
= get_target_expr (r
);
4935 TREE_CONSTANT (r
) = true;
4943 /* Returns true if T is a valid subexpression of a constant expression,
4944 even if it isn't itself a constant expression. */
4947 is_sub_constant_expr (tree t
)
4949 bool non_constant_p
= false;
4950 bool overflow_p
= false;
4951 hash_map
<tree
, tree
> map
;
4953 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4955 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4957 return !non_constant_p
&& !overflow_p
;
4960 /* If T represents a constant expression returns its reduced value.
4961 Otherwise return error_mark_node. If T is dependent, then
4965 cxx_constant_value (tree t
, tree decl
)
4967 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4970 /* Helper routine for fold_simple function. Either return simplified
4971 expression T, otherwise NULL_TREE.
4972 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4973 even if we are within template-declaration. So be careful on call, as in
4974 such case types can be undefined. */
4977 fold_simple_1 (tree t
)
4980 enum tree_code code
= TREE_CODE (t
);
4992 return fold_sizeof_expr (t
);
5000 case TRUTH_NOT_EXPR
:
5002 case VIEW_CONVERT_EXPR
:
5005 case FIX_TRUNC_EXPR
:
5006 case FIXED_CONVERT_EXPR
:
5007 case ADDR_SPACE_CONVERT_EXPR
:
5009 op1
= TREE_OPERAND (t
, 0);
5011 t
= const_unop (code
, TREE_TYPE (t
), op1
);
5015 if (CONVERT_EXPR_CODE_P (code
)
5016 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
5017 TREE_OVERFLOW (t
) = false;
5025 /* If T is a simple constant expression, returns its simplified value.
5026 Otherwise returns T. In contrast to maybe_constant_value we
5027 simplify only few operations on constant-expressions, and we don't
5028 try to simplify constexpressions. */
5031 fold_simple (tree t
)
5033 if (processing_template_decl
)
5036 tree r
= fold_simple_1 (t
);
5043 /* If T is a constant expression, returns its reduced value.
5044 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5045 Otherwise, returns a version of T without TREE_CONSTANT. */
5047 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5050 maybe_constant_value (tree t
, tree decl
)
5054 if (!is_nondependent_constant_expression (t
))
5056 if (TREE_OVERFLOW_P (t
))
5058 t
= build_nop (TREE_TYPE (t
), t
);
5059 TREE_CONSTANT (t
) = false;
5063 else if (CONSTANT_CLASS_P (t
))
5064 /* No caching or evaluation needed. */
5067 if (cv_cache
== NULL
)
5068 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5069 if (tree
*cached
= cv_cache
->get (t
))
5072 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
5073 gcc_checking_assert (r
== t
5074 || CONVERT_EXPR_P (t
)
5075 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5076 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5077 || !cp_tree_equal (r
, t
));
5078 cv_cache
->put (t
, r
);
5082 /* Dispose of the whole CV_CACHE. */
5085 clear_cv_cache (void)
5087 if (cv_cache
!= NULL
)
5091 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5094 clear_cv_and_fold_caches (void)
5097 clear_fold_cache ();
5100 /* Like maybe_constant_value but first fully instantiate the argument.
5102 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5103 (t, tf_none) followed by maybe_constant_value but is more efficient,
5104 because calls instantiation_dependent_expression_p and
5105 potential_constant_expression at most once. */
5108 fold_non_dependent_expr (tree t
)
5113 /* If we're in a template, but T isn't value dependent, simplify
5114 it. We're supposed to treat:
5116 template <typename T> void f(T[1 + 1]);
5117 template <typename T> void f(T[2]);
5119 as two declarations of the same function, for example. */
5120 if (processing_template_decl
)
5122 if (is_nondependent_constant_expression (t
))
5124 processing_template_decl_sentinel s
;
5125 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
5127 if (type_unknown_p (t
)
5128 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5130 if (TREE_OVERFLOW_P (t
))
5132 t
= build_nop (TREE_TYPE (t
), t
);
5133 TREE_CONSTANT (t
) = false;
5138 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
5139 /* cp_tree_equal looks through NOPs, so allow them. */
5140 gcc_checking_assert (r
== t
5141 || CONVERT_EXPR_P (t
)
5142 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5143 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5144 || !cp_tree_equal (r
, t
));
5147 else if (TREE_OVERFLOW_P (t
))
5149 t
= build_nop (TREE_TYPE (t
), t
);
5150 TREE_CONSTANT (t
) = false;
5155 return maybe_constant_value (t
);
5158 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5159 than wrapped in a TARGET_EXPR. */
5162 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
)
5166 if (TREE_CODE (t
) == EXPR_STMT
)
5167 t
= TREE_OPERAND (t
, 0);
5168 if (TREE_CODE (t
) == CONVERT_EXPR
5169 && VOID_TYPE_P (TREE_TYPE (t
)))
5170 t
= TREE_OPERAND (t
, 0);
5171 if (TREE_CODE (t
) == INIT_EXPR
)
5172 t
= TREE_OPERAND (t
, 1);
5173 if (TREE_CODE (t
) == TARGET_EXPR
)
5174 t
= TARGET_EXPR_INITIAL (t
);
5175 if (!is_nondependent_static_init_expression (t
))
5176 /* Don't try to evaluate it. */;
5177 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5178 /* No evaluation needed. */;
5180 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
, false, decl
);
5181 if (TREE_CODE (t
) == TARGET_EXPR
)
5183 tree init
= TARGET_EXPR_INITIAL (t
);
5184 if (TREE_CODE (init
) == CONSTRUCTOR
)
5190 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5193 maybe_constant_init (tree t
, tree decl
)
5195 return maybe_constant_init_1 (t
, decl
, true);
5198 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5201 cxx_constant_init (tree t
, tree decl
)
5203 return maybe_constant_init_1 (t
, decl
, false);
5207 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5208 /* Return true if the object referred to by REF has automatic or thread
5211 enum { ck_ok
, ck_bad
, ck_unknown
};
5213 check_automatic_or_tls (tree ref
)
5216 poly_int64 bitsize
, bitpos
;
5218 int volatilep
= 0, unsignedp
= 0;
5219 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5220 &mode
, &unsignedp
, &volatilep
, false);
5223 /* If there isn't a decl in the middle, we don't know the linkage here,
5224 and this isn't a constant expression anyway. */
5227 dk
= decl_storage_duration (decl
);
5228 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5232 /* Return true if T denotes a potentially constant expression. Issue
5233 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5234 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5235 consider the expression in the current context, independent of constexpr
5238 C++0x [expr.const] used to say
5240 6 An expression is a potential constant expression if it is
5241 a constant expression where all occurrences of function
5242 parameters are replaced by arbitrary constant expressions
5243 of the appropriate type.
5245 2 A conditional expression is a constant expression unless it
5246 involves one of the following as a potentially evaluated
5247 subexpression (3.2), but subexpressions of logical AND (5.14),
5248 logical OR (5.15), and conditional (5.16) operations that are
5249 not evaluated are not considered. */
5252 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5253 tsubst_flags_t flags
)
5255 #define RECUR(T,RV) \
5256 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5258 enum { any
= false, rval
= true };
5262 if (t
== error_mark_node
)
5266 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5267 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5269 if (flags
& tf_error
)
5270 error_at (loc
, "expression %qE has side-effects", t
);
5273 if (CONSTANT_CLASS_P (t
))
5275 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5276 && TREE_TYPE (t
) == error_mark_node
)
5279 switch (TREE_CODE (t
))
5285 case TEMPLATE_ID_EXPR
:
5288 case CASE_LABEL_EXPR
:
5294 case TEMPLATE_PARM_INDEX
:
5296 case IDENTIFIER_NODE
:
5297 case USERDEF_LITERAL
:
5298 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5303 case PLACEHOLDER_EXPR
:
5308 case DEBUG_BEGIN_STMT
:
5314 if (flags
& tf_error
)
5315 error ("%qE is not a constant expression", t
);
5320 case AGGR_INIT_EXPR
:
5322 /* -- an invocation of a function other than a constexpr function
5323 or a constexpr constructor. */
5325 tree fun
= get_function_named_in_call (t
);
5326 const int nargs
= call_expr_nargs (t
);
5329 if (fun
== NULL_TREE
)
5331 /* Reset to allow the function to continue past the end
5332 of the block below. Otherwise return early. */
5335 if (TREE_CODE (t
) == CALL_EXPR
5336 && CALL_EXPR_FN (t
) == NULL_TREE
)
5337 switch (CALL_EXPR_IFN (t
))
5339 /* These should be ignored, they are optimized away from
5340 constexpr functions. */
5341 case IFN_UBSAN_NULL
:
5342 case IFN_UBSAN_BOUNDS
:
5343 case IFN_UBSAN_VPTR
:
5344 case IFN_FALLTHROUGH
:
5347 case IFN_ADD_OVERFLOW
:
5348 case IFN_SUB_OVERFLOW
:
5349 case IFN_MUL_OVERFLOW
:
5359 /* fold_call_expr can't do anything with IFN calls. */
5360 if (flags
& tf_error
)
5361 error_at (loc
, "call to internal function %qE", t
);
5366 if (fun
&& is_overloaded_fn (fun
))
5368 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5370 if (builtin_valid_in_constant_expr_p (fun
))
5372 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5373 /* Allow any built-in function; if the expansion
5374 isn't constant, we'll deal with that then. */
5375 && !is_builtin_fn (fun
))
5377 if (flags
& tf_error
)
5379 error_at (loc
, "call to non-%<constexpr%> function %qD",
5381 explain_invalid_constexpr_fn (fun
);
5385 /* A call to a non-static member function takes the address
5386 of the object as the first argument. But in a constant
5387 expression the address will be folded away, so look
5389 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5390 && !DECL_CONSTRUCTOR_P (fun
))
5392 tree x
= get_nth_callarg (t
, 0);
5393 if (is_this_parameter (x
))
5395 /* Don't require an immediately constant value, as
5396 constexpr substitution might not use the value. */
5397 bool sub_now
= false;
5398 if (!potential_constant_expression_1 (x
, rval
, strict
,
5406 if (!RECUR (fun
, true))
5408 fun
= get_first_fn (fun
);
5410 /* Skip initial arguments to base constructors. */
5411 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5412 i
= num_artificial_parms_for (fun
);
5413 fun
= DECL_ORIGIN (fun
);
5417 if (RECUR (fun
, rval
))
5418 /* Might end up being a constant function pointer. */;
5422 for (; i
< nargs
; ++i
)
5424 tree x
= get_nth_callarg (t
, i
);
5425 /* In a template, reference arguments haven't been converted to
5426 REFERENCE_TYPE and we might not even know if the parameter
5427 is a reference, so accept lvalue constants too. */
5428 bool rv
= processing_template_decl
? any
: rval
;
5429 /* Don't require an immediately constant value, as constexpr
5430 substitution might not use the value of the argument. */
5431 bool sub_now
= false;
5432 if (!potential_constant_expression_1 (x
, rv
, strict
,
5439 case NON_LVALUE_EXPR
:
5440 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5441 -- an lvalue of integral type that refers to a non-volatile
5442 const variable or static data member initialized with
5443 constant expressions, or
5445 -- an lvalue of literal type that refers to non-volatile
5446 object defined with constexpr, or that refers to a
5447 sub-object of such an object; */
5448 return RECUR (TREE_OPERAND (t
, 0), rval
);
5451 if (DECL_HAS_VALUE_EXPR_P (t
))
5453 if (now
&& is_normal_capture_proxy (t
))
5455 /* -- in a lambda-expression, a reference to this or to a
5456 variable with automatic storage duration defined outside that
5457 lambda-expression, where the reference would be an
5459 if (flags
& tf_error
)
5461 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5462 error ("lambda capture of %qE is not a constant expression",
5464 if (!want_rval
&& decl_constant_var_p (cap
))
5465 inform (input_location
, "because it is used as a glvalue");
5469 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5472 && !var_in_maybe_constexpr_fn (t
)
5473 && !type_dependent_expression_p (t
)
5474 && !decl_maybe_constant_var_p (t
)
5476 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5477 || (DECL_INITIAL (t
)
5478 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5479 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5480 && !is_really_empty_class (TREE_TYPE (t
)))
5482 if (flags
& tf_error
)
5483 non_const_var_error (t
);
5490 case VIEW_CONVERT_EXPR
:
5491 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5492 may change to something more specific to type-punning (DR 1312). */
5494 tree from
= TREE_OPERAND (t
, 0);
5495 if (POINTER_TYPE_P (TREE_TYPE (t
))
5496 && TREE_CODE (from
) == INTEGER_CST
5497 && !integer_zerop (from
))
5499 if (flags
& tf_error
)
5500 error_at (loc
, "reinterpret_cast from integer to pointer");
5503 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5506 case ADDRESSOF_EXPR
:
5507 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5508 t
= TREE_OPERAND (t
, 0);
5509 goto handle_addr_expr
;
5512 /* -- a unary operator & that is applied to an lvalue that
5513 designates an object with thread or automatic storage
5515 t
= TREE_OPERAND (t
, 0);
5517 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5518 /* A pointer-to-member constant. */
5523 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5524 any checking here, as we might dereference the pointer later. If
5525 we remove this code, also remove check_automatic_or_tls. */
5526 i
= check_automatic_or_tls (t
);
5531 if (flags
& tf_error
)
5532 error ("address-of an object %qE with thread local or "
5533 "automatic storage is not a constant expression", t
);
5537 return RECUR (t
, any
);
5545 /* -- a class member access unless its postfix-expression is
5546 of literal type or of pointer to literal type. */
5547 /* This test would be redundant, as it follows from the
5548 postfix-expression being a potential constant expression. */
5549 if (type_unknown_p (t
))
5551 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5553 case EXPR_PACK_EXPANSION
:
5554 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5558 tree x
= TREE_OPERAND (t
, 0);
5560 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5562 if (!var_in_maybe_constexpr_fn (x
))
5564 if (flags
& tf_error
)
5565 error_at (loc
, "use of %<this%> in a constant expression");
5570 return RECUR (x
, rval
);
5573 case STATEMENT_LIST
:
5575 tree_stmt_iterator i
;
5576 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5578 if (!RECUR (tsi_stmt (i
), any
))
5586 if (cxx_dialect
< cxx14
)
5588 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5590 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5595 if (cxx_dialect
< cxx14
)
5597 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5599 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5604 if (!RECUR (DO_COND (t
), rval
))
5606 if (!RECUR (DO_BODY (t
), any
))
5611 if (!RECUR (FOR_INIT_STMT (t
), any
))
5613 if (!RECUR (FOR_COND (t
), rval
))
5615 if (!RECUR (FOR_EXPR (t
), any
))
5617 if (!RECUR (FOR_BODY (t
), any
))
5621 case RANGE_FOR_STMT
:
5622 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5624 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5629 if (!RECUR (WHILE_COND (t
), rval
))
5631 if (!RECUR (WHILE_BODY (t
), any
))
5636 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5638 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5639 unreachable labels would be checked. */
5643 return RECUR (STMT_EXPR_STMT (t
), rval
);
5646 if (cxx_dialect
>= cxx17
)
5647 /* In C++17 lambdas can be constexpr, don't give up yet. */
5649 else if (flags
& tf_error
)
5650 error_at (loc
, "lambda-expression is not a constant expression "
5654 case DYNAMIC_CAST_EXPR
:
5655 case PSEUDO_DTOR_EXPR
:
5659 case VEC_DELETE_EXPR
:
5665 case OMP_DISTRIBUTE
:
5668 case OMP_TARGET_DATA
:
5677 case OMP_TARGET_UPDATE
:
5678 case OMP_TARGET_ENTER_DATA
:
5679 case OMP_TARGET_EXIT_DATA
:
5681 case OMP_ATOMIC_READ
:
5682 case OMP_ATOMIC_CAPTURE_OLD
:
5683 case OMP_ATOMIC_CAPTURE_NEW
:
5687 case OACC_HOST_DATA
:
5691 case OACC_ENTER_DATA
:
5692 case OACC_EXIT_DATA
:
5694 /* GCC internal stuff. */
5697 case TRANSACTION_EXPR
:
5699 case AT_ENCODE_EXPR
:
5701 if (flags
& tf_error
)
5702 error_at (loc
, "expression %qE is not a constant expression", t
);
5706 /* -- a typeid expression whose operand is of polymorphic
5709 tree e
= TREE_OPERAND (t
, 0);
5710 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5711 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5713 if (flags
& tf_error
)
5714 error_at (loc
, "typeid-expression is not a constant expression "
5715 "because %qE is of polymorphic type", e
);
5721 case POINTER_DIFF_EXPR
:
5735 case PREINCREMENT_EXPR
:
5736 case POSTINCREMENT_EXPR
:
5737 case PREDECREMENT_EXPR
:
5738 case POSTDECREMENT_EXPR
:
5739 if (cxx_dialect
< cxx14
)
5745 if (TYPE_P (TREE_OPERAND (t
, 0)))
5751 case FIX_TRUNC_EXPR
:
5755 case TRUTH_NOT_EXPR
:
5756 case FIXED_CONVERT_EXPR
:
5757 case UNARY_PLUS_EXPR
:
5758 case UNARY_LEFT_FOLD_EXPR
:
5759 case UNARY_RIGHT_FOLD_EXPR
:
5761 return RECUR (TREE_OPERAND (t
, 0), rval
);
5764 case CONST_CAST_EXPR
:
5765 case STATIC_CAST_EXPR
:
5766 case REINTERPRET_CAST_EXPR
:
5767 case IMPLICIT_CONV_EXPR
:
5768 if (cxx_dialect
< cxx11
5769 && !dependent_type_p (TREE_TYPE (t
))
5770 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5771 /* In C++98, a conversion to non-integral type can't be part of a
5772 constant expression. */
5774 if (flags
& tf_error
)
5776 "cast to non-integral type %qT in a constant expression",
5781 return (RECUR (TREE_OPERAND (t
, 0),
5782 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5785 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5787 case CLEANUP_POINT_EXPR
:
5788 case MUST_NOT_THROW_EXPR
:
5789 case TRY_CATCH_EXPR
:
5794 case NON_DEPENDENT_EXPR
:
5795 /* For convenience. */
5799 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5802 tmp
= DECL_EXPR_DECL (t
);
5803 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5805 if (TREE_STATIC (tmp
))
5807 if (flags
& tf_error
)
5808 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5809 "%<static%> in %<constexpr%> context", tmp
);
5812 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5814 if (flags
& tf_error
)
5815 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5816 "%<thread_local%> in %<constexpr%> context", tmp
);
5819 else if (!check_for_uninitialized_const_var
5820 (tmp
, /*constexpr_context_p=*/true, flags
))
5823 return RECUR (tmp
, want_rval
);
5825 case TRY_FINALLY_EXPR
:
5826 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5827 && RECUR (TREE_OPERAND (t
, 1), any
));
5830 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5833 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
5834 && !literal_type_p (TREE_TYPE (t
)))
5836 if (flags
& tf_error
)
5838 error_at (loc
, "temporary of non-literal type %qT in a "
5839 "constant expression", TREE_TYPE (t
));
5840 explain_non_literal_class (TREE_TYPE (t
));
5846 return RECUR (TREE_OPERAND (t
, 1), rval
);
5850 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5851 constructor_elt
*ce
;
5852 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5853 if (!RECUR (ce
->value
, want_rval
))
5860 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5861 || DECL_P (TREE_PURPOSE (t
)));
5862 if (!RECUR (TREE_VALUE (t
), want_rval
))
5864 if (TREE_CHAIN (t
) == NULL_TREE
)
5866 return RECUR (TREE_CHAIN (t
), want_rval
);
5869 case TRUNC_DIV_EXPR
:
5871 case FLOOR_DIV_EXPR
:
5872 case ROUND_DIV_EXPR
:
5873 case TRUNC_MOD_EXPR
:
5875 case ROUND_MOD_EXPR
:
5877 tree denom
= TREE_OPERAND (t
, 1);
5878 if (!RECUR (denom
, rval
))
5880 /* We can't call cxx_eval_outermost_constant_expr on an expression
5881 that hasn't been through instantiate_non_dependent_expr yet. */
5882 if (!processing_template_decl
)
5883 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5884 if (integer_zerop (denom
))
5886 if (flags
& tf_error
)
5887 error ("division by zero is not a constant expression");
5893 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5899 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5900 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5901 introduced by build_call_a. */
5902 tree op0
= TREE_OPERAND (t
, 0);
5903 tree op1
= TREE_OPERAND (t
, 1);
5905 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5906 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5907 return RECUR (op0
, want_rval
);
5912 /* If the first operand is the non-short-circuit constant, look at
5913 the second operand; otherwise we only care about the first one for
5915 case TRUTH_AND_EXPR
:
5916 case TRUTH_ANDIF_EXPR
:
5917 tmp
= boolean_true_node
;
5920 case TRUTH_ORIF_EXPR
:
5921 tmp
= boolean_false_node
;
5924 tree op
= TREE_OPERAND (t
, 0);
5925 if (!RECUR (op
, rval
))
5927 if (!processing_template_decl
)
5928 op
= cxx_eval_outermost_constant_expr (op
, true);
5929 if (tree_int_cst_equal (op
, tmp
))
5930 return RECUR (TREE_OPERAND (t
, 1), rval
);
5937 case POINTER_PLUS_EXPR
:
5939 case EXACT_DIV_EXPR
:
5949 case TRUTH_XOR_EXPR
:
5950 case UNORDERED_EXPR
:
5963 case ARRAY_RANGE_REF
:
5967 case BINARY_LEFT_FOLD_EXPR
:
5968 case BINARY_RIGHT_FOLD_EXPR
:
5970 for (i
= 0; i
< 2; ++i
)
5971 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5977 for (i
= 0; i
< 3; ++i
)
5978 if (!RECUR (TREE_OPERAND (t
, i
), true))
5983 if (COND_EXPR_IS_VEC_DELETE (t
))
5985 if (flags
& tf_error
)
5986 error_at (loc
, "%<delete[]%> is not a constant expression");
5992 /* If the condition is a known constant, we know which of the legs we
5993 care about; otherwise we only require that the condition and
5994 either of the legs be potentially constant. */
5995 tmp
= TREE_OPERAND (t
, 0);
5996 if (!RECUR (tmp
, rval
))
5998 if (!processing_template_decl
)
5999 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6000 if (integer_zerop (tmp
))
6001 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
6002 else if (TREE_CODE (tmp
) == INTEGER_CST
)
6003 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6004 for (i
= 1; i
< 3; ++i
)
6005 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
6006 want_rval
, strict
, now
, tf_none
))
6008 if (flags
& tf_error
)
6009 error_at (loc
, "expression %qE is not a constant expression", t
);
6013 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
6015 if (flags
& tf_error
)
6017 error_at (loc
, "non-constant array initialization");
6018 diagnose_non_constexpr_vec_init (t
);
6024 /* We can see these in statement-expressions. */
6028 case EMPTY_CLASS_EXPR
:
6034 tree
*target
= &TREE_OPERAND (t
, 0);
6035 /* Gotos representing break and continue are OK. */
6036 if (breaks (target
) || continues (target
))
6038 if (flags
& tf_error
)
6039 error_at (loc
, "%<goto%> is not a constant expression");
6044 return RECUR (TREE_OPERAND (t
, 0), rval
);
6047 if (objc_is_property_ref (t
))
6050 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6057 /* The main entry point to the above. */
6060 potential_constant_expression (tree t
)
6062 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6065 /* As above, but require a constant rvalue. */
6068 potential_rvalue_constant_expression (tree t
)
6070 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6073 /* Like above, but complain about non-constant expressions. */
6076 require_potential_constant_expression (tree t
)
6078 return potential_constant_expression_1 (t
, false, true, false,
6079 tf_warning_or_error
);
6082 /* Cross product of the above. */
6085 require_potential_rvalue_constant_expression (tree t
)
6087 return potential_constant_expression_1 (t
, true, true, false,
6088 tf_warning_or_error
);
6091 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6094 require_rvalue_constant_expression (tree t
)
6096 return potential_constant_expression_1 (t
, true, true, true,
6097 tf_warning_or_error
);
6100 /* Like potential_constant_expression, but don't consider possible constexpr
6101 substitution of the current function. That is, PARM_DECL qualifies under
6102 potential_constant_expression, but not here.
6104 This is basically what you can check when any actual constant values might
6105 be value-dependent. */
6108 is_constant_expression (tree t
)
6110 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6113 /* Like above, but complain about non-constant expressions. */
6116 require_constant_expression (tree t
)
6118 return potential_constant_expression_1 (t
, false, true, true,
6119 tf_warning_or_error
);
6122 /* Like is_constant_expression, but allow const variables that are not allowed
6123 under constexpr rules. */
6126 is_static_init_expression (tree t
)
6128 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6131 /* Returns true if T is a potential constant expression that is not
6132 instantiation-dependent, and therefore a candidate for constant folding even
6136 is_nondependent_constant_expression (tree t
)
6138 return (!type_unknown_p (t
)
6139 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6140 && is_constant_expression (t
)
6141 && !instantiation_dependent_expression_p (t
));
6144 /* Returns true if T is a potential static initializer expression that is not
6145 instantiation-dependent. */
6148 is_nondependent_static_init_expression (tree t
)
6150 return (!type_unknown_p (t
)
6151 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6152 && is_static_init_expression (t
)
6153 && !instantiation_dependent_expression_p (t
));
6156 /* Finalize constexpr processing after parsing. */
6159 fini_constexpr (void)
6161 /* The contexpr call and fundef copies tables are no longer needed. */
6162 constexpr_call_table
= NULL
;
6163 fundef_copies_table
= NULL
;
6166 #include "gt-cp-constexpr.h"