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 x
= build_address (x
);
1292 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1293 non_constant_p
, overflow_p
);
1294 /* Don't VERIFY_CONSTANT here. */
1295 if (*non_constant_p
&& ctx
->quiet
)
1297 /* Just discard ellipsis args after checking their constantitude. */
1301 if (!*non_constant_p
)
1303 /* Make sure the binding has the same type as the parm. But
1304 only for constant args. */
1305 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1306 arg
= adjust_temp_type (type
, arg
);
1307 if (!TREE_CONSTANT (arg
))
1308 *non_constant_args
= true;
1309 *p
= build_tree_list (parms
, arg
);
1310 p
= &TREE_CHAIN (*p
);
1312 parms
= TREE_CHAIN (parms
);
1316 /* Variables and functions to manage constexpr call expansion context.
1317 These do not need to be marked for PCH or GC. */
1319 /* FIXME remember and print actual constant arguments. */
1320 static vec
<tree
> call_stack
;
1321 static int call_stack_tick
;
1322 static int last_cx_error_tick
;
1325 push_cx_call_context (tree call
)
1328 if (!EXPR_HAS_LOCATION (call
))
1329 SET_EXPR_LOCATION (call
, input_location
);
1330 call_stack
.safe_push (call
);
1331 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1337 pop_cx_call_context (void)
1344 cx_error_context (void)
1346 vec
<tree
> r
= vNULL
;
1347 if (call_stack_tick
!= last_cx_error_tick
1348 && !call_stack
.is_empty ())
1350 last_cx_error_tick
= call_stack_tick
;
1354 /* Evaluate a call T to a GCC internal function when possible and return
1355 the evaluated result or, under the control of CTX, give an error, set
1356 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1359 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1361 bool *non_constant_p
, bool *overflow_p
)
1363 enum tree_code opcode
= ERROR_MARK
;
1365 switch (CALL_EXPR_IFN (t
))
1367 case IFN_UBSAN_NULL
:
1368 case IFN_UBSAN_BOUNDS
:
1369 case IFN_UBSAN_VPTR
:
1370 case IFN_FALLTHROUGH
:
1373 case IFN_ADD_OVERFLOW
:
1376 case IFN_SUB_OVERFLOW
:
1377 opcode
= MINUS_EXPR
;
1379 case IFN_MUL_OVERFLOW
:
1384 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1385 false, non_constant_p
, overflow_p
);
1389 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1390 "call to internal function %qE", t
);
1391 *non_constant_p
= true;
1395 /* Evaluate constant arguments using OPCODE and return a complex
1396 number containing the result and the overflow bit. */
1397 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1398 non_constant_p
, overflow_p
);
1399 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1400 non_constant_p
, overflow_p
);
1402 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1404 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1405 tree type
= TREE_TYPE (TREE_TYPE (t
));
1406 tree result
= fold_binary_loc (loc
, opcode
, type
,
1407 fold_convert_loc (loc
, type
, arg0
),
1408 fold_convert_loc (loc
, type
, arg1
));
1410 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1411 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1412 if (TREE_OVERFLOW (result
))
1413 TREE_OVERFLOW (result
) = 0;
1415 return build_complex (TREE_TYPE (t
), result
, ovf
);
1418 *non_constant_p
= true;
1422 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1425 clear_no_implicit_zero (tree ctor
)
1427 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1429 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1430 tree elt
; unsigned HOST_WIDE_INT idx
;
1431 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1432 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1433 clear_no_implicit_zero (elt
);
1437 /* Subroutine of cxx_eval_constant_expression.
1438 Evaluate the call expression tree T in the context of OLD_CALL expression
1442 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1444 bool *non_constant_p
, bool *overflow_p
)
1446 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1447 tree fun
= get_function_named_in_call (t
);
1448 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1451 if (fun
== NULL_TREE
)
1452 return cxx_eval_internal_function (ctx
, t
, lval
,
1453 non_constant_p
, overflow_p
);
1455 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1457 /* Might be a constexpr function pointer. */
1458 fun
= cxx_eval_constant_expression (ctx
, fun
,
1459 /*lval*/false, non_constant_p
,
1462 if (TREE_CODE (fun
) == ADDR_EXPR
)
1463 fun
= TREE_OPERAND (fun
, 0);
1465 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1467 if (!ctx
->quiet
&& !*non_constant_p
)
1468 error_at (loc
, "expression %qE does not designate a constexpr "
1470 *non_constant_p
= true;
1473 if (DECL_CLONED_FUNCTION_P (fun
))
1474 fun
= DECL_CLONED_FUNCTION (fun
);
1476 if (is_ubsan_builtin_p (fun
))
1479 if (is_builtin_fn (fun
))
1480 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1481 lval
, non_constant_p
, overflow_p
);
1482 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1486 if (!lambda_static_thunk_p (fun
))
1487 error_at (loc
, "call to non-constexpr function %qD", fun
);
1488 explain_invalid_constexpr_fn (fun
);
1490 *non_constant_p
= true;
1494 constexpr_ctx new_ctx
= *ctx
;
1495 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1496 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1498 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1499 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1500 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1501 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1502 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1503 ctx
->values
->put (new_ctx
.object
, ctor
);
1507 /* Shortcut trivial constructor/op=. */
1508 if (trivial_fn_p (fun
))
1510 tree init
= NULL_TREE
;
1511 if (call_expr_nargs (t
) == 2)
1512 init
= convert_from_reference (get_nth_callarg (t
, 1));
1513 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1514 && AGGR_INIT_ZERO_FIRST (t
))
1515 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1518 tree op
= get_nth_callarg (t
, 0);
1519 if (is_dummy_object (op
))
1522 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1523 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1524 new_ctx
.call
= &new_call
;
1525 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1526 non_constant_p
, overflow_p
);
1530 /* We can't defer instantiating the function any longer. */
1531 if (!DECL_INITIAL (fun
)
1532 && DECL_TEMPLOID_INSTANTIATION (fun
))
1534 location_t save_loc
= input_location
;
1535 input_location
= loc
;
1537 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1539 input_location
= save_loc
;
1542 /* If in direct recursive call, optimize definition search. */
1543 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1544 new_call
.fundef
= ctx
->call
->fundef
;
1547 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1548 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1549 || fun
== current_function_decl
)
1553 /* We need to check for current_function_decl here in case we're
1554 being called during cp_fold_function, because at that point
1555 DECL_INITIAL is set properly and we have a fundef but we
1556 haven't lowered invisirefs yet (c++/70344). */
1557 if (DECL_INITIAL (fun
) == error_mark_node
1558 || fun
== current_function_decl
)
1559 error_at (loc
, "%qD called in a constant expression before its "
1560 "definition is complete", fun
);
1561 else if (DECL_INITIAL (fun
))
1563 /* The definition of fun was somehow unsuitable. But pretend
1564 that lambda static thunks don't exist. */
1565 if (!lambda_static_thunk_p (fun
))
1566 error_at (loc
, "%qD called in a constant expression", fun
);
1567 explain_invalid_constexpr_fn (fun
);
1570 error_at (loc
, "%qD used before its definition", fun
);
1572 *non_constant_p
= true;
1577 bool non_constant_args
= false;
1578 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1579 non_constant_p
, overflow_p
, &non_constant_args
);
1580 if (*non_constant_p
)
1583 depth_ok
= push_cx_call_context (t
);
1585 tree result
= NULL_TREE
;
1587 constexpr_call
*entry
= NULL
;
1588 if (depth_ok
&& !non_constant_args
)
1590 new_call
.hash
= iterative_hash_template_arg
1591 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1593 /* If we have seen this call before, we are done. */
1594 maybe_initialize_constexpr_call_table ();
1595 constexpr_call
**slot
1596 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1600 /* We need to keep a pointer to the entry, not just the slot, as the
1601 slot can move in the call to cxx_eval_builtin_function_call. */
1602 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1605 /* Calls that are in progress have their result set to NULL,
1606 so that we can detect circular dependencies. */
1607 else if (entry
->result
== NULL
)
1610 error ("call has circular dependency");
1611 *non_constant_p
= true;
1612 entry
->result
= result
= error_mark_node
;
1615 result
= entry
->result
;
1621 error ("constexpr evaluation depth exceeds maximum of %d (use "
1622 "-fconstexpr-depth= to increase the maximum)",
1623 max_constexpr_depth
);
1624 *non_constant_p
= true;
1625 result
= error_mark_node
;
1629 if (result
&& result
!= error_mark_node
)
1631 else if (!DECL_SAVED_TREE (fun
))
1633 /* When at_eof >= 2, cgraph has started throwing away
1634 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1635 late code generation for VEC_INIT_EXPR, which needs to be
1636 completely reconsidered. */
1637 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1638 *non_constant_p
= true;
1642 tree body
, parms
, res
;
1644 /* Reuse or create a new unshared copy of this function's body. */
1645 tree copy
= get_fundef_copy (fun
);
1646 body
= TREE_PURPOSE (copy
);
1647 parms
= TREE_VALUE (copy
);
1648 res
= TREE_TYPE (copy
);
1650 /* Associate the bindings with the remapped parms. */
1651 tree bound
= new_call
.bindings
;
1652 tree remapped
= parms
;
1655 tree oparm
= TREE_PURPOSE (bound
);
1656 tree arg
= TREE_VALUE (bound
);
1657 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1658 /* Don't share a CONSTRUCTOR that might be changed. */
1659 arg
= unshare_constructor (arg
);
1660 ctx
->values
->put (remapped
, arg
);
1661 bound
= TREE_CHAIN (bound
);
1662 remapped
= DECL_CHAIN (remapped
);
1664 /* Add the RESULT_DECL to the values map, too. */
1665 tree slot
= NULL_TREE
;
1666 if (DECL_BY_REFERENCE (res
))
1668 slot
= AGGR_INIT_EXPR_SLOT (t
);
1669 tree addr
= build_address (slot
);
1670 addr
= build_nop (TREE_TYPE (res
), addr
);
1671 ctx
->values
->put (res
, addr
);
1672 ctx
->values
->put (slot
, NULL_TREE
);
1675 ctx
->values
->put (res
, NULL_TREE
);
1677 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1678 their values after the call. */
1679 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1680 hash_set
<tree
> save_exprs
;
1681 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1682 ctx_with_save_exprs
.call
= &new_call
;
1684 tree jump_target
= NULL_TREE
;
1685 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1686 lval
, non_constant_p
, overflow_p
,
1689 if (DECL_CONSTRUCTOR_P (fun
))
1690 /* This can be null for a subobject constructor call, in
1691 which case what we care about is the initialization
1692 side-effects rather than the value. We could get at the
1693 value by evaluating *this, but we don't bother; there's
1694 no need to put such a call in the hash table. */
1695 result
= lval
? ctx
->object
: ctx
->ctor
;
1696 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1700 result
= *ctx
->values
->get (slot
? slot
: res
);
1701 if (result
== NULL_TREE
&& !*non_constant_p
)
1704 error ("constexpr call flows off the end "
1706 *non_constant_p
= true;
1710 /* Forget the saved values of the callee's SAVE_EXPRs. */
1711 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1712 iter
!= save_exprs
.end(); ++iter
)
1713 ctx_with_save_exprs
.values
->remove (*iter
);
1715 /* Remove the parms/result from the values map. Is it worth
1716 bothering to do this when the map itself is only live for
1717 one constexpr evaluation? If so, maybe also clear out
1718 other vars from call, maybe in BIND_EXPR handling? */
1719 ctx
->values
->remove (res
);
1721 ctx
->values
->remove (slot
);
1722 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1723 ctx
->values
->remove (parm
);
1725 /* Make the unshared function copy we used available for re-use. */
1726 save_fundef_copy (fun
, copy
);
1729 if (result
== error_mark_node
)
1730 *non_constant_p
= true;
1731 if (*non_constant_p
|| *overflow_p
)
1732 result
= error_mark_node
;
1736 entry
->result
= result
;
1739 /* The result of a constexpr function must be completely initialized. */
1740 if (TREE_CODE (result
) == CONSTRUCTOR
)
1741 clear_no_implicit_zero (result
);
1743 pop_cx_call_context ();
1744 return unshare_constructor (result
);
1747 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1750 reduced_constant_expression_p (tree t
)
1752 switch (TREE_CODE (t
))
1755 /* Even if we can't lower this yet, it's constant. */
1759 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1760 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1761 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1762 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1765 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1768 /* We're in the middle of initializing this element. */
1770 if (!reduced_constant_expression_p (val
))
1776 field
= next_initializable_field (DECL_CHAIN (field
));
1781 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1782 /* All the fields are initialized. */
1783 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1787 /* FIXME are we calling this too much? */
1788 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1792 /* Some expressions may have constant operands but are not constant
1793 themselves, such as 1/0. Call this function (or rather, the macro
1794 following it) to check for that condition.
1796 We only call this in places that require an arithmetic constant, not in
1797 places where we might have a non-constant expression that can be a
1798 component of a constant expression, such as the address of a constexpr
1799 variable that might be dereferenced later. */
1802 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1805 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1807 if (!allow_non_constant
)
1808 error ("%q+E is not a constant expression", t
);
1809 *non_constant_p
= true;
1811 if (TREE_OVERFLOW_P (t
))
1813 if (!allow_non_constant
)
1815 permerror (input_location
, "overflow in constant expression");
1816 /* If we're being permissive (and are in an enforcing
1817 context), ignore the overflow. */
1818 if (flag_permissive
)
1819 return *non_constant_p
;
1823 return *non_constant_p
;
1826 /* Check whether the shift operation with code CODE and type TYPE on LHS
1827 and RHS is undefined. If it is, give an error with an explanation,
1828 and return true; return false otherwise. */
1831 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1832 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1834 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1835 || TREE_CODE (lhs
) != INTEGER_CST
1836 || TREE_CODE (rhs
) != INTEGER_CST
)
1839 tree lhstype
= TREE_TYPE (lhs
);
1840 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1842 /* [expr.shift] The behavior is undefined if the right operand
1843 is negative, or greater than or equal to the length in bits
1844 of the promoted left operand. */
1845 if (tree_int_cst_sgn (rhs
) == -1)
1848 permerror (loc
, "right operand of shift expression %q+E is negative",
1849 build2_loc (loc
, code
, type
, lhs
, rhs
));
1850 return (!flag_permissive
|| ctx
->quiet
);
1852 if (compare_tree_int (rhs
, uprec
) >= 0)
1855 permerror (loc
, "right operand of shift expression %q+E is >= than "
1856 "the precision of the left operand",
1857 build2_loc (loc
, code
, type
, lhs
, rhs
));
1858 return (!flag_permissive
|| ctx
->quiet
);
1861 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1862 if E1 has a signed type and non-negative value, and E1x2^E2 is
1863 representable in the corresponding unsigned type of the result type,
1864 then that value, converted to the result type, is the resulting value;
1865 otherwise, the behavior is undefined. */
1866 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1867 && (cxx_dialect
>= cxx11
))
1869 if (tree_int_cst_sgn (lhs
) == -1)
1873 "left operand of shift expression %q+E is negative",
1874 build2_loc (loc
, code
, type
, lhs
, rhs
));
1875 return (!flag_permissive
|| ctx
->quiet
);
1877 /* For signed x << y the following:
1878 (unsigned) x >> ((prec (lhs) - 1) - y)
1879 if > 1, is undefined. The right-hand side of this formula
1880 is the highest bit of the LHS that can be set (starting from 0),
1881 so that the shift doesn't overflow. We then right-shift the LHS
1882 to see whether any other bit is set making the original shift
1883 undefined -- the result is not representable in the corresponding
1885 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1886 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1887 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1888 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1889 if (tree_int_cst_lt (integer_one_node
, t
))
1892 permerror (loc
, "shift expression %q+E overflows",
1893 build2_loc (loc
, code
, type
, lhs
, rhs
));
1894 return (!flag_permissive
|| ctx
->quiet
);
1900 /* Subroutine of cxx_eval_constant_expression.
1901 Attempt to reduce the unary expression tree T to a compile time value.
1902 If successful, return the value. Otherwise issue a diagnostic
1903 and return error_mark_node. */
1906 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1908 bool *non_constant_p
, bool *overflow_p
)
1911 tree orig_arg
= TREE_OPERAND (t
, 0);
1912 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1913 non_constant_p
, overflow_p
);
1914 VERIFY_CONSTANT (arg
);
1915 location_t loc
= EXPR_LOCATION (t
);
1916 enum tree_code code
= TREE_CODE (t
);
1917 tree type
= TREE_TYPE (t
);
1918 r
= fold_unary_loc (loc
, code
, type
, arg
);
1921 if (arg
== orig_arg
)
1924 r
= build1_loc (loc
, code
, type
, arg
);
1926 VERIFY_CONSTANT (r
);
1930 /* Helper function for cxx_eval_binary_expression. Try to optimize
1931 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1932 generic folding should be used. */
1935 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1936 tree lhs
, tree rhs
, bool *non_constant_p
,
1940 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1943 lhs
= TREE_OPERAND (lhs
, 0);
1945 /* &A[i] p+ j => &A[i + j] */
1946 if (TREE_CODE (lhs
) == ARRAY_REF
1947 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1948 && TREE_CODE (rhs
) == INTEGER_CST
1949 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1950 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1952 tree orig_type
= TREE_TYPE (t
);
1953 location_t loc
= EXPR_LOCATION (t
);
1954 tree type
= TREE_TYPE (lhs
);
1956 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1957 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1958 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1960 if (*non_constant_p
)
1962 /* Don't fold an out-of-bound access. */
1963 if (!tree_int_cst_le (t
, nelts
))
1965 rhs
= cp_fold_convert (ssizetype
, rhs
);
1966 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1967 constexpr int A[1]; ... (char *)&A[0] + 1 */
1968 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1969 rhs
, TYPE_SIZE_UNIT (type
))))
1971 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1973 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1974 TYPE_SIZE_UNIT (type
));
1975 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1976 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1977 t
, NULL_TREE
, NULL_TREE
);
1978 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1979 t
= cp_fold_convert (orig_type
, t
);
1980 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1981 non_constant_p
, overflow_p
);
1987 /* Subroutine of cxx_eval_constant_expression.
1988 Like cxx_eval_unary_expression, except for binary expressions. */
1991 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1993 bool *non_constant_p
, bool *overflow_p
)
1996 tree orig_lhs
= TREE_OPERAND (t
, 0);
1997 tree orig_rhs
= TREE_OPERAND (t
, 1);
1999 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2000 non_constant_p
, overflow_p
);
2001 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2003 if (*non_constant_p
)
2005 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2006 non_constant_p
, overflow_p
);
2007 if (*non_constant_p
)
2010 location_t loc
= EXPR_LOCATION (t
);
2011 enum tree_code code
= TREE_CODE (t
);
2012 tree type
= TREE_TYPE (t
);
2014 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2016 bool is_code_eq
= (code
== EQ_EXPR
);
2018 if (TREE_CODE (lhs
) == PTRMEM_CST
2019 && TREE_CODE (rhs
) == PTRMEM_CST
)
2020 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2022 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2023 || TREE_CODE (rhs
) == PTRMEM_CST
)
2024 && (null_member_pointer_value_p (lhs
)
2025 || null_member_pointer_value_p (rhs
)))
2026 r
= constant_boolean_node (!is_code_eq
, type
);
2027 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2028 lhs
= cplus_expand_constant (lhs
);
2029 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2030 rhs
= cplus_expand_constant (rhs
);
2032 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2033 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2036 error ("arithmetic involving a null pointer in %qE", lhs
);
2039 else if (code
== POINTER_PLUS_EXPR
)
2040 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2044 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2048 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2051 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2053 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2054 *non_constant_p
= true;
2055 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2056 a local array in a constexpr function. */
2057 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2059 VERIFY_CONSTANT (r
);
2063 /* Subroutine of cxx_eval_constant_expression.
2064 Attempt to evaluate condition expressions. Dead branches are not
2068 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2070 bool *non_constant_p
, bool *overflow_p
,
2073 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2075 non_constant_p
, overflow_p
);
2076 VERIFY_CONSTANT (val
);
2077 /* Don't VERIFY_CONSTANT the other operands. */
2078 if (integer_zerop (val
))
2079 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2081 non_constant_p
, overflow_p
,
2083 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2085 non_constant_p
, overflow_p
,
2089 /* Returns less than, equal to, or greater than zero if KEY is found to be
2090 less than, to match, or to be greater than the constructor_elt's INDEX. */
2093 array_index_cmp (tree key
, tree index
)
2095 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2097 switch (TREE_CODE (index
))
2100 return tree_int_cst_compare (key
, index
);
2103 tree lo
= TREE_OPERAND (index
, 0);
2104 tree hi
= TREE_OPERAND (index
, 1);
2105 if (tree_int_cst_lt (key
, lo
))
2107 else if (tree_int_cst_lt (hi
, key
))
2117 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2118 if none. If INSERT is true, insert a matching element rather than fail. */
2120 static HOST_WIDE_INT
2121 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2123 if (tree_int_cst_sgn (dindex
) < 0)
2126 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2127 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2128 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2130 unsigned HOST_WIDE_INT end
= len
;
2131 unsigned HOST_WIDE_INT begin
= 0;
2133 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2134 that the same is true of the other elements and index directly. */
2137 tree cindex
= (*elts
)[end
-1].index
;
2138 if (TREE_CODE (cindex
) == INTEGER_CST
2139 && compare_tree_int (cindex
, end
-1) == 0)
2148 /* Otherwise, find a matching index by means of a binary search. */
2149 while (begin
!= end
)
2151 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2152 constructor_elt
&elt
= (*elts
)[middle
];
2153 tree idx
= elt
.index
;
2155 int cmp
= array_index_cmp (dindex
, idx
);
2162 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2164 /* We need to split the range. */
2166 tree lo
= TREE_OPERAND (idx
, 0);
2167 tree hi
= TREE_OPERAND (idx
, 1);
2168 if (tree_int_cst_lt (lo
, dindex
))
2170 /* There are still some lower elts; shorten the range. */
2171 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2173 if (tree_int_cst_equal (lo
, new_hi
))
2174 /* Only one element left, no longer a range. */
2177 TREE_OPERAND (idx
, 1) = new_hi
;
2178 /* Append the element we want to insert. */
2181 e
.value
= unshare_constructor (elt
.value
);
2182 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2185 /* No lower elts, the range elt is now ours. */
2188 if (tree_int_cst_lt (dindex
, hi
))
2190 /* There are still some higher elts; append a range. */
2191 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2193 if (tree_int_cst_equal (new_lo
, hi
))
2196 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2197 e
.value
= unshare_constructor (elt
.value
);
2198 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2207 constructor_elt e
= { dindex
, NULL_TREE
};
2208 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2215 /* Under the control of CTX, issue a detailed diagnostic for
2216 an out-of-bounds subscript INDEX into the expression ARRAY. */
2219 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2223 tree arraytype
= TREE_TYPE (array
);
2225 /* Convert the unsigned array subscript to a signed integer to avoid
2226 printing huge numbers for small negative values. */
2227 tree sidx
= fold_convert (ssizetype
, index
);
2230 error ("array subscript value %qE is outside the bounds "
2231 "of array %qD of type %qT", sidx
, array
, arraytype
);
2232 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2235 error ("array subscript value %qE is outside the bounds "
2236 "of array type %qT", sidx
, arraytype
);
2240 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2241 STRING_CST STRING. */
2244 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2246 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2249 if (chars_per_elt
== 1)
2250 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2253 const unsigned char *ptr
2254 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2255 + index
* chars_per_elt
);
2256 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2261 /* Subroutine of cxx_eval_constant_expression.
2262 Attempt to reduce a reference to an array slot. */
2265 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2267 bool *non_constant_p
, bool *overflow_p
)
2269 tree oldary
= TREE_OPERAND (t
, 0);
2270 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2272 non_constant_p
, overflow_p
);
2274 HOST_WIDE_INT i
= 0;
2275 tree elem_type
= NULL_TREE
;
2276 unsigned len
= 0, elem_nchars
= 1;
2277 if (*non_constant_p
)
2279 oldidx
= TREE_OPERAND (t
, 1);
2280 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2282 non_constant_p
, overflow_p
);
2283 VERIFY_CONSTANT (index
);
2286 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2287 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2288 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2289 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2290 ary
= TREE_OPERAND (ary
, 0);
2291 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2292 len
= CONSTRUCTOR_NELTS (ary
);
2293 else if (TREE_CODE (ary
) == STRING_CST
)
2295 elem_nchars
= (TYPE_PRECISION (elem_type
)
2296 / TYPE_PRECISION (char_type_node
));
2297 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2299 else if (TREE_CODE (ary
) == VECTOR_CST
)
2300 len
= VECTOR_CST_NELTS (ary
);
2303 /* We can't do anything with other tree codes, so use
2304 VERIFY_CONSTANT to complain and fail. */
2305 VERIFY_CONSTANT (ary
);
2309 if (!tree_fits_shwi_p (index
)
2310 || (i
= tree_to_shwi (index
)) < 0)
2312 diag_array_subscript (ctx
, ary
, index
);
2313 *non_constant_p
= true;
2319 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2320 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2321 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2322 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2326 /* For VLAs, the number of elements won't be an integer constant. */
2327 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2329 VERIFY_CONSTANT (nelts
);
2331 ? !tree_int_cst_le (index
, nelts
)
2332 : !tree_int_cst_lt (index
, nelts
))
2333 || tree_int_cst_sgn (index
) < 0)
2335 diag_array_subscript (ctx
, ary
, index
);
2336 *non_constant_p
= true;
2340 if (lval
&& ary
== oldary
&& index
== oldidx
)
2343 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2346 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2348 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2359 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2360 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2361 else if (TREE_CODE (ary
) == VECTOR_CST
)
2362 r
= VECTOR_CST_ELT (ary
, i
);
2364 r
= extract_string_elt (ary
, elem_nchars
, i
);
2367 /* Don't VERIFY_CONSTANT here. */
2370 /* Otherwise the element doesn't have a value yet. */
2375 if (TREE_CODE (ary
) == CONSTRUCTOR
2376 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2378 /* 'ary' is part of the aggregate initializer we're currently
2379 building; if there's no initializer for this element yet,
2382 error ("accessing uninitialized array element");
2383 *non_constant_p
= true;
2387 /* If it's within the array bounds but doesn't have an explicit
2388 initializer, it's value-initialized. */
2389 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2390 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2394 /* Subroutine of cxx_eval_constant_expression.
2395 Attempt to reduce a field access of a value of class type. */
2398 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2400 bool *non_constant_p
, bool *overflow_p
)
2402 unsigned HOST_WIDE_INT i
;
2405 tree part
= TREE_OPERAND (t
, 1);
2406 tree orig_whole
= TREE_OPERAND (t
, 0);
2407 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2409 non_constant_p
, overflow_p
);
2410 if (TREE_CODE (whole
) == INDIRECT_REF
2411 && integer_zerop (TREE_OPERAND (whole
, 0))
2413 error ("dereferencing a null pointer in %qE", orig_whole
);
2415 if (TREE_CODE (whole
) == PTRMEM_CST
)
2416 whole
= cplus_expand_constant (whole
);
2417 if (whole
== orig_whole
)
2420 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2421 whole
, part
, NULL_TREE
);
2422 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2424 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2427 error ("%qE is not a constant expression", orig_whole
);
2428 *non_constant_p
= true;
2430 if (DECL_MUTABLE_P (part
))
2433 error ("mutable %qD is not usable in a constant expression", part
);
2434 *non_constant_p
= true;
2436 if (*non_constant_p
)
2438 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2439 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2441 /* Use name match for PMF fields, as a variant will have a
2442 different FIELD_DECL with a different type. */
2443 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2449 /* We're in the middle of initializing it. */
2453 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2454 && CONSTRUCTOR_NELTS (whole
) > 0)
2456 /* DR 1188 says we don't have to deal with this. */
2458 error ("accessing %qD member instead of initialized %qD member in "
2459 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2460 *non_constant_p
= true;
2464 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2465 classes never get represented; throw together a value now. */
2466 if (is_really_empty_class (TREE_TYPE (t
)))
2467 return build_constructor (TREE_TYPE (t
), NULL
);
2469 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2471 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2473 /* 'whole' is part of the aggregate initializer we're currently
2474 building; if there's no initializer for this member yet, that's an
2477 error ("accessing uninitialized member %qD", part
);
2478 *non_constant_p
= true;
2482 /* If there's no explicit init for this field, it's value-initialized. */
2483 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2484 return cxx_eval_constant_expression (ctx
, value
,
2486 non_constant_p
, overflow_p
);
2489 /* Subroutine of cxx_eval_constant_expression.
2490 Attempt to reduce a field access of a value of class type that is
2491 expressed as a BIT_FIELD_REF. */
2494 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2496 bool *non_constant_p
, bool *overflow_p
)
2498 tree orig_whole
= TREE_OPERAND (t
, 0);
2499 tree retval
, fldval
, utype
, mask
;
2500 bool fld_seen
= false;
2501 HOST_WIDE_INT istart
, isize
;
2502 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2504 non_constant_p
, overflow_p
);
2505 tree start
, field
, value
;
2506 unsigned HOST_WIDE_INT i
;
2508 if (whole
== orig_whole
)
2510 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2512 if (!*non_constant_p
2513 && TREE_CODE (whole
) != VECTOR_CST
2514 && TREE_CODE (whole
) != CONSTRUCTOR
)
2517 error ("%qE is not a constant expression", orig_whole
);
2518 *non_constant_p
= true;
2520 if (*non_constant_p
)
2523 if (TREE_CODE (whole
) == VECTOR_CST
)
2524 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2525 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2527 start
= TREE_OPERAND (t
, 2);
2528 istart
= tree_to_shwi (start
);
2529 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2530 utype
= TREE_TYPE (t
);
2531 if (!TYPE_UNSIGNED (utype
))
2532 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2533 retval
= build_int_cst (utype
, 0);
2534 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2536 tree bitpos
= bit_position (field
);
2537 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2539 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2540 && TREE_CODE (value
) == INTEGER_CST
2541 && tree_fits_shwi_p (bitpos
)
2542 && tree_fits_shwi_p (DECL_SIZE (field
)))
2544 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2545 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2546 HOST_WIDE_INT shift
;
2547 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2549 fldval
= fold_convert (utype
, value
);
2550 mask
= build_int_cst_type (utype
, -1);
2551 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2552 size_int (TYPE_PRECISION (utype
) - sz
));
2553 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2554 size_int (TYPE_PRECISION (utype
) - sz
));
2555 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2556 shift
= bit
- istart
;
2557 if (BYTES_BIG_ENDIAN
)
2558 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2559 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2561 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2567 return fold_convert (TREE_TYPE (t
), retval
);
2569 return error_mark_node
;
2572 /* Subroutine of cxx_eval_constant_expression.
2573 Evaluate a short-circuited logical expression T in the context
2574 of a given constexpr CALL. BAILOUT_VALUE is the value for
2575 early return. CONTINUE_VALUE is used here purely for
2576 sanity check purposes. */
2579 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2580 tree bailout_value
, tree continue_value
,
2582 bool *non_constant_p
, bool *overflow_p
)
2585 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2587 non_constant_p
, overflow_p
);
2588 VERIFY_CONSTANT (lhs
);
2589 if (tree_int_cst_equal (lhs
, bailout_value
))
2591 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2592 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2593 lval
, non_constant_p
,
2595 VERIFY_CONSTANT (r
);
2599 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2600 CONSTRUCTOR elements to initialize (part of) an object containing that
2601 field. Return a pointer to the constructor_elt corresponding to the
2602 initialization of the field. */
2604 static constructor_elt
*
2605 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2607 tree aggr
= TREE_OPERAND (ref
, 0);
2608 tree field
= TREE_OPERAND (ref
, 1);
2610 constructor_elt
*ce
;
2612 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2614 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2616 constructor_elt
*base_ce
2617 = base_field_constructor_elt (v
, aggr
);
2618 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2621 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2622 if (ce
->index
== field
)
2629 /* Some of the expressions fed to the constexpr mechanism are calls to
2630 constructors, which have type void. In that case, return the type being
2631 initialized by the constructor. */
2634 initialized_type (tree t
)
2638 tree type
= cv_unqualified (TREE_TYPE (t
));
2639 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2641 /* A constructor call has void type, so we need to look deeper. */
2642 tree fn
= get_function_named_in_call (t
);
2643 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2644 && DECL_CXX_CONSTRUCTOR_P (fn
))
2645 type
= DECL_CONTEXT (fn
);
2650 /* We're about to initialize element INDEX of an array or class from VALUE.
2651 Set up NEW_CTX appropriately by adjusting .object to refer to the
2652 subobject and creating a new CONSTRUCTOR if the element is itself
2653 a class or array. */
2656 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2657 tree index
, tree
&value
)
2661 if (index
&& TREE_CODE (index
) != INTEGER_CST
2662 && TREE_CODE (index
) != FIELD_DECL
)
2663 /* This won't have an element in the new CONSTRUCTOR. */
2666 tree type
= initialized_type (value
);
2667 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2668 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2671 /* The sub-aggregate initializer might contain a placeholder;
2672 update object to refer to the subobject and ctor to refer to
2673 the (newly created) sub-initializer. */
2675 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2676 tree elt
= build_constructor (type
, NULL
);
2677 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2680 if (TREE_CODE (value
) == TARGET_EXPR
)
2681 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2682 value
= TARGET_EXPR_INITIAL (value
);
2685 /* We're about to process an initializer for a class or array TYPE. Make
2686 sure that CTX is set up appropriately. */
2689 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2691 /* We don't bother building a ctor for an empty base subobject. */
2692 if (is_empty_class (type
))
2695 /* We're in the middle of an initializer that might involve placeholders;
2696 our caller should have created a CONSTRUCTOR for us to put the
2697 initializer into. We will either return that constructor or T. */
2698 gcc_assert (ctx
->ctor
);
2699 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2700 (type
, TREE_TYPE (ctx
->ctor
)));
2701 /* We used to check that ctx->ctor was empty, but that isn't the case when
2702 the object is zero-initialized before calling the constructor. */
2705 tree otype
= TREE_TYPE (ctx
->object
);
2706 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2707 /* Handle flexible array members. */
2708 || (TREE_CODE (otype
) == ARRAY_TYPE
2709 && TYPE_DOMAIN (otype
) == NULL_TREE
2710 && TREE_CODE (type
) == ARRAY_TYPE
2711 && (same_type_ignoring_top_level_qualifiers_p
2712 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2714 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2715 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2718 /* Subroutine of cxx_eval_constant_expression.
2719 The expression tree T denotes a C-style array or a C-style
2720 aggregate. Reduce it to a constant expression. */
2723 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2725 bool *non_constant_p
, bool *overflow_p
)
2727 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2728 bool changed
= false;
2729 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2730 tree type
= TREE_TYPE (t
);
2732 constexpr_ctx new_ctx
;
2733 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2735 /* We don't really need the ctx->ctor business for a PMF or
2736 vector, but it's simpler to use the same code. */
2738 new_ctx
.ctor
= build_constructor (type
, NULL
);
2739 new_ctx
.object
= NULL_TREE
;
2742 verify_ctor_sanity (ctx
, type
);
2743 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2744 vec_alloc (*p
, vec_safe_length (v
));
2748 bool constant_p
= true;
2749 bool side_effects_p
= false;
2750 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2752 tree orig_value
= value
;
2753 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2754 if (new_ctx
.ctor
!= ctx
->ctor
)
2755 /* If we built a new CONSTRUCTOR, attach it now so that other
2756 initializers can refer to it. */
2757 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2758 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2760 non_constant_p
, overflow_p
);
2761 /* Don't VERIFY_CONSTANT here. */
2762 if (ctx
->quiet
&& *non_constant_p
)
2764 if (elt
!= orig_value
)
2767 if (!TREE_CONSTANT (elt
))
2769 if (TREE_SIDE_EFFECTS (elt
))
2770 side_effects_p
= true;
2771 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2773 /* This is an initialization of a vfield inside a base
2774 subaggregate that we already initialized; push this
2775 initialization into the previous initialization. */
2776 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2781 && (TREE_CODE (index
) == NOP_EXPR
2782 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2784 /* This is an initializer for an empty base; now that we've
2785 checked that it's constant, we can ignore it. */
2786 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2789 else if (new_ctx
.ctor
!= ctx
->ctor
)
2791 /* We appended this element above; update the value. */
2792 gcc_assert ((*p
)->last().index
== index
);
2793 (*p
)->last().value
= elt
;
2796 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2798 if (*non_constant_p
|| !changed
)
2801 /* We're done building this CONSTRUCTOR, so now we can interpret an
2802 element without an explicit initializer as value-initialized. */
2803 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2804 TREE_CONSTANT (t
) = constant_p
;
2805 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2806 if (VECTOR_TYPE_P (type
))
2811 /* Subroutine of cxx_eval_constant_expression.
2812 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2813 initialization of a non-static data member of array type. Reduce it to a
2816 Note that apart from value-initialization (when VALUE_INIT is true),
2817 this is only intended to support value-initialization and the
2818 initializations done by defaulted constructors for classes with
2819 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2820 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2821 for the copy/move constructor. */
2824 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2825 bool value_init
, bool lval
,
2826 bool *non_constant_p
, bool *overflow_p
)
2828 tree elttype
= TREE_TYPE (atype
);
2829 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2830 verify_ctor_sanity (ctx
, atype
);
2831 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2832 vec_alloc (*p
, max
+ 1);
2833 bool pre_init
= false;
2834 unsigned HOST_WIDE_INT i
;
2836 /* For the default constructor, build up a call to the default
2837 constructor of the element type. We only need to handle class types
2838 here, as for a constructor to be constexpr, all members must be
2839 initialized, which for a defaulted default constructor means they must
2840 be of a class type with a constexpr default constructor. */
2841 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2842 /* We only do this at the lowest level. */;
2843 else if (value_init
)
2845 init
= build_value_init (elttype
, tf_warning_or_error
);
2850 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2851 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2852 &argvec
, elttype
, LOOKUP_NORMAL
,
2853 tf_warning_or_error
);
2854 release_tree_vector (argvec
);
2855 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2859 for (i
= 0; i
< max
; ++i
)
2861 tree idx
= build_int_cst (size_type_node
, i
);
2864 constexpr_ctx new_ctx
;
2865 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2866 if (new_ctx
.ctor
!= ctx
->ctor
)
2867 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2868 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2870 /* A multidimensional array; recurse. */
2871 if (value_init
|| init
== NULL_TREE
)
2873 eltinit
= NULL_TREE
;
2877 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2878 tf_warning_or_error
);
2879 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2881 non_constant_p
, overflow_p
);
2885 /* Initializing an element using value or default initialization
2886 we just pre-built above. */
2887 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2888 non_constant_p
, overflow_p
);
2893 /* Copying an element. */
2894 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2895 (atype
, TREE_TYPE (init
)));
2896 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2897 tf_warning_or_error
);
2898 if (!lvalue_p (init
))
2899 eltinit
= move (eltinit
);
2900 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2901 eltinit
= (cxx_eval_constant_expression
2902 (&new_ctx
, eltinit
, lval
,
2903 non_constant_p
, overflow_p
));
2905 if (*non_constant_p
&& !ctx
->quiet
)
2907 if (new_ctx
.ctor
!= ctx
->ctor
)
2909 /* We appended this element above; update the value. */
2910 gcc_assert ((*p
)->last().index
== idx
);
2911 (*p
)->last().value
= eltinit
;
2914 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2915 /* Reuse the result of cxx_eval_constant_expression call
2916 from the first iteration to all others if it is a constant
2917 initializer that doesn't require relocations. */
2920 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2921 == null_pointer_node
))
2923 if (new_ctx
.ctor
!= ctx
->ctor
)
2924 eltinit
= new_ctx
.ctor
;
2925 for (i
= 1; i
< max
; ++i
)
2927 idx
= build_int_cst (size_type_node
, i
);
2928 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2934 if (!*non_constant_p
)
2937 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2943 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2945 bool *non_constant_p
, bool *overflow_p
)
2947 tree atype
= TREE_TYPE (t
);
2948 tree init
= VEC_INIT_EXPR_INIT (t
);
2949 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2950 VEC_INIT_EXPR_VALUE_INIT (t
),
2951 lval
, non_constant_p
, overflow_p
);
2952 if (*non_constant_p
)
2958 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2959 match. We want to be less strict for simple *& folding; if we have a
2960 non-const temporary that we access through a const pointer, that should
2961 work. We handle this here rather than change fold_indirect_ref_1
2962 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2963 don't really make sense outside of constant expression evaluation. Also
2964 we want to allow folding to COMPONENT_REF, which could cause trouble
2965 with TBAA in fold_indirect_ref_1.
2967 Try to keep this function synced with fold_indirect_ref_1. */
2970 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2976 subtype
= TREE_TYPE (sub
);
2977 if (!POINTER_TYPE_P (subtype
))
2980 if (TREE_CODE (sub
) == ADDR_EXPR
)
2982 tree op
= TREE_OPERAND (sub
, 0);
2983 tree optype
= TREE_TYPE (op
);
2985 /* *&CONST_DECL -> to the value of the const decl. */
2986 if (TREE_CODE (op
) == CONST_DECL
)
2987 return DECL_INITIAL (op
);
2988 /* *&p => p; make sure to handle *&"str"[cst] here. */
2989 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2990 /* Also handle the case where the desired type is an array of unknown
2991 bounds because the variable has had its bounds deduced since the
2992 ADDR_EXPR was created. */
2993 || (TREE_CODE (type
) == ARRAY_TYPE
2994 && TREE_CODE (optype
) == ARRAY_TYPE
2995 && TYPE_DOMAIN (type
) == NULL_TREE
2996 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
2999 tree fop
= fold_read_from_constant_string (op
);
3005 /* *(foo *)&fooarray => fooarray[0] */
3006 else if (TREE_CODE (optype
) == ARRAY_TYPE
3007 && (same_type_ignoring_top_level_qualifiers_p
3008 (type
, TREE_TYPE (optype
))))
3010 tree type_domain
= TYPE_DOMAIN (optype
);
3011 tree min_val
= size_zero_node
;
3012 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3013 min_val
= TYPE_MIN_VALUE (type_domain
);
3014 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3015 NULL_TREE
, NULL_TREE
);
3017 /* *(foo *)&complexfoo => __real__ complexfoo */
3018 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3019 && (same_type_ignoring_top_level_qualifiers_p
3020 (type
, TREE_TYPE (optype
))))
3021 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3022 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3023 else if (VECTOR_TYPE_P (optype
)
3024 && (same_type_ignoring_top_level_qualifiers_p
3025 (type
, TREE_TYPE (optype
))))
3027 tree part_width
= TYPE_SIZE (type
);
3028 tree index
= bitsize_int (0);
3029 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
3031 /* Also handle conversion to an empty base class, which
3032 is represented with a NOP_EXPR. */
3033 else if (is_empty_class (type
)
3034 && CLASS_TYPE_P (optype
)
3035 && DERIVED_FROM_P (type
, optype
))
3040 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3041 else if (RECORD_OR_UNION_TYPE_P (optype
))
3043 tree field
= TYPE_FIELDS (optype
);
3044 for (; field
; field
= DECL_CHAIN (field
))
3045 if (TREE_CODE (field
) == FIELD_DECL
3046 && TREE_TYPE (field
) != error_mark_node
3047 && integer_zerop (byte_position (field
))
3048 && (same_type_ignoring_top_level_qualifiers_p
3049 (TREE_TYPE (field
), type
)))
3050 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3053 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3054 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
3056 tree op00
= TREE_OPERAND (sub
, 0);
3057 tree op01
= TREE_OPERAND (sub
, 1);
3060 if (TREE_CODE (op00
) == ADDR_EXPR
)
3063 op00
= TREE_OPERAND (op00
, 0);
3064 op00type
= TREE_TYPE (op00
);
3066 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3067 if (VECTOR_TYPE_P (op00type
)
3068 && (same_type_ignoring_top_level_qualifiers_p
3069 (type
, TREE_TYPE (op00type
))))
3071 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
3072 tree part_width
= TYPE_SIZE (type
);
3073 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
3074 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
3075 tree index
= bitsize_int (indexi
);
3077 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
3078 return fold_build3_loc (loc
,
3079 BIT_FIELD_REF
, type
, op00
,
3083 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3084 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3085 && (same_type_ignoring_top_level_qualifiers_p
3086 (type
, TREE_TYPE (op00type
))))
3088 tree size
= TYPE_SIZE_UNIT (type
);
3089 if (tree_int_cst_equal (size
, op01
))
3090 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3092 /* ((foo *)&fooarray)[1] => fooarray[1] */
3093 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3094 && (same_type_ignoring_top_level_qualifiers_p
3095 (type
, TREE_TYPE (op00type
))))
3097 tree type_domain
= TYPE_DOMAIN (op00type
);
3098 tree min_val
= size_zero_node
;
3099 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3100 min_val
= TYPE_MIN_VALUE (type_domain
);
3101 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
3102 TYPE_SIZE_UNIT (type
));
3103 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
3104 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3105 NULL_TREE
, NULL_TREE
);
3107 /* Also handle conversion to an empty base class, which
3108 is represented with a NOP_EXPR. */
3109 else if (is_empty_class (type
)
3110 && CLASS_TYPE_P (op00type
)
3111 && DERIVED_FROM_P (type
, op00type
))
3116 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3117 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3119 tree field
= TYPE_FIELDS (op00type
);
3120 for (; field
; field
= DECL_CHAIN (field
))
3121 if (TREE_CODE (field
) == FIELD_DECL
3122 && TREE_TYPE (field
) != error_mark_node
3123 && tree_int_cst_equal (byte_position (field
), op01
)
3124 && (same_type_ignoring_top_level_qualifiers_p
3125 (TREE_TYPE (field
), type
)))
3126 return fold_build3 (COMPONENT_REF
, type
, op00
,
3131 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3132 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3133 && (same_type_ignoring_top_level_qualifiers_p
3134 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3137 tree min_val
= size_zero_node
;
3138 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3142 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3143 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3144 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3145 min_val
= TYPE_MIN_VALUE (type_domain
);
3146 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3154 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3156 bool *non_constant_p
, bool *overflow_p
)
3158 tree orig_op0
= TREE_OPERAND (t
, 0);
3159 bool empty_base
= false;
3161 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3162 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3164 if (TREE_CODE (t
) == MEM_REF
3165 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3167 gcc_assert (ctx
->quiet
);
3168 *non_constant_p
= true;
3172 /* First try to simplify it directly. */
3173 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3177 /* If that didn't work, evaluate the operand first. */
3178 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3179 /*lval*/false, non_constant_p
,
3181 /* Don't VERIFY_CONSTANT here. */
3182 if (*non_constant_p
)
3185 if (!lval
&& integer_zerop (op0
))
3188 error ("dereferencing a null pointer");
3189 *non_constant_p
= true;
3193 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3197 /* We couldn't fold to a constant value. Make sure it's not
3198 something we should have been able to fold. */
3201 if (TREE_CODE (sub
) == ADDR_EXPR
)
3203 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3204 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3205 /* DR 1188 says we don't have to deal with this. */
3207 error ("accessing value of %qE through a %qT glvalue in a "
3208 "constant expression", build_fold_indirect_ref (sub
),
3210 *non_constant_p
= true;
3214 if (lval
&& op0
!= orig_op0
)
3215 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3217 VERIFY_CONSTANT (t
);
3222 r
= cxx_eval_constant_expression (ctx
, r
,
3223 lval
, non_constant_p
, overflow_p
);
3224 if (*non_constant_p
)
3227 /* If we're pulling out the value of an empty base, just return an empty
3229 if (empty_base
&& !lval
)
3231 r
= build_constructor (TREE_TYPE (t
), NULL
);
3232 TREE_CONSTANT (r
) = true;
3238 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3239 Shared between potential_constant_expression and
3240 cxx_eval_constant_expression. */
3243 non_const_var_error (tree r
)
3245 tree type
= TREE_TYPE (r
);
3246 error ("the value of %qD is not usable in a constant "
3248 /* Avoid error cascade. */
3249 if (DECL_INITIAL (r
) == error_mark_node
)
3251 if (DECL_DECLARED_CONSTEXPR_P (r
))
3252 inform (DECL_SOURCE_LOCATION (r
),
3253 "%qD used in its own initializer", r
);
3254 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3256 if (!CP_TYPE_CONST_P (type
))
3257 inform (DECL_SOURCE_LOCATION (r
),
3258 "%q#D is not const", r
);
3259 else if (CP_TYPE_VOLATILE_P (type
))
3260 inform (DECL_SOURCE_LOCATION (r
),
3261 "%q#D is volatile", r
);
3262 else if (!DECL_INITIAL (r
)
3263 || !TREE_CONSTANT (DECL_INITIAL (r
))
3264 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3265 inform (DECL_SOURCE_LOCATION (r
),
3266 "%qD was not initialized with a constant "
3271 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3272 inform (DECL_SOURCE_LOCATION (r
),
3273 "%qD was not initialized with a constant "
3277 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3278 inform (DECL_SOURCE_LOCATION (r
),
3279 "%qD was not declared %<constexpr%>", r
);
3281 inform (DECL_SOURCE_LOCATION (r
),
3282 "%qD does not have integral or enumeration type",
3287 /* Subroutine of cxx_eval_constant_expression.
3288 Like cxx_eval_unary_expression, except for trinary expressions. */
3291 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3293 bool *non_constant_p
, bool *overflow_p
)
3299 for (i
= 0; i
< 3; i
++)
3301 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3303 non_constant_p
, overflow_p
);
3304 VERIFY_CONSTANT (args
[i
]);
3307 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3308 args
[0], args
[1], args
[2]);
3309 if (val
== NULL_TREE
)
3311 VERIFY_CONSTANT (val
);
3315 /* True if T was declared in a function declared to be constexpr, and
3316 therefore potentially constant in C++14. */
3319 var_in_constexpr_fn (tree t
)
3321 tree ctx
= DECL_CONTEXT (t
);
3322 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3323 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3326 /* True if T was declared in a function that might be constexpr: either a
3327 function that was declared constexpr, or a C++17 lambda op(). */
3330 var_in_maybe_constexpr_fn (tree t
)
3332 if (cxx_dialect
>= cxx17
3333 && DECL_FUNCTION_SCOPE_P (t
)
3334 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3336 return var_in_constexpr_fn (t
);
3339 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3340 build_over_call we implement trivial copy of a class with tail padding using
3341 assignment of character arrays, which is valid in normal code, but not in
3342 constexpr evaluation. We don't need to worry about clobbering tail padding
3343 in constexpr evaluation, so strip the type punning. */
3346 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3348 if (TREE_CODE (target
) == MEM_REF
3349 && TREE_CODE (init
) == MEM_REF
3350 && TREE_TYPE (target
) == TREE_TYPE (init
)
3351 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3352 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3354 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3355 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3359 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3362 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3364 bool *non_constant_p
, bool *overflow_p
)
3366 constexpr_ctx new_ctx
= *ctx
;
3368 tree init
= TREE_OPERAND (t
, 1);
3369 if (TREE_CLOBBER_P (init
))
3370 /* Just ignore clobbers. */
3373 /* First we figure out where we're storing to. */
3374 tree target
= TREE_OPERAND (t
, 0);
3376 maybe_simplify_trivial_copy (target
, init
);
3378 tree type
= TREE_TYPE (target
);
3379 target
= cxx_eval_constant_expression (ctx
, target
,
3381 non_constant_p
, overflow_p
);
3382 if (*non_constant_p
)
3385 /* cxx_eval_array_reference for lval = true allows references one past
3386 end of array, because it does not know if it is just taking address
3387 (which is valid), or actual dereference. Here we know it is
3388 a dereference, so diagnose it here. */
3389 for (tree probe
= target
; probe
; )
3391 switch (TREE_CODE (probe
))
3395 ary
= TREE_OPERAND (probe
, 0);
3396 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3397 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3398 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3399 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3402 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3403 non_constant_p
, overflow_p
);
3404 VERIFY_CONSTANT (nelts
);
3405 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3406 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3407 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3409 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3410 *non_constant_p
= true;
3417 probe
= TREE_OPERAND (probe
, 0);
3426 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3428 /* For initialization of an empty base, the original target will be
3429 *(base*)this, which the above evaluation resolves to the object
3430 argument, which has the derived type rather than the base type. In
3431 this situation, just evaluate the initializer and return, since
3432 there's no actual data to store. */
3433 gcc_assert (is_empty_class (type
));
3434 return cxx_eval_constant_expression (ctx
, init
, false,
3435 non_constant_p
, overflow_p
);
3438 /* And then find the underlying variable. */
3439 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3440 tree object
= NULL_TREE
;
3441 for (tree probe
= target
; object
== NULL_TREE
; )
3443 switch (TREE_CODE (probe
))
3448 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3449 vec_safe_push (refs
, TREE_TYPE (probe
));
3450 probe
= TREE_OPERAND (probe
, 0);
3458 /* And then find/build up our initializer for the path to the subobject
3459 we're initializing. */
3461 if (object
== ctx
->object
&& VAR_P (object
)
3462 && DECL_NAME (object
) && ctx
->call
== NULL
)
3463 /* The variable we're building up an aggregate initializer for is outside
3464 the constant-expression, so don't evaluate the store. We check
3465 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3467 else if (DECL_P (object
))
3468 valp
= ctx
->values
->get (object
);
3473 /* A constant-expression cannot modify objects from outside the
3474 constant-expression. */
3476 error ("modification of %qE is not a constant expression", object
);
3477 *non_constant_p
= true;
3480 type
= TREE_TYPE (object
);
3481 bool no_zero_init
= true;
3483 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3484 while (!refs
->is_empty())
3486 if (*valp
== NULL_TREE
)
3488 *valp
= build_constructor (type
, NULL
);
3489 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3491 else if (TREE_CODE (*valp
) == STRING_CST
)
3493 /* An array was initialized with a string constant, and now
3494 we're writing into one of its elements. Explode the
3495 single initialization into a set of element
3497 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3499 tree string
= *valp
;
3500 tree elt_type
= TREE_TYPE (type
);
3501 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3502 / TYPE_PRECISION (char_type_node
));
3503 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3504 tree ary_ctor
= build_constructor (type
, NULL
);
3506 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3507 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3509 constructor_elt elt
=
3511 build_int_cst (size_type_node
, ix
),
3512 extract_string_elt (string
, chars_per_elt
, ix
)
3514 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3520 /* If the value of object is already zero-initialized, any new ctors for
3521 subobjects will also be zero-initialized. */
3522 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3524 vec_safe_push (ctors
, *valp
);
3526 enum tree_code code
= TREE_CODE (type
);
3528 tree index
= refs
->pop();
3530 constructor_elt
*cep
= NULL
;
3531 if (code
== ARRAY_TYPE
)
3534 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3535 gcc_assert (i
>= 0);
3536 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3537 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3541 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3543 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3544 Usually we meet initializers in that order, but it is
3545 possible for base types to be placed not in program
3547 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3548 unsigned HOST_WIDE_INT idx
;
3550 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3551 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3552 /* Changing active member. */
3553 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3556 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3557 idx
++, fields
= DECL_CHAIN (fields
))
3559 if (index
== cep
->index
)
3562 /* The field we're initializing must be on the field
3563 list. Look to see if it is present before the
3564 field the current ELT initializes. */
3565 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3566 if (index
== fields
)
3570 /* We fell off the end of the CONSTRUCTOR, so insert a new
3571 entry at the end. */
3574 constructor_elt ce
= { index
, NULL_TREE
};
3576 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3577 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3583 release_tree_vector (refs
);
3585 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3587 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3588 wants to modify it. */
3589 if (*valp
== NULL_TREE
)
3591 *valp
= build_constructor (type
, NULL
);
3592 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3594 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3595 *valp
= cplus_expand_constant (*valp
);
3596 new_ctx
.ctor
= *valp
;
3597 new_ctx
.object
= target
;
3600 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3601 non_constant_p
, overflow_p
);
3602 /* Don't share a CONSTRUCTOR that might be changed later. */
3603 init
= unshare_constructor (init
);
3604 if (target
== object
)
3605 /* The hash table might have moved since the get earlier. */
3606 valp
= ctx
->values
->get (object
);
3608 if (TREE_CODE (init
) == CONSTRUCTOR
)
3610 /* An outer ctx->ctor might be pointing to *valp, so replace
3612 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3613 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3614 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3615 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3616 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3621 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3622 CONSTRUCTORs, if any. */
3625 bool c
= TREE_CONSTANT (init
);
3626 bool s
= TREE_SIDE_EFFECTS (init
);
3628 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3631 TREE_CONSTANT (elt
) = false;
3633 TREE_SIDE_EFFECTS (elt
) = true;
3635 release_tree_vector (ctors
);
3637 if (*non_constant_p
)
3645 /* Evaluate a ++ or -- expression. */
3648 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3650 bool *non_constant_p
, bool *overflow_p
)
3652 enum tree_code code
= TREE_CODE (t
);
3653 tree type
= TREE_TYPE (t
);
3654 tree op
= TREE_OPERAND (t
, 0);
3655 tree offset
= TREE_OPERAND (t
, 1);
3656 gcc_assert (TREE_CONSTANT (offset
));
3658 /* The operand as an lvalue. */
3659 op
= cxx_eval_constant_expression (ctx
, op
, true,
3660 non_constant_p
, overflow_p
);
3662 /* The operand as an rvalue. */
3664 = cxx_eval_constant_expression (ctx
, op
, false,
3665 non_constant_p
, overflow_p
);
3666 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3667 a local array in a constexpr function. */
3668 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3670 VERIFY_CONSTANT (val
);
3672 /* The modified value. */
3673 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3675 if (POINTER_TYPE_P (type
))
3677 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3678 offset
= convert_to_ptrofftype (offset
);
3680 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3681 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3684 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3686 VERIFY_CONSTANT (mod
);
3688 /* Storing the modified value. */
3689 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3690 cxx_eval_constant_expression (ctx
, store
,
3691 true, non_constant_p
, overflow_p
);
3693 /* And the value of the expression. */
3694 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3696 /* Prefix ops are lvalues. */
3700 /* But we optimize when the caller wants an rvalue. */
3704 /* Postfix ops are rvalues. */
3708 /* Predicates for the meaning of *jump_target. */
3711 returns (tree
*jump_target
)
3714 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3715 || (TREE_CODE (*jump_target
) == LABEL_DECL
3716 && LABEL_DECL_CDTOR (*jump_target
)));
3720 breaks (tree
*jump_target
)
3723 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3724 && LABEL_DECL_BREAK (*jump_target
))
3725 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3729 continues (tree
*jump_target
)
3732 && TREE_CODE (*jump_target
) == LABEL_DECL
3733 && LABEL_DECL_CONTINUE (*jump_target
);
3737 switches (tree
*jump_target
)
3740 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3743 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3744 STMT matches *jump_target. If we're looking for a case label and we see
3745 the default label, note it in ctx->css_state. */
3748 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3750 switch (TREE_CODE (*jump_target
))
3753 if (TREE_CODE (stmt
) == LABEL_EXPR
3754 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3759 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3761 gcc_assert (ctx
->css_state
!= NULL
);
3762 if (!CASE_LOW (stmt
))
3764 /* default: should appear just once in a SWITCH_EXPR
3765 body (excluding nested SWITCH_EXPR). */
3766 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3767 /* When evaluating SWITCH_EXPR body for the second time,
3768 return true for the default: label. */
3769 if (*ctx
->css_state
== css_default_processing
)
3771 *ctx
->css_state
= css_default_seen
;
3773 else if (CASE_HIGH (stmt
))
3775 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3776 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3779 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3790 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3791 semantics, for switch, break, continue, and return. */
3794 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3795 bool *non_constant_p
, bool *overflow_p
,
3798 tree_stmt_iterator i
;
3800 /* In a statement-expression we want to return the last value.
3801 For empty statement expression return void_node. */
3805 local_target
= NULL_TREE
;
3806 jump_target
= &local_target
;
3808 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3810 tree stmt
= tsi_stmt (i
);
3811 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3812 non_constant_p
, overflow_p
,
3814 if (*non_constant_p
)
3816 if (returns (jump_target
) || breaks (jump_target
))
3822 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3823 semantics; continue semantics are covered by cxx_eval_statement_list. */
3826 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3827 bool *non_constant_p
, bool *overflow_p
,
3830 constexpr_ctx new_ctx
= *ctx
;
3832 tree body
= TREE_OPERAND (t
, 0);
3836 hash_set
<tree
> save_exprs
;
3837 new_ctx
.save_exprs
= &save_exprs
;
3839 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3840 non_constant_p
, overflow_p
, jump_target
);
3842 /* Forget saved values of SAVE_EXPRs. */
3843 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3844 iter
!= save_exprs
.end(); ++iter
)
3845 new_ctx
.values
->remove (*iter
);
3846 if (++count
>= constexpr_loop_limit
)
3849 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3850 "constexpr loop iteration count exceeds limit of %d "
3851 "(use -fconstexpr-loop-limit= to increase the limit)",
3852 constexpr_loop_limit
);
3853 *non_constant_p
= true;
3857 while (!returns (jump_target
)
3858 && !breaks (jump_target
)
3859 && !switches (jump_target
)
3860 && !*non_constant_p
);
3862 if (breaks (jump_target
))
3863 *jump_target
= NULL_TREE
;
3868 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3872 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3873 bool *non_constant_p
, bool *overflow_p
,
3876 tree cond
= TREE_OPERAND (t
, 0);
3877 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3878 non_constant_p
, overflow_p
);
3879 VERIFY_CONSTANT (cond
);
3880 *jump_target
= cond
;
3882 tree body
= TREE_OPERAND (t
, 1);
3883 constexpr_ctx new_ctx
= *ctx
;
3884 constexpr_switch_state css
= css_default_not_seen
;
3885 new_ctx
.css_state
= &css
;
3886 cxx_eval_constant_expression (&new_ctx
, body
, false,
3887 non_constant_p
, overflow_p
, jump_target
);
3888 if (switches (jump_target
) && css
== css_default_seen
)
3890 /* If the SWITCH_EXPR body has default: label, process it once again,
3891 this time instructing label_matches to return true for default:
3892 label on switches (jump_target). */
3893 css
= css_default_processing
;
3894 cxx_eval_constant_expression (&new_ctx
, body
, false,
3895 non_constant_p
, overflow_p
, jump_target
);
3897 if (breaks (jump_target
) || switches (jump_target
))
3898 *jump_target
= NULL_TREE
;
3902 /* Find the object of TYPE under initialization in CTX. */
3905 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3910 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3911 can is a minor optimization. */
3912 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
3918 /* Since an object cannot have a field of its own type, we can search outward
3919 from ctx->object to find the unique containing object of TYPE. */
3920 tree ob
= ctx
->object
;
3923 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
3925 if (handled_component_p (ob
))
3926 ob
= TREE_OPERAND (ob
, 0);
3934 /* Attempt to reduce the expression T to a constant value.
3935 On failure, issue diagnostic and return error_mark_node. */
3936 /* FIXME unify with c_fully_fold */
3937 /* FIXME overflow_p is too global */
3940 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3942 bool *non_constant_p
, bool *overflow_p
,
3945 constexpr_ctx new_ctx
;
3948 if (jump_target
&& *jump_target
)
3950 /* If we are jumping, ignore all statements/expressions except those
3951 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
3952 switch (TREE_CODE (t
))
3955 case STATEMENT_LIST
:
3960 case CASE_LABEL_EXPR
:
3961 if (label_matches (ctx
, jump_target
, t
))
3963 *jump_target
= NULL_TREE
;
3969 if (t
== error_mark_node
)
3971 *non_constant_p
= true;
3974 if (CONSTANT_CLASS_P (t
))
3976 if (TREE_OVERFLOW (t
))
3979 permerror (input_location
, "overflow in constant expression");
3980 if (!flag_permissive
|| ctx
->quiet
)
3984 if (TREE_CODE (t
) == INTEGER_CST
3985 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
3986 && !integer_zerop (t
))
3989 error ("value %qE of type %qT is not a constant expression",
3991 *non_constant_p
= true;
3997 tree_code tcode
= TREE_CODE (t
);
4003 /* We ask for an rvalue for the RESULT_DECL when indirecting
4004 through an invisible reference, or in named return value
4006 return (*ctx
->values
->get (t
));
4009 if (DECL_HAS_VALUE_EXPR_P (t
))
4010 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4011 lval
, non_constant_p
, overflow_p
);
4014 /* We used to not check lval for CONST_DECL, but darwin.c uses
4015 CONST_DECL for aggregate constants. */
4018 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4019 && is_really_empty_class (TREE_TYPE (t
)))
4021 /* If the class is empty, we aren't actually loading anything. */
4022 r
= build_constructor (TREE_TYPE (t
), NULL
);
4023 TREE_CONSTANT (r
) = true;
4025 else if (ctx
->strict
)
4026 r
= decl_really_constant_value (t
);
4028 r
= decl_constant_value (t
);
4029 if (TREE_CODE (r
) == TARGET_EXPR
4030 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4031 r
= TARGET_EXPR_INITIAL (r
);
4033 if (tree
*p
= ctx
->values
->get (r
))
4034 if (*p
!= NULL_TREE
)
4039 non_const_var_error (r
);
4040 *non_constant_p
= true;
4048 case CASE_LABEL_EXPR
:
4053 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4055 else if (tree
*p
= ctx
->values
->get (r
))
4058 /* Defer in case this is only used for its type. */;
4059 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4060 /* Defer, there's no lvalue->rvalue conversion. */;
4061 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4062 && is_really_empty_class (TREE_TYPE (t
)))
4064 /* If the class is empty, we aren't actually loading anything. */
4065 r
= build_constructor (TREE_TYPE (t
), NULL
);
4066 TREE_CONSTANT (r
) = true;
4071 error ("%qE is not a constant expression", t
);
4072 *non_constant_p
= true;
4077 case AGGR_INIT_EXPR
:
4078 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4079 non_constant_p
, overflow_p
);
4084 r
= DECL_EXPR_DECL (t
);
4085 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4086 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4090 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4091 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4092 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4096 if (tree init
= DECL_INITIAL (r
))
4098 init
= cxx_eval_constant_expression (ctx
, init
,
4100 non_constant_p
, overflow_p
);
4101 /* Don't share a CONSTRUCTOR that might be changed. */
4102 init
= unshare_constructor (init
);
4103 ctx
->values
->put (r
, init
);
4105 else if (ctx
== &new_ctx
)
4106 /* We gave it a CONSTRUCTOR above. */;
4108 ctx
->values
->put (r
, NULL_TREE
);
4113 if (!literal_type_p (TREE_TYPE (t
)))
4117 error ("temporary of non-literal type %qT in a "
4118 "constant expression", TREE_TYPE (t
));
4119 explain_non_literal_class (TREE_TYPE (t
));
4121 *non_constant_p
= true;
4124 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4126 /* We're being expanded without an explicit target, so start
4127 initializing a new object; expansion with an explicit target
4128 strips the TARGET_EXPR before we get here. */
4130 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4131 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4132 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4133 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4136 /* Pass false for 'lval' because this indicates
4137 initialization of a temporary. */
4138 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4140 non_constant_p
, overflow_p
);
4141 if (!*non_constant_p
)
4142 /* Adjust the type of the result to the type of the temporary. */
4143 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4146 tree slot
= TARGET_EXPR_SLOT (t
);
4147 r
= unshare_constructor (r
);
4148 ctx
->values
->put (slot
, r
);
4155 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4156 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4157 non_constant_p
, overflow_p
);
4161 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4163 non_constant_p
, overflow_p
);
4167 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4168 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4170 non_constant_p
, overflow_p
);
4175 /* Avoid evaluating a SAVE_EXPR more than once. */
4176 if (tree
*p
= ctx
->values
->get (t
))
4180 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4181 non_constant_p
, overflow_p
);
4182 ctx
->values
->put (t
, r
);
4183 if (ctx
->save_exprs
)
4184 ctx
->save_exprs
->add (t
);
4188 case NON_LVALUE_EXPR
:
4189 case TRY_CATCH_EXPR
:
4191 case CLEANUP_POINT_EXPR
:
4192 case MUST_NOT_THROW_EXPR
:
4195 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4197 non_constant_p
, overflow_p
,
4201 case TRY_FINALLY_EXPR
:
4202 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4203 non_constant_p
, overflow_p
,
4205 if (!*non_constant_p
)
4206 /* Also evaluate the cleanup. */
4207 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4208 non_constant_p
, overflow_p
,
4212 /* These differ from cxx_eval_unary_expression in that this doesn't
4213 check for a constant operand or result; an address can be
4214 constant without its operand being, and vice versa. */
4217 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4218 non_constant_p
, overflow_p
);
4223 tree oldop
= TREE_OPERAND (t
, 0);
4224 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4226 non_constant_p
, overflow_p
);
4227 /* Don't VERIFY_CONSTANT here. */
4228 if (*non_constant_p
)
4230 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4231 /* This function does more aggressive folding than fold itself. */
4232 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4233 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4242 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4243 non_constant_p
, overflow_p
);
4244 if (r
== error_mark_node
)
4246 else if (r
== TREE_OPERAND (t
, 0))
4249 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4254 case FIX_TRUNC_EXPR
:
4259 case TRUTH_NOT_EXPR
:
4260 case FIXED_CONVERT_EXPR
:
4261 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4262 non_constant_p
, overflow_p
);
4266 r
= fold_sizeof_expr (t
);
4267 VERIFY_CONSTANT (r
);
4272 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4273 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4274 introduced by build_call_a. */
4275 tree op0
= TREE_OPERAND (t
, 0);
4276 tree op1
= TREE_OPERAND (t
, 1);
4278 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4279 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4280 r
= cxx_eval_constant_expression (ctx
, op0
,
4281 lval
, non_constant_p
, overflow_p
,
4285 /* Check that the LHS is constant and then discard it. */
4286 cxx_eval_constant_expression (ctx
, op0
,
4287 true, non_constant_p
, overflow_p
,
4289 if (*non_constant_p
)
4291 op1
= TREE_OPERAND (t
, 1);
4292 r
= cxx_eval_constant_expression (ctx
, op1
,
4293 lval
, non_constant_p
, overflow_p
,
4299 case POINTER_PLUS_EXPR
:
4303 case TRUNC_DIV_EXPR
:
4305 case FLOOR_DIV_EXPR
:
4306 case ROUND_DIV_EXPR
:
4307 case TRUNC_MOD_EXPR
:
4309 case ROUND_MOD_EXPR
:
4311 case EXACT_DIV_EXPR
:
4321 case TRUTH_XOR_EXPR
:
4328 case UNORDERED_EXPR
:
4338 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4339 non_constant_p
, overflow_p
);
4342 /* fold can introduce non-IF versions of these; still treat them as
4343 short-circuiting. */
4344 case TRUTH_AND_EXPR
:
4345 case TRUTH_ANDIF_EXPR
:
4346 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4349 non_constant_p
, overflow_p
);
4353 case TRUTH_ORIF_EXPR
:
4354 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4357 non_constant_p
, overflow_p
);
4361 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4362 non_constant_p
, overflow_p
);
4366 if (is_overloaded_fn (t
))
4368 /* We can only get here in checking mode via
4369 build_non_dependent_expr, because any expression that
4370 calls or takes the address of the function will have
4371 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4372 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4373 *non_constant_p
= true;
4376 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4377 non_constant_p
, overflow_p
);
4381 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4382 non_constant_p
, overflow_p
);
4386 if (jump_target
&& *jump_target
)
4388 /* When jumping to a label, the label might be either in the
4389 then or else blocks, so process then block first in skipping
4390 mode first, and if we are still in the skipping mode at its end,
4391 process the else block too. */
4392 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4393 lval
, non_constant_p
, overflow_p
,
4396 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4397 lval
, non_constant_p
, overflow_p
,
4403 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4404 non_constant_p
, overflow_p
,
4409 if (TREE_CONSTANT (t
))
4411 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4412 VECTOR_CST if applicable. */
4413 /* FIXME after GCC 6 branches, make the verify unconditional. */
4415 verify_constructor_flags (t
);
4417 recompute_constructor_flags (t
);
4418 if (TREE_CONSTANT (t
))
4421 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4422 non_constant_p
, overflow_p
);
4426 /* We can get this in a defaulted constructor for a class with a
4427 non-static data member of array type. Either the initializer will
4428 be NULL, meaning default-initialization, or it will be an lvalue
4429 or xvalue of the same type, meaning direct-initialization from the
4430 corresponding member. */
4431 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4432 non_constant_p
, overflow_p
);
4437 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4438 non_constant_p
, overflow_p
);
4442 case VIEW_CONVERT_EXPR
:
4444 case UNARY_PLUS_EXPR
:
4446 tree oldop
= TREE_OPERAND (t
, 0);
4448 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4450 non_constant_p
, overflow_p
);
4451 if (*non_constant_p
)
4453 tree type
= TREE_TYPE (t
);
4454 if (TREE_CODE (op
) == PTRMEM_CST
4455 && !TYPE_PTRMEM_P (type
))
4456 op
= cplus_expand_constant (op
);
4457 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4459 if (same_type_ignoring_top_level_qualifiers_p (type
,
4461 || can_convert_qual (type
, op
))
4462 return cp_fold_convert (type
, op
);
4466 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4467 "a reinterpret_cast is not a constant expression");
4468 *non_constant_p
= true;
4473 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4475 if (integer_zerop (op
))
4477 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4480 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4481 "dereferencing a null pointer");
4482 *non_constant_p
= true;
4485 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4487 tree from
= TREE_TYPE (op
);
4489 if (!can_convert (type
, from
, tf_none
))
4492 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4493 "conversion of %qT null pointer to %qT "
4494 "is not a constant expression",
4496 *non_constant_p
= true;
4503 /* This detects for example:
4504 reinterpret_cast<void*>(sizeof 0)
4507 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4508 "%<reinterpret_cast<%T>(%E)%> is not "
4509 "a constant expression",
4511 *non_constant_p
= true;
4515 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4516 /* We didn't fold at the top so we could check for ptr-int
4519 if (tcode
== UNARY_PLUS_EXPR
)
4520 r
= fold_convert (TREE_TYPE (t
), op
);
4522 r
= fold_build1 (tcode
, type
, op
);
4523 /* Conversion of an out-of-range value has implementation-defined
4524 behavior; the language considers it different from arithmetic
4525 overflow, which is undefined. */
4526 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4527 TREE_OVERFLOW (r
) = false;
4531 case EMPTY_CLASS_EXPR
:
4532 /* This is good enough for a function argument that might not get
4533 used, and they can't do anything with it, so just return it. */
4536 case STATEMENT_LIST
:
4538 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4539 return cxx_eval_statement_list (&new_ctx
, t
,
4540 non_constant_p
, overflow_p
, jump_target
);
4543 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4545 non_constant_p
, overflow_p
,
4548 case PREINCREMENT_EXPR
:
4549 case POSTINCREMENT_EXPR
:
4550 case PREDECREMENT_EXPR
:
4551 case POSTDECREMENT_EXPR
:
4552 return cxx_eval_increment_expression (ctx
, t
,
4553 lval
, non_constant_p
, overflow_p
);
4559 case VEC_DELETE_EXPR
:
4562 /* GCC internal stuff. */
4565 case NON_DEPENDENT_EXPR
:
4569 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4570 "expression %qE is not a constant expression", t
);
4571 *non_constant_p
= true;
4574 case PLACEHOLDER_EXPR
:
4575 /* Use of the value or address of the current object. */
4576 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4577 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4578 non_constant_p
, overflow_p
);
4579 /* A placeholder without a referent. We can get here when
4580 checking whether NSDMIs are noexcept, or in massage_init_elt;
4581 just say it's non-constant for now. */
4582 gcc_assert (ctx
->quiet
);
4583 *non_constant_p
= true;
4588 tree cond
= TREE_OPERAND (t
, 0);
4589 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4590 non_constant_p
, overflow_p
);
4591 VERIFY_CONSTANT (cond
);
4592 if (integer_nonzerop (cond
))
4598 *jump_target
= TREE_OPERAND (t
, 0);
4599 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4600 /* Allow for jumping to a cdtor_label. */
4601 || returns (jump_target
));
4605 cxx_eval_loop_expr (ctx
, t
,
4606 non_constant_p
, overflow_p
, jump_target
);
4610 cxx_eval_switch_expr (ctx
, t
,
4611 non_constant_p
, overflow_p
, jump_target
);
4615 /* It's possible to get a requires-expression in a constant
4616 expression. For example:
4618 template<typename T> concept bool C() {
4619 return requires (T t) { t; };
4622 template<typename T> requires !C<T>() void f(T);
4624 Normalization leaves f with the associated constraint
4625 '!requires (T t) { ... }' which is not transformed into
4627 if (!processing_template_decl
)
4628 return evaluate_constraint_expression (t
, NULL_TREE
);
4630 *non_constant_p
= true;
4634 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
4635 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4637 non_constant_p
, overflow_p
,
4642 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4644 /* This function doesn't know how to deal with pre-genericize
4645 statements; this can only happen with statement-expressions,
4646 so for now just fail. */
4648 error_at (EXPR_LOCATION (t
),
4649 "statement is not a constant expression");
4652 internal_error ("unexpected expression %qE of kind %s", t
,
4653 get_tree_code_name (TREE_CODE (t
)));
4654 *non_constant_p
= true;
4658 if (r
== error_mark_node
)
4659 *non_constant_p
= true;
4661 if (*non_constant_p
)
4668 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4669 bool strict
= true, tree object
= NULL_TREE
)
4671 auto_timevar
time (TV_CONSTEXPR
);
4673 bool non_constant_p
= false;
4674 bool overflow_p
= false;
4675 hash_map
<tree
,tree
> map
;
4677 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4678 allow_non_constant
, strict
};
4680 tree type
= initialized_type (t
);
4682 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4684 /* In C++14 an NSDMI can participate in aggregate initialization,
4685 and can refer to the address of the object being initialized, so
4686 we need to pass in the relevant VAR_DECL if we want to do the
4687 evaluation in a single pass. The evaluation will dynamically
4688 update ctx.values for the VAR_DECL. We use the same strategy
4689 for C++11 constexpr constructors that refer to the object being
4691 ctx
.ctor
= build_constructor (type
, NULL
);
4692 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4695 if (TREE_CODE (t
) == TARGET_EXPR
)
4696 object
= TARGET_EXPR_SLOT (t
);
4697 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4698 object
= AGGR_INIT_EXPR_SLOT (t
);
4700 ctx
.object
= object
;
4702 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4703 (type
, TREE_TYPE (object
)));
4704 if (object
&& DECL_P (object
))
4705 map
.put (object
, ctx
.ctor
);
4706 if (TREE_CODE (r
) == TARGET_EXPR
)
4707 /* Avoid creating another CONSTRUCTOR when we expand the
4709 r
= TARGET_EXPR_INITIAL (r
);
4712 r
= cxx_eval_constant_expression (&ctx
, r
,
4713 false, &non_constant_p
, &overflow_p
);
4715 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4717 /* Mutable logic is a bit tricky: we want to allow initialization of
4718 constexpr variables with mutable members, but we can't copy those
4719 members to another constexpr variable. */
4720 if (TREE_CODE (r
) == CONSTRUCTOR
4721 && CONSTRUCTOR_MUTABLE_POISON (r
))
4723 if (!allow_non_constant
)
4724 error ("%qE is not a constant expression because it refers to "
4725 "mutable subobjects of %qT", t
, type
);
4726 non_constant_p
= true;
4729 if (TREE_CODE (r
) == CONSTRUCTOR
4730 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4732 if (!allow_non_constant
)
4733 error ("%qE is not a constant expression because it refers to "
4734 "an incompletely initialized variable", t
);
4735 TREE_CONSTANT (r
) = false;
4736 non_constant_p
= true;
4739 /* Technically we should check this for all subexpressions, but that
4740 runs into problems with our internal representation of pointer
4741 subtraction and the 5.19 rules are still in flux. */
4742 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4743 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4744 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4746 if (!allow_non_constant
)
4747 error ("conversion from pointer type %qT "
4748 "to arithmetic type %qT in a constant expression",
4749 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4750 non_constant_p
= true;
4753 if (!non_constant_p
&& overflow_p
)
4754 non_constant_p
= true;
4756 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4758 bool should_unshare
= true;
4759 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4760 should_unshare
= false;
4762 if (non_constant_p
&& !allow_non_constant
)
4763 return error_mark_node
;
4764 else if (non_constant_p
&& TREE_CONSTANT (r
))
4766 /* This isn't actually constant, so unset TREE_CONSTANT. */
4769 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4770 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4772 r
= build_nop (TREE_TYPE (r
), r
);
4773 TREE_CONSTANT (r
) = false;
4775 else if (non_constant_p
|| r
== t
)
4779 r
= unshare_expr (r
);
4781 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4783 if (TREE_CODE (t
) == TARGET_EXPR
4784 && TARGET_EXPR_INITIAL (t
) == r
)
4788 r
= get_target_expr (r
);
4789 TREE_CONSTANT (r
) = true;
4797 /* Returns true if T is a valid subexpression of a constant expression,
4798 even if it isn't itself a constant expression. */
4801 is_sub_constant_expr (tree t
)
4803 bool non_constant_p
= false;
4804 bool overflow_p
= false;
4805 hash_map
<tree
, tree
> map
;
4807 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4809 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4811 return !non_constant_p
&& !overflow_p
;
4814 /* If T represents a constant expression returns its reduced value.
4815 Otherwise return error_mark_node. If T is dependent, then
4819 cxx_constant_value (tree t
, tree decl
)
4821 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4824 /* Helper routine for fold_simple function. Either return simplified
4825 expression T, otherwise NULL_TREE.
4826 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4827 even if we are within template-declaration. So be careful on call, as in
4828 such case types can be undefined. */
4831 fold_simple_1 (tree t
)
4834 enum tree_code code
= TREE_CODE (t
);
4846 return fold_sizeof_expr (t
);
4854 case TRUTH_NOT_EXPR
:
4856 case VIEW_CONVERT_EXPR
:
4859 case FIX_TRUNC_EXPR
:
4860 case FIXED_CONVERT_EXPR
:
4861 case ADDR_SPACE_CONVERT_EXPR
:
4863 op1
= TREE_OPERAND (t
, 0);
4865 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4869 if (CONVERT_EXPR_CODE_P (code
)
4870 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4871 TREE_OVERFLOW (t
) = false;
4879 /* If T is a simple constant expression, returns its simplified value.
4880 Otherwise returns T. In contrast to maybe_constant_value do we
4881 simplify only few operations on constant-expressions, and we don't
4882 try to simplify constexpressions. */
4885 fold_simple (tree t
)
4888 if (processing_template_decl
)
4891 r
= fold_simple_1 (t
);
4898 /* If T is a constant expression, returns its reduced value.
4899 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4900 Otherwise, returns a version of T without TREE_CONSTANT. */
4902 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4905 maybe_constant_value (tree t
, tree decl
)
4909 if (!is_nondependent_constant_expression (t
))
4911 if (TREE_OVERFLOW_P (t
))
4913 t
= build_nop (TREE_TYPE (t
), t
);
4914 TREE_CONSTANT (t
) = false;
4918 else if (CONSTANT_CLASS_P (t
))
4919 /* No caching or evaluation needed. */
4922 if (cv_cache
== NULL
)
4923 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4924 if (tree
*cached
= cv_cache
->get (t
))
4927 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4928 gcc_checking_assert (r
== t
4929 || CONVERT_EXPR_P (t
)
4930 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4931 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4932 || !cp_tree_equal (r
, t
));
4933 cv_cache
->put (t
, r
);
4937 /* Dispose of the whole CV_CACHE. */
4940 clear_cv_cache (void)
4942 if (cv_cache
!= NULL
)
4946 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4949 clear_cv_and_fold_caches (void)
4952 clear_fold_cache ();
4955 /* Like maybe_constant_value but first fully instantiate the argument.
4957 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4958 (t, tf_none) followed by maybe_constant_value but is more efficient,
4959 because calls instantiation_dependent_expression_p and
4960 potential_constant_expression at most once. */
4963 fold_non_dependent_expr (tree t
)
4968 /* If we're in a template, but T isn't value dependent, simplify
4969 it. We're supposed to treat:
4971 template <typename T> void f(T[1 + 1]);
4972 template <typename T> void f(T[2]);
4974 as two declarations of the same function, for example. */
4975 if (processing_template_decl
)
4977 if (is_nondependent_constant_expression (t
))
4979 processing_template_decl_sentinel s
;
4980 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4982 if (type_unknown_p (t
)
4983 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4985 if (TREE_OVERFLOW_P (t
))
4987 t
= build_nop (TREE_TYPE (t
), t
);
4988 TREE_CONSTANT (t
) = false;
4993 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4994 /* cp_tree_equal looks through NOPs, so allow them. */
4995 gcc_checking_assert (r
== t
4996 || CONVERT_EXPR_P (t
)
4997 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4998 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4999 || !cp_tree_equal (r
, t
));
5002 else if (TREE_OVERFLOW_P (t
))
5004 t
= build_nop (TREE_TYPE (t
), t
);
5005 TREE_CONSTANT (t
) = false;
5010 return maybe_constant_value (t
);
5013 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5014 than wrapped in a TARGET_EXPR. */
5017 maybe_constant_init (tree t
, tree decl
)
5021 if (TREE_CODE (t
) == EXPR_STMT
)
5022 t
= TREE_OPERAND (t
, 0);
5023 if (TREE_CODE (t
) == CONVERT_EXPR
5024 && VOID_TYPE_P (TREE_TYPE (t
)))
5025 t
= TREE_OPERAND (t
, 0);
5026 if (TREE_CODE (t
) == INIT_EXPR
)
5027 t
= TREE_OPERAND (t
, 1);
5028 if (TREE_CODE (t
) == TARGET_EXPR
)
5029 t
= TARGET_EXPR_INITIAL (t
);
5030 if (!is_nondependent_static_init_expression (t
))
5031 /* Don't try to evaluate it. */;
5032 else if (CONSTANT_CLASS_P (t
))
5033 /* No evaluation needed. */;
5035 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
5036 if (TREE_CODE (t
) == TARGET_EXPR
)
5038 tree init
= TARGET_EXPR_INITIAL (t
);
5039 if (TREE_CODE (init
) == CONSTRUCTOR
)
5046 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5047 /* Return true if the object referred to by REF has automatic or thread
5050 enum { ck_ok
, ck_bad
, ck_unknown
};
5052 check_automatic_or_tls (tree ref
)
5055 HOST_WIDE_INT bitsize
, bitpos
;
5057 int volatilep
= 0, unsignedp
= 0;
5058 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5059 &mode
, &unsignedp
, &volatilep
, false);
5062 /* If there isn't a decl in the middle, we don't know the linkage here,
5063 and this isn't a constant expression anyway. */
5066 dk
= decl_storage_duration (decl
);
5067 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5071 /* Return true if T denotes a potentially constant expression. Issue
5072 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5073 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5074 consider the expression in the current context, independent of constexpr
5077 C++0x [expr.const] used to say
5079 6 An expression is a potential constant expression if it is
5080 a constant expression where all occurrences of function
5081 parameters are replaced by arbitrary constant expressions
5082 of the appropriate type.
5084 2 A conditional expression is a constant expression unless it
5085 involves one of the following as a potentially evaluated
5086 subexpression (3.2), but subexpressions of logical AND (5.14),
5087 logical OR (5.15), and conditional (5.16) operations that are
5088 not evaluated are not considered. */
5091 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5092 tsubst_flags_t flags
)
5094 #define RECUR(T,RV) \
5095 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5097 enum { any
= false, rval
= true };
5101 if (t
== error_mark_node
)
5105 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5106 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5108 if (flags
& tf_error
)
5109 error_at (loc
, "expression %qE has side-effects", t
);
5112 if (CONSTANT_CLASS_P (t
))
5114 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5115 && TREE_TYPE (t
) == error_mark_node
)
5118 switch (TREE_CODE (t
))
5124 case TEMPLATE_ID_EXPR
:
5127 case CASE_LABEL_EXPR
:
5133 case TEMPLATE_PARM_INDEX
:
5135 case IDENTIFIER_NODE
:
5136 case USERDEF_LITERAL
:
5137 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5142 case PLACEHOLDER_EXPR
:
5152 if (flags
& tf_error
)
5153 error ("%qE is not a constant expression", t
);
5158 case AGGR_INIT_EXPR
:
5160 /* -- an invocation of a function other than a constexpr function
5161 or a constexpr constructor. */
5163 tree fun
= get_function_named_in_call (t
);
5164 const int nargs
= call_expr_nargs (t
);
5167 if (fun
== NULL_TREE
)
5169 /* Reset to allow the function to continue past the end
5170 of the block below. Otherwise return early. */
5173 if (TREE_CODE (t
) == CALL_EXPR
5174 && CALL_EXPR_FN (t
) == NULL_TREE
)
5175 switch (CALL_EXPR_IFN (t
))
5177 /* These should be ignored, they are optimized away from
5178 constexpr functions. */
5179 case IFN_UBSAN_NULL
:
5180 case IFN_UBSAN_BOUNDS
:
5181 case IFN_UBSAN_VPTR
:
5182 case IFN_FALLTHROUGH
:
5185 case IFN_ADD_OVERFLOW
:
5186 case IFN_SUB_OVERFLOW
:
5187 case IFN_MUL_OVERFLOW
:
5197 /* fold_call_expr can't do anything with IFN calls. */
5198 if (flags
& tf_error
)
5199 error_at (loc
, "call to internal function %qE", t
);
5204 if (fun
&& is_overloaded_fn (fun
))
5206 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5208 if (builtin_valid_in_constant_expr_p (fun
))
5210 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5211 /* Allow any built-in function; if the expansion
5212 isn't constant, we'll deal with that then. */
5213 && !is_builtin_fn (fun
))
5215 if (flags
& tf_error
)
5217 error_at (loc
, "call to non-constexpr function %qD",
5219 explain_invalid_constexpr_fn (fun
);
5223 /* A call to a non-static member function takes the address
5224 of the object as the first argument. But in a constant
5225 expression the address will be folded away, so look
5227 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5228 && !DECL_CONSTRUCTOR_P (fun
))
5230 tree x
= get_nth_callarg (t
, 0);
5231 if (is_this_parameter (x
))
5233 /* Don't require an immediately constant value, as
5234 constexpr substitution might not use the value. */
5235 bool sub_now
= false;
5236 if (!potential_constant_expression_1 (x
, rval
, strict
,
5244 if (!RECUR (fun
, true))
5246 fun
= get_first_fn (fun
);
5248 /* Skip initial arguments to base constructors. */
5249 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5250 i
= num_artificial_parms_for (fun
);
5251 fun
= DECL_ORIGIN (fun
);
5255 if (RECUR (fun
, rval
))
5256 /* Might end up being a constant function pointer. */;
5260 for (; i
< nargs
; ++i
)
5262 tree x
= get_nth_callarg (t
, i
);
5263 /* In a template, reference arguments haven't been converted to
5264 REFERENCE_TYPE and we might not even know if the parameter
5265 is a reference, so accept lvalue constants too. */
5266 bool rv
= processing_template_decl
? any
: rval
;
5267 /* Don't require an immediately constant value, as constexpr
5268 substitution might not use the value of the argument. */
5269 bool sub_now
= false;
5270 if (!potential_constant_expression_1 (x
, rv
, strict
,
5277 case NON_LVALUE_EXPR
:
5278 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5279 -- an lvalue of integral type that refers to a non-volatile
5280 const variable or static data member initialized with
5281 constant expressions, or
5283 -- an lvalue of literal type that refers to non-volatile
5284 object defined with constexpr, or that refers to a
5285 sub-object of such an object; */
5286 return RECUR (TREE_OPERAND (t
, 0), rval
);
5289 if (DECL_HAS_VALUE_EXPR_P (t
))
5291 if (now
&& is_normal_capture_proxy (t
))
5293 /* -- in a lambda-expression, a reference to this or to a
5294 variable with automatic storage duration defined outside that
5295 lambda-expression, where the reference would be an
5297 if (flags
& tf_error
)
5299 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5300 error ("lambda capture of %qE is not a constant expression",
5302 if (!want_rval
&& decl_constant_var_p (cap
))
5303 inform (input_location
, "because it is used as a glvalue");
5307 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5310 && !var_in_maybe_constexpr_fn (t
)
5311 && !type_dependent_expression_p (t
)
5312 && !decl_maybe_constant_var_p (t
)
5314 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5315 || (DECL_INITIAL (t
)
5316 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5317 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5318 && !is_really_empty_class (TREE_TYPE (t
)))
5320 if (flags
& tf_error
)
5321 non_const_var_error (t
);
5328 case VIEW_CONVERT_EXPR
:
5329 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5330 may change to something more specific to type-punning (DR 1312). */
5332 tree from
= TREE_OPERAND (t
, 0);
5333 if (POINTER_TYPE_P (TREE_TYPE (t
))
5334 && TREE_CODE (from
) == INTEGER_CST
5335 && !integer_zerop (from
))
5337 if (flags
& tf_error
)
5338 error_at (loc
, "reinterpret_cast from integer to pointer");
5341 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5344 case ADDRESSOF_EXPR
:
5345 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5346 t
= TREE_OPERAND (t
, 0);
5347 goto handle_addr_expr
;
5350 /* -- a unary operator & that is applied to an lvalue that
5351 designates an object with thread or automatic storage
5353 t
= TREE_OPERAND (t
, 0);
5355 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5356 /* A pointer-to-member constant. */
5361 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5362 any checking here, as we might dereference the pointer later. If
5363 we remove this code, also remove check_automatic_or_tls. */
5364 i
= check_automatic_or_tls (t
);
5369 if (flags
& tf_error
)
5370 error ("address-of an object %qE with thread local or "
5371 "automatic storage is not a constant expression", t
);
5375 return RECUR (t
, any
);
5383 /* -- a class member access unless its postfix-expression is
5384 of literal type or of pointer to literal type. */
5385 /* This test would be redundant, as it follows from the
5386 postfix-expression being a potential constant expression. */
5387 if (type_unknown_p (t
))
5389 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5391 case EXPR_PACK_EXPANSION
:
5392 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5396 tree x
= TREE_OPERAND (t
, 0);
5398 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5400 if (!var_in_maybe_constexpr_fn (x
))
5402 if (flags
& tf_error
)
5403 error_at (loc
, "use of %<this%> in a constant expression");
5408 return RECUR (x
, rval
);
5411 case STATEMENT_LIST
:
5413 tree_stmt_iterator i
;
5414 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5416 if (!RECUR (tsi_stmt (i
), any
))
5424 if (cxx_dialect
< cxx14
)
5426 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5428 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5433 if (cxx_dialect
< cxx14
)
5435 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5437 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5442 if (!RECUR (DO_COND (t
), rval
))
5444 if (!RECUR (DO_BODY (t
), any
))
5449 if (!RECUR (FOR_INIT_STMT (t
), any
))
5451 if (!RECUR (FOR_COND (t
), rval
))
5453 if (!RECUR (FOR_EXPR (t
), any
))
5455 if (!RECUR (FOR_BODY (t
), any
))
5459 case RANGE_FOR_STMT
:
5460 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5462 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5467 if (!RECUR (WHILE_COND (t
), rval
))
5469 if (!RECUR (WHILE_BODY (t
), any
))
5474 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5476 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5477 unreachable labels would be checked. */
5481 return RECUR (STMT_EXPR_STMT (t
), rval
);
5484 case DYNAMIC_CAST_EXPR
:
5485 case PSEUDO_DTOR_EXPR
:
5489 case VEC_DELETE_EXPR
:
5494 case OMP_DISTRIBUTE
:
5497 case OMP_TARGET_DATA
:
5506 case OMP_TARGET_UPDATE
:
5507 case OMP_TARGET_ENTER_DATA
:
5508 case OMP_TARGET_EXIT_DATA
:
5510 case OMP_ATOMIC_READ
:
5511 case OMP_ATOMIC_CAPTURE_OLD
:
5512 case OMP_ATOMIC_CAPTURE_NEW
:
5516 case OACC_HOST_DATA
:
5520 case OACC_ENTER_DATA
:
5521 case OACC_EXIT_DATA
:
5525 /* GCC internal stuff. */
5528 case TRANSACTION_EXPR
:
5530 case AT_ENCODE_EXPR
:
5532 if (flags
& tf_error
)
5533 error_at (loc
, "expression %qE is not a constant expression", t
);
5537 /* -- a typeid expression whose operand is of polymorphic
5540 tree e
= TREE_OPERAND (t
, 0);
5541 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5542 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5544 if (flags
& tf_error
)
5545 error_at (loc
, "typeid-expression is not a constant expression "
5546 "because %qE is of polymorphic type", e
);
5565 case PREINCREMENT_EXPR
:
5566 case POSTINCREMENT_EXPR
:
5567 case PREDECREMENT_EXPR
:
5568 case POSTDECREMENT_EXPR
:
5569 if (cxx_dialect
< cxx14
)
5575 if (TYPE_P (TREE_OPERAND (t
, 0)))
5581 case FIX_TRUNC_EXPR
:
5585 case TRUTH_NOT_EXPR
:
5586 case FIXED_CONVERT_EXPR
:
5587 case UNARY_PLUS_EXPR
:
5588 case UNARY_LEFT_FOLD_EXPR
:
5589 case UNARY_RIGHT_FOLD_EXPR
:
5591 return RECUR (TREE_OPERAND (t
, 0), rval
);
5594 case CONST_CAST_EXPR
:
5595 case STATIC_CAST_EXPR
:
5596 case REINTERPRET_CAST_EXPR
:
5597 case IMPLICIT_CONV_EXPR
:
5598 if (cxx_dialect
< cxx11
5599 && !dependent_type_p (TREE_TYPE (t
))
5600 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5601 /* In C++98, a conversion to non-integral type can't be part of a
5602 constant expression. */
5604 if (flags
& tf_error
)
5606 "cast to non-integral type %qT in a constant expression",
5611 return (RECUR (TREE_OPERAND (t
, 0),
5612 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5615 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5617 case CLEANUP_POINT_EXPR
:
5618 case MUST_NOT_THROW_EXPR
:
5619 case TRY_CATCH_EXPR
:
5624 case NON_DEPENDENT_EXPR
:
5625 /* For convenience. */
5629 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5632 tmp
= DECL_EXPR_DECL (t
);
5633 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5635 if (TREE_STATIC (tmp
))
5637 if (flags
& tf_error
)
5638 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5639 "%<static%> in %<constexpr%> context", tmp
);
5642 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5644 if (flags
& tf_error
)
5645 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5646 "%<thread_local%> in %<constexpr%> context", tmp
);
5649 else if (!DECL_NONTRIVIALLY_INITIALIZED_P (tmp
))
5651 if (flags
& tf_error
)
5652 error_at (DECL_SOURCE_LOCATION (tmp
), "uninitialized "
5653 "variable %qD in %<constexpr%> context", tmp
);
5657 return RECUR (tmp
, want_rval
);
5659 case TRY_FINALLY_EXPR
:
5660 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5661 && RECUR (TREE_OPERAND (t
, 1), any
));
5664 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5667 if (!literal_type_p (TREE_TYPE (t
)))
5669 if (flags
& tf_error
)
5671 error_at (loc
, "temporary of non-literal type %qT in a "
5672 "constant expression", TREE_TYPE (t
));
5673 explain_non_literal_class (TREE_TYPE (t
));
5679 return RECUR (TREE_OPERAND (t
, 1), rval
);
5683 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5684 constructor_elt
*ce
;
5685 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5686 if (!RECUR (ce
->value
, want_rval
))
5693 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5694 || DECL_P (TREE_PURPOSE (t
)));
5695 if (!RECUR (TREE_VALUE (t
), want_rval
))
5697 if (TREE_CHAIN (t
) == NULL_TREE
)
5699 return RECUR (TREE_CHAIN (t
), want_rval
);
5702 case TRUNC_DIV_EXPR
:
5704 case FLOOR_DIV_EXPR
:
5705 case ROUND_DIV_EXPR
:
5706 case TRUNC_MOD_EXPR
:
5708 case ROUND_MOD_EXPR
:
5710 tree denom
= TREE_OPERAND (t
, 1);
5711 if (!RECUR (denom
, rval
))
5713 /* We can't call cxx_eval_outermost_constant_expr on an expression
5714 that hasn't been through instantiate_non_dependent_expr yet. */
5715 if (!processing_template_decl
)
5716 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5717 if (integer_zerop (denom
))
5719 if (flags
& tf_error
)
5720 error ("division by zero is not a constant expression");
5726 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5732 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5733 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5734 introduced by build_call_a. */
5735 tree op0
= TREE_OPERAND (t
, 0);
5736 tree op1
= TREE_OPERAND (t
, 1);
5738 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5739 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5740 return RECUR (op0
, want_rval
);
5745 /* If the first operand is the non-short-circuit constant, look at
5746 the second operand; otherwise we only care about the first one for
5748 case TRUTH_AND_EXPR
:
5749 case TRUTH_ANDIF_EXPR
:
5750 tmp
= boolean_true_node
;
5753 case TRUTH_ORIF_EXPR
:
5754 tmp
= boolean_false_node
;
5757 tree op
= TREE_OPERAND (t
, 0);
5758 if (!RECUR (op
, rval
))
5760 if (!processing_template_decl
)
5761 op
= cxx_eval_outermost_constant_expr (op
, true);
5762 if (tree_int_cst_equal (op
, tmp
))
5763 return RECUR (TREE_OPERAND (t
, 1), rval
);
5770 case POINTER_PLUS_EXPR
:
5772 case EXACT_DIV_EXPR
:
5782 case TRUTH_XOR_EXPR
:
5783 case UNORDERED_EXPR
:
5796 case ARRAY_RANGE_REF
:
5800 case BINARY_LEFT_FOLD_EXPR
:
5801 case BINARY_RIGHT_FOLD_EXPR
:
5803 for (i
= 0; i
< 2; ++i
)
5804 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5808 case CILK_SYNC_STMT
:
5809 case CILK_SPAWN_STMT
:
5810 case ARRAY_NOTATION_REF
:
5815 for (i
= 0; i
< 3; ++i
)
5816 if (!RECUR (TREE_OPERAND (t
, i
), true))
5821 if (COND_EXPR_IS_VEC_DELETE (t
))
5823 if (flags
& tf_error
)
5824 error_at (loc
, "%<delete[]%> is not a constant expression");
5830 /* If the condition is a known constant, we know which of the legs we
5831 care about; otherwise we only require that the condition and
5832 either of the legs be potentially constant. */
5833 tmp
= TREE_OPERAND (t
, 0);
5834 if (!RECUR (tmp
, rval
))
5836 if (!processing_template_decl
)
5837 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5838 if (integer_zerop (tmp
))
5839 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5840 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5841 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5842 for (i
= 1; i
< 3; ++i
)
5843 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5844 want_rval
, strict
, now
, tf_none
))
5846 if (flags
& tf_error
)
5847 error_at (loc
, "expression %qE is not a constant expression", t
);
5851 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5853 if (flags
& tf_error
)
5855 error_at (loc
, "non-constant array initialization");
5856 diagnose_non_constexpr_vec_init (t
);
5862 /* We can see these in statement-expressions. */
5866 case EMPTY_CLASS_EXPR
:
5872 tree
*target
= &TREE_OPERAND (t
, 0);
5873 /* Gotos representing break and continue are OK. */
5874 if (breaks (target
) || continues (target
))
5876 if (flags
& tf_error
)
5877 error_at (loc
, "%<goto%> is not a constant expression");
5882 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
5883 return RECUR (TREE_OPERAND (t
, 0), rval
);
5886 if (objc_is_property_ref (t
))
5889 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5896 /* The main entry point to the above. */
5899 potential_constant_expression (tree t
)
5901 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
5904 /* As above, but require a constant rvalue. */
5907 potential_rvalue_constant_expression (tree t
)
5909 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
5912 /* Like above, but complain about non-constant expressions. */
5915 require_potential_constant_expression (tree t
)
5917 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
5920 /* Cross product of the above. */
5923 require_potential_rvalue_constant_expression (tree t
)
5925 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
5928 /* Like potential_constant_expression, but don't consider possible constexpr
5929 substitution of the current function. That is, PARM_DECL qualifies under
5930 potential_constant_expression, but not here.
5932 This is basically what you can check when any actual constant values might
5933 be value-dependent. */
5936 is_constant_expression (tree t
)
5938 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
5941 /* Like above, but complain about non-constant expressions. */
5944 require_constant_expression (tree t
)
5946 return potential_constant_expression_1 (t
, false, true, true,
5947 tf_warning_or_error
);
5950 /* Like is_constant_expression, but allow const variables that are not allowed
5951 under constexpr rules. */
5954 is_static_init_expression (tree t
)
5956 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
5959 /* Returns true if T is a potential constant expression that is not
5960 instantiation-dependent, and therefore a candidate for constant folding even
5964 is_nondependent_constant_expression (tree t
)
5966 return (!type_unknown_p (t
)
5967 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5968 && is_constant_expression (t
)
5969 && !instantiation_dependent_expression_p (t
));
5972 /* Returns true if T is a potential static initializer expression that is not
5973 instantiation-dependent. */
5976 is_nondependent_static_init_expression (tree t
)
5978 return (!type_unknown_p (t
)
5979 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5980 && is_static_init_expression (t
)
5981 && !instantiation_dependent_expression_p (t
));
5984 /* Finalize constexpr processing after parsing. */
5987 fini_constexpr (void)
5989 /* The contexpr call and fundef copies tables are no longer needed. */
5990 constexpr_call_table
= NULL
;
5991 fundef_copies_table
= NULL
;
5994 #include "gt-cp-constexpr.h"