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-2017 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 the DECL if OK, otherwise NULL. */
81 ensure_literal_type_for_constexpr_object (tree decl
)
83 tree type
= TREE_TYPE (decl
);
85 && (DECL_DECLARED_CONSTEXPR_P (decl
)
86 || var_in_constexpr_fn (decl
))
87 && !processing_template_decl
)
89 tree stype
= strip_array_types (type
);
90 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
91 /* Don't complain here, we'll complain about incompleteness
92 when we try to initialize the variable. */;
93 else if (!literal_type_p (type
))
95 if (DECL_DECLARED_CONSTEXPR_P (decl
))
97 error ("the type %qT of constexpr variable %qD is not literal",
99 explain_non_literal_class (type
);
103 if (!is_instantiation_of_constexpr (current_function_decl
))
105 error ("variable %qD of non-literal type %qT in %<constexpr%> "
106 "function", decl
, type
);
107 explain_non_literal_class (type
);
109 cp_function_chain
->invalid_constexpr
= true;
117 /* Representation of entries in the constexpr function definition table. */
119 struct GTY((for_user
)) constexpr_fundef
{
124 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
126 static hashval_t
hash (constexpr_fundef
*);
127 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
130 /* This table holds all constexpr function definitions seen in
131 the current translation unit. */
133 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
135 /* Utility function used for managing the constexpr function table.
136 Return true if the entries pointed to by P and Q are for the
137 same constexpr function. */
140 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
142 return lhs
->decl
== rhs
->decl
;
145 /* Utility function used for managing the constexpr function table.
146 Return a hash value for the entry pointed to by Q. */
149 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
151 return DECL_UID (fundef
->decl
);
154 /* Return a previously saved definition of function FUN. */
156 static constexpr_fundef
*
157 retrieve_constexpr_fundef (tree fun
)
159 constexpr_fundef fundef
= { NULL
, NULL
};
160 if (constexpr_fundef_table
== NULL
)
164 return constexpr_fundef_table
->find (&fundef
);
167 /* Check whether the parameter and return types of FUN are valid for a
168 constexpr function, and complain if COMPLAIN. */
171 is_valid_constexpr_fn (tree fun
, bool complain
)
175 if (DECL_INHERITED_CTOR (fun
)
176 && TREE_CODE (fun
) == TEMPLATE_DECL
)
180 error ("inherited constructor %qD is not constexpr",
181 DECL_INHERITED_CTOR (fun
));
185 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
186 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
187 if (!literal_type_p (TREE_TYPE (parm
)))
192 error ("invalid type for parameter %d of constexpr "
193 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
194 explain_non_literal_class (TREE_TYPE (parm
));
199 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
203 inform (DECL_SOURCE_LOCATION (fun
),
204 "lambdas are implicitly constexpr only in C++17 and later");
206 else if (!DECL_CONSTRUCTOR_P (fun
))
208 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
209 if (!literal_type_p (rettype
))
214 error ("invalid return type %qT of constexpr function %q+D",
216 explain_non_literal_class (rettype
);
220 /* C++14 DR 1684 removed this restriction. */
221 if (cxx_dialect
< cxx14
222 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
223 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
227 && pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
228 "enclosing class of constexpr non-static member "
229 "function %q+#D is not a literal type", fun
))
230 explain_non_literal_class (DECL_CONTEXT (fun
));
233 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
237 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
243 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
244 for a member of an anonymous aggregate, INIT is the initializer for that
245 member, and VEC_OUTER is the vector of constructor elements for the class
246 whose constructor we are processing. Add the initializer to the vector
247 and return true to indicate success. */
250 build_anon_member_initialization (tree member
, tree init
,
251 vec
<constructor_elt
, va_gc
> **vec_outer
)
253 /* MEMBER presents the relevant fields from the inside out, but we need
254 to build up the initializer from the outside in so that we can reuse
255 previously built CONSTRUCTORs if this is, say, the second field in an
256 anonymous struct. So we use a vec as a stack. */
257 auto_vec
<tree
, 2> fields
;
260 fields
.safe_push (TREE_OPERAND (member
, 1));
261 member
= TREE_OPERAND (member
, 0);
263 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
264 && TREE_CODE (member
) == COMPONENT_REF
);
266 /* VEC has the constructor elements vector for the context of FIELD.
267 If FIELD is an anonymous aggregate, we will push inside it. */
268 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
270 while (field
= fields
.pop(),
271 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
274 /* If there is already an outer constructor entry for the anonymous
275 aggregate FIELD, use it; otherwise, insert one. */
276 if (vec_safe_is_empty (*vec
)
277 || (*vec
)->last().index
!= field
)
279 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
280 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
283 ctor
= (*vec
)->last().value
;
284 vec
= &CONSTRUCTOR_ELTS (ctor
);
287 /* Now we're at the innermost field, the one that isn't an anonymous
288 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
289 gcc_assert (fields
.is_empty());
290 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
295 /* Subroutine of build_constexpr_constructor_member_initializers.
296 The expression tree T represents a data member initialization
297 in a (constexpr) constructor definition. Build a pairing of
298 the data member with its initializer, and prepend that pair
299 to the existing initialization pair INITS. */
302 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
305 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
306 t
= TREE_OPERAND (t
, 0);
307 if (TREE_CODE (t
) == EXPR_STMT
)
308 t
= TREE_OPERAND (t
, 0);
309 if (t
== error_mark_node
)
311 if (TREE_CODE (t
) == STATEMENT_LIST
)
313 tree_stmt_iterator i
;
314 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
316 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
321 if (TREE_CODE (t
) == CLEANUP_STMT
)
323 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
324 but we can in a constexpr constructor for a non-literal class. Just
325 ignore it; either all the initialization will be constant, in which
326 case the cleanup can't run, or it can't be constexpr.
327 Still recurse into CLEANUP_BODY. */
328 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
330 if (TREE_CODE (t
) == CONVERT_EXPR
)
331 t
= TREE_OPERAND (t
, 0);
332 if (TREE_CODE (t
) == INIT_EXPR
333 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
334 use what this function builds for cx_check_missing_mem_inits, and
335 assignment in the ctor body doesn't count. */
336 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
338 member
= TREE_OPERAND (t
, 0);
339 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
341 else if (TREE_CODE (t
) == CALL_EXPR
)
343 tree fn
= get_callee_fndecl (t
);
344 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
345 /* We're only interested in calls to subobject constructors. */
347 member
= CALL_EXPR_ARG (t
, 0);
348 /* We don't use build_cplus_new here because it complains about
349 abstract bases. Leaving the call unwrapped means that it has the
350 wrong type, but cxx_eval_constant_expression doesn't care. */
351 init
= break_out_target_exprs (t
);
353 else if (TREE_CODE (t
) == BIND_EXPR
)
354 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
356 /* Don't add anything else to the CONSTRUCTOR. */
358 if (INDIRECT_REF_P (member
))
359 member
= TREE_OPERAND (member
, 0);
360 if (TREE_CODE (member
) == NOP_EXPR
)
364 if (TREE_CODE (op
) == ADDR_EXPR
)
366 gcc_assert (same_type_ignoring_top_level_qualifiers_p
367 (TREE_TYPE (TREE_TYPE (op
)),
368 TREE_TYPE (TREE_TYPE (member
))));
369 /* Initializing a cv-qualified member; we need to look through
373 else if (op
== current_class_ptr
374 && (same_type_ignoring_top_level_qualifiers_p
375 (TREE_TYPE (TREE_TYPE (member
)),
376 current_class_type
)))
377 /* Delegating constructor. */
381 /* This is an initializer for an empty base; keep it for now so
382 we can check it in cxx_eval_bare_aggregate. */
383 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
386 if (TREE_CODE (member
) == ADDR_EXPR
)
387 member
= TREE_OPERAND (member
, 0);
388 if (TREE_CODE (member
) == COMPONENT_REF
)
390 tree aggr
= TREE_OPERAND (member
, 0);
391 if (TREE_CODE (aggr
) == VAR_DECL
)
392 /* Initializing a local variable, don't add anything. */
394 if (TREE_CODE (aggr
) != COMPONENT_REF
)
395 /* Normal member initialization. */
396 member
= TREE_OPERAND (member
, 1);
397 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
398 /* Initializing a member of an anonymous union. */
399 return build_anon_member_initialization (member
, init
, vec
);
401 /* We're initializing a vtable pointer in a base. Leave it as
402 COMPONENT_REF so we remember the path to get to the vfield. */
403 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
406 /* Value-initialization can produce multiple initializers for the
407 same field; use the last one. */
408 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
409 (*vec
)->last().value
= init
;
411 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
415 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
416 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
417 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
420 check_constexpr_bind_expr_vars (tree t
)
422 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
424 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
425 if (TREE_CODE (var
) == TYPE_DECL
426 && DECL_IMPLICIT_TYPEDEF_P (var
)
427 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
432 /* Subroutine of check_constexpr_ctor_body. */
435 check_constexpr_ctor_body_1 (tree last
, tree list
)
437 switch (TREE_CODE (list
))
440 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
441 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
445 case CLEANUP_POINT_EXPR
:
446 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
450 if (!check_constexpr_bind_expr_vars (list
)
451 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
465 /* Make sure that there are no statements after LAST in the constructor
466 body represented by LIST. */
469 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
471 /* C++14 doesn't require a constexpr ctor to have an empty body. */
472 if (cxx_dialect
>= cxx14
)
476 if (TREE_CODE (list
) == STATEMENT_LIST
)
478 tree_stmt_iterator i
= tsi_last (list
);
479 for (; !tsi_end_p (i
); tsi_prev (&i
))
481 tree t
= tsi_stmt (i
);
484 if (!check_constexpr_ctor_body_1 (last
, t
))
491 else if (list
!= last
492 && !check_constexpr_ctor_body_1 (last
, list
))
497 error ("constexpr constructor does not have empty body");
498 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
503 /* V is a vector of constructor elements built up for the base and member
504 initializers of a constructor for TYPE. They need to be in increasing
505 offset order, which they might not be yet if TYPE has a primary base
506 which is not first in the base-clause or a vptr and at least one base
507 all of which are non-primary. */
509 static vec
<constructor_elt
, va_gc
> *
510 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
512 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
518 field_type
= BINFO_TYPE (pri
);
519 else if (TYPE_CONTAINS_VPTR_P (type
))
520 field_type
= vtbl_ptr_type_node
;
524 /* Find the element for the primary base or vptr and move it to the
525 beginning of the vec. */
526 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
527 if (TREE_TYPE (ce
->index
) == field_type
)
530 if (i
> 0 && i
< vec_safe_length (v
))
532 vec
<constructor_elt
, va_gc
> &vref
= *v
;
533 constructor_elt elt
= vref
[i
];
542 /* Build compile-time evalable representations of member-initializer list
543 for a constexpr constructor. */
546 build_constexpr_constructor_member_initializers (tree type
, tree body
)
548 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
551 switch (TREE_CODE (body
))
553 case MUST_NOT_THROW_EXPR
:
555 body
= TREE_OPERAND (body
, 0);
559 for (tree_stmt_iterator i
= tsi_start (body
);
560 !tsi_end_p (i
); tsi_next (&i
))
563 if (TREE_CODE (body
) == BIND_EXPR
)
569 body
= BIND_EXPR_BODY (body
);
576 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
578 body
= TREE_OPERAND (body
, 0);
579 if (TREE_CODE (body
) == EXPR_STMT
)
580 body
= TREE_OPERAND (body
, 0);
581 if (TREE_CODE (body
) == INIT_EXPR
582 && (same_type_ignoring_top_level_qualifiers_p
583 (TREE_TYPE (TREE_OPERAND (body
, 0)),
584 current_class_type
)))
587 return TREE_OPERAND (body
, 1);
589 ok
= build_data_member_initialization (body
, &vec
);
591 else if (TREE_CODE (body
) == STATEMENT_LIST
)
593 tree_stmt_iterator i
;
594 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
596 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
601 else if (TREE_CODE (body
) == TRY_BLOCK
)
603 error ("body of %<constexpr%> constructor cannot be "
604 "a function-try-block");
605 return error_mark_node
;
607 else if (EXPR_P (body
))
608 ok
= build_data_member_initialization (body
, &vec
);
610 gcc_assert (errorcount
> 0);
613 if (vec_safe_length (vec
) > 0)
615 /* In a delegating constructor, return the target. */
616 constructor_elt
*ce
= &(*vec
)[0];
617 if (ce
->index
== current_class_ptr
)
624 vec
= sort_constexpr_mem_initializers (type
, vec
);
625 return build_constructor (type
, vec
);
628 return error_mark_node
;
631 /* We have an expression tree T that represents a call, either CALL_EXPR
632 or AGGR_INIT_EXPR. If the call is lexically to a named function,
633 retrun the _DECL for that function. */
636 get_function_named_in_call (tree t
)
638 tree fun
= cp_get_callee (t
);
639 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
640 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
641 fun
= TREE_OPERAND (fun
, 0);
645 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
646 declared to be constexpr, or a sub-statement thereof. Returns the
647 return value if suitable, error_mark_node for a statement not allowed in
648 a constexpr function, or NULL_TREE if no return value was found. */
651 constexpr_fn_retval (tree body
)
653 switch (TREE_CODE (body
))
657 tree_stmt_iterator i
;
658 tree expr
= NULL_TREE
;
659 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
661 tree s
= constexpr_fn_retval (tsi_stmt (i
));
662 if (s
== error_mark_node
)
663 return error_mark_node
;
664 else if (s
== NULL_TREE
)
665 /* Keep iterating. */;
667 /* Multiple return statements. */
668 return error_mark_node
;
676 return break_out_target_exprs (TREE_OPERAND (body
, 0));
680 tree decl
= DECL_EXPR_DECL (body
);
681 if (TREE_CODE (decl
) == USING_DECL
682 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
683 || DECL_ARTIFICIAL (decl
))
685 return error_mark_node
;
688 case CLEANUP_POINT_EXPR
:
689 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
692 if (!check_constexpr_bind_expr_vars (body
))
693 return error_mark_node
;
694 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
701 tree fun
= get_function_named_in_call (body
);
703 && DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
)
709 return error_mark_node
;
713 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
714 FUN; do the necessary transformations to turn it into a single expression
715 that we can store in the hash table. */
718 massage_constexpr_body (tree fun
, tree body
)
720 if (DECL_CONSTRUCTOR_P (fun
))
721 body
= build_constexpr_constructor_member_initializers
722 (DECL_CONTEXT (fun
), body
);
723 else if (cxx_dialect
< cxx14
)
725 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
726 body
= EH_SPEC_STMTS (body
);
727 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
728 body
= TREE_OPERAND (body
, 0);
729 body
= constexpr_fn_retval (body
);
734 /* CTYPE is a type constructed from BODY. Return true if some
735 bases/fields are uninitialized, and complain if COMPLAIN. */
738 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
744 if (TREE_CODE (body
) != CONSTRUCTOR
)
746 nelts
= CONSTRUCTOR_NELTS (body
);
748 tree field
= TYPE_FIELDS (ctype
);
750 if (TREE_CODE (ctype
) == UNION_TYPE
)
752 if (nelts
== 0 && next_initializable_field (field
))
755 error ("%<constexpr%> constructor for union %qT must "
756 "initialize exactly one non-static data member", ctype
);
762 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
763 need an explicit initialization. */
765 for (unsigned i
= 0; i
<= nelts
; ++i
)
767 tree index
= NULL_TREE
;
770 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
771 /* Skip base and vtable inits. */
772 if (TREE_CODE (index
) != FIELD_DECL
773 || DECL_ARTIFICIAL (index
))
777 for (; field
!= index
; field
= DECL_CHAIN (field
))
780 if (TREE_CODE (field
) != FIELD_DECL
)
782 if (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
784 if (DECL_ARTIFICIAL (field
))
786 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
788 /* Recurse to check the anonummous aggregate member. */
789 bad
|= cx_check_missing_mem_inits
790 (TREE_TYPE (field
), NULL_TREE
, complain
);
791 if (bad
&& !complain
)
795 ftype
= strip_array_types (TREE_TYPE (field
));
796 if (type_has_constexpr_default_constructor (ftype
))
798 /* It's OK to skip a member with a trivial constexpr ctor.
799 A constexpr ctor that isn't trivial should have been
801 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
807 error ("member %qD must be initialized by mem-initializer "
808 "in %<constexpr%> constructor", field
);
809 inform (DECL_SOURCE_LOCATION (field
), "declared here");
812 if (field
== NULL_TREE
)
815 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
817 /* Check the anonymous aggregate initializer is valid. */
818 bad
|= cx_check_missing_mem_inits
819 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
820 if (bad
&& !complain
)
823 field
= DECL_CHAIN (field
);
829 /* We are processing the definition of the constexpr function FUN.
830 Check that its BODY fulfills the propriate requirements and
831 enter it in the constexpr function definition table.
832 For constructor BODY is actually the TREE_LIST of the
833 member-initializer list. */
836 register_constexpr_fundef (tree fun
, tree body
)
838 constexpr_fundef entry
;
839 constexpr_fundef
**slot
;
841 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
844 tree massaged
= massage_constexpr_body (fun
, body
);
845 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
847 if (!DECL_CONSTRUCTOR_P (fun
))
848 error ("body of constexpr function %qD not a return-statement", fun
);
852 if (!potential_rvalue_constant_expression (massaged
))
854 if (!DECL_GENERATED_P (fun
))
855 require_potential_rvalue_constant_expression (massaged
);
859 if (DECL_CONSTRUCTOR_P (fun
)
860 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
861 massaged
, !DECL_GENERATED_P (fun
)))
864 /* Create the constexpr function table if necessary. */
865 if (constexpr_fundef_table
== NULL
)
866 constexpr_fundef_table
867 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
871 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
873 gcc_assert (*slot
== NULL
);
874 *slot
= ggc_alloc
<constexpr_fundef
> ();
880 /* FUN is a non-constexpr function called in a context that requires a
881 constant expression. If it comes from a constexpr template, explain why
882 the instantiation isn't constexpr. */
885 explain_invalid_constexpr_fn (tree fun
)
887 static hash_set
<tree
> *diagnosed
;
890 /* Only diagnose defaulted functions, lambdas, or instantiations. */
891 if (!DECL_DEFAULTED_FN (fun
)
892 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
893 && !is_instantiation_of_constexpr (fun
))
895 if (diagnosed
== NULL
)
896 diagnosed
= new hash_set
<tree
>;
897 if (diagnosed
->add (fun
))
898 /* Already explained. */
901 save_loc
= input_location
;
902 if (!lambda_static_thunk_p (fun
))
904 /* Diagnostics should completely ignore the static thunk, so leave
905 input_location set to our caller's location. */
906 input_location
= DECL_SOURCE_LOCATION (fun
);
907 inform (input_location
,
908 "%qD is not usable as a constexpr function because:", fun
);
910 /* First check the declaration. */
911 if (is_valid_constexpr_fn (fun
, true))
913 /* Then if it's OK, the body. */
914 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
915 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
916 explain_implicit_non_constexpr (fun
);
919 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
920 require_potential_rvalue_constant_expression (body
);
921 if (DECL_CONSTRUCTOR_P (fun
))
922 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
925 input_location
= save_loc
;
928 /* Objects of this type represent calls to constexpr functions
929 along with the bindings of parameters to their arguments, for
930 the purpose of compile time evaluation. */
932 struct GTY((for_user
)) constexpr_call
{
933 /* Description of the constexpr function definition. */
934 constexpr_fundef
*fundef
;
935 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
936 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
937 Note: This arrangement is made to accommodate the use of
938 iterative_hash_template_arg (see pt.c). If you change this
939 representation, also change the hash calculation in
940 cxx_eval_call_expression. */
942 /* Result of the call.
943 NULL means the call is being evaluated.
944 error_mark_node means that the evaluation was erroneous;
945 otherwise, the actuall value of the call. */
947 /* The hash of this call; we remember it here to avoid having to
948 recalculate it when expanding the hash table. */
952 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
954 static hashval_t
hash (constexpr_call
*);
955 static bool equal (constexpr_call
*, constexpr_call
*);
958 enum constexpr_switch_state
{
959 /* Used when processing a switch for the first time by cxx_eval_switch_expr
960 and default: label for that switch has not been seen yet. */
961 css_default_not_seen
,
962 /* Used when processing a switch for the first time by cxx_eval_switch_expr
963 and default: label for that switch has been seen already. */
965 /* Used when processing a switch for the second time by
966 cxx_eval_switch_expr, where default: label should match. */
967 css_default_processing
970 /* The constexpr expansion context. CALL is the current function
971 expansion, CTOR is the current aggregate initializer, OBJECT is the
972 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
973 is a map of values of variables initialized within the expression. */
975 struct constexpr_ctx
{
976 /* The innermost call we're evaluating. */
977 constexpr_call
*call
;
978 /* Values for any temporaries or local variables within the
979 constant-expression. */
980 hash_map
<tree
,tree
> *values
;
981 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
982 aren't inside a loop. */
983 hash_set
<tree
> *save_exprs
;
984 /* The CONSTRUCTOR we're currently building up for an aggregate
987 /* The object we're building the CONSTRUCTOR for. */
989 /* If inside SWITCH_EXPR. */
990 constexpr_switch_state
*css_state
;
991 /* Whether we should error on a non-constant expression or fail quietly. */
993 /* Whether we are strictly conforming to constant expression rules or
994 trying harder to get a constant value. */
998 /* A table of all constexpr calls that have been evaluated by the
999 compiler in this translation unit. */
1001 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1003 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1004 bool, bool *, bool *, tree
* = NULL
);
1006 /* Compute a hash value for a constexpr call representation. */
1009 constexpr_call_hasher::hash (constexpr_call
*info
)
1014 /* Return true if the objects pointed to by P and Q represent calls
1015 to the same constexpr function with the same arguments.
1016 Otherwise, return false. */
1019 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1025 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1027 lhs_bindings
= lhs
->bindings
;
1028 rhs_bindings
= rhs
->bindings
;
1029 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1031 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1032 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1033 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1034 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1036 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1037 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1039 return lhs_bindings
== rhs_bindings
;
1042 /* Initialize the constexpr call table, if needed. */
1045 maybe_initialize_constexpr_call_table (void)
1047 if (constexpr_call_table
== NULL
)
1048 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1051 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1052 a function happens to get called recursively, we unshare the callee
1053 function's body and evaluate this unshared copy instead of evaluating the
1056 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1057 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1058 that's keyed off of the original FUNCTION_DECL and whose value is a
1059 TREE_LIST of this function's unused copies awaiting reuse.
1061 This is not GC-deletable to avoid GC affecting UID generation. */
1063 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1065 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1068 maybe_initialize_fundef_copies_table ()
1070 if (fundef_copies_table
== NULL
)
1071 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1074 /* Reuse a copy or create a new unshared copy of the function FUN.
1075 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1076 is parms, TYPE is result. */
1079 get_fundef_copy (tree fun
)
1081 maybe_initialize_fundef_copies_table ();
1085 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1089 /* There is no cached function available, or in use. We can use
1090 the function directly. That the slot is now created records
1091 that this function is now in use. */
1092 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1093 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1095 else if (*slot
== NULL_TREE
)
1097 /* We've already used the function itself, so make a copy. */
1098 copy
= build_tree_list (NULL
, NULL
);
1099 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1103 /* We have a cached function available. */
1105 *slot
= TREE_CHAIN (copy
);
1111 /* Save the copy COPY of function FUN for later reuse by
1112 get_fundef_copy(). By construction, there will always be an entry
1116 save_fundef_copy (tree fun
, tree copy
)
1118 tree
*slot
= fundef_copies_table
->get (fun
);
1119 TREE_CHAIN (copy
) = *slot
;
1123 /* We have an expression tree T that represents a call, either CALL_EXPR
1124 or AGGR_INIT_EXPR. Return the Nth argument. */
1127 get_nth_callarg (tree t
, int n
)
1129 switch (TREE_CODE (t
))
1132 return CALL_EXPR_ARG (t
, n
);
1134 case AGGR_INIT_EXPR
:
1135 return AGGR_INIT_EXPR_ARG (t
, n
);
1143 /* Attempt to evaluate T which represents a call to a builtin function.
1144 We assume here that all builtin functions evaluate to scalar types
1145 represented by _CST nodes. */
1148 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1150 bool *non_constant_p
, bool *overflow_p
)
1152 const int nargs
= call_expr_nargs (t
);
1153 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1157 /* Don't fold __builtin_constant_p within a constexpr function. */
1158 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1161 && current_function_decl
1162 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1164 *non_constant_p
= true;
1168 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1169 return constant false for a non-constant argument. */
1170 constexpr_ctx new_ctx
= *ctx
;
1171 new_ctx
.quiet
= true;
1172 bool dummy1
= false, dummy2
= false;
1173 for (i
= 0; i
< nargs
; ++i
)
1175 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1176 false, &dummy1
, &dummy2
);
1178 /* For __built_in_constant_p, fold all expressions with constant values
1179 even if they aren't C++ constant-expressions. */
1180 args
[i
] = cp_fully_fold (args
[i
]);
1183 bool save_ffbcp
= force_folding_builtin_constant_p
;
1184 force_folding_builtin_constant_p
= true;
1185 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1186 CALL_EXPR_FN (t
), nargs
, args
);
1187 force_folding_builtin_constant_p
= save_ffbcp
;
1188 if (new_call
== NULL
)
1190 if (!*non_constant_p
&& !ctx
->quiet
)
1192 /* Do not allow__builtin_unreachable in constexpr function.
1193 The __builtin_unreachable call with BUILTINS_LOCATION
1194 comes from cp_maybe_instrument_return. */
1195 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
1196 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1197 error ("constexpr call flows off the end of the function");
1200 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1201 CALL_EXPR_FN (t
), nargs
, args
);
1202 error ("%q+E is not a constant expression", new_call
);
1205 *non_constant_p
= true;
1209 if (!is_constant_expression (new_call
))
1211 if (!*non_constant_p
&& !ctx
->quiet
)
1212 error ("%q+E is not a constant expression", new_call
);
1213 *non_constant_p
= true;
1217 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1218 non_constant_p
, overflow_p
);
1221 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1222 the type of the value to match. */
1225 adjust_temp_type (tree type
, tree temp
)
1227 if (TREE_TYPE (temp
) == type
)
1229 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1230 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1231 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1232 gcc_assert (scalarish_type_p (type
));
1233 return cp_fold_convert (type
, temp
);
1236 /* Callback for walk_tree used by unshare_constructor. */
1239 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1243 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1248 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1249 subexpression, return an unshared copy of T. Otherwise return T. */
1252 unshare_constructor (tree t
)
1254 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1255 if (ctor
!= NULL_TREE
)
1256 return unshare_expr (t
);
1260 /* Subroutine of cxx_eval_call_expression.
1261 We are processing a call expression (either CALL_EXPR or
1262 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1263 all arguments and bind their values to correspondings
1264 parameters, making up the NEW_CALL context. */
1267 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1268 constexpr_call
*new_call
,
1269 bool *non_constant_p
, bool *overflow_p
,
1270 bool *non_constant_args
)
1272 const int nargs
= call_expr_nargs (t
);
1273 tree fun
= new_call
->fundef
->decl
;
1274 tree parms
= DECL_ARGUMENTS (fun
);
1276 tree
*p
= &new_call
->bindings
;
1277 for (i
= 0; i
< nargs
; ++i
)
1280 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1281 x
= get_nth_callarg (t
, i
);
1282 /* For member function, the first argument is a pointer to the implied
1283 object. For a constructor, it might still be a dummy object, in
1284 which case we get the real argument from ctx. */
1285 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1286 && is_dummy_object (x
))
1289 /* We don't use cp_build_addr_expr here because we don't want to
1290 capture the object argument during constexpr evaluation. */
1291 x
= build_address (x
);
1294 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1295 non_constant_p
, overflow_p
);
1296 /* Don't VERIFY_CONSTANT here. */
1297 if (*non_constant_p
&& ctx
->quiet
)
1299 /* Just discard ellipsis args after checking their constantitude. */
1303 if (!*non_constant_p
)
1305 /* Make sure the binding has the same type as the parm. But
1306 only for constant args. */
1307 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1308 arg
= adjust_temp_type (type
, arg
);
1309 if (!TREE_CONSTANT (arg
))
1310 *non_constant_args
= true;
1311 *p
= build_tree_list (parms
, arg
);
1312 p
= &TREE_CHAIN (*p
);
1314 parms
= TREE_CHAIN (parms
);
1318 /* Variables and functions to manage constexpr call expansion context.
1319 These do not need to be marked for PCH or GC. */
1321 /* FIXME remember and print actual constant arguments. */
1322 static vec
<tree
> call_stack
;
1323 static int call_stack_tick
;
1324 static int last_cx_error_tick
;
1327 push_cx_call_context (tree call
)
1330 if (!EXPR_HAS_LOCATION (call
))
1331 SET_EXPR_LOCATION (call
, input_location
);
1332 call_stack
.safe_push (call
);
1333 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1339 pop_cx_call_context (void)
1346 cx_error_context (void)
1348 vec
<tree
> r
= vNULL
;
1349 if (call_stack_tick
!= last_cx_error_tick
1350 && !call_stack
.is_empty ())
1352 last_cx_error_tick
= call_stack_tick
;
1356 /* Evaluate a call T to a GCC internal function when possible and return
1357 the evaluated result or, under the control of CTX, give an error, set
1358 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1361 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1363 bool *non_constant_p
, bool *overflow_p
)
1365 enum tree_code opcode
= ERROR_MARK
;
1367 switch (CALL_EXPR_IFN (t
))
1369 case IFN_UBSAN_NULL
:
1370 case IFN_UBSAN_BOUNDS
:
1371 case IFN_UBSAN_VPTR
:
1372 case IFN_FALLTHROUGH
:
1375 case IFN_ADD_OVERFLOW
:
1378 case IFN_SUB_OVERFLOW
:
1379 opcode
= MINUS_EXPR
;
1381 case IFN_MUL_OVERFLOW
:
1386 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1387 false, non_constant_p
, overflow_p
);
1391 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1392 "call to internal function %qE", t
);
1393 *non_constant_p
= true;
1397 /* Evaluate constant arguments using OPCODE and return a complex
1398 number containing the result and the overflow bit. */
1399 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1400 non_constant_p
, overflow_p
);
1401 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1402 non_constant_p
, overflow_p
);
1404 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1406 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1407 tree type
= TREE_TYPE (TREE_TYPE (t
));
1408 tree result
= fold_binary_loc (loc
, opcode
, type
,
1409 fold_convert_loc (loc
, type
, arg0
),
1410 fold_convert_loc (loc
, type
, arg1
));
1412 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1413 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1414 if (TREE_OVERFLOW (result
))
1415 TREE_OVERFLOW (result
) = 0;
1417 return build_complex (TREE_TYPE (t
), result
, ovf
);
1420 *non_constant_p
= true;
1424 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1427 clear_no_implicit_zero (tree ctor
)
1429 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1431 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1432 tree elt
; unsigned HOST_WIDE_INT idx
;
1433 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1434 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1435 clear_no_implicit_zero (elt
);
1439 /* Subroutine of cxx_eval_constant_expression.
1440 Evaluate the call expression tree T in the context of OLD_CALL expression
1444 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1446 bool *non_constant_p
, bool *overflow_p
)
1448 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1449 tree fun
= get_function_named_in_call (t
);
1450 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1453 if (fun
== NULL_TREE
)
1454 return cxx_eval_internal_function (ctx
, t
, lval
,
1455 non_constant_p
, overflow_p
);
1457 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1459 /* Might be a constexpr function pointer. */
1460 fun
= cxx_eval_constant_expression (ctx
, fun
,
1461 /*lval*/false, non_constant_p
,
1464 if (TREE_CODE (fun
) == ADDR_EXPR
)
1465 fun
= TREE_OPERAND (fun
, 0);
1467 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1469 if (!ctx
->quiet
&& !*non_constant_p
)
1470 error_at (loc
, "expression %qE does not designate a constexpr "
1472 *non_constant_p
= true;
1475 if (DECL_CLONED_FUNCTION_P (fun
))
1476 fun
= DECL_CLONED_FUNCTION (fun
);
1478 if (is_ubsan_builtin_p (fun
))
1481 if (is_builtin_fn (fun
))
1482 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1483 lval
, non_constant_p
, overflow_p
);
1484 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1488 if (!lambda_static_thunk_p (fun
))
1489 error_at (loc
, "call to non-constexpr function %qD", fun
);
1490 explain_invalid_constexpr_fn (fun
);
1492 *non_constant_p
= true;
1496 constexpr_ctx new_ctx
= *ctx
;
1497 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1498 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1500 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1501 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1502 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1503 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1504 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1505 ctx
->values
->put (new_ctx
.object
, ctor
);
1509 /* Shortcut trivial constructor/op=. */
1510 if (trivial_fn_p (fun
))
1512 tree init
= NULL_TREE
;
1513 if (call_expr_nargs (t
) == 2)
1514 init
= convert_from_reference (get_nth_callarg (t
, 1));
1515 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1516 && AGGR_INIT_ZERO_FIRST (t
))
1517 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1520 tree op
= get_nth_callarg (t
, 0);
1521 if (is_dummy_object (op
))
1524 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1525 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1526 new_ctx
.call
= &new_call
;
1527 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1528 non_constant_p
, overflow_p
);
1532 /* We can't defer instantiating the function any longer. */
1533 if (!DECL_INITIAL (fun
)
1534 && DECL_TEMPLOID_INSTANTIATION (fun
))
1536 location_t save_loc
= input_location
;
1537 input_location
= loc
;
1539 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1541 input_location
= save_loc
;
1544 /* If in direct recursive call, optimize definition search. */
1545 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1546 new_call
.fundef
= ctx
->call
->fundef
;
1549 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1550 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1551 || fun
== current_function_decl
)
1555 /* We need to check for current_function_decl here in case we're
1556 being called during cp_fold_function, because at that point
1557 DECL_INITIAL is set properly and we have a fundef but we
1558 haven't lowered invisirefs yet (c++/70344). */
1559 if (DECL_INITIAL (fun
) == error_mark_node
1560 || fun
== current_function_decl
)
1561 error_at (loc
, "%qD called in a constant expression before its "
1562 "definition is complete", fun
);
1563 else if (DECL_INITIAL (fun
))
1565 /* The definition of fun was somehow unsuitable. But pretend
1566 that lambda static thunks don't exist. */
1567 if (!lambda_static_thunk_p (fun
))
1568 error_at (loc
, "%qD called in a constant expression", fun
);
1569 explain_invalid_constexpr_fn (fun
);
1572 error_at (loc
, "%qD used before its definition", fun
);
1574 *non_constant_p
= true;
1579 bool non_constant_args
= false;
1580 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1581 non_constant_p
, overflow_p
, &non_constant_args
);
1582 if (*non_constant_p
)
1585 depth_ok
= push_cx_call_context (t
);
1587 tree result
= NULL_TREE
;
1589 constexpr_call
*entry
= NULL
;
1590 if (depth_ok
&& !non_constant_args
)
1592 new_call
.hash
= iterative_hash_template_arg
1593 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1595 /* If we have seen this call before, we are done. */
1596 maybe_initialize_constexpr_call_table ();
1597 constexpr_call
**slot
1598 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1602 /* We need to keep a pointer to the entry, not just the slot, as the
1603 slot can move in the call to cxx_eval_builtin_function_call. */
1604 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1607 /* Calls that are in progress have their result set to NULL,
1608 so that we can detect circular dependencies. */
1609 else if (entry
->result
== NULL
)
1612 error ("call has circular dependency");
1613 *non_constant_p
= true;
1614 entry
->result
= result
= error_mark_node
;
1617 result
= entry
->result
;
1623 error ("constexpr evaluation depth exceeds maximum of %d (use "
1624 "-fconstexpr-depth= to increase the maximum)",
1625 max_constexpr_depth
);
1626 *non_constant_p
= true;
1627 result
= error_mark_node
;
1631 if (result
&& result
!= error_mark_node
)
1633 else if (!DECL_SAVED_TREE (fun
))
1635 /* When at_eof >= 2, cgraph has started throwing away
1636 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1637 late code generation for VEC_INIT_EXPR, which needs to be
1638 completely reconsidered. */
1639 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1640 *non_constant_p
= true;
1644 tree body
, parms
, res
;
1646 /* Reuse or create a new unshared copy of this function's body. */
1647 tree copy
= get_fundef_copy (fun
);
1648 body
= TREE_PURPOSE (copy
);
1649 parms
= TREE_VALUE (copy
);
1650 res
= TREE_TYPE (copy
);
1652 /* Associate the bindings with the remapped parms. */
1653 tree bound
= new_call
.bindings
;
1654 tree remapped
= parms
;
1657 tree oparm
= TREE_PURPOSE (bound
);
1658 tree arg
= TREE_VALUE (bound
);
1659 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1660 /* Don't share a CONSTRUCTOR that might be changed. */
1661 arg
= unshare_constructor (arg
);
1662 ctx
->values
->put (remapped
, arg
);
1663 bound
= TREE_CHAIN (bound
);
1664 remapped
= DECL_CHAIN (remapped
);
1666 /* Add the RESULT_DECL to the values map, too. */
1667 tree slot
= NULL_TREE
;
1668 if (DECL_BY_REFERENCE (res
))
1670 slot
= AGGR_INIT_EXPR_SLOT (t
);
1671 tree addr
= build_address (slot
);
1672 addr
= build_nop (TREE_TYPE (res
), addr
);
1673 ctx
->values
->put (res
, addr
);
1674 ctx
->values
->put (slot
, NULL_TREE
);
1677 ctx
->values
->put (res
, NULL_TREE
);
1679 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1680 their values after the call. */
1681 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1682 hash_set
<tree
> save_exprs
;
1683 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1684 ctx_with_save_exprs
.call
= &new_call
;
1686 tree jump_target
= NULL_TREE
;
1687 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1688 lval
, non_constant_p
, overflow_p
,
1691 if (DECL_CONSTRUCTOR_P (fun
))
1692 /* This can be null for a subobject constructor call, in
1693 which case what we care about is the initialization
1694 side-effects rather than the value. We could get at the
1695 value by evaluating *this, but we don't bother; there's
1696 no need to put such a call in the hash table. */
1697 result
= lval
? ctx
->object
: ctx
->ctor
;
1698 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1702 result
= *ctx
->values
->get (slot
? slot
: res
);
1703 if (result
== NULL_TREE
&& !*non_constant_p
)
1706 error ("constexpr call flows off the end "
1708 *non_constant_p
= true;
1712 /* Forget the saved values of the callee's SAVE_EXPRs. */
1713 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1714 iter
!= save_exprs
.end(); ++iter
)
1715 ctx_with_save_exprs
.values
->remove (*iter
);
1717 /* Remove the parms/result from the values map. Is it worth
1718 bothering to do this when the map itself is only live for
1719 one constexpr evaluation? If so, maybe also clear out
1720 other vars from call, maybe in BIND_EXPR handling? */
1721 ctx
->values
->remove (res
);
1723 ctx
->values
->remove (slot
);
1724 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1725 ctx
->values
->remove (parm
);
1727 /* Make the unshared function copy we used available for re-use. */
1728 save_fundef_copy (fun
, copy
);
1731 if (result
== error_mark_node
)
1732 *non_constant_p
= true;
1733 if (*non_constant_p
|| *overflow_p
)
1734 result
= error_mark_node
;
1738 entry
->result
= result
;
1741 /* The result of a constexpr function must be completely initialized. */
1742 if (TREE_CODE (result
) == CONSTRUCTOR
)
1743 clear_no_implicit_zero (result
);
1745 pop_cx_call_context ();
1746 return unshare_constructor (result
);
1749 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1752 reduced_constant_expression_p (tree t
)
1754 switch (TREE_CODE (t
))
1757 /* Even if we can't lower this yet, it's constant. */
1761 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1762 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1763 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1764 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1767 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1770 /* We're in the middle of initializing this element. */
1772 if (!reduced_constant_expression_p (val
))
1778 field
= next_initializable_field (DECL_CHAIN (field
));
1783 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1784 /* All the fields are initialized. */
1785 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1789 /* FIXME are we calling this too much? */
1790 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1794 /* Some expressions may have constant operands but are not constant
1795 themselves, such as 1/0. Call this function (or rather, the macro
1796 following it) to check for that condition.
1798 We only call this in places that require an arithmetic constant, not in
1799 places where we might have a non-constant expression that can be a
1800 component of a constant expression, such as the address of a constexpr
1801 variable that might be dereferenced later. */
1804 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1807 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1809 if (!allow_non_constant
)
1810 error ("%q+E is not a constant expression", t
);
1811 *non_constant_p
= true;
1813 if (TREE_OVERFLOW_P (t
))
1815 if (!allow_non_constant
)
1817 permerror (input_location
, "overflow in constant expression");
1818 /* If we're being permissive (and are in an enforcing
1819 context), ignore the overflow. */
1820 if (flag_permissive
)
1821 return *non_constant_p
;
1825 return *non_constant_p
;
1828 /* Check whether the shift operation with code CODE and type TYPE on LHS
1829 and RHS is undefined. If it is, give an error with an explanation,
1830 and return true; return false otherwise. */
1833 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1834 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1836 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1837 || TREE_CODE (lhs
) != INTEGER_CST
1838 || TREE_CODE (rhs
) != INTEGER_CST
)
1841 tree lhstype
= TREE_TYPE (lhs
);
1842 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1844 /* [expr.shift] The behavior is undefined if the right operand
1845 is negative, or greater than or equal to the length in bits
1846 of the promoted left operand. */
1847 if (tree_int_cst_sgn (rhs
) == -1)
1850 permerror (loc
, "right operand of shift expression %q+E is negative",
1851 build2_loc (loc
, code
, type
, lhs
, rhs
));
1852 return (!flag_permissive
|| ctx
->quiet
);
1854 if (compare_tree_int (rhs
, uprec
) >= 0)
1857 permerror (loc
, "right operand of shift expression %q+E is >= than "
1858 "the precision of the left operand",
1859 build2_loc (loc
, code
, type
, lhs
, rhs
));
1860 return (!flag_permissive
|| ctx
->quiet
);
1863 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1864 if E1 has a signed type and non-negative value, and E1x2^E2 is
1865 representable in the corresponding unsigned type of the result type,
1866 then that value, converted to the result type, is the resulting value;
1867 otherwise, the behavior is undefined. */
1868 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1869 && (cxx_dialect
>= cxx11
))
1871 if (tree_int_cst_sgn (lhs
) == -1)
1875 "left operand of shift expression %q+E is negative",
1876 build2_loc (loc
, code
, type
, lhs
, rhs
));
1877 return (!flag_permissive
|| ctx
->quiet
);
1879 /* For signed x << y the following:
1880 (unsigned) x >> ((prec (lhs) - 1) - y)
1881 if > 1, is undefined. The right-hand side of this formula
1882 is the highest bit of the LHS that can be set (starting from 0),
1883 so that the shift doesn't overflow. We then right-shift the LHS
1884 to see whether any other bit is set making the original shift
1885 undefined -- the result is not representable in the corresponding
1887 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1888 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1889 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1890 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1891 if (tree_int_cst_lt (integer_one_node
, t
))
1894 permerror (loc
, "shift expression %q+E overflows",
1895 build2_loc (loc
, code
, type
, lhs
, rhs
));
1896 return (!flag_permissive
|| ctx
->quiet
);
1902 /* Subroutine of cxx_eval_constant_expression.
1903 Attempt to reduce the unary expression tree T to a compile time value.
1904 If successful, return the value. Otherwise issue a diagnostic
1905 and return error_mark_node. */
1908 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1910 bool *non_constant_p
, bool *overflow_p
)
1913 tree orig_arg
= TREE_OPERAND (t
, 0);
1914 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1915 non_constant_p
, overflow_p
);
1916 VERIFY_CONSTANT (arg
);
1917 location_t loc
= EXPR_LOCATION (t
);
1918 enum tree_code code
= TREE_CODE (t
);
1919 tree type
= TREE_TYPE (t
);
1920 r
= fold_unary_loc (loc
, code
, type
, arg
);
1923 if (arg
== orig_arg
)
1926 r
= build1_loc (loc
, code
, type
, arg
);
1928 VERIFY_CONSTANT (r
);
1932 /* Helper function for cxx_eval_binary_expression. Try to optimize
1933 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1934 generic folding should be used. */
1937 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1938 tree lhs
, tree rhs
, bool *non_constant_p
,
1942 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1945 lhs
= TREE_OPERAND (lhs
, 0);
1947 /* &A[i] p+ j => &A[i + j] */
1948 if (TREE_CODE (lhs
) == ARRAY_REF
1949 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1950 && TREE_CODE (rhs
) == INTEGER_CST
1951 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1952 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1954 tree orig_type
= TREE_TYPE (t
);
1955 location_t loc
= EXPR_LOCATION (t
);
1956 tree type
= TREE_TYPE (lhs
);
1958 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1959 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1960 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1962 if (*non_constant_p
)
1964 /* Don't fold an out-of-bound access. */
1965 if (!tree_int_cst_le (t
, nelts
))
1967 rhs
= cp_fold_convert (ssizetype
, rhs
);
1968 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1969 constexpr int A[1]; ... (char *)&A[0] + 1 */
1970 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1971 rhs
, TYPE_SIZE_UNIT (type
))))
1973 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1975 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1976 TYPE_SIZE_UNIT (type
));
1977 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1978 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1979 t
, NULL_TREE
, NULL_TREE
);
1980 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1981 t
= cp_fold_convert (orig_type
, t
);
1982 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1983 non_constant_p
, overflow_p
);
1989 /* Subroutine of cxx_eval_constant_expression.
1990 Like cxx_eval_unary_expression, except for binary expressions. */
1993 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1995 bool *non_constant_p
, bool *overflow_p
)
1998 tree orig_lhs
= TREE_OPERAND (t
, 0);
1999 tree orig_rhs
= TREE_OPERAND (t
, 1);
2001 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2002 non_constant_p
, overflow_p
);
2003 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2005 if (*non_constant_p
)
2007 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2008 non_constant_p
, overflow_p
);
2009 if (*non_constant_p
)
2012 location_t loc
= EXPR_LOCATION (t
);
2013 enum tree_code code
= TREE_CODE (t
);
2014 tree type
= TREE_TYPE (t
);
2016 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2018 bool is_code_eq
= (code
== EQ_EXPR
);
2020 if (TREE_CODE (lhs
) == PTRMEM_CST
2021 && TREE_CODE (rhs
) == PTRMEM_CST
)
2022 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2024 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2025 || TREE_CODE (rhs
) == PTRMEM_CST
)
2026 && (null_member_pointer_value_p (lhs
)
2027 || null_member_pointer_value_p (rhs
)))
2028 r
= constant_boolean_node (!is_code_eq
, type
);
2029 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2030 lhs
= cplus_expand_constant (lhs
);
2031 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2032 rhs
= cplus_expand_constant (rhs
);
2034 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2035 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2038 error ("arithmetic involving a null pointer in %qE", lhs
);
2041 else if (code
== POINTER_PLUS_EXPR
)
2042 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2046 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2050 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2053 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2055 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2056 *non_constant_p
= true;
2057 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2058 a local array in a constexpr function. */
2059 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2061 VERIFY_CONSTANT (r
);
2065 /* Subroutine of cxx_eval_constant_expression.
2066 Attempt to evaluate condition expressions. Dead branches are not
2070 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2072 bool *non_constant_p
, bool *overflow_p
,
2075 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2077 non_constant_p
, overflow_p
);
2078 VERIFY_CONSTANT (val
);
2079 /* Don't VERIFY_CONSTANT the other operands. */
2080 if (integer_zerop (val
))
2081 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2083 non_constant_p
, overflow_p
,
2085 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2087 non_constant_p
, overflow_p
,
2091 /* Returns less than, equal to, or greater than zero if KEY is found to be
2092 less than, to match, or to be greater than the constructor_elt's INDEX. */
2095 array_index_cmp (tree key
, tree index
)
2097 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2099 switch (TREE_CODE (index
))
2102 return tree_int_cst_compare (key
, index
);
2105 tree lo
= TREE_OPERAND (index
, 0);
2106 tree hi
= TREE_OPERAND (index
, 1);
2107 if (tree_int_cst_lt (key
, lo
))
2109 else if (tree_int_cst_lt (hi
, key
))
2119 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2120 if none. If INSERT is true, insert a matching element rather than fail. */
2122 static HOST_WIDE_INT
2123 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2125 if (tree_int_cst_sgn (dindex
) < 0)
2128 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2129 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2130 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2132 unsigned HOST_WIDE_INT end
= len
;
2133 unsigned HOST_WIDE_INT begin
= 0;
2135 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2136 that the same is true of the other elements and index directly. */
2139 tree cindex
= (*elts
)[end
-1].index
;
2140 if (TREE_CODE (cindex
) == INTEGER_CST
2141 && compare_tree_int (cindex
, end
-1) == 0)
2150 /* Otherwise, find a matching index by means of a binary search. */
2151 while (begin
!= end
)
2153 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2154 constructor_elt
&elt
= (*elts
)[middle
];
2155 tree idx
= elt
.index
;
2157 int cmp
= array_index_cmp (dindex
, idx
);
2164 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2166 /* We need to split the range. */
2168 tree lo
= TREE_OPERAND (idx
, 0);
2169 tree hi
= TREE_OPERAND (idx
, 1);
2170 if (tree_int_cst_lt (lo
, dindex
))
2172 /* There are still some lower elts; shorten the range. */
2173 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2175 if (tree_int_cst_equal (lo
, new_hi
))
2176 /* Only one element left, no longer a range. */
2179 TREE_OPERAND (idx
, 1) = new_hi
;
2180 /* Append the element we want to insert. */
2183 e
.value
= unshare_constructor (elt
.value
);
2184 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2187 /* No lower elts, the range elt is now ours. */
2190 if (tree_int_cst_lt (dindex
, hi
))
2192 /* There are still some higher elts; append a range. */
2193 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2195 if (tree_int_cst_equal (new_lo
, hi
))
2198 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2199 e
.value
= unshare_constructor (elt
.value
);
2200 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2209 constructor_elt e
= { dindex
, NULL_TREE
};
2210 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2217 /* Under the control of CTX, issue a detailed diagnostic for
2218 an out-of-bounds subscript INDEX into the expression ARRAY. */
2221 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2225 tree arraytype
= TREE_TYPE (array
);
2227 /* Convert the unsigned array subscript to a signed integer to avoid
2228 printing huge numbers for small negative values. */
2229 tree sidx
= fold_convert (ssizetype
, index
);
2232 error ("array subscript value %qE is outside the bounds "
2233 "of array %qD of type %qT", sidx
, array
, arraytype
);
2234 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2237 error ("array subscript value %qE is outside the bounds "
2238 "of array type %qT", sidx
, arraytype
);
2242 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2243 STRING_CST STRING. */
2246 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2248 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2251 if (chars_per_elt
== 1)
2252 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2255 const unsigned char *ptr
2256 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2257 + index
* chars_per_elt
);
2258 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2263 /* Subroutine of cxx_eval_constant_expression.
2264 Attempt to reduce a reference to an array slot. */
2267 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2269 bool *non_constant_p
, bool *overflow_p
)
2271 tree oldary
= TREE_OPERAND (t
, 0);
2272 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2274 non_constant_p
, overflow_p
);
2276 HOST_WIDE_INT i
= 0;
2277 tree elem_type
= NULL_TREE
;
2278 unsigned len
= 0, elem_nchars
= 1;
2279 if (*non_constant_p
)
2281 oldidx
= TREE_OPERAND (t
, 1);
2282 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2284 non_constant_p
, overflow_p
);
2285 VERIFY_CONSTANT (index
);
2288 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2289 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2290 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2291 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2292 ary
= TREE_OPERAND (ary
, 0);
2293 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2294 len
= CONSTRUCTOR_NELTS (ary
);
2295 else if (TREE_CODE (ary
) == STRING_CST
)
2297 elem_nchars
= (TYPE_PRECISION (elem_type
)
2298 / TYPE_PRECISION (char_type_node
));
2299 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2301 else if (TREE_CODE (ary
) == VECTOR_CST
)
2302 len
= VECTOR_CST_NELTS (ary
);
2305 /* We can't do anything with other tree codes, so use
2306 VERIFY_CONSTANT to complain and fail. */
2307 VERIFY_CONSTANT (ary
);
2311 if (!tree_fits_shwi_p (index
)
2312 || (i
= tree_to_shwi (index
)) < 0)
2314 diag_array_subscript (ctx
, ary
, index
);
2315 *non_constant_p
= true;
2321 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2322 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2323 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2324 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2328 /* For VLAs, the number of elements won't be an integer constant. */
2329 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2331 VERIFY_CONSTANT (nelts
);
2333 ? !tree_int_cst_le (index
, nelts
)
2334 : !tree_int_cst_lt (index
, nelts
))
2335 || tree_int_cst_sgn (index
) < 0)
2337 diag_array_subscript (ctx
, ary
, index
);
2338 *non_constant_p
= true;
2342 if (lval
&& ary
== oldary
&& index
== oldidx
)
2345 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2348 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2350 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2361 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2362 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2363 else if (TREE_CODE (ary
) == VECTOR_CST
)
2364 r
= VECTOR_CST_ELT (ary
, i
);
2366 r
= extract_string_elt (ary
, elem_nchars
, i
);
2369 /* Don't VERIFY_CONSTANT here. */
2372 /* Otherwise the element doesn't have a value yet. */
2377 if (TREE_CODE (ary
) == CONSTRUCTOR
2378 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2380 /* 'ary' is part of the aggregate initializer we're currently
2381 building; if there's no initializer for this element yet,
2384 error ("accessing uninitialized array element");
2385 *non_constant_p
= true;
2389 /* If it's within the array bounds but doesn't have an explicit
2390 initializer, it's value-initialized. */
2391 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2392 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2396 /* Subroutine of cxx_eval_constant_expression.
2397 Attempt to reduce a field access of a value of class type. */
2400 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2402 bool *non_constant_p
, bool *overflow_p
)
2404 unsigned HOST_WIDE_INT i
;
2407 tree part
= TREE_OPERAND (t
, 1);
2408 tree orig_whole
= TREE_OPERAND (t
, 0);
2409 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2411 non_constant_p
, overflow_p
);
2412 if (TREE_CODE (whole
) == INDIRECT_REF
2413 && integer_zerop (TREE_OPERAND (whole
, 0))
2415 error ("dereferencing a null pointer in %qE", orig_whole
);
2417 if (TREE_CODE (whole
) == PTRMEM_CST
)
2418 whole
= cplus_expand_constant (whole
);
2419 if (whole
== orig_whole
)
2422 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2423 whole
, part
, NULL_TREE
);
2424 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2426 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2429 error ("%qE is not a constant expression", orig_whole
);
2430 *non_constant_p
= true;
2432 if (DECL_MUTABLE_P (part
))
2435 error ("mutable %qD is not usable in a constant expression", part
);
2436 *non_constant_p
= true;
2438 if (*non_constant_p
)
2440 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2441 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2443 /* Use name match for PMF fields, as a variant will have a
2444 different FIELD_DECL with a different type. */
2445 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2451 /* We're in the middle of initializing it. */
2455 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2456 && CONSTRUCTOR_NELTS (whole
) > 0)
2458 /* DR 1188 says we don't have to deal with this. */
2460 error ("accessing %qD member instead of initialized %qD member in "
2461 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2462 *non_constant_p
= true;
2466 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2467 classes never get represented; throw together a value now. */
2468 if (is_really_empty_class (TREE_TYPE (t
)))
2469 return build_constructor (TREE_TYPE (t
), NULL
);
2471 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2473 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2475 /* 'whole' is part of the aggregate initializer we're currently
2476 building; if there's no initializer for this member yet, that's an
2479 error ("accessing uninitialized member %qD", part
);
2480 *non_constant_p
= true;
2484 /* If there's no explicit init for this field, it's value-initialized. */
2485 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2486 return cxx_eval_constant_expression (ctx
, value
,
2488 non_constant_p
, overflow_p
);
2491 /* Subroutine of cxx_eval_constant_expression.
2492 Attempt to reduce a field access of a value of class type that is
2493 expressed as a BIT_FIELD_REF. */
2496 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2498 bool *non_constant_p
, bool *overflow_p
)
2500 tree orig_whole
= TREE_OPERAND (t
, 0);
2501 tree retval
, fldval
, utype
, mask
;
2502 bool fld_seen
= false;
2503 HOST_WIDE_INT istart
, isize
;
2504 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2506 non_constant_p
, overflow_p
);
2507 tree start
, field
, value
;
2508 unsigned HOST_WIDE_INT i
;
2510 if (whole
== orig_whole
)
2512 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2514 if (!*non_constant_p
2515 && TREE_CODE (whole
) != VECTOR_CST
2516 && TREE_CODE (whole
) != CONSTRUCTOR
)
2519 error ("%qE is not a constant expression", orig_whole
);
2520 *non_constant_p
= true;
2522 if (*non_constant_p
)
2525 if (TREE_CODE (whole
) == VECTOR_CST
)
2526 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2527 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2529 start
= TREE_OPERAND (t
, 2);
2530 istart
= tree_to_shwi (start
);
2531 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2532 utype
= TREE_TYPE (t
);
2533 if (!TYPE_UNSIGNED (utype
))
2534 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2535 retval
= build_int_cst (utype
, 0);
2536 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2538 tree bitpos
= bit_position (field
);
2539 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2541 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2542 && TREE_CODE (value
) == INTEGER_CST
2543 && tree_fits_shwi_p (bitpos
)
2544 && tree_fits_shwi_p (DECL_SIZE (field
)))
2546 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2547 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2548 HOST_WIDE_INT shift
;
2549 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2551 fldval
= fold_convert (utype
, value
);
2552 mask
= build_int_cst_type (utype
, -1);
2553 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2554 size_int (TYPE_PRECISION (utype
) - sz
));
2555 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2556 size_int (TYPE_PRECISION (utype
) - sz
));
2557 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2558 shift
= bit
- istart
;
2559 if (BYTES_BIG_ENDIAN
)
2560 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2561 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2563 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2569 return fold_convert (TREE_TYPE (t
), retval
);
2571 return error_mark_node
;
2574 /* Subroutine of cxx_eval_constant_expression.
2575 Evaluate a short-circuited logical expression T in the context
2576 of a given constexpr CALL. BAILOUT_VALUE is the value for
2577 early return. CONTINUE_VALUE is used here purely for
2578 sanity check purposes. */
2581 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2582 tree bailout_value
, tree continue_value
,
2584 bool *non_constant_p
, bool *overflow_p
)
2587 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2589 non_constant_p
, overflow_p
);
2590 VERIFY_CONSTANT (lhs
);
2591 if (tree_int_cst_equal (lhs
, bailout_value
))
2593 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2594 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2595 lval
, non_constant_p
,
2597 VERIFY_CONSTANT (r
);
2601 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2602 CONSTRUCTOR elements to initialize (part of) an object containing that
2603 field. Return a pointer to the constructor_elt corresponding to the
2604 initialization of the field. */
2606 static constructor_elt
*
2607 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2609 tree aggr
= TREE_OPERAND (ref
, 0);
2610 tree field
= TREE_OPERAND (ref
, 1);
2612 constructor_elt
*ce
;
2614 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2616 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2618 constructor_elt
*base_ce
2619 = base_field_constructor_elt (v
, aggr
);
2620 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2623 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2624 if (ce
->index
== field
)
2631 /* Some of the expressions fed to the constexpr mechanism are calls to
2632 constructors, which have type void. In that case, return the type being
2633 initialized by the constructor. */
2636 initialized_type (tree t
)
2640 tree type
= cv_unqualified (TREE_TYPE (t
));
2641 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2643 /* A constructor call has void type, so we need to look deeper. */
2644 tree fn
= get_function_named_in_call (t
);
2645 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2646 && DECL_CXX_CONSTRUCTOR_P (fn
))
2647 type
= DECL_CONTEXT (fn
);
2652 /* We're about to initialize element INDEX of an array or class from VALUE.
2653 Set up NEW_CTX appropriately by adjusting .object to refer to the
2654 subobject and creating a new CONSTRUCTOR if the element is itself
2655 a class or array. */
2658 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2659 tree index
, tree
&value
)
2663 if (index
&& TREE_CODE (index
) != INTEGER_CST
2664 && TREE_CODE (index
) != FIELD_DECL
)
2665 /* This won't have an element in the new CONSTRUCTOR. */
2668 tree type
= initialized_type (value
);
2669 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2670 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2673 /* The sub-aggregate initializer might contain a placeholder;
2674 update object to refer to the subobject and ctor to refer to
2675 the (newly created) sub-initializer. */
2677 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2678 tree elt
= build_constructor (type
, NULL
);
2679 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2682 if (TREE_CODE (value
) == TARGET_EXPR
)
2683 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2684 value
= TARGET_EXPR_INITIAL (value
);
2687 /* We're about to process an initializer for a class or array TYPE. Make
2688 sure that CTX is set up appropriately. */
2691 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2693 /* We don't bother building a ctor for an empty base subobject. */
2694 if (is_empty_class (type
))
2697 /* We're in the middle of an initializer that might involve placeholders;
2698 our caller should have created a CONSTRUCTOR for us to put the
2699 initializer into. We will either return that constructor or T. */
2700 gcc_assert (ctx
->ctor
);
2701 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2702 (type
, TREE_TYPE (ctx
->ctor
)));
2703 /* We used to check that ctx->ctor was empty, but that isn't the case when
2704 the object is zero-initialized before calling the constructor. */
2707 tree otype
= TREE_TYPE (ctx
->object
);
2708 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2709 /* Handle flexible array members. */
2710 || (TREE_CODE (otype
) == ARRAY_TYPE
2711 && TYPE_DOMAIN (otype
) == NULL_TREE
2712 && TREE_CODE (type
) == ARRAY_TYPE
2713 && (same_type_ignoring_top_level_qualifiers_p
2714 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2716 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2717 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2720 /* Subroutine of cxx_eval_constant_expression.
2721 The expression tree T denotes a C-style array or a C-style
2722 aggregate. Reduce it to a constant expression. */
2725 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2727 bool *non_constant_p
, bool *overflow_p
)
2729 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2730 bool changed
= false;
2731 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2732 tree type
= TREE_TYPE (t
);
2734 constexpr_ctx new_ctx
;
2735 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2737 /* We don't really need the ctx->ctor business for a PMF or
2738 vector, but it's simpler to use the same code. */
2740 new_ctx
.ctor
= build_constructor (type
, NULL
);
2741 new_ctx
.object
= NULL_TREE
;
2744 verify_ctor_sanity (ctx
, type
);
2745 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2746 vec_alloc (*p
, vec_safe_length (v
));
2750 bool constant_p
= true;
2751 bool side_effects_p
= false;
2752 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2754 tree orig_value
= value
;
2755 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2756 if (new_ctx
.ctor
!= ctx
->ctor
)
2757 /* If we built a new CONSTRUCTOR, attach it now so that other
2758 initializers can refer to it. */
2759 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2760 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2762 non_constant_p
, overflow_p
);
2763 /* Don't VERIFY_CONSTANT here. */
2764 if (ctx
->quiet
&& *non_constant_p
)
2766 if (elt
!= orig_value
)
2769 if (!TREE_CONSTANT (elt
))
2771 if (TREE_SIDE_EFFECTS (elt
))
2772 side_effects_p
= true;
2773 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2775 /* This is an initialization of a vfield inside a base
2776 subaggregate that we already initialized; push this
2777 initialization into the previous initialization. */
2778 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2783 && (TREE_CODE (index
) == NOP_EXPR
2784 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2786 /* This is an initializer for an empty base; now that we've
2787 checked that it's constant, we can ignore it. */
2788 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2791 else if (new_ctx
.ctor
!= ctx
->ctor
)
2793 /* We appended this element above; update the value. */
2794 gcc_assert ((*p
)->last().index
== index
);
2795 (*p
)->last().value
= elt
;
2798 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2800 if (*non_constant_p
|| !changed
)
2803 /* We're done building this CONSTRUCTOR, so now we can interpret an
2804 element without an explicit initializer as value-initialized. */
2805 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2806 TREE_CONSTANT (t
) = constant_p
;
2807 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2808 if (VECTOR_TYPE_P (type
))
2813 /* Subroutine of cxx_eval_constant_expression.
2814 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2815 initialization of a non-static data member of array type. Reduce it to a
2818 Note that apart from value-initialization (when VALUE_INIT is true),
2819 this is only intended to support value-initialization and the
2820 initializations done by defaulted constructors for classes with
2821 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2822 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2823 for the copy/move constructor. */
2826 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2827 bool value_init
, bool lval
,
2828 bool *non_constant_p
, bool *overflow_p
)
2830 tree elttype
= TREE_TYPE (atype
);
2831 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2832 verify_ctor_sanity (ctx
, atype
);
2833 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2834 vec_alloc (*p
, max
+ 1);
2835 bool pre_init
= false;
2836 unsigned HOST_WIDE_INT i
;
2838 /* For the default constructor, build up a call to the default
2839 constructor of the element type. We only need to handle class types
2840 here, as for a constructor to be constexpr, all members must be
2841 initialized, which for a defaulted default constructor means they must
2842 be of a class type with a constexpr default constructor. */
2843 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2844 /* We only do this at the lowest level. */;
2845 else if (value_init
)
2847 init
= build_value_init (elttype
, tf_warning_or_error
);
2852 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2853 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2854 &argvec
, elttype
, LOOKUP_NORMAL
,
2855 tf_warning_or_error
);
2856 release_tree_vector (argvec
);
2857 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2861 for (i
= 0; i
< max
; ++i
)
2863 tree idx
= build_int_cst (size_type_node
, i
);
2866 constexpr_ctx new_ctx
;
2867 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2868 if (new_ctx
.ctor
!= ctx
->ctor
)
2869 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2870 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2872 /* A multidimensional array; recurse. */
2873 if (value_init
|| init
== NULL_TREE
)
2875 eltinit
= NULL_TREE
;
2879 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2880 tf_warning_or_error
);
2881 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2883 non_constant_p
, overflow_p
);
2887 /* Initializing an element using value or default initialization
2888 we just pre-built above. */
2889 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2890 non_constant_p
, overflow_p
);
2895 /* Copying an element. */
2896 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2897 (atype
, TREE_TYPE (init
)));
2898 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2899 tf_warning_or_error
);
2900 if (!lvalue_p (init
))
2901 eltinit
= move (eltinit
);
2902 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2903 eltinit
= (cxx_eval_constant_expression
2904 (&new_ctx
, eltinit
, lval
,
2905 non_constant_p
, overflow_p
));
2907 if (*non_constant_p
&& !ctx
->quiet
)
2909 if (new_ctx
.ctor
!= ctx
->ctor
)
2911 /* We appended this element above; update the value. */
2912 gcc_assert ((*p
)->last().index
== idx
);
2913 (*p
)->last().value
= eltinit
;
2916 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2917 /* Reuse the result of cxx_eval_constant_expression call
2918 from the first iteration to all others if it is a constant
2919 initializer that doesn't require relocations. */
2922 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2923 == null_pointer_node
))
2925 if (new_ctx
.ctor
!= ctx
->ctor
)
2926 eltinit
= new_ctx
.ctor
;
2927 for (i
= 1; i
< max
; ++i
)
2929 idx
= build_int_cst (size_type_node
, i
);
2930 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2936 if (!*non_constant_p
)
2939 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2945 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2947 bool *non_constant_p
, bool *overflow_p
)
2949 tree atype
= TREE_TYPE (t
);
2950 tree init
= VEC_INIT_EXPR_INIT (t
);
2951 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2952 VEC_INIT_EXPR_VALUE_INIT (t
),
2953 lval
, non_constant_p
, overflow_p
);
2954 if (*non_constant_p
)
2960 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2961 match. We want to be less strict for simple *& folding; if we have a
2962 non-const temporary that we access through a const pointer, that should
2963 work. We handle this here rather than change fold_indirect_ref_1
2964 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2965 don't really make sense outside of constant expression evaluation. Also
2966 we want to allow folding to COMPONENT_REF, which could cause trouble
2967 with TBAA in fold_indirect_ref_1.
2969 Try to keep this function synced with fold_indirect_ref_1. */
2972 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2978 subtype
= TREE_TYPE (sub
);
2979 if (!POINTER_TYPE_P (subtype
))
2982 if (TREE_CODE (sub
) == ADDR_EXPR
)
2984 tree op
= TREE_OPERAND (sub
, 0);
2985 tree optype
= TREE_TYPE (op
);
2987 /* *&CONST_DECL -> to the value of the const decl. */
2988 if (TREE_CODE (op
) == CONST_DECL
)
2989 return DECL_INITIAL (op
);
2990 /* *&p => p; make sure to handle *&"str"[cst] here. */
2991 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2992 /* Also handle the case where the desired type is an array of unknown
2993 bounds because the variable has had its bounds deduced since the
2994 ADDR_EXPR was created. */
2995 || (TREE_CODE (type
) == ARRAY_TYPE
2996 && TREE_CODE (optype
) == ARRAY_TYPE
2997 && TYPE_DOMAIN (type
) == NULL_TREE
2998 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3001 tree fop
= fold_read_from_constant_string (op
);
3007 /* *(foo *)&fooarray => fooarray[0] */
3008 else if (TREE_CODE (optype
) == ARRAY_TYPE
3009 && (same_type_ignoring_top_level_qualifiers_p
3010 (type
, TREE_TYPE (optype
))))
3012 tree type_domain
= TYPE_DOMAIN (optype
);
3013 tree min_val
= size_zero_node
;
3014 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3015 min_val
= TYPE_MIN_VALUE (type_domain
);
3016 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3017 NULL_TREE
, NULL_TREE
);
3019 /* *(foo *)&complexfoo => __real__ complexfoo */
3020 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3021 && (same_type_ignoring_top_level_qualifiers_p
3022 (type
, TREE_TYPE (optype
))))
3023 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3024 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3025 else if (VECTOR_TYPE_P (optype
)
3026 && (same_type_ignoring_top_level_qualifiers_p
3027 (type
, TREE_TYPE (optype
))))
3029 tree part_width
= TYPE_SIZE (type
);
3030 tree index
= bitsize_int (0);
3031 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
3033 /* Also handle conversion to an empty base class, which
3034 is represented with a NOP_EXPR. */
3035 else if (is_empty_class (type
)
3036 && CLASS_TYPE_P (optype
)
3037 && DERIVED_FROM_P (type
, optype
))
3042 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3043 else if (RECORD_OR_UNION_TYPE_P (optype
))
3045 tree field
= TYPE_FIELDS (optype
);
3046 for (; field
; field
= DECL_CHAIN (field
))
3047 if (TREE_CODE (field
) == FIELD_DECL
3048 && TREE_TYPE (field
) != error_mark_node
3049 && integer_zerop (byte_position (field
))
3050 && (same_type_ignoring_top_level_qualifiers_p
3051 (TREE_TYPE (field
), type
)))
3052 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3055 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3056 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
3058 tree op00
= TREE_OPERAND (sub
, 0);
3059 tree op01
= TREE_OPERAND (sub
, 1);
3062 if (TREE_CODE (op00
) == ADDR_EXPR
)
3065 op00
= TREE_OPERAND (op00
, 0);
3066 op00type
= TREE_TYPE (op00
);
3068 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3069 if (VECTOR_TYPE_P (op00type
)
3070 && (same_type_ignoring_top_level_qualifiers_p
3071 (type
, TREE_TYPE (op00type
))))
3073 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
3074 tree part_width
= TYPE_SIZE (type
);
3075 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
3076 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
3077 tree index
= bitsize_int (indexi
);
3079 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
3080 return fold_build3_loc (loc
,
3081 BIT_FIELD_REF
, type
, op00
,
3085 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3086 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3087 && (same_type_ignoring_top_level_qualifiers_p
3088 (type
, TREE_TYPE (op00type
))))
3090 tree size
= TYPE_SIZE_UNIT (type
);
3091 if (tree_int_cst_equal (size
, op01
))
3092 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3094 /* ((foo *)&fooarray)[1] => fooarray[1] */
3095 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3096 && (same_type_ignoring_top_level_qualifiers_p
3097 (type
, TREE_TYPE (op00type
))))
3099 tree type_domain
= TYPE_DOMAIN (op00type
);
3100 tree min_val
= size_zero_node
;
3101 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3102 min_val
= TYPE_MIN_VALUE (type_domain
);
3103 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
3104 TYPE_SIZE_UNIT (type
));
3105 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
3106 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3107 NULL_TREE
, NULL_TREE
);
3109 /* Also handle conversion to an empty base class, which
3110 is represented with a NOP_EXPR. */
3111 else if (is_empty_class (type
)
3112 && CLASS_TYPE_P (op00type
)
3113 && DERIVED_FROM_P (type
, op00type
))
3118 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3119 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3121 tree field
= TYPE_FIELDS (op00type
);
3122 for (; field
; field
= DECL_CHAIN (field
))
3123 if (TREE_CODE (field
) == FIELD_DECL
3124 && TREE_TYPE (field
) != error_mark_node
3125 && tree_int_cst_equal (byte_position (field
), op01
)
3126 && (same_type_ignoring_top_level_qualifiers_p
3127 (TREE_TYPE (field
), type
)))
3128 return fold_build3 (COMPONENT_REF
, type
, op00
,
3133 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3134 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3135 && (same_type_ignoring_top_level_qualifiers_p
3136 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3139 tree min_val
= size_zero_node
;
3140 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3144 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3145 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3146 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3147 min_val
= TYPE_MIN_VALUE (type_domain
);
3148 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3156 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3158 bool *non_constant_p
, bool *overflow_p
)
3160 tree orig_op0
= TREE_OPERAND (t
, 0);
3161 bool empty_base
= false;
3163 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3164 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3166 if (TREE_CODE (t
) == MEM_REF
3167 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3169 gcc_assert (ctx
->quiet
);
3170 *non_constant_p
= true;
3174 /* First try to simplify it directly. */
3175 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3179 /* If that didn't work, evaluate the operand first. */
3180 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3181 /*lval*/false, non_constant_p
,
3183 /* Don't VERIFY_CONSTANT here. */
3184 if (*non_constant_p
)
3187 if (!lval
&& integer_zerop (op0
))
3190 error ("dereferencing a null pointer");
3191 *non_constant_p
= true;
3195 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3199 /* We couldn't fold to a constant value. Make sure it's not
3200 something we should have been able to fold. */
3203 if (TREE_CODE (sub
) == ADDR_EXPR
)
3205 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3206 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3207 /* DR 1188 says we don't have to deal with this. */
3209 error ("accessing value of %qE through a %qT glvalue in a "
3210 "constant expression", build_fold_indirect_ref (sub
),
3212 *non_constant_p
= true;
3216 if (lval
&& op0
!= orig_op0
)
3217 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3219 VERIFY_CONSTANT (t
);
3224 r
= cxx_eval_constant_expression (ctx
, r
,
3225 lval
, non_constant_p
, overflow_p
);
3226 if (*non_constant_p
)
3229 /* If we're pulling out the value of an empty base, just return an empty
3231 if (empty_base
&& !lval
)
3233 r
= build_constructor (TREE_TYPE (t
), NULL
);
3234 TREE_CONSTANT (r
) = true;
3240 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3241 Shared between potential_constant_expression and
3242 cxx_eval_constant_expression. */
3245 non_const_var_error (tree r
)
3247 tree type
= TREE_TYPE (r
);
3248 error ("the value of %qD is not usable in a constant "
3250 /* Avoid error cascade. */
3251 if (DECL_INITIAL (r
) == error_mark_node
)
3253 if (DECL_DECLARED_CONSTEXPR_P (r
))
3254 inform (DECL_SOURCE_LOCATION (r
),
3255 "%qD used in its own initializer", r
);
3256 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3258 if (!CP_TYPE_CONST_P (type
))
3259 inform (DECL_SOURCE_LOCATION (r
),
3260 "%q#D is not const", r
);
3261 else if (CP_TYPE_VOLATILE_P (type
))
3262 inform (DECL_SOURCE_LOCATION (r
),
3263 "%q#D is volatile", r
);
3264 else if (!DECL_INITIAL (r
)
3265 || !TREE_CONSTANT (DECL_INITIAL (r
))
3266 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3267 inform (DECL_SOURCE_LOCATION (r
),
3268 "%qD was not initialized with a constant "
3273 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3274 inform (DECL_SOURCE_LOCATION (r
),
3275 "%qD was not initialized with a constant "
3279 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3280 inform (DECL_SOURCE_LOCATION (r
),
3281 "%qD was not declared %<constexpr%>", r
);
3283 inform (DECL_SOURCE_LOCATION (r
),
3284 "%qD does not have integral or enumeration type",
3289 /* Subroutine of cxx_eval_constant_expression.
3290 Like cxx_eval_unary_expression, except for trinary expressions. */
3293 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3295 bool *non_constant_p
, bool *overflow_p
)
3301 for (i
= 0; i
< 3; i
++)
3303 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3305 non_constant_p
, overflow_p
);
3306 VERIFY_CONSTANT (args
[i
]);
3309 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3310 args
[0], args
[1], args
[2]);
3311 if (val
== NULL_TREE
)
3313 VERIFY_CONSTANT (val
);
3317 /* True if T was declared in a function declared to be constexpr, and
3318 therefore potentially constant in C++14. */
3321 var_in_constexpr_fn (tree t
)
3323 tree ctx
= DECL_CONTEXT (t
);
3324 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3325 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3328 /* True if T was declared in a function that might be constexpr: either a
3329 function that was declared constexpr, or a C++17 lambda op(). */
3332 var_in_maybe_constexpr_fn (tree t
)
3334 if (cxx_dialect
>= cxx17
3335 && DECL_FUNCTION_SCOPE_P (t
)
3336 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3338 return var_in_constexpr_fn (t
);
3341 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3342 build_over_call we implement trivial copy of a class with tail padding using
3343 assignment of character arrays, which is valid in normal code, but not in
3344 constexpr evaluation. We don't need to worry about clobbering tail padding
3345 in constexpr evaluation, so strip the type punning. */
3348 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3350 if (TREE_CODE (target
) == MEM_REF
3351 && TREE_CODE (init
) == MEM_REF
3352 && TREE_TYPE (target
) == TREE_TYPE (init
)
3353 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3354 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3356 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3357 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3361 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3364 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3366 bool *non_constant_p
, bool *overflow_p
)
3368 constexpr_ctx new_ctx
= *ctx
;
3370 tree init
= TREE_OPERAND (t
, 1);
3371 if (TREE_CLOBBER_P (init
))
3372 /* Just ignore clobbers. */
3375 /* First we figure out where we're storing to. */
3376 tree target
= TREE_OPERAND (t
, 0);
3378 maybe_simplify_trivial_copy (target
, init
);
3380 tree type
= TREE_TYPE (target
);
3381 target
= cxx_eval_constant_expression (ctx
, target
,
3383 non_constant_p
, overflow_p
);
3384 if (*non_constant_p
)
3387 /* cxx_eval_array_reference for lval = true allows references one past
3388 end of array, because it does not know if it is just taking address
3389 (which is valid), or actual dereference. Here we know it is
3390 a dereference, so diagnose it here. */
3391 for (tree probe
= target
; probe
; )
3393 switch (TREE_CODE (probe
))
3397 ary
= TREE_OPERAND (probe
, 0);
3398 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3399 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3400 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3401 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3404 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3405 non_constant_p
, overflow_p
);
3406 VERIFY_CONSTANT (nelts
);
3407 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3408 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3409 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3411 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3412 *non_constant_p
= true;
3419 probe
= TREE_OPERAND (probe
, 0);
3428 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3430 /* For initialization of an empty base, the original target will be
3431 *(base*)this, which the above evaluation resolves to the object
3432 argument, which has the derived type rather than the base type. In
3433 this situation, just evaluate the initializer and return, since
3434 there's no actual data to store. */
3435 gcc_assert (is_empty_class (type
));
3436 return cxx_eval_constant_expression (ctx
, init
, false,
3437 non_constant_p
, overflow_p
);
3440 /* And then find the underlying variable. */
3441 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3442 tree object
= NULL_TREE
;
3443 for (tree probe
= target
; object
== NULL_TREE
; )
3445 switch (TREE_CODE (probe
))
3450 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3451 vec_safe_push (refs
, TREE_TYPE (probe
));
3452 probe
= TREE_OPERAND (probe
, 0);
3460 /* And then find/build up our initializer for the path to the subobject
3461 we're initializing. */
3463 if (object
== ctx
->object
&& VAR_P (object
)
3464 && DECL_NAME (object
) && ctx
->call
== NULL
)
3465 /* The variable we're building up an aggregate initializer for is outside
3466 the constant-expression, so don't evaluate the store. We check
3467 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3469 else if (DECL_P (object
))
3470 valp
= ctx
->values
->get (object
);
3475 /* A constant-expression cannot modify objects from outside the
3476 constant-expression. */
3478 error ("modification of %qE is not a constant expression", object
);
3479 *non_constant_p
= true;
3482 type
= TREE_TYPE (object
);
3483 bool no_zero_init
= true;
3485 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3486 while (!refs
->is_empty())
3488 if (*valp
== NULL_TREE
)
3490 *valp
= build_constructor (type
, NULL
);
3491 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3493 else if (TREE_CODE (*valp
) == STRING_CST
)
3495 /* An array was initialized with a string constant, and now
3496 we're writing into one of its elements. Explode the
3497 single initialization into a set of element
3499 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3501 tree string
= *valp
;
3502 tree elt_type
= TREE_TYPE (type
);
3503 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3504 / TYPE_PRECISION (char_type_node
));
3505 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3506 tree ary_ctor
= build_constructor (type
, NULL
);
3508 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3509 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3511 constructor_elt elt
=
3513 build_int_cst (size_type_node
, ix
),
3514 extract_string_elt (string
, chars_per_elt
, ix
)
3516 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3522 /* If the value of object is already zero-initialized, any new ctors for
3523 subobjects will also be zero-initialized. */
3524 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3526 vec_safe_push (ctors
, *valp
);
3528 enum tree_code code
= TREE_CODE (type
);
3530 tree index
= refs
->pop();
3532 constructor_elt
*cep
= NULL
;
3533 if (code
== ARRAY_TYPE
)
3536 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3537 gcc_assert (i
>= 0);
3538 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3539 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3543 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3545 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3546 Usually we meet initializers in that order, but it is
3547 possible for base types to be placed not in program
3549 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3550 unsigned HOST_WIDE_INT idx
;
3552 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3553 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3554 /* Changing active member. */
3555 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3558 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3559 idx
++, fields
= DECL_CHAIN (fields
))
3561 if (index
== cep
->index
)
3564 /* The field we're initializing must be on the field
3565 list. Look to see if it is present before the
3566 field the current ELT initializes. */
3567 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3568 if (index
== fields
)
3572 /* We fell off the end of the CONSTRUCTOR, so insert a new
3573 entry at the end. */
3576 constructor_elt ce
= { index
, NULL_TREE
};
3578 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3579 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3585 release_tree_vector (refs
);
3587 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3589 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3590 wants to modify it. */
3591 if (*valp
== NULL_TREE
)
3593 *valp
= build_constructor (type
, NULL
);
3594 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3596 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3597 *valp
= cplus_expand_constant (*valp
);
3598 new_ctx
.ctor
= *valp
;
3599 new_ctx
.object
= target
;
3602 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3603 non_constant_p
, overflow_p
);
3604 /* Don't share a CONSTRUCTOR that might be changed later. */
3605 init
= unshare_constructor (init
);
3606 if (target
== object
)
3607 /* The hash table might have moved since the get earlier. */
3608 valp
= ctx
->values
->get (object
);
3610 if (TREE_CODE (init
) == CONSTRUCTOR
)
3612 /* An outer ctx->ctor might be pointing to *valp, so replace
3614 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3615 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3616 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3617 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3618 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3623 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3624 CONSTRUCTORs, if any. */
3627 bool c
= TREE_CONSTANT (init
);
3628 bool s
= TREE_SIDE_EFFECTS (init
);
3630 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3633 TREE_CONSTANT (elt
) = false;
3635 TREE_SIDE_EFFECTS (elt
) = true;
3637 release_tree_vector (ctors
);
3639 if (*non_constant_p
)
3647 /* Evaluate a ++ or -- expression. */
3650 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3652 bool *non_constant_p
, bool *overflow_p
)
3654 enum tree_code code
= TREE_CODE (t
);
3655 tree type
= TREE_TYPE (t
);
3656 tree op
= TREE_OPERAND (t
, 0);
3657 tree offset
= TREE_OPERAND (t
, 1);
3658 gcc_assert (TREE_CONSTANT (offset
));
3660 /* The operand as an lvalue. */
3661 op
= cxx_eval_constant_expression (ctx
, op
, true,
3662 non_constant_p
, overflow_p
);
3664 /* The operand as an rvalue. */
3666 = cxx_eval_constant_expression (ctx
, op
, false,
3667 non_constant_p
, overflow_p
);
3668 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3669 a local array in a constexpr function. */
3670 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3672 VERIFY_CONSTANT (val
);
3674 /* The modified value. */
3675 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3677 if (POINTER_TYPE_P (type
))
3679 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3680 offset
= convert_to_ptrofftype (offset
);
3682 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3683 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3686 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3688 VERIFY_CONSTANT (mod
);
3690 /* Storing the modified value. */
3691 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3692 cxx_eval_constant_expression (ctx
, store
,
3693 true, non_constant_p
, overflow_p
);
3695 /* And the value of the expression. */
3696 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3698 /* Prefix ops are lvalues. */
3702 /* But we optimize when the caller wants an rvalue. */
3706 /* Postfix ops are rvalues. */
3710 /* Predicates for the meaning of *jump_target. */
3713 returns (tree
*jump_target
)
3716 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3717 || (TREE_CODE (*jump_target
) == LABEL_DECL
3718 && LABEL_DECL_CDTOR (*jump_target
)));
3722 breaks (tree
*jump_target
)
3725 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3726 && LABEL_DECL_BREAK (*jump_target
))
3727 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3731 continues (tree
*jump_target
)
3734 && TREE_CODE (*jump_target
) == LABEL_DECL
3735 && LABEL_DECL_CONTINUE (*jump_target
);
3739 switches (tree
*jump_target
)
3742 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3745 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3746 STMT matches *jump_target. If we're looking for a case label and we see
3747 the default label, note it in ctx->css_state. */
3750 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3752 switch (TREE_CODE (*jump_target
))
3755 if (TREE_CODE (stmt
) == LABEL_EXPR
3756 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3761 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3763 gcc_assert (ctx
->css_state
!= NULL
);
3764 if (!CASE_LOW (stmt
))
3766 /* default: should appear just once in a SWITCH_EXPR
3767 body (excluding nested SWITCH_EXPR). */
3768 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3769 /* When evaluating SWITCH_EXPR body for the second time,
3770 return true for the default: label. */
3771 if (*ctx
->css_state
== css_default_processing
)
3773 *ctx
->css_state
= css_default_seen
;
3775 else if (CASE_HIGH (stmt
))
3777 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3778 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3781 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3792 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3793 semantics, for switch, break, continue, and return. */
3796 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3797 bool *non_constant_p
, bool *overflow_p
,
3800 tree_stmt_iterator i
;
3802 /* In a statement-expression we want to return the last value.
3803 For empty statement expression return void_node. */
3807 local_target
= NULL_TREE
;
3808 jump_target
= &local_target
;
3810 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3812 tree stmt
= tsi_stmt (i
);
3813 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3814 non_constant_p
, overflow_p
,
3816 if (*non_constant_p
)
3818 if (returns (jump_target
) || breaks (jump_target
))
3824 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3825 semantics; continue semantics are covered by cxx_eval_statement_list. */
3828 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3829 bool *non_constant_p
, bool *overflow_p
,
3832 constexpr_ctx new_ctx
= *ctx
;
3834 tree body
= TREE_OPERAND (t
, 0);
3838 hash_set
<tree
> save_exprs
;
3839 new_ctx
.save_exprs
= &save_exprs
;
3841 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3842 non_constant_p
, overflow_p
, jump_target
);
3844 /* Forget saved values of SAVE_EXPRs. */
3845 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3846 iter
!= save_exprs
.end(); ++iter
)
3847 new_ctx
.values
->remove (*iter
);
3848 if (++count
>= constexpr_loop_limit
)
3851 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3852 "constexpr loop iteration count exceeds limit of %d "
3853 "(use -fconstexpr-loop-limit= to increase the limit)",
3854 constexpr_loop_limit
);
3855 *non_constant_p
= true;
3859 while (!returns (jump_target
)
3860 && !breaks (jump_target
)
3861 && !switches (jump_target
)
3862 && !*non_constant_p
);
3864 if (breaks (jump_target
))
3865 *jump_target
= NULL_TREE
;
3870 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3874 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3875 bool *non_constant_p
, bool *overflow_p
,
3878 tree cond
= TREE_OPERAND (t
, 0);
3879 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3880 non_constant_p
, overflow_p
);
3881 VERIFY_CONSTANT (cond
);
3882 *jump_target
= cond
;
3884 tree body
= TREE_OPERAND (t
, 1);
3885 constexpr_ctx new_ctx
= *ctx
;
3886 constexpr_switch_state css
= css_default_not_seen
;
3887 new_ctx
.css_state
= &css
;
3888 cxx_eval_constant_expression (&new_ctx
, body
, false,
3889 non_constant_p
, overflow_p
, jump_target
);
3890 if (switches (jump_target
) && css
== css_default_seen
)
3892 /* If the SWITCH_EXPR body has default: label, process it once again,
3893 this time instructing label_matches to return true for default:
3894 label on switches (jump_target). */
3895 css
= css_default_processing
;
3896 cxx_eval_constant_expression (&new_ctx
, body
, false,
3897 non_constant_p
, overflow_p
, jump_target
);
3899 if (breaks (jump_target
) || switches (jump_target
))
3900 *jump_target
= NULL_TREE
;
3904 /* Find the object of TYPE under initialization in CTX. */
3907 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3912 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3913 can is a minor optimization. */
3914 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
3920 /* Since an object cannot have a field of its own type, we can search outward
3921 from ctx->object to find the unique containing object of TYPE. */
3922 tree ob
= ctx
->object
;
3925 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
3927 if (handled_component_p (ob
))
3928 ob
= TREE_OPERAND (ob
, 0);
3936 /* Attempt to reduce the expression T to a constant value.
3937 On failure, issue diagnostic and return error_mark_node. */
3938 /* FIXME unify with c_fully_fold */
3939 /* FIXME overflow_p is too global */
3942 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3944 bool *non_constant_p
, bool *overflow_p
,
3947 constexpr_ctx new_ctx
;
3950 if (jump_target
&& *jump_target
)
3952 /* If we are jumping, ignore all statements/expressions except those
3953 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
3954 switch (TREE_CODE (t
))
3957 case STATEMENT_LIST
:
3962 case CASE_LABEL_EXPR
:
3963 if (label_matches (ctx
, jump_target
, t
))
3965 *jump_target
= NULL_TREE
;
3971 if (t
== error_mark_node
)
3973 *non_constant_p
= true;
3976 if (CONSTANT_CLASS_P (t
))
3978 if (TREE_OVERFLOW (t
))
3981 permerror (input_location
, "overflow in constant expression");
3982 if (!flag_permissive
|| ctx
->quiet
)
3986 if (TREE_CODE (t
) == INTEGER_CST
3987 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
3988 && !integer_zerop (t
))
3991 error ("value %qE of type %qT is not a constant expression",
3993 *non_constant_p
= true;
3999 tree_code tcode
= TREE_CODE (t
);
4005 /* We ask for an rvalue for the RESULT_DECL when indirecting
4006 through an invisible reference, or in named return value
4008 return (*ctx
->values
->get (t
));
4011 if (DECL_HAS_VALUE_EXPR_P (t
))
4012 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4013 lval
, non_constant_p
, overflow_p
);
4016 /* We used to not check lval for CONST_DECL, but darwin.c uses
4017 CONST_DECL for aggregate constants. */
4020 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4021 && is_really_empty_class (TREE_TYPE (t
)))
4023 /* If the class is empty, we aren't actually loading anything. */
4024 r
= build_constructor (TREE_TYPE (t
), NULL
);
4025 TREE_CONSTANT (r
) = true;
4027 else if (ctx
->strict
)
4028 r
= decl_really_constant_value (t
);
4030 r
= decl_constant_value (t
);
4031 if (TREE_CODE (r
) == TARGET_EXPR
4032 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4033 r
= TARGET_EXPR_INITIAL (r
);
4035 if (tree
*p
= ctx
->values
->get (r
))
4036 if (*p
!= NULL_TREE
)
4041 non_const_var_error (r
);
4042 *non_constant_p
= true;
4050 case CASE_LABEL_EXPR
:
4055 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4057 else if (tree
*p
= ctx
->values
->get (r
))
4060 /* Defer in case this is only used for its type. */;
4061 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4062 /* Defer, there's no lvalue->rvalue conversion. */;
4063 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4064 && is_really_empty_class (TREE_TYPE (t
)))
4066 /* If the class is empty, we aren't actually loading anything. */
4067 r
= build_constructor (TREE_TYPE (t
), NULL
);
4068 TREE_CONSTANT (r
) = true;
4073 error ("%qE is not a constant expression", t
);
4074 *non_constant_p
= true;
4079 case AGGR_INIT_EXPR
:
4080 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4081 non_constant_p
, overflow_p
);
4086 r
= DECL_EXPR_DECL (t
);
4087 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4088 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4092 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4093 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4094 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4098 if (tree init
= DECL_INITIAL (r
))
4100 init
= cxx_eval_constant_expression (ctx
, init
,
4102 non_constant_p
, overflow_p
);
4103 /* Don't share a CONSTRUCTOR that might be changed. */
4104 init
= unshare_constructor (init
);
4105 ctx
->values
->put (r
, init
);
4107 else if (ctx
== &new_ctx
)
4108 /* We gave it a CONSTRUCTOR above. */;
4110 ctx
->values
->put (r
, NULL_TREE
);
4115 if (!literal_type_p (TREE_TYPE (t
)))
4119 error ("temporary of non-literal type %qT in a "
4120 "constant expression", TREE_TYPE (t
));
4121 explain_non_literal_class (TREE_TYPE (t
));
4123 *non_constant_p
= true;
4126 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4128 /* We're being expanded without an explicit target, so start
4129 initializing a new object; expansion with an explicit target
4130 strips the TARGET_EXPR before we get here. */
4132 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4133 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4134 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4135 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4138 /* Pass false for 'lval' because this indicates
4139 initialization of a temporary. */
4140 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4142 non_constant_p
, overflow_p
);
4143 if (!*non_constant_p
)
4144 /* Adjust the type of the result to the type of the temporary. */
4145 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4148 tree slot
= TARGET_EXPR_SLOT (t
);
4149 r
= unshare_constructor (r
);
4150 ctx
->values
->put (slot
, r
);
4157 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4158 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4159 non_constant_p
, overflow_p
);
4163 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4165 non_constant_p
, overflow_p
);
4169 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4170 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4172 non_constant_p
, overflow_p
);
4177 /* Avoid evaluating a SAVE_EXPR more than once. */
4178 if (tree
*p
= ctx
->values
->get (t
))
4182 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4183 non_constant_p
, overflow_p
);
4184 ctx
->values
->put (t
, r
);
4185 if (ctx
->save_exprs
)
4186 ctx
->save_exprs
->add (t
);
4190 case NON_LVALUE_EXPR
:
4191 case TRY_CATCH_EXPR
:
4193 case CLEANUP_POINT_EXPR
:
4194 case MUST_NOT_THROW_EXPR
:
4197 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4199 non_constant_p
, overflow_p
,
4203 case TRY_FINALLY_EXPR
:
4204 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4205 non_constant_p
, overflow_p
,
4207 if (!*non_constant_p
)
4208 /* Also evaluate the cleanup. */
4209 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4210 non_constant_p
, overflow_p
,
4214 /* These differ from cxx_eval_unary_expression in that this doesn't
4215 check for a constant operand or result; an address can be
4216 constant without its operand being, and vice versa. */
4219 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4220 non_constant_p
, overflow_p
);
4225 tree oldop
= TREE_OPERAND (t
, 0);
4226 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4228 non_constant_p
, overflow_p
);
4229 /* Don't VERIFY_CONSTANT here. */
4230 if (*non_constant_p
)
4232 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4233 /* This function does more aggressive folding than fold itself. */
4234 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4235 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4244 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4245 non_constant_p
, overflow_p
);
4246 if (r
== error_mark_node
)
4248 else if (r
== TREE_OPERAND (t
, 0))
4251 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4256 case FIX_TRUNC_EXPR
:
4261 case TRUTH_NOT_EXPR
:
4262 case FIXED_CONVERT_EXPR
:
4263 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4264 non_constant_p
, overflow_p
);
4268 r
= fold_sizeof_expr (t
);
4269 VERIFY_CONSTANT (r
);
4274 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4275 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4276 introduced by build_call_a. */
4277 tree op0
= TREE_OPERAND (t
, 0);
4278 tree op1
= TREE_OPERAND (t
, 1);
4280 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4281 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4282 r
= cxx_eval_constant_expression (ctx
, op0
,
4283 lval
, non_constant_p
, overflow_p
,
4287 /* Check that the LHS is constant and then discard it. */
4288 cxx_eval_constant_expression (ctx
, op0
,
4289 true, non_constant_p
, overflow_p
,
4291 if (*non_constant_p
)
4293 op1
= TREE_OPERAND (t
, 1);
4294 r
= cxx_eval_constant_expression (ctx
, op1
,
4295 lval
, non_constant_p
, overflow_p
,
4301 case POINTER_PLUS_EXPR
:
4305 case TRUNC_DIV_EXPR
:
4307 case FLOOR_DIV_EXPR
:
4308 case ROUND_DIV_EXPR
:
4309 case TRUNC_MOD_EXPR
:
4311 case ROUND_MOD_EXPR
:
4313 case EXACT_DIV_EXPR
:
4323 case TRUTH_XOR_EXPR
:
4330 case UNORDERED_EXPR
:
4340 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4341 non_constant_p
, overflow_p
);
4344 /* fold can introduce non-IF versions of these; still treat them as
4345 short-circuiting. */
4346 case TRUTH_AND_EXPR
:
4347 case TRUTH_ANDIF_EXPR
:
4348 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4351 non_constant_p
, overflow_p
);
4355 case TRUTH_ORIF_EXPR
:
4356 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4359 non_constant_p
, overflow_p
);
4363 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4364 non_constant_p
, overflow_p
);
4368 if (is_overloaded_fn (t
))
4370 /* We can only get here in checking mode via
4371 build_non_dependent_expr, because any expression that
4372 calls or takes the address of the function will have
4373 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4374 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4375 *non_constant_p
= true;
4378 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4379 non_constant_p
, overflow_p
);
4383 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4384 non_constant_p
, overflow_p
);
4388 if (jump_target
&& *jump_target
)
4390 /* When jumping to a label, the label might be either in the
4391 then or else blocks, so process then block first in skipping
4392 mode first, and if we are still in the skipping mode at its end,
4393 process the else block too. */
4394 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4395 lval
, non_constant_p
, overflow_p
,
4398 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4399 lval
, non_constant_p
, overflow_p
,
4405 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4406 non_constant_p
, overflow_p
,
4411 if (TREE_CONSTANT (t
))
4413 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4414 VECTOR_CST if applicable. */
4415 /* FIXME after GCC 6 branches, make the verify unconditional. */
4417 verify_constructor_flags (t
);
4419 recompute_constructor_flags (t
);
4420 if (TREE_CONSTANT (t
))
4423 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4424 non_constant_p
, overflow_p
);
4428 /* We can get this in a defaulted constructor for a class with a
4429 non-static data member of array type. Either the initializer will
4430 be NULL, meaning default-initialization, or it will be an lvalue
4431 or xvalue of the same type, meaning direct-initialization from the
4432 corresponding member. */
4433 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4434 non_constant_p
, overflow_p
);
4439 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4440 non_constant_p
, overflow_p
);
4444 case VIEW_CONVERT_EXPR
:
4446 case UNARY_PLUS_EXPR
:
4448 tree oldop
= TREE_OPERAND (t
, 0);
4450 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4452 non_constant_p
, overflow_p
);
4453 if (*non_constant_p
)
4455 tree type
= TREE_TYPE (t
);
4456 if (TREE_CODE (op
) == PTRMEM_CST
4457 && !TYPE_PTRMEM_P (type
))
4458 op
= cplus_expand_constant (op
);
4459 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4461 if (same_type_ignoring_top_level_qualifiers_p (type
,
4463 || can_convert_qual (type
, op
))
4464 return cp_fold_convert (type
, op
);
4468 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4469 "a reinterpret_cast is not a constant expression");
4470 *non_constant_p
= true;
4475 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4477 if (integer_zerop (op
))
4479 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4482 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4483 "dereferencing a null pointer");
4484 *non_constant_p
= true;
4487 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4489 tree from
= TREE_TYPE (op
);
4491 if (!can_convert (type
, from
, tf_none
))
4494 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4495 "conversion of %qT null pointer to %qT "
4496 "is not a constant expression",
4498 *non_constant_p
= true;
4505 /* This detects for example:
4506 reinterpret_cast<void*>(sizeof 0)
4509 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4510 "%<reinterpret_cast<%T>(%E)%> is not "
4511 "a constant expression",
4513 *non_constant_p
= true;
4517 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4518 /* We didn't fold at the top so we could check for ptr-int
4521 if (tcode
== UNARY_PLUS_EXPR
)
4522 r
= fold_convert (TREE_TYPE (t
), op
);
4524 r
= fold_build1 (tcode
, type
, op
);
4525 /* Conversion of an out-of-range value has implementation-defined
4526 behavior; the language considers it different from arithmetic
4527 overflow, which is undefined. */
4528 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4529 TREE_OVERFLOW (r
) = false;
4533 case EMPTY_CLASS_EXPR
:
4534 /* This is good enough for a function argument that might not get
4535 used, and they can't do anything with it, so just return it. */
4538 case STATEMENT_LIST
:
4540 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4541 return cxx_eval_statement_list (&new_ctx
, t
,
4542 non_constant_p
, overflow_p
, jump_target
);
4545 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4547 non_constant_p
, overflow_p
,
4550 case PREINCREMENT_EXPR
:
4551 case POSTINCREMENT_EXPR
:
4552 case PREDECREMENT_EXPR
:
4553 case POSTDECREMENT_EXPR
:
4554 return cxx_eval_increment_expression (ctx
, t
,
4555 lval
, non_constant_p
, overflow_p
);
4561 case VEC_DELETE_EXPR
:
4564 /* GCC internal stuff. */
4567 case NON_DEPENDENT_EXPR
:
4571 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4572 "expression %qE is not a constant expression", t
);
4573 *non_constant_p
= true;
4576 case PLACEHOLDER_EXPR
:
4577 /* Use of the value or address of the current object. */
4578 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4579 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4580 non_constant_p
, overflow_p
);
4581 /* A placeholder without a referent. We can get here when
4582 checking whether NSDMIs are noexcept, or in massage_init_elt;
4583 just say it's non-constant for now. */
4584 gcc_assert (ctx
->quiet
);
4585 *non_constant_p
= true;
4590 tree cond
= TREE_OPERAND (t
, 0);
4591 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4592 non_constant_p
, overflow_p
);
4593 VERIFY_CONSTANT (cond
);
4594 if (integer_nonzerop (cond
))
4600 *jump_target
= TREE_OPERAND (t
, 0);
4601 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4602 /* Allow for jumping to a cdtor_label. */
4603 || returns (jump_target
));
4607 cxx_eval_loop_expr (ctx
, t
,
4608 non_constant_p
, overflow_p
, jump_target
);
4612 cxx_eval_switch_expr (ctx
, t
,
4613 non_constant_p
, overflow_p
, jump_target
);
4617 /* It's possible to get a requires-expression in a constant
4618 expression. For example:
4620 template<typename T> concept bool C() {
4621 return requires (T t) { t; };
4624 template<typename T> requires !C<T>() void f(T);
4626 Normalization leaves f with the associated constraint
4627 '!requires (T t) { ... }' which is not transformed into
4629 if (!processing_template_decl
)
4630 return evaluate_constraint_expression (t
, NULL_TREE
);
4632 *non_constant_p
= true;
4636 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
4637 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4639 non_constant_p
, overflow_p
,
4644 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4646 /* This function doesn't know how to deal with pre-genericize
4647 statements; this can only happen with statement-expressions,
4648 so for now just fail. */
4650 error_at (EXPR_LOCATION (t
),
4651 "statement is not a constant expression");
4654 internal_error ("unexpected expression %qE of kind %s", t
,
4655 get_tree_code_name (TREE_CODE (t
)));
4656 *non_constant_p
= true;
4660 if (r
== error_mark_node
)
4661 *non_constant_p
= true;
4663 if (*non_constant_p
)
4670 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4671 bool strict
= true, tree object
= NULL_TREE
)
4673 auto_timevar
time (TV_CONSTEXPR
);
4675 bool non_constant_p
= false;
4676 bool overflow_p
= false;
4677 hash_map
<tree
,tree
> map
;
4679 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4680 allow_non_constant
, strict
};
4682 tree type
= initialized_type (t
);
4684 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4686 /* In C++14 an NSDMI can participate in aggregate initialization,
4687 and can refer to the address of the object being initialized, so
4688 we need to pass in the relevant VAR_DECL if we want to do the
4689 evaluation in a single pass. The evaluation will dynamically
4690 update ctx.values for the VAR_DECL. We use the same strategy
4691 for C++11 constexpr constructors that refer to the object being
4693 ctx
.ctor
= build_constructor (type
, NULL
);
4694 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4697 if (TREE_CODE (t
) == TARGET_EXPR
)
4698 object
= TARGET_EXPR_SLOT (t
);
4699 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4700 object
= AGGR_INIT_EXPR_SLOT (t
);
4702 ctx
.object
= object
;
4704 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4705 (type
, TREE_TYPE (object
)));
4706 if (object
&& DECL_P (object
))
4707 map
.put (object
, ctx
.ctor
);
4708 if (TREE_CODE (r
) == TARGET_EXPR
)
4709 /* Avoid creating another CONSTRUCTOR when we expand the
4711 r
= TARGET_EXPR_INITIAL (r
);
4714 r
= cxx_eval_constant_expression (&ctx
, r
,
4715 false, &non_constant_p
, &overflow_p
);
4717 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4719 /* Mutable logic is a bit tricky: we want to allow initialization of
4720 constexpr variables with mutable members, but we can't copy those
4721 members to another constexpr variable. */
4722 if (TREE_CODE (r
) == CONSTRUCTOR
4723 && CONSTRUCTOR_MUTABLE_POISON (r
))
4725 if (!allow_non_constant
)
4726 error ("%qE is not a constant expression because it refers to "
4727 "mutable subobjects of %qT", t
, type
);
4728 non_constant_p
= true;
4731 if (TREE_CODE (r
) == CONSTRUCTOR
4732 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4734 if (!allow_non_constant
)
4735 error ("%qE is not a constant expression because it refers to "
4736 "an incompletely initialized variable", t
);
4737 TREE_CONSTANT (r
) = false;
4738 non_constant_p
= true;
4741 /* Technically we should check this for all subexpressions, but that
4742 runs into problems with our internal representation of pointer
4743 subtraction and the 5.19 rules are still in flux. */
4744 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4745 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4746 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4748 if (!allow_non_constant
)
4749 error ("conversion from pointer type %qT "
4750 "to arithmetic type %qT in a constant expression",
4751 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4752 non_constant_p
= true;
4755 if (!non_constant_p
&& overflow_p
)
4756 non_constant_p
= true;
4758 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4760 bool should_unshare
= true;
4761 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4762 should_unshare
= false;
4764 if (non_constant_p
&& !allow_non_constant
)
4765 return error_mark_node
;
4766 else if (non_constant_p
&& TREE_CONSTANT (r
))
4768 /* This isn't actually constant, so unset TREE_CONSTANT. */
4771 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4772 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4774 r
= build_nop (TREE_TYPE (r
), r
);
4775 TREE_CONSTANT (r
) = false;
4777 else if (non_constant_p
|| r
== t
)
4781 r
= unshare_expr (r
);
4783 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4785 if (TREE_CODE (t
) == TARGET_EXPR
4786 && TARGET_EXPR_INITIAL (t
) == r
)
4790 r
= get_target_expr (r
);
4791 TREE_CONSTANT (r
) = true;
4799 /* Returns true if T is a valid subexpression of a constant expression,
4800 even if it isn't itself a constant expression. */
4803 is_sub_constant_expr (tree t
)
4805 bool non_constant_p
= false;
4806 bool overflow_p
= false;
4807 hash_map
<tree
, tree
> map
;
4809 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4811 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4813 return !non_constant_p
&& !overflow_p
;
4816 /* If T represents a constant expression returns its reduced value.
4817 Otherwise return error_mark_node. If T is dependent, then
4821 cxx_constant_value (tree t
, tree decl
)
4823 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4826 /* Helper routine for fold_simple function. Either return simplified
4827 expression T, otherwise NULL_TREE.
4828 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4829 even if we are within template-declaration. So be careful on call, as in
4830 such case types can be undefined. */
4833 fold_simple_1 (tree t
)
4836 enum tree_code code
= TREE_CODE (t
);
4848 return fold_sizeof_expr (t
);
4856 case TRUTH_NOT_EXPR
:
4858 case VIEW_CONVERT_EXPR
:
4861 case FIX_TRUNC_EXPR
:
4862 case FIXED_CONVERT_EXPR
:
4863 case ADDR_SPACE_CONVERT_EXPR
:
4865 op1
= TREE_OPERAND (t
, 0);
4867 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4871 if (CONVERT_EXPR_CODE_P (code
)
4872 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4873 TREE_OVERFLOW (t
) = false;
4881 /* If T is a simple constant expression, returns its simplified value.
4882 Otherwise returns T. In contrast to maybe_constant_value do we
4883 simplify only few operations on constant-expressions, and we don't
4884 try to simplify constexpressions. */
4887 fold_simple (tree t
)
4890 if (processing_template_decl
)
4893 r
= fold_simple_1 (t
);
4900 /* If T is a constant expression, returns its reduced value.
4901 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4902 Otherwise, returns a version of T without TREE_CONSTANT. */
4904 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4907 maybe_constant_value (tree t
, tree decl
)
4911 if (!is_nondependent_constant_expression (t
))
4913 if (TREE_OVERFLOW_P (t
))
4915 t
= build_nop (TREE_TYPE (t
), t
);
4916 TREE_CONSTANT (t
) = false;
4920 else if (CONSTANT_CLASS_P (t
))
4921 /* No caching or evaluation needed. */
4924 if (cv_cache
== NULL
)
4925 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4926 if (tree
*cached
= cv_cache
->get (t
))
4929 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4930 gcc_checking_assert (r
== t
4931 || CONVERT_EXPR_P (t
)
4932 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4933 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4934 || !cp_tree_equal (r
, t
));
4935 cv_cache
->put (t
, r
);
4939 /* Dispose of the whole CV_CACHE. */
4942 clear_cv_cache (void)
4944 if (cv_cache
!= NULL
)
4948 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4951 clear_cv_and_fold_caches (void)
4954 clear_fold_cache ();
4957 /* Like maybe_constant_value but first fully instantiate the argument.
4959 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4960 (t, tf_none) followed by maybe_constant_value but is more efficient,
4961 because calls instantiation_dependent_expression_p and
4962 potential_constant_expression at most once. */
4965 fold_non_dependent_expr (tree t
)
4970 /* If we're in a template, but T isn't value dependent, simplify
4971 it. We're supposed to treat:
4973 template <typename T> void f(T[1 + 1]);
4974 template <typename T> void f(T[2]);
4976 as two declarations of the same function, for example. */
4977 if (processing_template_decl
)
4979 if (is_nondependent_constant_expression (t
))
4981 processing_template_decl_sentinel s
;
4982 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4984 if (type_unknown_p (t
)
4985 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4987 if (TREE_OVERFLOW_P (t
))
4989 t
= build_nop (TREE_TYPE (t
), t
);
4990 TREE_CONSTANT (t
) = false;
4995 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4996 /* cp_tree_equal looks through NOPs, so allow them. */
4997 gcc_checking_assert (r
== t
4998 || CONVERT_EXPR_P (t
)
4999 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5000 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5001 || !cp_tree_equal (r
, t
));
5004 else if (TREE_OVERFLOW_P (t
))
5006 t
= build_nop (TREE_TYPE (t
), t
);
5007 TREE_CONSTANT (t
) = false;
5012 return maybe_constant_value (t
);
5015 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5016 than wrapped in a TARGET_EXPR. */
5019 maybe_constant_init (tree t
, tree decl
)
5023 if (TREE_CODE (t
) == EXPR_STMT
)
5024 t
= TREE_OPERAND (t
, 0);
5025 if (TREE_CODE (t
) == CONVERT_EXPR
5026 && VOID_TYPE_P (TREE_TYPE (t
)))
5027 t
= TREE_OPERAND (t
, 0);
5028 if (TREE_CODE (t
) == INIT_EXPR
)
5029 t
= TREE_OPERAND (t
, 1);
5030 if (TREE_CODE (t
) == TARGET_EXPR
)
5031 t
= TARGET_EXPR_INITIAL (t
);
5032 if (!is_nondependent_static_init_expression (t
))
5033 /* Don't try to evaluate it. */;
5034 else if (CONSTANT_CLASS_P (t
))
5035 /* No evaluation needed. */;
5037 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
5038 if (TREE_CODE (t
) == TARGET_EXPR
)
5040 tree init
= TARGET_EXPR_INITIAL (t
);
5041 if (TREE_CODE (init
) == CONSTRUCTOR
)
5048 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5049 /* Return true if the object referred to by REF has automatic or thread
5052 enum { ck_ok
, ck_bad
, ck_unknown
};
5054 check_automatic_or_tls (tree ref
)
5057 HOST_WIDE_INT bitsize
, bitpos
;
5059 int volatilep
= 0, unsignedp
= 0;
5060 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5061 &mode
, &unsignedp
, &volatilep
, false);
5064 /* If there isn't a decl in the middle, we don't know the linkage here,
5065 and this isn't a constant expression anyway. */
5068 dk
= decl_storage_duration (decl
);
5069 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5073 /* Return true if T denotes a potentially constant expression. Issue
5074 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5075 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5076 consider the expression in the current context, independent of constexpr
5079 C++0x [expr.const] used to say
5081 6 An expression is a potential constant expression if it is
5082 a constant expression where all occurrences of function
5083 parameters are replaced by arbitrary constant expressions
5084 of the appropriate type.
5086 2 A conditional expression is a constant expression unless it
5087 involves one of the following as a potentially evaluated
5088 subexpression (3.2), but subexpressions of logical AND (5.14),
5089 logical OR (5.15), and conditional (5.16) operations that are
5090 not evaluated are not considered. */
5093 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5094 tsubst_flags_t flags
)
5096 #define RECUR(T,RV) \
5097 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5099 enum { any
= false, rval
= true };
5103 if (t
== error_mark_node
)
5107 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5108 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5110 if (flags
& tf_error
)
5111 error_at (loc
, "expression %qE has side-effects", t
);
5114 if (CONSTANT_CLASS_P (t
))
5116 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5117 && TREE_TYPE (t
) == error_mark_node
)
5120 switch (TREE_CODE (t
))
5126 case TEMPLATE_ID_EXPR
:
5129 case CASE_LABEL_EXPR
:
5135 case TEMPLATE_PARM_INDEX
:
5137 case IDENTIFIER_NODE
:
5138 case USERDEF_LITERAL
:
5139 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5144 case PLACEHOLDER_EXPR
:
5154 if (flags
& tf_error
)
5155 error ("%qE is not a constant expression", t
);
5160 case AGGR_INIT_EXPR
:
5162 /* -- an invocation of a function other than a constexpr function
5163 or a constexpr constructor. */
5165 tree fun
= get_function_named_in_call (t
);
5166 const int nargs
= call_expr_nargs (t
);
5169 if (fun
== NULL_TREE
)
5171 /* Reset to allow the function to continue past the end
5172 of the block below. Otherwise return early. */
5175 if (TREE_CODE (t
) == CALL_EXPR
5176 && CALL_EXPR_FN (t
) == NULL_TREE
)
5177 switch (CALL_EXPR_IFN (t
))
5179 /* These should be ignored, they are optimized away from
5180 constexpr functions. */
5181 case IFN_UBSAN_NULL
:
5182 case IFN_UBSAN_BOUNDS
:
5183 case IFN_UBSAN_VPTR
:
5184 case IFN_FALLTHROUGH
:
5187 case IFN_ADD_OVERFLOW
:
5188 case IFN_SUB_OVERFLOW
:
5189 case IFN_MUL_OVERFLOW
:
5199 /* fold_call_expr can't do anything with IFN calls. */
5200 if (flags
& tf_error
)
5201 error_at (loc
, "call to internal function %qE", t
);
5206 if (fun
&& is_overloaded_fn (fun
))
5208 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5210 if (builtin_valid_in_constant_expr_p (fun
))
5212 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5213 /* Allow any built-in function; if the expansion
5214 isn't constant, we'll deal with that then. */
5215 && !is_builtin_fn (fun
))
5217 if (flags
& tf_error
)
5219 error_at (loc
, "call to non-constexpr function %qD",
5221 explain_invalid_constexpr_fn (fun
);
5225 /* A call to a non-static member function takes the address
5226 of the object as the first argument. But in a constant
5227 expression the address will be folded away, so look
5229 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5230 && !DECL_CONSTRUCTOR_P (fun
))
5232 tree x
= get_nth_callarg (t
, 0);
5233 if (is_this_parameter (x
))
5235 /* Don't require an immediately constant value, as
5236 constexpr substitution might not use the value. */
5237 bool sub_now
= false;
5238 if (!potential_constant_expression_1 (x
, rval
, strict
,
5246 if (!RECUR (fun
, true))
5248 fun
= get_first_fn (fun
);
5250 /* Skip initial arguments to base constructors. */
5251 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5252 i
= num_artificial_parms_for (fun
);
5253 fun
= DECL_ORIGIN (fun
);
5257 if (RECUR (fun
, rval
))
5258 /* Might end up being a constant function pointer. */;
5262 for (; i
< nargs
; ++i
)
5264 tree x
= get_nth_callarg (t
, i
);
5265 /* In a template, reference arguments haven't been converted to
5266 REFERENCE_TYPE and we might not even know if the parameter
5267 is a reference, so accept lvalue constants too. */
5268 bool rv
= processing_template_decl
? any
: rval
;
5269 /* Don't require an immediately constant value, as constexpr
5270 substitution might not use the value of the argument. */
5271 bool sub_now
= false;
5272 if (!potential_constant_expression_1 (x
, rv
, strict
,
5279 case NON_LVALUE_EXPR
:
5280 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5281 -- an lvalue of integral type that refers to a non-volatile
5282 const variable or static data member initialized with
5283 constant expressions, or
5285 -- an lvalue of literal type that refers to non-volatile
5286 object defined with constexpr, or that refers to a
5287 sub-object of such an object; */
5288 return RECUR (TREE_OPERAND (t
, 0), rval
);
5291 if (DECL_HAS_VALUE_EXPR_P (t
))
5292 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5294 && !var_in_maybe_constexpr_fn (t
)
5295 && !type_dependent_expression_p (t
)
5296 && !decl_maybe_constant_var_p (t
)
5298 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5299 || (DECL_INITIAL (t
)
5300 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5301 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5302 && !is_really_empty_class (TREE_TYPE (t
)))
5304 if (flags
& tf_error
)
5305 non_const_var_error (t
);
5312 case VIEW_CONVERT_EXPR
:
5313 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5314 may change to something more specific to type-punning (DR 1312). */
5316 tree from
= TREE_OPERAND (t
, 0);
5317 if (POINTER_TYPE_P (TREE_TYPE (t
))
5318 && TREE_CODE (from
) == INTEGER_CST
5319 && !integer_zerop (from
))
5321 if (flags
& tf_error
)
5322 error_at (loc
, "reinterpret_cast from integer to pointer");
5325 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5328 case ADDRESSOF_EXPR
:
5329 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5330 t
= TREE_OPERAND (t
, 0);
5331 goto handle_addr_expr
;
5334 /* -- a unary operator & that is applied to an lvalue that
5335 designates an object with thread or automatic storage
5337 t
= TREE_OPERAND (t
, 0);
5339 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5340 /* A pointer-to-member constant. */
5345 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5346 any checking here, as we might dereference the pointer later. If
5347 we remove this code, also remove check_automatic_or_tls. */
5348 i
= check_automatic_or_tls (t
);
5353 if (flags
& tf_error
)
5354 error ("address-of an object %qE with thread local or "
5355 "automatic storage is not a constant expression", t
);
5359 return RECUR (t
, any
);
5367 /* -- a class member access unless its postfix-expression is
5368 of literal type or of pointer to literal type. */
5369 /* This test would be redundant, as it follows from the
5370 postfix-expression being a potential constant expression. */
5371 if (type_unknown_p (t
))
5373 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5375 case EXPR_PACK_EXPANSION
:
5376 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5380 tree x
= TREE_OPERAND (t
, 0);
5382 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5384 if (!var_in_maybe_constexpr_fn (x
))
5386 if (flags
& tf_error
)
5387 error_at (loc
, "use of %<this%> in a constant expression");
5392 return RECUR (x
, rval
);
5395 case STATEMENT_LIST
:
5397 tree_stmt_iterator i
;
5398 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5400 if (!RECUR (tsi_stmt (i
), any
))
5408 if (cxx_dialect
< cxx14
)
5410 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5412 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5417 if (cxx_dialect
< cxx14
)
5419 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5421 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5426 if (!RECUR (DO_COND (t
), rval
))
5428 if (!RECUR (DO_BODY (t
), any
))
5433 if (!RECUR (FOR_INIT_STMT (t
), any
))
5435 if (!RECUR (FOR_COND (t
), rval
))
5437 if (!RECUR (FOR_EXPR (t
), any
))
5439 if (!RECUR (FOR_BODY (t
), any
))
5443 case RANGE_FOR_STMT
:
5444 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5446 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5451 if (!RECUR (WHILE_COND (t
), rval
))
5453 if (!RECUR (WHILE_BODY (t
), any
))
5458 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5460 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5461 unreachable labels would be checked. */
5465 return RECUR (STMT_EXPR_STMT (t
), rval
);
5468 case DYNAMIC_CAST_EXPR
:
5469 case PSEUDO_DTOR_EXPR
:
5473 case VEC_DELETE_EXPR
:
5478 case OMP_DISTRIBUTE
:
5481 case OMP_TARGET_DATA
:
5490 case OMP_TARGET_UPDATE
:
5491 case OMP_TARGET_ENTER_DATA
:
5492 case OMP_TARGET_EXIT_DATA
:
5494 case OMP_ATOMIC_READ
:
5495 case OMP_ATOMIC_CAPTURE_OLD
:
5496 case OMP_ATOMIC_CAPTURE_NEW
:
5500 case OACC_HOST_DATA
:
5504 case OACC_ENTER_DATA
:
5505 case OACC_EXIT_DATA
:
5509 /* GCC internal stuff. */
5512 case TRANSACTION_EXPR
:
5514 case AT_ENCODE_EXPR
:
5516 if (flags
& tf_error
)
5517 error_at (loc
, "expression %qE is not a constant expression", t
);
5521 /* -- a typeid expression whose operand is of polymorphic
5524 tree e
= TREE_OPERAND (t
, 0);
5525 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5526 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5528 if (flags
& tf_error
)
5529 error_at (loc
, "typeid-expression is not a constant expression "
5530 "because %qE is of polymorphic type", e
);
5549 case PREINCREMENT_EXPR
:
5550 case POSTINCREMENT_EXPR
:
5551 case PREDECREMENT_EXPR
:
5552 case POSTDECREMENT_EXPR
:
5553 if (cxx_dialect
< cxx14
)
5559 if (TYPE_P (TREE_OPERAND (t
, 0)))
5565 case FIX_TRUNC_EXPR
:
5569 case TRUTH_NOT_EXPR
:
5570 case FIXED_CONVERT_EXPR
:
5571 case UNARY_PLUS_EXPR
:
5572 case UNARY_LEFT_FOLD_EXPR
:
5573 case UNARY_RIGHT_FOLD_EXPR
:
5575 return RECUR (TREE_OPERAND (t
, 0), rval
);
5578 case CONST_CAST_EXPR
:
5579 case STATIC_CAST_EXPR
:
5580 case REINTERPRET_CAST_EXPR
:
5581 case IMPLICIT_CONV_EXPR
:
5582 if (cxx_dialect
< cxx11
5583 && !dependent_type_p (TREE_TYPE (t
))
5584 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5585 /* In C++98, a conversion to non-integral type can't be part of a
5586 constant expression. */
5588 if (flags
& tf_error
)
5590 "cast to non-integral type %qT in a constant expression",
5595 return (RECUR (TREE_OPERAND (t
, 0),
5596 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5599 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5601 case CLEANUP_POINT_EXPR
:
5602 case MUST_NOT_THROW_EXPR
:
5603 case TRY_CATCH_EXPR
:
5608 case NON_DEPENDENT_EXPR
:
5609 /* For convenience. */
5613 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5616 tmp
= DECL_EXPR_DECL (t
);
5617 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5619 if (TREE_STATIC (tmp
))
5621 if (flags
& tf_error
)
5622 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5623 "%<static%> in %<constexpr%> context", tmp
);
5626 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5628 if (flags
& tf_error
)
5629 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5630 "%<thread_local%> in %<constexpr%> context", tmp
);
5633 else if (!DECL_NONTRIVIALLY_INITIALIZED_P (tmp
))
5635 if (flags
& tf_error
)
5636 error_at (DECL_SOURCE_LOCATION (tmp
), "uninitialized "
5637 "variable %qD in %<constexpr%> context", tmp
);
5641 return RECUR (tmp
, want_rval
);
5643 case TRY_FINALLY_EXPR
:
5644 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5645 && RECUR (TREE_OPERAND (t
, 1), any
));
5648 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5651 if (!literal_type_p (TREE_TYPE (t
)))
5653 if (flags
& tf_error
)
5655 error_at (loc
, "temporary of non-literal type %qT in a "
5656 "constant expression", TREE_TYPE (t
));
5657 explain_non_literal_class (TREE_TYPE (t
));
5663 return RECUR (TREE_OPERAND (t
, 1), rval
);
5667 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5668 constructor_elt
*ce
;
5669 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5670 if (!RECUR (ce
->value
, want_rval
))
5677 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5678 || DECL_P (TREE_PURPOSE (t
)));
5679 if (!RECUR (TREE_VALUE (t
), want_rval
))
5681 if (TREE_CHAIN (t
) == NULL_TREE
)
5683 return RECUR (TREE_CHAIN (t
), want_rval
);
5686 case TRUNC_DIV_EXPR
:
5688 case FLOOR_DIV_EXPR
:
5689 case ROUND_DIV_EXPR
:
5690 case TRUNC_MOD_EXPR
:
5692 case ROUND_MOD_EXPR
:
5694 tree denom
= TREE_OPERAND (t
, 1);
5695 if (!RECUR (denom
, rval
))
5697 /* We can't call cxx_eval_outermost_constant_expr on an expression
5698 that hasn't been through instantiate_non_dependent_expr yet. */
5699 if (!processing_template_decl
)
5700 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5701 if (integer_zerop (denom
))
5703 if (flags
& tf_error
)
5704 error ("division by zero is not a constant expression");
5710 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5716 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5717 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5718 introduced by build_call_a. */
5719 tree op0
= TREE_OPERAND (t
, 0);
5720 tree op1
= TREE_OPERAND (t
, 1);
5722 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5723 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5724 return RECUR (op0
, want_rval
);
5729 /* If the first operand is the non-short-circuit constant, look at
5730 the second operand; otherwise we only care about the first one for
5732 case TRUTH_AND_EXPR
:
5733 case TRUTH_ANDIF_EXPR
:
5734 tmp
= boolean_true_node
;
5737 case TRUTH_ORIF_EXPR
:
5738 tmp
= boolean_false_node
;
5741 tree op
= TREE_OPERAND (t
, 0);
5742 if (!RECUR (op
, rval
))
5744 if (!processing_template_decl
)
5745 op
= cxx_eval_outermost_constant_expr (op
, true);
5746 if (tree_int_cst_equal (op
, tmp
))
5747 return RECUR (TREE_OPERAND (t
, 1), rval
);
5754 case POINTER_PLUS_EXPR
:
5756 case EXACT_DIV_EXPR
:
5766 case TRUTH_XOR_EXPR
:
5767 case UNORDERED_EXPR
:
5780 case ARRAY_RANGE_REF
:
5784 case BINARY_LEFT_FOLD_EXPR
:
5785 case BINARY_RIGHT_FOLD_EXPR
:
5787 for (i
= 0; i
< 2; ++i
)
5788 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5792 case CILK_SYNC_STMT
:
5793 case CILK_SPAWN_STMT
:
5794 case ARRAY_NOTATION_REF
:
5799 for (i
= 0; i
< 3; ++i
)
5800 if (!RECUR (TREE_OPERAND (t
, i
), true))
5805 if (COND_EXPR_IS_VEC_DELETE (t
))
5807 if (flags
& tf_error
)
5808 error_at (loc
, "%<delete[]%> is not a constant expression");
5814 /* If the condition is a known constant, we know which of the legs we
5815 care about; otherwise we only require that the condition and
5816 either of the legs be potentially constant. */
5817 tmp
= TREE_OPERAND (t
, 0);
5818 if (!RECUR (tmp
, rval
))
5820 if (!processing_template_decl
)
5821 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5822 if (integer_zerop (tmp
))
5823 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5824 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5825 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5826 for (i
= 1; i
< 3; ++i
)
5827 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5828 want_rval
, strict
, now
, tf_none
))
5830 if (flags
& tf_error
)
5831 error_at (loc
, "expression %qE is not a constant expression", t
);
5835 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5837 if (flags
& tf_error
)
5839 error_at (loc
, "non-constant array initialization");
5840 diagnose_non_constexpr_vec_init (t
);
5846 /* We can see these in statement-expressions. */
5850 case EMPTY_CLASS_EXPR
:
5856 tree
*target
= &TREE_OPERAND (t
, 0);
5857 /* Gotos representing break and continue are OK. */
5858 if (breaks (target
) || continues (target
))
5860 if (flags
& tf_error
)
5861 error_at (loc
, "%<goto%> is not a constant expression");
5866 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
5867 return RECUR (TREE_OPERAND (t
, 0), rval
);
5870 if (objc_is_property_ref (t
))
5873 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5880 /* The main entry point to the above. */
5883 potential_constant_expression (tree t
)
5885 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
5888 /* As above, but require a constant rvalue. */
5891 potential_rvalue_constant_expression (tree t
)
5893 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
5896 /* Like above, but complain about non-constant expressions. */
5899 require_potential_constant_expression (tree t
)
5901 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
5904 /* Cross product of the above. */
5907 require_potential_rvalue_constant_expression (tree t
)
5909 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
5912 /* Like potential_constant_expression, but don't consider possible constexpr
5913 substitution of the current function. That is, PARM_DECL qualifies under
5914 potential_constant_expression, but not here.
5916 This is basically what you can check when any actual constant values might
5917 be value-dependent. */
5920 is_constant_expression (tree t
)
5922 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
5925 /* Like above, but complain about non-constant expressions. */
5928 require_constant_expression (tree t
)
5930 return potential_constant_expression_1 (t
, false, true, true,
5931 tf_warning_or_error
);
5934 /* Like is_constant_expression, but allow const variables that are not allowed
5935 under constexpr rules. */
5938 is_static_init_expression (tree t
)
5940 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
5943 /* Returns true if T is a potential constant expression that is not
5944 instantiation-dependent, and therefore a candidate for constant folding even
5948 is_nondependent_constant_expression (tree t
)
5950 return (!type_unknown_p (t
)
5951 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5952 && is_constant_expression (t
)
5953 && !instantiation_dependent_expression_p (t
));
5956 /* Returns true if T is a potential static initializer expression that is not
5957 instantiation-dependent. */
5960 is_nondependent_static_init_expression (tree t
)
5962 return (!type_unknown_p (t
)
5963 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5964 && is_static_init_expression (t
)
5965 && !instantiation_dependent_expression_p (t
));
5968 /* Finalize constexpr processing after parsing. */
5971 fini_constexpr (void)
5973 /* The contexpr call and fundef copies tables are no longer needed. */
5974 constexpr_call_table
= NULL
;
5975 fundef_copies_table
= NULL
;
5978 #include "gt-cp-constexpr.h"