1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2018 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
34 #include "gimple-fold.h"
37 static bool verify_constant (tree
, bool, bool *, bool *);
38 #define VERIFY_CONSTANT(X) \
40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
44 /* Returns true iff FUN is an instantiation of a constexpr function
45 template or a defaulted constexpr function. */
48 is_instantiation_of_constexpr (tree fun
)
50 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
52 || (DECL_DEFAULTED_FN (fun
)
53 && DECL_DECLARED_CONSTEXPR_P (fun
)));
56 /* Return true if T is a literal type. */
59 literal_type_p (tree t
)
63 || TREE_CODE (t
) == REFERENCE_TYPE
64 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
68 t
= complete_type (t
);
69 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
70 return CLASSTYPE_LITERAL_P (t
);
72 if (TREE_CODE (t
) == ARRAY_TYPE
)
73 return literal_type_p (strip_array_types (t
));
77 /* If DECL is a variable declared `constexpr', require its type
78 be literal. Return 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 "
98 "is not literal", type
, decl
);
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
),
458 case DEBUG_BEGIN_STMT
:
466 /* Make sure that there are no statements after LAST in the constructor
467 body represented by LIST. */
470 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
472 /* C++14 doesn't require a constexpr ctor to have an empty body. */
473 if (cxx_dialect
>= cxx14
)
477 if (TREE_CODE (list
) == STATEMENT_LIST
)
479 tree_stmt_iterator i
= tsi_last (list
);
480 for (; !tsi_end_p (i
); tsi_prev (&i
))
482 tree t
= tsi_stmt (i
);
485 if (!check_constexpr_ctor_body_1 (last
, t
))
492 else if (list
!= last
493 && !check_constexpr_ctor_body_1 (last
, list
))
498 error ("%<constexpr%> constructor does not have empty body");
499 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
504 /* V is a vector of constructor elements built up for the base and member
505 initializers of a constructor for TYPE. They need to be in increasing
506 offset order, which they might not be yet if TYPE has a primary base
507 which is not first in the base-clause or a vptr and at least one base
508 all of which are non-primary. */
510 static vec
<constructor_elt
, va_gc
> *
511 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
513 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
519 field_type
= BINFO_TYPE (pri
);
520 else if (TYPE_CONTAINS_VPTR_P (type
))
521 field_type
= vtbl_ptr_type_node
;
525 /* Find the element for the primary base or vptr and move it to the
526 beginning of the vec. */
527 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
528 if (TREE_TYPE (ce
->index
) == field_type
)
531 if (i
> 0 && i
< vec_safe_length (v
))
533 vec
<constructor_elt
, va_gc
> &vref
= *v
;
534 constructor_elt elt
= vref
[i
];
543 /* Build compile-time evalable representations of member-initializer list
544 for a constexpr constructor. */
547 build_constexpr_constructor_member_initializers (tree type
, tree body
)
549 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
552 switch (TREE_CODE (body
))
554 case MUST_NOT_THROW_EXPR
:
556 body
= TREE_OPERAND (body
, 0);
560 for (tree_stmt_iterator i
= tsi_start (body
);
561 !tsi_end_p (i
); tsi_next (&i
))
564 if (TREE_CODE (body
) == BIND_EXPR
)
570 body
= BIND_EXPR_BODY (body
);
577 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
579 body
= TREE_OPERAND (body
, 0);
580 if (TREE_CODE (body
) == EXPR_STMT
)
581 body
= TREE_OPERAND (body
, 0);
582 if (TREE_CODE (body
) == INIT_EXPR
583 && (same_type_ignoring_top_level_qualifiers_p
584 (TREE_TYPE (TREE_OPERAND (body
, 0)),
585 current_class_type
)))
588 return TREE_OPERAND (body
, 1);
590 ok
= build_data_member_initialization (body
, &vec
);
592 else if (TREE_CODE (body
) == STATEMENT_LIST
)
594 tree_stmt_iterator i
;
595 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
597 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
602 else if (TREE_CODE (body
) == TRY_BLOCK
)
604 error ("body of %<constexpr%> constructor cannot be "
605 "a function-try-block");
606 return error_mark_node
;
608 else if (EXPR_P (body
))
609 ok
= build_data_member_initialization (body
, &vec
);
611 gcc_assert (errorcount
> 0);
614 if (vec_safe_length (vec
) > 0)
616 /* In a delegating constructor, return the target. */
617 constructor_elt
*ce
= &(*vec
)[0];
618 if (ce
->index
== current_class_ptr
)
625 vec
= sort_constexpr_mem_initializers (type
, vec
);
626 return build_constructor (type
, vec
);
629 return error_mark_node
;
632 /* We have an expression tree T that represents a call, either CALL_EXPR
633 or AGGR_INIT_EXPR. If the call is lexically to a named function,
634 retrun the _DECL for that function. */
637 get_function_named_in_call (tree t
)
639 tree fun
= cp_get_callee (t
);
640 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
641 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
642 fun
= TREE_OPERAND (fun
, 0);
646 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
647 declared to be constexpr, or a sub-statement thereof. Returns the
648 return value if suitable, error_mark_node for a statement not allowed in
649 a constexpr function, or NULL_TREE if no return value was found. */
652 constexpr_fn_retval (tree body
)
654 switch (TREE_CODE (body
))
658 tree_stmt_iterator i
;
659 tree expr
= NULL_TREE
;
660 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
662 tree s
= constexpr_fn_retval (tsi_stmt (i
));
663 if (s
== error_mark_node
)
664 return error_mark_node
;
665 else if (s
== NULL_TREE
)
666 /* Keep iterating. */;
668 /* Multiple return statements. */
669 return error_mark_node
;
677 return break_out_target_exprs (TREE_OPERAND (body
, 0));
681 tree decl
= DECL_EXPR_DECL (body
);
682 if (TREE_CODE (decl
) == USING_DECL
683 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
684 || DECL_ARTIFICIAL (decl
))
686 return error_mark_node
;
689 case CLEANUP_POINT_EXPR
:
690 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
693 if (!check_constexpr_bind_expr_vars (body
))
694 return error_mark_node
;
695 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
698 case DEBUG_BEGIN_STMT
:
703 tree fun
= get_function_named_in_call (body
);
705 && DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
)
711 return error_mark_node
;
715 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
716 FUN; do the necessary transformations to turn it into a single expression
717 that we can store in the hash table. */
720 massage_constexpr_body (tree fun
, tree body
)
722 if (DECL_CONSTRUCTOR_P (fun
))
723 body
= build_constexpr_constructor_member_initializers
724 (DECL_CONTEXT (fun
), body
);
725 else if (cxx_dialect
< cxx14
)
727 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
728 body
= EH_SPEC_STMTS (body
);
729 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
730 body
= TREE_OPERAND (body
, 0);
731 body
= constexpr_fn_retval (body
);
736 /* CTYPE is a type constructed from BODY. Return true if some
737 bases/fields are uninitialized, and complain if COMPLAIN. */
740 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
746 if (TREE_CODE (body
) != CONSTRUCTOR
)
748 nelts
= CONSTRUCTOR_NELTS (body
);
750 tree field
= TYPE_FIELDS (ctype
);
752 if (TREE_CODE (ctype
) == UNION_TYPE
)
754 if (nelts
== 0 && next_initializable_field (field
))
757 error ("%<constexpr%> constructor for union %qT must "
758 "initialize exactly one non-static data member", ctype
);
764 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
765 need an explicit initialization. */
767 for (unsigned i
= 0; i
<= nelts
; ++i
)
769 tree index
= NULL_TREE
;
772 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
773 /* Skip base and vtable inits. */
774 if (TREE_CODE (index
) != FIELD_DECL
775 || DECL_ARTIFICIAL (index
))
779 for (; field
!= index
; field
= DECL_CHAIN (field
))
782 if (TREE_CODE (field
) != FIELD_DECL
)
784 if (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
786 if (DECL_ARTIFICIAL (field
))
788 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
790 /* Recurse to check the anonummous aggregate member. */
791 bad
|= cx_check_missing_mem_inits
792 (TREE_TYPE (field
), NULL_TREE
, complain
);
793 if (bad
&& !complain
)
797 ftype
= strip_array_types (TREE_TYPE (field
));
798 if (type_has_constexpr_default_constructor (ftype
))
800 /* It's OK to skip a member with a trivial constexpr ctor.
801 A constexpr ctor that isn't trivial should have been
803 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
809 error ("member %qD must be initialized by mem-initializer "
810 "in %<constexpr%> constructor", field
);
811 inform (DECL_SOURCE_LOCATION (field
), "declared here");
814 if (field
== NULL_TREE
)
817 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
819 /* Check the anonymous aggregate initializer is valid. */
820 bad
|= cx_check_missing_mem_inits
821 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
822 if (bad
&& !complain
)
825 field
= DECL_CHAIN (field
);
831 /* We are processing the definition of the constexpr function FUN.
832 Check that its BODY fulfills the propriate requirements and
833 enter it in the constexpr function definition table.
834 For constructor BODY is actually the TREE_LIST of the
835 member-initializer list. */
838 register_constexpr_fundef (tree fun
, tree body
)
840 constexpr_fundef entry
;
841 constexpr_fundef
**slot
;
843 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
846 tree massaged
= massage_constexpr_body (fun
, body
);
847 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
849 if (!DECL_CONSTRUCTOR_P (fun
))
850 error ("body of %<constexpr%> function %qD not a return-statement",
855 if (!potential_rvalue_constant_expression (massaged
))
857 if (!DECL_GENERATED_P (fun
))
858 require_potential_rvalue_constant_expression (massaged
);
862 if (DECL_CONSTRUCTOR_P (fun
)
863 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
864 massaged
, !DECL_GENERATED_P (fun
)))
867 /* Create the constexpr function table if necessary. */
868 if (constexpr_fundef_table
== NULL
)
869 constexpr_fundef_table
870 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
874 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
876 gcc_assert (*slot
== NULL
);
877 *slot
= ggc_alloc
<constexpr_fundef
> ();
883 /* FUN is a non-constexpr function called in a context that requires a
884 constant expression. If it comes from a constexpr template, explain why
885 the instantiation isn't constexpr. */
888 explain_invalid_constexpr_fn (tree fun
)
890 static hash_set
<tree
> *diagnosed
;
893 /* Only diagnose defaulted functions, lambdas, or instantiations. */
894 if (!DECL_DEFAULTED_FN (fun
)
895 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
896 && !is_instantiation_of_constexpr (fun
))
898 if (diagnosed
== NULL
)
899 diagnosed
= new hash_set
<tree
>;
900 if (diagnosed
->add (fun
))
901 /* Already explained. */
904 save_loc
= input_location
;
905 if (!lambda_static_thunk_p (fun
))
907 /* Diagnostics should completely ignore the static thunk, so leave
908 input_location set to our caller's location. */
909 input_location
= DECL_SOURCE_LOCATION (fun
);
910 inform (input_location
,
911 "%qD is not usable as a %<constexpr%> function because:", fun
);
913 /* First check the declaration. */
914 if (is_valid_constexpr_fn (fun
, true))
916 /* Then if it's OK, the body. */
917 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
918 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
919 explain_implicit_non_constexpr (fun
);
922 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
923 require_potential_rvalue_constant_expression (body
);
924 if (DECL_CONSTRUCTOR_P (fun
))
925 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
928 input_location
= save_loc
;
931 /* Objects of this type represent calls to constexpr functions
932 along with the bindings of parameters to their arguments, for
933 the purpose of compile time evaluation. */
935 struct GTY((for_user
)) constexpr_call
{
936 /* Description of the constexpr function definition. */
937 constexpr_fundef
*fundef
;
938 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
939 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
940 Note: This arrangement is made to accommodate the use of
941 iterative_hash_template_arg (see pt.c). If you change this
942 representation, also change the hash calculation in
943 cxx_eval_call_expression. */
945 /* Result of the call.
946 NULL means the call is being evaluated.
947 error_mark_node means that the evaluation was erroneous;
948 otherwise, the actuall value of the call. */
950 /* The hash of this call; we remember it here to avoid having to
951 recalculate it when expanding the hash table. */
955 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
957 static hashval_t
hash (constexpr_call
*);
958 static bool equal (constexpr_call
*, constexpr_call
*);
961 enum constexpr_switch_state
{
962 /* Used when processing a switch for the first time by cxx_eval_switch_expr
963 and default: label for that switch has not been seen yet. */
964 css_default_not_seen
,
965 /* Used when processing a switch for the first time by cxx_eval_switch_expr
966 and default: label for that switch has been seen already. */
968 /* Used when processing a switch for the second time by
969 cxx_eval_switch_expr, where default: label should match. */
970 css_default_processing
973 /* The constexpr expansion context. CALL is the current function
974 expansion, CTOR is the current aggregate initializer, OBJECT is the
975 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
976 is a map of values of variables initialized within the expression. */
978 struct constexpr_ctx
{
979 /* The innermost call we're evaluating. */
980 constexpr_call
*call
;
981 /* Values for any temporaries or local variables within the
982 constant-expression. */
983 hash_map
<tree
,tree
> *values
;
984 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
985 aren't inside a loop. */
986 hash_set
<tree
> *save_exprs
;
987 /* The CONSTRUCTOR we're currently building up for an aggregate
990 /* The object we're building the CONSTRUCTOR for. */
992 /* If inside SWITCH_EXPR. */
993 constexpr_switch_state
*css_state
;
994 /* Whether we should error on a non-constant expression or fail quietly. */
996 /* Whether we are strictly conforming to constant expression rules or
997 trying harder to get a constant value. */
1001 /* A table of all constexpr calls that have been evaluated by the
1002 compiler in this translation unit. */
1004 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1006 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1007 bool, bool *, bool *, tree
* = NULL
);
1009 /* Compute a hash value for a constexpr call representation. */
1012 constexpr_call_hasher::hash (constexpr_call
*info
)
1017 /* Return true if the objects pointed to by P and Q represent calls
1018 to the same constexpr function with the same arguments.
1019 Otherwise, return false. */
1022 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1028 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1030 lhs_bindings
= lhs
->bindings
;
1031 rhs_bindings
= rhs
->bindings
;
1032 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1034 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1035 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1036 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1037 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1039 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1040 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1042 return lhs_bindings
== rhs_bindings
;
1045 /* Initialize the constexpr call table, if needed. */
1048 maybe_initialize_constexpr_call_table (void)
1050 if (constexpr_call_table
== NULL
)
1051 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1054 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1055 a function happens to get called recursively, we unshare the callee
1056 function's body and evaluate this unshared copy instead of evaluating the
1059 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1060 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1061 that's keyed off of the original FUNCTION_DECL and whose value is a
1062 TREE_LIST of this function's unused copies awaiting reuse.
1064 This is not GC-deletable to avoid GC affecting UID generation. */
1066 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1068 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1071 maybe_initialize_fundef_copies_table ()
1073 if (fundef_copies_table
== NULL
)
1074 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1077 /* Reuse a copy or create a new unshared copy of the function FUN.
1078 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1079 is parms, TYPE is result. */
1082 get_fundef_copy (tree fun
)
1084 maybe_initialize_fundef_copies_table ();
1088 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1092 /* There is no cached function available, or in use. We can use
1093 the function directly. That the slot is now created records
1094 that this function is now in use. */
1095 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1096 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1098 else if (*slot
== NULL_TREE
)
1100 /* We've already used the function itself, so make a copy. */
1101 copy
= build_tree_list (NULL
, NULL
);
1102 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1106 /* We have a cached function available. */
1108 *slot
= TREE_CHAIN (copy
);
1114 /* Save the copy COPY of function FUN for later reuse by
1115 get_fundef_copy(). By construction, there will always be an entry
1119 save_fundef_copy (tree fun
, tree copy
)
1121 tree
*slot
= fundef_copies_table
->get (fun
);
1122 TREE_CHAIN (copy
) = *slot
;
1126 /* We have an expression tree T that represents a call, either CALL_EXPR
1127 or AGGR_INIT_EXPR. Return the Nth argument. */
1130 get_nth_callarg (tree t
, int n
)
1132 switch (TREE_CODE (t
))
1135 return CALL_EXPR_ARG (t
, n
);
1137 case AGGR_INIT_EXPR
:
1138 return AGGR_INIT_EXPR_ARG (t
, n
);
1146 /* Attempt to evaluate T which represents a call to a builtin function.
1147 We assume here that all builtin functions evaluate to scalar types
1148 represented by _CST nodes. */
1151 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1153 bool *non_constant_p
, bool *overflow_p
)
1155 const int nargs
= call_expr_nargs (t
);
1156 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1160 /* Don't fold __builtin_constant_p within a constexpr function. */
1161 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1164 && current_function_decl
1165 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1167 *non_constant_p
= true;
1171 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1172 return constant false for a non-constant argument. */
1173 constexpr_ctx new_ctx
= *ctx
;
1174 new_ctx
.quiet
= true;
1175 bool dummy1
= false, dummy2
= false;
1176 for (i
= 0; i
< nargs
; ++i
)
1178 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1179 false, &dummy1
, &dummy2
);
1181 /* For __built_in_constant_p, fold all expressions with constant values
1182 even if they aren't C++ constant-expressions. */
1183 args
[i
] = cp_fully_fold (args
[i
]);
1186 bool save_ffbcp
= force_folding_builtin_constant_p
;
1187 force_folding_builtin_constant_p
= true;
1188 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1189 CALL_EXPR_FN (t
), nargs
, args
);
1190 force_folding_builtin_constant_p
= save_ffbcp
;
1191 if (new_call
== NULL
)
1193 if (!*non_constant_p
&& !ctx
->quiet
)
1195 /* Do not allow__builtin_unreachable in constexpr function.
1196 The __builtin_unreachable call with BUILTINS_LOCATION
1197 comes from cp_maybe_instrument_return. */
1198 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
1199 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1200 error ("%<constexpr%> call flows off the end of the function");
1203 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1204 CALL_EXPR_FN (t
), nargs
, args
);
1205 error ("%q+E is not a constant expression", new_call
);
1208 *non_constant_p
= true;
1212 if (!is_constant_expression (new_call
))
1214 if (!*non_constant_p
&& !ctx
->quiet
)
1215 error ("%q+E is not a constant expression", new_call
);
1216 *non_constant_p
= true;
1220 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1221 non_constant_p
, overflow_p
);
1224 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1225 the type of the value to match. */
1228 adjust_temp_type (tree type
, tree temp
)
1230 if (TREE_TYPE (temp
) == type
)
1232 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1233 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1234 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1235 gcc_assert (scalarish_type_p (type
));
1236 return cp_fold_convert (type
, temp
);
1239 /* Callback for walk_tree used by unshare_constructor. */
1242 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1246 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1251 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1252 subexpression, return an unshared copy of T. Otherwise return T. */
1255 unshare_constructor (tree t
)
1257 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1258 if (ctor
!= NULL_TREE
)
1259 return unshare_expr (t
);
1263 /* Subroutine of cxx_eval_call_expression.
1264 We are processing a call expression (either CALL_EXPR or
1265 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1266 all arguments and bind their values to correspondings
1267 parameters, making up the NEW_CALL context. */
1270 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1271 constexpr_call
*new_call
,
1272 bool *non_constant_p
, bool *overflow_p
,
1273 bool *non_constant_args
)
1275 const int nargs
= call_expr_nargs (t
);
1276 tree fun
= new_call
->fundef
->decl
;
1277 tree parms
= DECL_ARGUMENTS (fun
);
1279 tree
*p
= &new_call
->bindings
;
1280 for (i
= 0; i
< nargs
; ++i
)
1283 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1284 x
= get_nth_callarg (t
, i
);
1285 /* For member function, the first argument is a pointer to the implied
1286 object. For a constructor, it might still be a dummy object, in
1287 which case we get the real argument from ctx. */
1288 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1289 && is_dummy_object (x
))
1292 x
= build_address (x
);
1294 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1295 non_constant_p
, overflow_p
);
1296 /* Don't VERIFY_CONSTANT here. */
1297 if (*non_constant_p
&& ctx
->quiet
)
1299 /* Just discard ellipsis args after checking their constantitude. */
1303 if (!*non_constant_p
)
1305 /* Make sure the binding has the same type as the parm. But
1306 only for constant args. */
1307 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1308 arg
= adjust_temp_type (type
, arg
);
1309 if (!TREE_CONSTANT (arg
))
1310 *non_constant_args
= true;
1311 *p
= build_tree_list (parms
, arg
);
1312 p
= &TREE_CHAIN (*p
);
1314 parms
= TREE_CHAIN (parms
);
1318 /* Variables and functions to manage constexpr call expansion context.
1319 These do not need to be marked for PCH or GC. */
1321 /* FIXME remember and print actual constant arguments. */
1322 static vec
<tree
> call_stack
;
1323 static int call_stack_tick
;
1324 static int last_cx_error_tick
;
1327 push_cx_call_context (tree call
)
1330 if (!EXPR_HAS_LOCATION (call
))
1331 SET_EXPR_LOCATION (call
, input_location
);
1332 call_stack
.safe_push (call
);
1333 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1339 pop_cx_call_context (void)
1346 cx_error_context (void)
1348 vec
<tree
> r
= vNULL
;
1349 if (call_stack_tick
!= last_cx_error_tick
1350 && !call_stack
.is_empty ())
1352 last_cx_error_tick
= call_stack_tick
;
1356 /* Evaluate a call T to a GCC internal function when possible and return
1357 the evaluated result or, under the control of CTX, give an error, set
1358 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1361 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1363 bool *non_constant_p
, bool *overflow_p
)
1365 enum tree_code opcode
= ERROR_MARK
;
1367 switch (CALL_EXPR_IFN (t
))
1369 case IFN_UBSAN_NULL
:
1370 case IFN_UBSAN_BOUNDS
:
1371 case IFN_UBSAN_VPTR
:
1372 case IFN_FALLTHROUGH
:
1375 case IFN_ADD_OVERFLOW
:
1378 case IFN_SUB_OVERFLOW
:
1379 opcode
= MINUS_EXPR
;
1381 case IFN_MUL_OVERFLOW
:
1386 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1387 false, non_constant_p
, overflow_p
);
1391 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1392 "call to internal function %qE", t
);
1393 *non_constant_p
= true;
1397 /* Evaluate constant arguments using OPCODE and return a complex
1398 number containing the result and the overflow bit. */
1399 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1400 non_constant_p
, overflow_p
);
1401 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1402 non_constant_p
, overflow_p
);
1404 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1406 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1407 tree type
= TREE_TYPE (TREE_TYPE (t
));
1408 tree result
= fold_binary_loc (loc
, opcode
, type
,
1409 fold_convert_loc (loc
, type
, arg0
),
1410 fold_convert_loc (loc
, type
, arg1
));
1412 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1413 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1414 if (TREE_OVERFLOW (result
))
1415 TREE_OVERFLOW (result
) = 0;
1417 return build_complex (TREE_TYPE (t
), result
, ovf
);
1420 *non_constant_p
= true;
1424 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1427 clear_no_implicit_zero (tree ctor
)
1429 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1431 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1432 tree elt
; unsigned HOST_WIDE_INT idx
;
1433 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1434 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1435 clear_no_implicit_zero (elt
);
1439 /* Subroutine of cxx_eval_constant_expression.
1440 Evaluate the call expression tree T in the context of OLD_CALL expression
1444 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1446 bool *non_constant_p
, bool *overflow_p
)
1448 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1449 tree fun
= get_function_named_in_call (t
);
1450 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1453 if (fun
== NULL_TREE
)
1454 return cxx_eval_internal_function (ctx
, t
, lval
,
1455 non_constant_p
, overflow_p
);
1457 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1459 /* Might be a constexpr function pointer. */
1460 fun
= cxx_eval_constant_expression (ctx
, fun
,
1461 /*lval*/false, non_constant_p
,
1464 if (TREE_CODE (fun
) == ADDR_EXPR
)
1465 fun
= TREE_OPERAND (fun
, 0);
1467 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1469 if (!ctx
->quiet
&& !*non_constant_p
)
1470 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1472 *non_constant_p
= true;
1475 if (DECL_CLONED_FUNCTION_P (fun
))
1476 fun
= DECL_CLONED_FUNCTION (fun
);
1478 if (is_ubsan_builtin_p (fun
))
1481 if (is_builtin_fn (fun
))
1482 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1483 lval
, non_constant_p
, overflow_p
);
1484 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1488 if (!lambda_static_thunk_p (fun
))
1489 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1490 explain_invalid_constexpr_fn (fun
);
1492 *non_constant_p
= true;
1496 constexpr_ctx new_ctx
= *ctx
;
1497 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1498 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1500 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1501 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1502 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1503 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1504 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1505 ctx
->values
->put (new_ctx
.object
, ctor
);
1509 /* Shortcut trivial constructor/op=. */
1510 if (trivial_fn_p (fun
))
1512 tree init
= NULL_TREE
;
1513 if (call_expr_nargs (t
) == 2)
1514 init
= convert_from_reference (get_nth_callarg (t
, 1));
1515 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1516 && AGGR_INIT_ZERO_FIRST (t
))
1517 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1520 tree op
= get_nth_callarg (t
, 0);
1521 if (is_dummy_object (op
))
1524 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1525 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1526 new_ctx
.call
= &new_call
;
1527 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1528 non_constant_p
, overflow_p
);
1532 /* We can't defer instantiating the function any longer. */
1533 if (!DECL_INITIAL (fun
)
1534 && DECL_TEMPLOID_INSTANTIATION (fun
))
1536 location_t save_loc
= input_location
;
1537 input_location
= loc
;
1539 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1541 input_location
= save_loc
;
1544 /* If in direct recursive call, optimize definition search. */
1545 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1546 new_call
.fundef
= ctx
->call
->fundef
;
1549 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1550 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1551 || fun
== current_function_decl
)
1555 /* We need to check for current_function_decl here in case we're
1556 being called during cp_fold_function, because at that point
1557 DECL_INITIAL is set properly and we have a fundef but we
1558 haven't lowered invisirefs yet (c++/70344). */
1559 if (DECL_INITIAL (fun
) == error_mark_node
1560 || fun
== current_function_decl
)
1561 error_at (loc
, "%qD called in a constant expression before its "
1562 "definition is complete", fun
);
1563 else if (DECL_INITIAL (fun
))
1565 /* The definition of fun was somehow unsuitable. But pretend
1566 that lambda static thunks don't exist. */
1567 if (!lambda_static_thunk_p (fun
))
1568 error_at (loc
, "%qD called in a constant expression", fun
);
1569 explain_invalid_constexpr_fn (fun
);
1572 error_at (loc
, "%qD used before its definition", fun
);
1574 *non_constant_p
= true;
1579 bool non_constant_args
= false;
1580 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1581 non_constant_p
, overflow_p
, &non_constant_args
);
1582 if (*non_constant_p
)
1585 depth_ok
= push_cx_call_context (t
);
1587 tree result
= NULL_TREE
;
1589 constexpr_call
*entry
= NULL
;
1590 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1592 new_call
.hash
= iterative_hash_template_arg
1593 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1595 /* If we have seen this call before, we are done. */
1596 maybe_initialize_constexpr_call_table ();
1597 constexpr_call
**slot
1598 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1602 /* We need to keep a pointer to the entry, not just the slot, as the
1603 slot can move in the call to cxx_eval_builtin_function_call. */
1604 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1607 /* Calls that are in progress have their result set to NULL,
1608 so that we can detect circular dependencies. */
1609 else if (entry
->result
== NULL
)
1612 error ("call has circular dependency");
1613 *non_constant_p
= true;
1614 entry
->result
= result
= error_mark_node
;
1617 result
= entry
->result
;
1623 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1624 "-fconstexpr-depth= to increase the maximum)",
1625 max_constexpr_depth
);
1626 *non_constant_p
= true;
1627 result
= error_mark_node
;
1631 if (result
&& result
!= error_mark_node
)
1633 else if (!DECL_SAVED_TREE (fun
))
1635 /* When at_eof >= 2, cgraph has started throwing away
1636 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1637 late code generation for VEC_INIT_EXPR, which needs to be
1638 completely reconsidered. */
1639 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1640 *non_constant_p
= true;
1644 tree body
, parms
, res
;
1646 /* Reuse or create a new unshared copy of this function's body. */
1647 tree copy
= get_fundef_copy (fun
);
1648 body
= TREE_PURPOSE (copy
);
1649 parms
= TREE_VALUE (copy
);
1650 res
= TREE_TYPE (copy
);
1652 /* Associate the bindings with the remapped parms. */
1653 tree bound
= new_call
.bindings
;
1654 tree remapped
= parms
;
1657 tree oparm
= TREE_PURPOSE (bound
);
1658 tree arg
= TREE_VALUE (bound
);
1659 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1660 /* Don't share a CONSTRUCTOR that might be changed. */
1661 arg
= unshare_constructor (arg
);
1662 ctx
->values
->put (remapped
, arg
);
1663 bound
= TREE_CHAIN (bound
);
1664 remapped
= DECL_CHAIN (remapped
);
1666 /* Add the RESULT_DECL to the values map, too. */
1667 tree slot
= NULL_TREE
;
1668 if (DECL_BY_REFERENCE (res
))
1670 slot
= AGGR_INIT_EXPR_SLOT (t
);
1671 tree addr
= build_address (slot
);
1672 addr
= build_nop (TREE_TYPE (res
), addr
);
1673 ctx
->values
->put (res
, addr
);
1674 ctx
->values
->put (slot
, NULL_TREE
);
1677 ctx
->values
->put (res
, NULL_TREE
);
1679 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1680 their values after the call. */
1681 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1682 hash_set
<tree
> save_exprs
;
1683 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1684 ctx_with_save_exprs
.call
= &new_call
;
1686 tree jump_target
= NULL_TREE
;
1687 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1688 lval
, non_constant_p
, overflow_p
,
1691 if (DECL_CONSTRUCTOR_P (fun
))
1692 /* This can be null for a subobject constructor call, in
1693 which case what we care about is the initialization
1694 side-effects rather than the value. We could get at the
1695 value by evaluating *this, but we don't bother; there's
1696 no need to put such a call in the hash table. */
1697 result
= lval
? ctx
->object
: ctx
->ctor
;
1698 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1702 result
= *ctx
->values
->get (slot
? slot
: res
);
1703 if (result
== NULL_TREE
&& !*non_constant_p
)
1706 error ("%<constexpr%> call flows off the end "
1708 *non_constant_p
= true;
1712 /* Forget the saved values of the callee's SAVE_EXPRs. */
1713 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1714 iter
!= save_exprs
.end(); ++iter
)
1715 ctx_with_save_exprs
.values
->remove (*iter
);
1717 /* Remove the parms/result from the values map. Is it worth
1718 bothering to do this when the map itself is only live for
1719 one constexpr evaluation? If so, maybe also clear out
1720 other vars from call, maybe in BIND_EXPR handling? */
1721 ctx
->values
->remove (res
);
1723 ctx
->values
->remove (slot
);
1724 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1725 ctx
->values
->remove (parm
);
1727 /* Make the unshared function copy we used available for re-use. */
1728 save_fundef_copy (fun
, copy
);
1731 if (result
== error_mark_node
)
1732 *non_constant_p
= true;
1733 if (*non_constant_p
|| *overflow_p
)
1734 result
= error_mark_node
;
1738 entry
->result
= result
;
1741 /* The result of a constexpr function must be completely initialized. */
1742 if (TREE_CODE (result
) == CONSTRUCTOR
)
1743 clear_no_implicit_zero (result
);
1745 pop_cx_call_context ();
1746 return unshare_constructor (result
);
1749 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1752 reduced_constant_expression_p (tree t
)
1754 switch (TREE_CODE (t
))
1757 /* Even if we can't lower this yet, it's constant. */
1761 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1762 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1763 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1764 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1767 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1770 /* We're in the middle of initializing this element. */
1772 if (!reduced_constant_expression_p (val
))
1778 field
= next_initializable_field (DECL_CHAIN (field
));
1783 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1784 /* All the fields are initialized. */
1785 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1789 /* FIXME are we calling this too much? */
1790 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1794 /* Some expressions may have constant operands but are not constant
1795 themselves, such as 1/0. Call this function (or rather, the macro
1796 following it) to check for that condition.
1798 We only call this in places that require an arithmetic constant, not in
1799 places where we might have a non-constant expression that can be a
1800 component of a constant expression, such as the address of a constexpr
1801 variable that might be dereferenced later. */
1804 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1807 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1809 if (!allow_non_constant
)
1810 error ("%q+E is not a constant expression", t
);
1811 *non_constant_p
= true;
1813 if (TREE_OVERFLOW_P (t
))
1815 if (!allow_non_constant
)
1817 permerror (input_location
, "overflow in constant expression");
1818 /* If we're being permissive (and are in an enforcing
1819 context), ignore the overflow. */
1820 if (flag_permissive
)
1821 return *non_constant_p
;
1825 return *non_constant_p
;
1828 /* Check whether the shift operation with code CODE and type TYPE on LHS
1829 and RHS is undefined. If it is, give an error with an explanation,
1830 and return true; return false otherwise. */
1833 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1834 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1836 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1837 || TREE_CODE (lhs
) != INTEGER_CST
1838 || TREE_CODE (rhs
) != INTEGER_CST
)
1841 tree lhstype
= TREE_TYPE (lhs
);
1842 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1844 /* [expr.shift] The behavior is undefined if the right operand
1845 is negative, or greater than or equal to the length in bits
1846 of the promoted left operand. */
1847 if (tree_int_cst_sgn (rhs
) == -1)
1850 permerror (loc
, "right operand of shift expression %q+E is negative",
1851 build2_loc (loc
, code
, type
, lhs
, rhs
));
1852 return (!flag_permissive
|| ctx
->quiet
);
1854 if (compare_tree_int (rhs
, uprec
) >= 0)
1857 permerror (loc
, "right operand of shift expression %q+E is >= than "
1858 "the precision of the left operand",
1859 build2_loc (loc
, code
, type
, lhs
, rhs
));
1860 return (!flag_permissive
|| ctx
->quiet
);
1863 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1864 if E1 has a signed type and non-negative value, and E1x2^E2 is
1865 representable in the corresponding unsigned type of the result type,
1866 then that value, converted to the result type, is the resulting value;
1867 otherwise, the behavior is undefined. */
1868 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1869 && (cxx_dialect
>= cxx11
))
1871 if (tree_int_cst_sgn (lhs
) == -1)
1875 "left operand of shift expression %q+E is negative",
1876 build2_loc (loc
, code
, type
, lhs
, rhs
));
1877 return (!flag_permissive
|| ctx
->quiet
);
1879 /* For signed x << y the following:
1880 (unsigned) x >> ((prec (lhs) - 1) - y)
1881 if > 1, is undefined. The right-hand side of this formula
1882 is the highest bit of the LHS that can be set (starting from 0),
1883 so that the shift doesn't overflow. We then right-shift the LHS
1884 to see whether any other bit is set making the original shift
1885 undefined -- the result is not representable in the corresponding
1887 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1888 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1889 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1890 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1891 if (tree_int_cst_lt (integer_one_node
, t
))
1894 permerror (loc
, "shift expression %q+E overflows",
1895 build2_loc (loc
, code
, type
, lhs
, rhs
));
1896 return (!flag_permissive
|| ctx
->quiet
);
1902 /* Subroutine of cxx_eval_constant_expression.
1903 Attempt to reduce the unary expression tree T to a compile time value.
1904 If successful, return the value. Otherwise issue a diagnostic
1905 and return error_mark_node. */
1908 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1910 bool *non_constant_p
, bool *overflow_p
)
1913 tree orig_arg
= TREE_OPERAND (t
, 0);
1914 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1915 non_constant_p
, overflow_p
);
1916 VERIFY_CONSTANT (arg
);
1917 location_t loc
= EXPR_LOCATION (t
);
1918 enum tree_code code
= TREE_CODE (t
);
1919 tree type
= TREE_TYPE (t
);
1920 r
= fold_unary_loc (loc
, code
, type
, arg
);
1923 if (arg
== orig_arg
)
1926 r
= build1_loc (loc
, code
, type
, arg
);
1928 VERIFY_CONSTANT (r
);
1932 /* Helper function for cxx_eval_binary_expression. Try to optimize
1933 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1934 generic folding should be used. */
1937 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1938 tree lhs
, tree rhs
, bool *non_constant_p
,
1942 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1945 lhs
= TREE_OPERAND (lhs
, 0);
1947 /* &A[i] p+ j => &A[i + j] */
1948 if (TREE_CODE (lhs
) == ARRAY_REF
1949 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1950 && TREE_CODE (rhs
) == INTEGER_CST
1951 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1952 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1954 tree orig_type
= TREE_TYPE (t
);
1955 location_t loc
= EXPR_LOCATION (t
);
1956 tree type
= TREE_TYPE (lhs
);
1958 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1959 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1960 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1962 if (*non_constant_p
)
1964 /* Don't fold an out-of-bound access. */
1965 if (!tree_int_cst_le (t
, nelts
))
1967 rhs
= cp_fold_convert (ssizetype
, rhs
);
1968 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1969 constexpr int A[1]; ... (char *)&A[0] + 1 */
1970 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1971 rhs
, TYPE_SIZE_UNIT (type
))))
1973 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1975 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1976 TYPE_SIZE_UNIT (type
));
1977 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1978 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1979 t
, NULL_TREE
, NULL_TREE
);
1980 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1981 t
= cp_fold_convert (orig_type
, t
);
1982 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1983 non_constant_p
, overflow_p
);
1989 /* Subroutine of cxx_eval_constant_expression.
1990 Like cxx_eval_unary_expression, except for binary expressions. */
1993 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1995 bool *non_constant_p
, bool *overflow_p
)
1998 tree orig_lhs
= TREE_OPERAND (t
, 0);
1999 tree orig_rhs
= TREE_OPERAND (t
, 1);
2001 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2002 non_constant_p
, overflow_p
);
2003 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2005 if (*non_constant_p
)
2007 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2008 non_constant_p
, overflow_p
);
2009 if (*non_constant_p
)
2012 location_t loc
= EXPR_LOCATION (t
);
2013 enum tree_code code
= TREE_CODE (t
);
2014 tree type
= TREE_TYPE (t
);
2016 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2018 bool is_code_eq
= (code
== EQ_EXPR
);
2020 if (TREE_CODE (lhs
) == PTRMEM_CST
2021 && TREE_CODE (rhs
) == PTRMEM_CST
)
2022 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2024 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2025 || TREE_CODE (rhs
) == PTRMEM_CST
)
2026 && (null_member_pointer_value_p (lhs
)
2027 || null_member_pointer_value_p (rhs
)))
2028 r
= constant_boolean_node (!is_code_eq
, type
);
2029 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2030 lhs
= cplus_expand_constant (lhs
);
2031 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2032 rhs
= cplus_expand_constant (rhs
);
2034 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2035 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2038 error ("arithmetic involving a null pointer in %qE", lhs
);
2041 else if (code
== POINTER_PLUS_EXPR
)
2042 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2046 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2050 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2053 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2055 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2056 *non_constant_p
= true;
2057 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2058 a local array in a constexpr function. */
2059 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2061 VERIFY_CONSTANT (r
);
2065 /* Subroutine of cxx_eval_constant_expression.
2066 Attempt to evaluate condition expressions. Dead branches are not
2070 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2072 bool *non_constant_p
, bool *overflow_p
,
2075 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2077 non_constant_p
, overflow_p
);
2078 VERIFY_CONSTANT (val
);
2079 /* Don't VERIFY_CONSTANT the other operands. */
2080 if (integer_zerop (val
))
2081 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2083 non_constant_p
, overflow_p
,
2085 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2087 non_constant_p
, overflow_p
,
2091 /* Subroutine of cxx_eval_constant_expression.
2092 Attempt to evaluate vector condition expressions. Unlike
2093 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2094 ternary arithmetics operation, where all 3 arguments have to be
2095 evaluated as constants and then folding computes the result from
2099 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2100 bool *non_constant_p
, bool *overflow_p
)
2102 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2104 non_constant_p
, overflow_p
);
2105 VERIFY_CONSTANT (arg1
);
2106 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2108 non_constant_p
, overflow_p
);
2109 VERIFY_CONSTANT (arg2
);
2110 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2112 non_constant_p
, overflow_p
);
2113 VERIFY_CONSTANT (arg3
);
2114 location_t loc
= EXPR_LOCATION (t
);
2115 tree type
= TREE_TYPE (t
);
2116 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2119 if (arg1
== TREE_OPERAND (t
, 0)
2120 && arg2
== TREE_OPERAND (t
, 1)
2121 && arg3
== TREE_OPERAND (t
, 2))
2124 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2126 VERIFY_CONSTANT (r
);
2130 /* Returns less than, equal to, or greater than zero if KEY is found to be
2131 less than, to match, or to be greater than the constructor_elt's INDEX. */
2134 array_index_cmp (tree key
, tree index
)
2136 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2138 switch (TREE_CODE (index
))
2141 return tree_int_cst_compare (key
, index
);
2144 tree lo
= TREE_OPERAND (index
, 0);
2145 tree hi
= TREE_OPERAND (index
, 1);
2146 if (tree_int_cst_lt (key
, lo
))
2148 else if (tree_int_cst_lt (hi
, key
))
2158 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2159 if none. If INSERT is true, insert a matching element rather than fail. */
2161 static HOST_WIDE_INT
2162 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2164 if (tree_int_cst_sgn (dindex
) < 0)
2167 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2168 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2169 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2171 unsigned HOST_WIDE_INT end
= len
;
2172 unsigned HOST_WIDE_INT begin
= 0;
2174 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2175 that the same is true of the other elements and index directly. */
2178 tree cindex
= (*elts
)[end
-1].index
;
2179 if (TREE_CODE (cindex
) == INTEGER_CST
2180 && compare_tree_int (cindex
, end
-1) == 0)
2189 /* Otherwise, find a matching index by means of a binary search. */
2190 while (begin
!= end
)
2192 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2193 constructor_elt
&elt
= (*elts
)[middle
];
2194 tree idx
= elt
.index
;
2196 int cmp
= array_index_cmp (dindex
, idx
);
2203 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2205 /* We need to split the range. */
2207 tree lo
= TREE_OPERAND (idx
, 0);
2208 tree hi
= TREE_OPERAND (idx
, 1);
2209 if (tree_int_cst_lt (lo
, dindex
))
2211 /* There are still some lower elts; shorten the range. */
2212 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2214 if (tree_int_cst_equal (lo
, new_hi
))
2215 /* Only one element left, no longer a range. */
2218 TREE_OPERAND (idx
, 1) = new_hi
;
2219 /* Append the element we want to insert. */
2222 e
.value
= unshare_constructor (elt
.value
);
2223 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2226 /* No lower elts, the range elt is now ours. */
2229 if (tree_int_cst_lt (dindex
, hi
))
2231 /* There are still some higher elts; append a range. */
2232 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2234 if (tree_int_cst_equal (new_lo
, hi
))
2237 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2238 e
.value
= unshare_constructor (elt
.value
);
2239 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2248 constructor_elt e
= { dindex
, NULL_TREE
};
2249 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2256 /* Under the control of CTX, issue a detailed diagnostic for
2257 an out-of-bounds subscript INDEX into the expression ARRAY. */
2260 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2264 tree arraytype
= TREE_TYPE (array
);
2266 /* Convert the unsigned array subscript to a signed integer to avoid
2267 printing huge numbers for small negative values. */
2268 tree sidx
= fold_convert (ssizetype
, index
);
2271 error ("array subscript value %qE is outside the bounds "
2272 "of array %qD of type %qT", sidx
, array
, arraytype
);
2273 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2276 error ("array subscript value %qE is outside the bounds "
2277 "of array type %qT", sidx
, arraytype
);
2281 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2282 STRING_CST STRING. */
2285 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2287 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2290 if (chars_per_elt
== 1)
2291 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2294 const unsigned char *ptr
2295 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2296 + index
* chars_per_elt
);
2297 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2302 /* Subroutine of cxx_eval_constant_expression.
2303 Attempt to reduce a reference to an array slot. */
2306 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2308 bool *non_constant_p
, bool *overflow_p
)
2310 tree oldary
= TREE_OPERAND (t
, 0);
2311 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2313 non_constant_p
, overflow_p
);
2315 HOST_WIDE_INT i
= 0;
2316 tree elem_type
= NULL_TREE
;
2317 unsigned len
= 0, elem_nchars
= 1;
2318 if (*non_constant_p
)
2320 oldidx
= TREE_OPERAND (t
, 1);
2321 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2323 non_constant_p
, overflow_p
);
2324 VERIFY_CONSTANT (index
);
2327 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2328 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2329 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2330 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2331 ary
= TREE_OPERAND (ary
, 0);
2332 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2333 len
= CONSTRUCTOR_NELTS (ary
);
2334 else if (TREE_CODE (ary
) == STRING_CST
)
2336 elem_nchars
= (TYPE_PRECISION (elem_type
)
2337 / TYPE_PRECISION (char_type_node
));
2338 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2340 else if (TREE_CODE (ary
) == VECTOR_CST
)
2341 /* We don't create variable-length VECTOR_CSTs. */
2342 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2345 /* We can't do anything with other tree codes, so use
2346 VERIFY_CONSTANT to complain and fail. */
2347 VERIFY_CONSTANT (ary
);
2351 if (!tree_fits_shwi_p (index
)
2352 || (i
= tree_to_shwi (index
)) < 0)
2354 diag_array_subscript (ctx
, ary
, index
);
2355 *non_constant_p
= true;
2361 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2362 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2363 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2364 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2368 /* For VLAs, the number of elements won't be an integer constant. */
2369 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2371 VERIFY_CONSTANT (nelts
);
2373 ? !tree_int_cst_le (index
, nelts
)
2374 : !tree_int_cst_lt (index
, nelts
))
2375 || tree_int_cst_sgn (index
) < 0)
2377 diag_array_subscript (ctx
, ary
, index
);
2378 *non_constant_p
= true;
2382 if (lval
&& ary
== oldary
&& index
== oldidx
)
2385 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2388 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2390 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2401 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2402 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2403 else if (TREE_CODE (ary
) == VECTOR_CST
)
2404 r
= VECTOR_CST_ELT (ary
, i
);
2406 r
= extract_string_elt (ary
, elem_nchars
, i
);
2409 /* Don't VERIFY_CONSTANT here. */
2412 /* Otherwise the element doesn't have a value yet. */
2417 if (TREE_CODE (ary
) == CONSTRUCTOR
2418 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2420 /* 'ary' is part of the aggregate initializer we're currently
2421 building; if there's no initializer for this element yet,
2424 error ("accessing uninitialized array element");
2425 *non_constant_p
= true;
2429 /* If it's within the array bounds but doesn't have an explicit
2430 initializer, it's value-initialized. */
2431 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2432 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2436 /* Subroutine of cxx_eval_constant_expression.
2437 Attempt to reduce a field access of a value of class type. */
2440 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2442 bool *non_constant_p
, bool *overflow_p
)
2444 unsigned HOST_WIDE_INT i
;
2447 tree part
= TREE_OPERAND (t
, 1);
2448 tree orig_whole
= TREE_OPERAND (t
, 0);
2449 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2451 non_constant_p
, overflow_p
);
2452 if (TREE_CODE (whole
) == INDIRECT_REF
2453 && integer_zerop (TREE_OPERAND (whole
, 0))
2455 error ("dereferencing a null pointer in %qE", orig_whole
);
2457 if (TREE_CODE (whole
) == PTRMEM_CST
)
2458 whole
= cplus_expand_constant (whole
);
2459 if (whole
== orig_whole
)
2462 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2463 whole
, part
, NULL_TREE
);
2464 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2466 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2469 error ("%qE is not a constant expression", orig_whole
);
2470 *non_constant_p
= true;
2472 if (DECL_MUTABLE_P (part
))
2475 error ("mutable %qD is not usable in a constant expression", part
);
2476 *non_constant_p
= true;
2478 if (*non_constant_p
)
2480 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2481 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2483 /* Use name match for PMF fields, as a variant will have a
2484 different FIELD_DECL with a different type. */
2485 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2491 /* We're in the middle of initializing it. */
2495 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2496 && CONSTRUCTOR_NELTS (whole
) > 0)
2498 /* DR 1188 says we don't have to deal with this. */
2500 error ("accessing %qD member instead of initialized %qD member in "
2501 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2502 *non_constant_p
= true;
2506 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2507 classes never get represented; throw together a value now. */
2508 if (is_really_empty_class (TREE_TYPE (t
)))
2509 return build_constructor (TREE_TYPE (t
), NULL
);
2511 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2513 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2515 /* 'whole' is part of the aggregate initializer we're currently
2516 building; if there's no initializer for this member yet, that's an
2519 error ("accessing uninitialized member %qD", part
);
2520 *non_constant_p
= true;
2524 /* If there's no explicit init for this field, it's value-initialized. */
2525 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2526 return cxx_eval_constant_expression (ctx
, value
,
2528 non_constant_p
, overflow_p
);
2531 /* Subroutine of cxx_eval_constant_expression.
2532 Attempt to reduce a field access of a value of class type that is
2533 expressed as a BIT_FIELD_REF. */
2536 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2538 bool *non_constant_p
, bool *overflow_p
)
2540 tree orig_whole
= TREE_OPERAND (t
, 0);
2541 tree retval
, fldval
, utype
, mask
;
2542 bool fld_seen
= false;
2543 HOST_WIDE_INT istart
, isize
;
2544 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2546 non_constant_p
, overflow_p
);
2547 tree start
, field
, value
;
2548 unsigned HOST_WIDE_INT i
;
2550 if (whole
== orig_whole
)
2552 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2554 if (!*non_constant_p
2555 && TREE_CODE (whole
) != VECTOR_CST
2556 && TREE_CODE (whole
) != CONSTRUCTOR
)
2559 error ("%qE is not a constant expression", orig_whole
);
2560 *non_constant_p
= true;
2562 if (*non_constant_p
)
2565 if (TREE_CODE (whole
) == VECTOR_CST
)
2566 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2567 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2569 start
= TREE_OPERAND (t
, 2);
2570 istart
= tree_to_shwi (start
);
2571 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2572 utype
= TREE_TYPE (t
);
2573 if (!TYPE_UNSIGNED (utype
))
2574 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2575 retval
= build_int_cst (utype
, 0);
2576 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2578 tree bitpos
= bit_position (field
);
2579 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2581 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2582 && TREE_CODE (value
) == INTEGER_CST
2583 && tree_fits_shwi_p (bitpos
)
2584 && tree_fits_shwi_p (DECL_SIZE (field
)))
2586 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2587 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2588 HOST_WIDE_INT shift
;
2589 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2591 fldval
= fold_convert (utype
, value
);
2592 mask
= build_int_cst_type (utype
, -1);
2593 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2594 size_int (TYPE_PRECISION (utype
) - sz
));
2595 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2596 size_int (TYPE_PRECISION (utype
) - sz
));
2597 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2598 shift
= bit
- istart
;
2599 if (BYTES_BIG_ENDIAN
)
2600 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2601 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2603 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2609 return fold_convert (TREE_TYPE (t
), retval
);
2611 return error_mark_node
;
2614 /* Subroutine of cxx_eval_constant_expression.
2615 Evaluate a short-circuited logical expression T in the context
2616 of a given constexpr CALL. BAILOUT_VALUE is the value for
2617 early return. CONTINUE_VALUE is used here purely for
2618 sanity check purposes. */
2621 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2622 tree bailout_value
, tree continue_value
,
2624 bool *non_constant_p
, bool *overflow_p
)
2627 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2629 non_constant_p
, overflow_p
);
2630 VERIFY_CONSTANT (lhs
);
2631 if (tree_int_cst_equal (lhs
, bailout_value
))
2633 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2634 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2635 lval
, non_constant_p
,
2637 VERIFY_CONSTANT (r
);
2641 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2642 CONSTRUCTOR elements to initialize (part of) an object containing that
2643 field. Return a pointer to the constructor_elt corresponding to the
2644 initialization of the field. */
2646 static constructor_elt
*
2647 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2649 tree aggr
= TREE_OPERAND (ref
, 0);
2650 tree field
= TREE_OPERAND (ref
, 1);
2652 constructor_elt
*ce
;
2654 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2656 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2658 constructor_elt
*base_ce
2659 = base_field_constructor_elt (v
, aggr
);
2660 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2663 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2664 if (ce
->index
== field
)
2671 /* Some of the expressions fed to the constexpr mechanism are calls to
2672 constructors, which have type void. In that case, return the type being
2673 initialized by the constructor. */
2676 initialized_type (tree t
)
2680 tree type
= cv_unqualified (TREE_TYPE (t
));
2681 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2683 /* A constructor call has void type, so we need to look deeper. */
2684 tree fn
= get_function_named_in_call (t
);
2685 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2686 && DECL_CXX_CONSTRUCTOR_P (fn
))
2687 type
= DECL_CONTEXT (fn
);
2692 /* We're about to initialize element INDEX of an array or class from VALUE.
2693 Set up NEW_CTX appropriately by adjusting .object to refer to the
2694 subobject and creating a new CONSTRUCTOR if the element is itself
2695 a class or array. */
2698 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2699 tree index
, tree
&value
)
2703 if (index
&& TREE_CODE (index
) != INTEGER_CST
2704 && TREE_CODE (index
) != FIELD_DECL
)
2705 /* This won't have an element in the new CONSTRUCTOR. */
2708 tree type
= initialized_type (value
);
2709 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2710 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2713 /* The sub-aggregate initializer might contain a placeholder;
2714 update object to refer to the subobject and ctor to refer to
2715 the (newly created) sub-initializer. */
2717 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2718 tree elt
= build_constructor (type
, NULL
);
2719 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2722 if (TREE_CODE (value
) == TARGET_EXPR
)
2723 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2724 value
= TARGET_EXPR_INITIAL (value
);
2727 /* We're about to process an initializer for a class or array TYPE. Make
2728 sure that CTX is set up appropriately. */
2731 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2733 /* We don't bother building a ctor for an empty base subobject. */
2734 if (is_empty_class (type
))
2737 /* We're in the middle of an initializer that might involve placeholders;
2738 our caller should have created a CONSTRUCTOR for us to put the
2739 initializer into. We will either return that constructor or T. */
2740 gcc_assert (ctx
->ctor
);
2741 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2742 (type
, TREE_TYPE (ctx
->ctor
)));
2743 /* We used to check that ctx->ctor was empty, but that isn't the case when
2744 the object is zero-initialized before calling the constructor. */
2747 tree otype
= TREE_TYPE (ctx
->object
);
2748 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2749 /* Handle flexible array members. */
2750 || (TREE_CODE (otype
) == ARRAY_TYPE
2751 && TYPE_DOMAIN (otype
) == NULL_TREE
2752 && TREE_CODE (type
) == ARRAY_TYPE
2753 && (same_type_ignoring_top_level_qualifiers_p
2754 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2756 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2757 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2760 /* Subroutine of cxx_eval_constant_expression.
2761 The expression tree T denotes a C-style array or a C-style
2762 aggregate. Reduce it to a constant expression. */
2765 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2767 bool *non_constant_p
, bool *overflow_p
)
2769 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2770 bool changed
= false;
2771 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2772 tree type
= TREE_TYPE (t
);
2774 constexpr_ctx new_ctx
;
2775 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2777 /* We don't really need the ctx->ctor business for a PMF or
2778 vector, but it's simpler to use the same code. */
2780 new_ctx
.ctor
= build_constructor (type
, NULL
);
2781 new_ctx
.object
= NULL_TREE
;
2784 verify_ctor_sanity (ctx
, type
);
2785 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2786 vec_alloc (*p
, vec_safe_length (v
));
2790 bool constant_p
= true;
2791 bool side_effects_p
= false;
2792 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2794 tree orig_value
= value
;
2795 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2796 if (new_ctx
.ctor
!= ctx
->ctor
)
2797 /* If we built a new CONSTRUCTOR, attach it now so that other
2798 initializers can refer to it. */
2799 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2800 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2802 non_constant_p
, overflow_p
);
2803 /* Don't VERIFY_CONSTANT here. */
2804 if (ctx
->quiet
&& *non_constant_p
)
2806 if (elt
!= orig_value
)
2809 if (!TREE_CONSTANT (elt
))
2811 if (TREE_SIDE_EFFECTS (elt
))
2812 side_effects_p
= true;
2813 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2815 /* This is an initialization of a vfield inside a base
2816 subaggregate that we already initialized; push this
2817 initialization into the previous initialization. */
2818 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2823 && (TREE_CODE (index
) == NOP_EXPR
2824 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2826 /* This is an initializer for an empty base; now that we've
2827 checked that it's constant, we can ignore it. */
2828 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2831 else if (new_ctx
.ctor
!= ctx
->ctor
)
2833 /* We appended this element above; update the value. */
2834 gcc_assert ((*p
)->last().index
== index
);
2835 (*p
)->last().value
= elt
;
2838 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2840 if (*non_constant_p
|| !changed
)
2843 /* We're done building this CONSTRUCTOR, so now we can interpret an
2844 element without an explicit initializer as value-initialized. */
2845 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2846 TREE_CONSTANT (t
) = constant_p
;
2847 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2848 if (VECTOR_TYPE_P (type
))
2853 /* Subroutine of cxx_eval_constant_expression.
2854 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2855 initialization of a non-static data member of array type. Reduce it to a
2858 Note that apart from value-initialization (when VALUE_INIT is true),
2859 this is only intended to support value-initialization and the
2860 initializations done by defaulted constructors for classes with
2861 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2862 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2863 for the copy/move constructor. */
2866 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2867 bool value_init
, bool lval
,
2868 bool *non_constant_p
, bool *overflow_p
)
2870 tree elttype
= TREE_TYPE (atype
);
2871 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2872 verify_ctor_sanity (ctx
, atype
);
2873 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2874 vec_alloc (*p
, max
+ 1);
2875 bool pre_init
= false;
2876 unsigned HOST_WIDE_INT i
;
2878 /* For the default constructor, build up a call to the default
2879 constructor of the element type. We only need to handle class types
2880 here, as for a constructor to be constexpr, all members must be
2881 initialized, which for a defaulted default constructor means they must
2882 be of a class type with a constexpr default constructor. */
2883 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2884 /* We only do this at the lowest level. */;
2885 else if (value_init
)
2887 init
= build_value_init (elttype
, tf_warning_or_error
);
2892 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2893 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2894 &argvec
, elttype
, LOOKUP_NORMAL
,
2895 tf_warning_or_error
);
2896 release_tree_vector (argvec
);
2897 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2901 for (i
= 0; i
< max
; ++i
)
2903 tree idx
= build_int_cst (size_type_node
, i
);
2906 constexpr_ctx new_ctx
;
2907 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2908 if (new_ctx
.ctor
!= ctx
->ctor
)
2909 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2910 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2912 /* A multidimensional array; recurse. */
2913 if (value_init
|| init
== NULL_TREE
)
2915 eltinit
= NULL_TREE
;
2919 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2920 tf_warning_or_error
);
2921 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2923 non_constant_p
, overflow_p
);
2927 /* Initializing an element using value or default initialization
2928 we just pre-built above. */
2929 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2930 non_constant_p
, overflow_p
);
2935 /* Copying an element. */
2936 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2937 (atype
, TREE_TYPE (init
)));
2938 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2939 tf_warning_or_error
);
2940 if (!lvalue_p (init
))
2941 eltinit
= move (eltinit
);
2942 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2943 eltinit
= (cxx_eval_constant_expression
2944 (&new_ctx
, eltinit
, lval
,
2945 non_constant_p
, overflow_p
));
2947 if (*non_constant_p
&& !ctx
->quiet
)
2949 if (new_ctx
.ctor
!= ctx
->ctor
)
2951 /* We appended this element above; update the value. */
2952 gcc_assert ((*p
)->last().index
== idx
);
2953 (*p
)->last().value
= eltinit
;
2956 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2957 /* Reuse the result of cxx_eval_constant_expression call
2958 from the first iteration to all others if it is a constant
2959 initializer that doesn't require relocations. */
2962 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2963 == null_pointer_node
))
2965 if (new_ctx
.ctor
!= ctx
->ctor
)
2966 eltinit
= new_ctx
.ctor
;
2967 for (i
= 1; i
< max
; ++i
)
2969 idx
= build_int_cst (size_type_node
, i
);
2970 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2976 if (!*non_constant_p
)
2979 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2985 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2987 bool *non_constant_p
, bool *overflow_p
)
2989 tree atype
= TREE_TYPE (t
);
2990 tree init
= VEC_INIT_EXPR_INIT (t
);
2991 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2992 VEC_INIT_EXPR_VALUE_INIT (t
),
2993 lval
, non_constant_p
, overflow_p
);
2994 if (*non_constant_p
)
3000 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3001 match. We want to be less strict for simple *& folding; if we have a
3002 non-const temporary that we access through a const pointer, that should
3003 work. We handle this here rather than change fold_indirect_ref_1
3004 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3005 don't really make sense outside of constant expression evaluation. Also
3006 we want to allow folding to COMPONENT_REF, which could cause trouble
3007 with TBAA in fold_indirect_ref_1.
3009 Try to keep this function synced with fold_indirect_ref_1. */
3012 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3018 subtype
= TREE_TYPE (sub
);
3019 if (!POINTER_TYPE_P (subtype
))
3022 if (TREE_CODE (sub
) == ADDR_EXPR
)
3024 tree op
= TREE_OPERAND (sub
, 0);
3025 tree optype
= TREE_TYPE (op
);
3027 /* *&CONST_DECL -> to the value of the const decl. */
3028 if (TREE_CODE (op
) == CONST_DECL
)
3029 return DECL_INITIAL (op
);
3030 /* *&p => p; make sure to handle *&"str"[cst] here. */
3031 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
3032 /* Also handle the case where the desired type is an array of unknown
3033 bounds because the variable has had its bounds deduced since the
3034 ADDR_EXPR was created. */
3035 || (TREE_CODE (type
) == ARRAY_TYPE
3036 && TREE_CODE (optype
) == ARRAY_TYPE
3037 && TYPE_DOMAIN (type
) == NULL_TREE
3038 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3041 tree fop
= fold_read_from_constant_string (op
);
3047 /* *(foo *)&fooarray => fooarray[0] */
3048 else if (TREE_CODE (optype
) == ARRAY_TYPE
3049 && (same_type_ignoring_top_level_qualifiers_p
3050 (type
, TREE_TYPE (optype
))))
3052 tree type_domain
= TYPE_DOMAIN (optype
);
3053 tree min_val
= size_zero_node
;
3054 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3055 min_val
= TYPE_MIN_VALUE (type_domain
);
3056 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3057 NULL_TREE
, NULL_TREE
);
3059 /* *(foo *)&complexfoo => __real__ complexfoo */
3060 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3061 && (same_type_ignoring_top_level_qualifiers_p
3062 (type
, TREE_TYPE (optype
))))
3063 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3064 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3065 else if (VECTOR_TYPE_P (optype
)
3066 && (same_type_ignoring_top_level_qualifiers_p
3067 (type
, TREE_TYPE (optype
))))
3069 tree part_width
= TYPE_SIZE (type
);
3070 tree index
= bitsize_int (0);
3071 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
3073 /* Also handle conversion to an empty base class, which
3074 is represented with a NOP_EXPR. */
3075 else if (is_empty_class (type
)
3076 && CLASS_TYPE_P (optype
)
3077 && DERIVED_FROM_P (type
, optype
))
3082 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3083 else if (RECORD_OR_UNION_TYPE_P (optype
))
3085 tree field
= TYPE_FIELDS (optype
);
3086 for (; field
; field
= DECL_CHAIN (field
))
3087 if (TREE_CODE (field
) == FIELD_DECL
3088 && TREE_TYPE (field
) != error_mark_node
3089 && integer_zerop (byte_position (field
))
3090 && (same_type_ignoring_top_level_qualifiers_p
3091 (TREE_TYPE (field
), type
)))
3092 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3095 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3096 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
3098 tree op00
= TREE_OPERAND (sub
, 0);
3099 tree op01
= TREE_OPERAND (sub
, 1);
3102 if (TREE_CODE (op00
) == ADDR_EXPR
)
3105 op00
= TREE_OPERAND (op00
, 0);
3106 op00type
= TREE_TYPE (op00
);
3108 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3109 if (VECTOR_TYPE_P (op00type
)
3110 && (same_type_ignoring_top_level_qualifiers_p
3111 (type
, TREE_TYPE (op00type
))))
3113 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
3114 tree part_width
= TYPE_SIZE (type
);
3115 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
3116 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
3117 tree index
= bitsize_int (indexi
);
3119 if (known_lt (offset
/ part_widthi
,
3120 TYPE_VECTOR_SUBPARTS (op00type
)))
3121 return fold_build3_loc (loc
,
3122 BIT_FIELD_REF
, type
, op00
,
3126 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3127 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3128 && (same_type_ignoring_top_level_qualifiers_p
3129 (type
, TREE_TYPE (op00type
))))
3131 tree size
= TYPE_SIZE_UNIT (type
);
3132 if (tree_int_cst_equal (size
, op01
))
3133 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3135 /* ((foo *)&fooarray)[1] => fooarray[1] */
3136 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3137 && (same_type_ignoring_top_level_qualifiers_p
3138 (type
, TREE_TYPE (op00type
))))
3140 tree type_domain
= TYPE_DOMAIN (op00type
);
3141 tree min_val
= size_zero_node
;
3142 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3143 min_val
= TYPE_MIN_VALUE (type_domain
);
3144 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
3145 TYPE_SIZE_UNIT (type
));
3146 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
3147 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3148 NULL_TREE
, NULL_TREE
);
3150 /* Also handle conversion to an empty base class, which
3151 is represented with a NOP_EXPR. */
3152 else if (is_empty_class (type
)
3153 && CLASS_TYPE_P (op00type
)
3154 && DERIVED_FROM_P (type
, op00type
))
3159 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3160 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3162 tree field
= TYPE_FIELDS (op00type
);
3163 for (; field
; field
= DECL_CHAIN (field
))
3164 if (TREE_CODE (field
) == FIELD_DECL
3165 && TREE_TYPE (field
) != error_mark_node
3166 && tree_int_cst_equal (byte_position (field
), op01
)
3167 && (same_type_ignoring_top_level_qualifiers_p
3168 (TREE_TYPE (field
), type
)))
3169 return fold_build3 (COMPONENT_REF
, type
, op00
,
3174 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3175 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3176 && (same_type_ignoring_top_level_qualifiers_p
3177 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3180 tree min_val
= size_zero_node
;
3181 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3185 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3186 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3187 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3188 min_val
= TYPE_MIN_VALUE (type_domain
);
3189 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3197 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3199 bool *non_constant_p
, bool *overflow_p
)
3201 tree orig_op0
= TREE_OPERAND (t
, 0);
3202 bool empty_base
= false;
3204 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3205 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3207 if (TREE_CODE (t
) == MEM_REF
3208 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3210 gcc_assert (ctx
->quiet
);
3211 *non_constant_p
= true;
3215 /* First try to simplify it directly. */
3216 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3220 /* If that didn't work, evaluate the operand first. */
3221 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3222 /*lval*/false, non_constant_p
,
3224 /* Don't VERIFY_CONSTANT here. */
3225 if (*non_constant_p
)
3228 if (!lval
&& integer_zerop (op0
))
3231 error ("dereferencing a null pointer");
3232 *non_constant_p
= true;
3236 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3240 /* We couldn't fold to a constant value. Make sure it's not
3241 something we should have been able to fold. */
3244 if (TREE_CODE (sub
) == ADDR_EXPR
)
3246 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3247 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3248 /* DR 1188 says we don't have to deal with this. */
3250 error ("accessing value of %qE through a %qT glvalue in a "
3251 "constant expression", build_fold_indirect_ref (sub
),
3253 *non_constant_p
= true;
3257 if (lval
&& op0
!= orig_op0
)
3258 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3260 VERIFY_CONSTANT (t
);
3265 r
= cxx_eval_constant_expression (ctx
, r
,
3266 lval
, non_constant_p
, overflow_p
);
3267 if (*non_constant_p
)
3270 /* If we're pulling out the value of an empty base, just return an empty
3272 if (empty_base
&& !lval
)
3274 r
= build_constructor (TREE_TYPE (t
), NULL
);
3275 TREE_CONSTANT (r
) = true;
3281 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3282 Shared between potential_constant_expression and
3283 cxx_eval_constant_expression. */
3286 non_const_var_error (tree r
)
3288 tree type
= TREE_TYPE (r
);
3289 error ("the value of %qD is not usable in a constant "
3291 /* Avoid error cascade. */
3292 if (DECL_INITIAL (r
) == error_mark_node
)
3294 if (DECL_DECLARED_CONSTEXPR_P (r
))
3295 inform (DECL_SOURCE_LOCATION (r
),
3296 "%qD used in its own initializer", r
);
3297 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3299 if (!CP_TYPE_CONST_P (type
))
3300 inform (DECL_SOURCE_LOCATION (r
),
3301 "%q#D is not const", r
);
3302 else if (CP_TYPE_VOLATILE_P (type
))
3303 inform (DECL_SOURCE_LOCATION (r
),
3304 "%q#D is volatile", r
);
3305 else if (!DECL_INITIAL (r
)
3306 || !TREE_CONSTANT (DECL_INITIAL (r
))
3307 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3308 inform (DECL_SOURCE_LOCATION (r
),
3309 "%qD was not initialized with a constant "
3314 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3315 inform (DECL_SOURCE_LOCATION (r
),
3316 "%qD was not initialized with a constant "
3320 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3321 inform (DECL_SOURCE_LOCATION (r
),
3322 "%qD was not declared %<constexpr%>", r
);
3324 inform (DECL_SOURCE_LOCATION (r
),
3325 "%qD does not have integral or enumeration type",
3330 /* Subroutine of cxx_eval_constant_expression.
3331 Like cxx_eval_unary_expression, except for trinary expressions. */
3334 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3336 bool *non_constant_p
, bool *overflow_p
)
3342 for (i
= 0; i
< 3; i
++)
3344 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3346 non_constant_p
, overflow_p
);
3347 VERIFY_CONSTANT (args
[i
]);
3350 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3351 args
[0], args
[1], args
[2]);
3352 if (val
== NULL_TREE
)
3354 VERIFY_CONSTANT (val
);
3358 /* True if T was declared in a function declared to be constexpr, and
3359 therefore potentially constant in C++14. */
3362 var_in_constexpr_fn (tree t
)
3364 tree ctx
= DECL_CONTEXT (t
);
3365 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3366 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3369 /* True if T was declared in a function that might be constexpr: either a
3370 function that was declared constexpr, or a C++17 lambda op(). */
3373 var_in_maybe_constexpr_fn (tree t
)
3375 if (cxx_dialect
>= cxx17
3376 && DECL_FUNCTION_SCOPE_P (t
)
3377 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3379 return var_in_constexpr_fn (t
);
3382 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3383 build_over_call we implement trivial copy of a class with tail padding using
3384 assignment of character arrays, which is valid in normal code, but not in
3385 constexpr evaluation. We don't need to worry about clobbering tail padding
3386 in constexpr evaluation, so strip the type punning. */
3389 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3391 if (TREE_CODE (target
) == MEM_REF
3392 && TREE_CODE (init
) == MEM_REF
3393 && TREE_TYPE (target
) == TREE_TYPE (init
)
3394 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3395 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3397 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3398 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3402 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3405 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3407 bool *non_constant_p
, bool *overflow_p
)
3409 constexpr_ctx new_ctx
= *ctx
;
3411 tree init
= TREE_OPERAND (t
, 1);
3412 if (TREE_CLOBBER_P (init
))
3413 /* Just ignore clobbers. */
3416 /* First we figure out where we're storing to. */
3417 tree target
= TREE_OPERAND (t
, 0);
3419 maybe_simplify_trivial_copy (target
, init
);
3421 tree type
= TREE_TYPE (target
);
3422 target
= cxx_eval_constant_expression (ctx
, target
,
3424 non_constant_p
, overflow_p
);
3425 if (*non_constant_p
)
3428 /* cxx_eval_array_reference for lval = true allows references one past
3429 end of array, because it does not know if it is just taking address
3430 (which is valid), or actual dereference. Here we know it is
3431 a dereference, so diagnose it here. */
3432 for (tree probe
= target
; probe
; )
3434 switch (TREE_CODE (probe
))
3438 ary
= TREE_OPERAND (probe
, 0);
3439 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3440 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3441 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3442 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3445 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3446 non_constant_p
, overflow_p
);
3447 VERIFY_CONSTANT (nelts
);
3448 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3449 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3450 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3452 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3453 *non_constant_p
= true;
3460 probe
= TREE_OPERAND (probe
, 0);
3469 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3471 /* For initialization of an empty base, the original target will be
3472 *(base*)this, which the above evaluation resolves to the object
3473 argument, which has the derived type rather than the base type. In
3474 this situation, just evaluate the initializer and return, since
3475 there's no actual data to store. */
3476 gcc_assert (is_empty_class (type
));
3477 return cxx_eval_constant_expression (ctx
, init
, false,
3478 non_constant_p
, overflow_p
);
3481 /* And then find the underlying variable. */
3482 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3483 tree object
= NULL_TREE
;
3484 for (tree probe
= target
; object
== NULL_TREE
; )
3486 switch (TREE_CODE (probe
))
3491 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3492 vec_safe_push (refs
, TREE_TYPE (probe
));
3493 probe
= TREE_OPERAND (probe
, 0);
3501 /* And then find/build up our initializer for the path to the subobject
3502 we're initializing. */
3504 if (object
== ctx
->object
&& VAR_P (object
)
3505 && DECL_NAME (object
) && ctx
->call
== NULL
)
3506 /* The variable we're building up an aggregate initializer for is outside
3507 the constant-expression, so don't evaluate the store. We check
3508 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3510 else if (DECL_P (object
))
3511 valp
= ctx
->values
->get (object
);
3516 /* A constant-expression cannot modify objects from outside the
3517 constant-expression. */
3519 error ("modification of %qE is not a constant expression", object
);
3520 *non_constant_p
= true;
3523 type
= TREE_TYPE (object
);
3524 bool no_zero_init
= true;
3526 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3527 while (!refs
->is_empty())
3529 if (*valp
== NULL_TREE
)
3531 *valp
= build_constructor (type
, NULL
);
3532 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3534 else if (TREE_CODE (*valp
) == STRING_CST
)
3536 /* An array was initialized with a string constant, and now
3537 we're writing into one of its elements. Explode the
3538 single initialization into a set of element
3540 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3542 tree string
= *valp
;
3543 tree elt_type
= TREE_TYPE (type
);
3544 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3545 / TYPE_PRECISION (char_type_node
));
3546 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3547 tree ary_ctor
= build_constructor (type
, NULL
);
3549 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3550 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3552 constructor_elt elt
=
3554 build_int_cst (size_type_node
, ix
),
3555 extract_string_elt (string
, chars_per_elt
, ix
)
3557 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3563 /* If the value of object is already zero-initialized, any new ctors for
3564 subobjects will also be zero-initialized. */
3565 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3567 vec_safe_push (ctors
, *valp
);
3569 enum tree_code code
= TREE_CODE (type
);
3571 tree index
= refs
->pop();
3573 constructor_elt
*cep
= NULL
;
3574 if (code
== ARRAY_TYPE
)
3577 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3578 gcc_assert (i
>= 0);
3579 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3580 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3584 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3586 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3587 Usually we meet initializers in that order, but it is
3588 possible for base types to be placed not in program
3590 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3591 unsigned HOST_WIDE_INT idx
;
3593 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3594 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3595 /* Changing active member. */
3596 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3599 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3600 idx
++, fields
= DECL_CHAIN (fields
))
3602 if (index
== cep
->index
)
3605 /* The field we're initializing must be on the field
3606 list. Look to see if it is present before the
3607 field the current ELT initializes. */
3608 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3609 if (index
== fields
)
3613 /* We fell off the end of the CONSTRUCTOR, so insert a new
3614 entry at the end. */
3617 constructor_elt ce
= { index
, NULL_TREE
};
3619 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3620 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3626 release_tree_vector (refs
);
3628 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3630 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3631 wants to modify it. */
3632 if (*valp
== NULL_TREE
)
3634 *valp
= build_constructor (type
, NULL
);
3635 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3637 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3638 *valp
= cplus_expand_constant (*valp
);
3639 new_ctx
.ctor
= *valp
;
3640 new_ctx
.object
= target
;
3643 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3644 non_constant_p
, overflow_p
);
3645 /* Don't share a CONSTRUCTOR that might be changed later. */
3646 init
= unshare_constructor (init
);
3647 if (target
== object
)
3648 /* The hash table might have moved since the get earlier. */
3649 valp
= ctx
->values
->get (object
);
3651 if (TREE_CODE (init
) == CONSTRUCTOR
)
3653 /* An outer ctx->ctor might be pointing to *valp, so replace
3655 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3656 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3657 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3658 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3659 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3664 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3665 CONSTRUCTORs, if any. */
3668 bool c
= TREE_CONSTANT (init
);
3669 bool s
= TREE_SIDE_EFFECTS (init
);
3671 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3674 TREE_CONSTANT (elt
) = false;
3676 TREE_SIDE_EFFECTS (elt
) = true;
3678 release_tree_vector (ctors
);
3680 if (*non_constant_p
)
3688 /* Evaluate a ++ or -- expression. */
3691 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3693 bool *non_constant_p
, bool *overflow_p
)
3695 enum tree_code code
= TREE_CODE (t
);
3696 tree type
= TREE_TYPE (t
);
3697 tree op
= TREE_OPERAND (t
, 0);
3698 tree offset
= TREE_OPERAND (t
, 1);
3699 gcc_assert (TREE_CONSTANT (offset
));
3701 /* The operand as an lvalue. */
3702 op
= cxx_eval_constant_expression (ctx
, op
, true,
3703 non_constant_p
, overflow_p
);
3705 /* The operand as an rvalue. */
3707 = cxx_eval_constant_expression (ctx
, op
, false,
3708 non_constant_p
, overflow_p
);
3709 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3710 a local array in a constexpr function. */
3711 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3713 VERIFY_CONSTANT (val
);
3715 /* The modified value. */
3716 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3718 if (POINTER_TYPE_P (type
))
3720 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3721 offset
= convert_to_ptrofftype (offset
);
3723 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3724 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3727 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3729 VERIFY_CONSTANT (mod
);
3731 /* Storing the modified value. */
3732 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3733 cxx_eval_constant_expression (ctx
, store
,
3734 true, non_constant_p
, overflow_p
);
3736 /* And the value of the expression. */
3737 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3739 /* Prefix ops are lvalues. */
3743 /* But we optimize when the caller wants an rvalue. */
3747 /* Postfix ops are rvalues. */
3751 /* Predicates for the meaning of *jump_target. */
3754 returns (tree
*jump_target
)
3757 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3758 || (TREE_CODE (*jump_target
) == LABEL_DECL
3759 && LABEL_DECL_CDTOR (*jump_target
)));
3763 breaks (tree
*jump_target
)
3766 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3767 && LABEL_DECL_BREAK (*jump_target
))
3768 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3772 continues (tree
*jump_target
)
3775 && TREE_CODE (*jump_target
) == LABEL_DECL
3776 && LABEL_DECL_CONTINUE (*jump_target
);
3780 switches (tree
*jump_target
)
3783 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3786 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3787 STMT matches *jump_target. If we're looking for a case label and we see
3788 the default label, note it in ctx->css_state. */
3791 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3793 switch (TREE_CODE (*jump_target
))
3796 if (TREE_CODE (stmt
) == LABEL_EXPR
3797 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3802 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3804 gcc_assert (ctx
->css_state
!= NULL
);
3805 if (!CASE_LOW (stmt
))
3807 /* default: should appear just once in a SWITCH_EXPR
3808 body (excluding nested SWITCH_EXPR). */
3809 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3810 /* When evaluating SWITCH_EXPR body for the second time,
3811 return true for the default: label. */
3812 if (*ctx
->css_state
== css_default_processing
)
3814 *ctx
->css_state
= css_default_seen
;
3816 else if (CASE_HIGH (stmt
))
3818 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3819 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3822 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3833 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3834 semantics, for switch, break, continue, and return. */
3837 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3838 bool *non_constant_p
, bool *overflow_p
,
3841 tree_stmt_iterator i
;
3843 /* In a statement-expression we want to return the last value.
3844 For empty statement expression return void_node. */
3848 local_target
= NULL_TREE
;
3849 jump_target
= &local_target
;
3851 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3853 tree stmt
= tsi_stmt (i
);
3854 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3855 non_constant_p
, overflow_p
,
3857 if (*non_constant_p
)
3859 if (returns (jump_target
) || breaks (jump_target
))
3862 /* Make sure we don't use the "result" of a debug-only marker. That
3863 would be wrong. We should be using the result of the previous
3864 statement, or NULL if there isn't one. In practice, this should
3865 never happen: the statement after the marker should override the
3866 result of the marker, so its value shouldn't survive in R. Now,
3867 should that ever change, we'll need some fixing here to stop
3868 markers from modifying the generated executable code. */
3869 gcc_checking_assert (!r
|| TREE_CODE (r
) != DEBUG_BEGIN_STMT
);
3873 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3874 semantics; continue semantics are covered by cxx_eval_statement_list. */
3877 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3878 bool *non_constant_p
, bool *overflow_p
,
3881 constexpr_ctx new_ctx
= *ctx
;
3883 tree body
= TREE_OPERAND (t
, 0);
3887 hash_set
<tree
> save_exprs
;
3888 new_ctx
.save_exprs
= &save_exprs
;
3890 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3891 non_constant_p
, overflow_p
, jump_target
);
3893 /* Forget saved values of SAVE_EXPRs. */
3894 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3895 iter
!= save_exprs
.end(); ++iter
)
3896 new_ctx
.values
->remove (*iter
);
3897 if (++count
>= constexpr_loop_limit
)
3900 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3901 "%<constexpr%> loop iteration count exceeds limit of %d "
3902 "(use -fconstexpr-loop-limit= to increase the limit)",
3903 constexpr_loop_limit
);
3904 *non_constant_p
= true;
3908 while (!returns (jump_target
)
3909 && !breaks (jump_target
)
3910 && !switches (jump_target
)
3911 && !*non_constant_p
);
3913 if (breaks (jump_target
))
3914 *jump_target
= NULL_TREE
;
3919 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3923 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3924 bool *non_constant_p
, bool *overflow_p
,
3927 tree cond
= TREE_OPERAND (t
, 0);
3928 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3929 non_constant_p
, overflow_p
);
3930 VERIFY_CONSTANT (cond
);
3931 *jump_target
= cond
;
3933 tree body
= TREE_OPERAND (t
, 1);
3934 constexpr_ctx new_ctx
= *ctx
;
3935 constexpr_switch_state css
= css_default_not_seen
;
3936 new_ctx
.css_state
= &css
;
3937 cxx_eval_constant_expression (&new_ctx
, body
, false,
3938 non_constant_p
, overflow_p
, jump_target
);
3939 if (switches (jump_target
) && css
== css_default_seen
)
3941 /* If the SWITCH_EXPR body has default: label, process it once again,
3942 this time instructing label_matches to return true for default:
3943 label on switches (jump_target). */
3944 css
= css_default_processing
;
3945 cxx_eval_constant_expression (&new_ctx
, body
, false,
3946 non_constant_p
, overflow_p
, jump_target
);
3948 if (breaks (jump_target
) || switches (jump_target
))
3949 *jump_target
= NULL_TREE
;
3953 /* Find the object of TYPE under initialization in CTX. */
3956 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3961 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3962 can is a minor optimization. */
3963 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
3969 /* Since an object cannot have a field of its own type, we can search outward
3970 from ctx->object to find the unique containing object of TYPE. */
3971 tree ob
= ctx
->object
;
3974 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
3976 if (handled_component_p (ob
))
3977 ob
= TREE_OPERAND (ob
, 0);
3985 /* Attempt to reduce the expression T to a constant value.
3986 On failure, issue diagnostic and return error_mark_node. */
3987 /* FIXME unify with c_fully_fold */
3988 /* FIXME overflow_p is too global */
3991 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3993 bool *non_constant_p
, bool *overflow_p
,
3996 constexpr_ctx new_ctx
;
3999 if (jump_target
&& *jump_target
)
4001 /* If we are jumping, ignore all statements/expressions except those
4002 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4003 switch (TREE_CODE (t
))
4006 case STATEMENT_LIST
:
4011 case CASE_LABEL_EXPR
:
4012 if (label_matches (ctx
, jump_target
, t
))
4014 *jump_target
= NULL_TREE
;
4020 if (t
== error_mark_node
)
4022 *non_constant_p
= true;
4025 if (CONSTANT_CLASS_P (t
))
4027 if (TREE_OVERFLOW (t
))
4030 permerror (input_location
, "overflow in constant expression");
4031 if (!flag_permissive
|| ctx
->quiet
)
4035 if (TREE_CODE (t
) == INTEGER_CST
4036 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
4037 && !integer_zerop (t
))
4040 error ("value %qE of type %qT is not a constant expression",
4042 *non_constant_p
= true;
4048 tree_code tcode
= TREE_CODE (t
);
4054 /* We ask for an rvalue for the RESULT_DECL when indirecting
4055 through an invisible reference, or in named return value
4057 return (*ctx
->values
->get (t
));
4060 if (DECL_HAS_VALUE_EXPR_P (t
))
4061 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4062 lval
, non_constant_p
, overflow_p
);
4065 /* We used to not check lval for CONST_DECL, but darwin.c uses
4066 CONST_DECL for aggregate constants. */
4069 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4070 && is_really_empty_class (TREE_TYPE (t
)))
4072 /* If the class is empty, we aren't actually loading anything. */
4073 r
= build_constructor (TREE_TYPE (t
), NULL
);
4074 TREE_CONSTANT (r
) = true;
4076 else if (ctx
->strict
)
4077 r
= decl_really_constant_value (t
);
4079 r
= decl_constant_value (t
);
4080 if (TREE_CODE (r
) == TARGET_EXPR
4081 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4082 r
= TARGET_EXPR_INITIAL (r
);
4084 if (tree
*p
= ctx
->values
->get (r
))
4085 if (*p
!= NULL_TREE
)
4090 non_const_var_error (r
);
4091 *non_constant_p
= true;
4095 case DEBUG_BEGIN_STMT
:
4096 /* ??? It might be nice to retain this information somehow, so
4097 as to be able to step into a constexpr function call. */
4104 case CASE_LABEL_EXPR
:
4109 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4111 else if (tree
*p
= ctx
->values
->get (r
))
4114 /* Defer in case this is only used for its type. */;
4115 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4116 /* Defer, there's no lvalue->rvalue conversion. */;
4117 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4118 && is_really_empty_class (TREE_TYPE (t
)))
4120 /* If the class is empty, we aren't actually loading anything. */
4121 r
= build_constructor (TREE_TYPE (t
), NULL
);
4122 TREE_CONSTANT (r
) = true;
4127 error ("%qE is not a constant expression", t
);
4128 *non_constant_p
= true;
4133 case AGGR_INIT_EXPR
:
4134 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4135 non_constant_p
, overflow_p
);
4140 r
= DECL_EXPR_DECL (t
);
4141 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4142 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4146 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4147 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4148 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4152 if (tree init
= DECL_INITIAL (r
))
4154 init
= cxx_eval_constant_expression (ctx
, init
,
4156 non_constant_p
, overflow_p
);
4157 /* Don't share a CONSTRUCTOR that might be changed. */
4158 init
= unshare_constructor (init
);
4159 ctx
->values
->put (r
, init
);
4161 else if (ctx
== &new_ctx
)
4162 /* We gave it a CONSTRUCTOR above. */;
4164 ctx
->values
->put (r
, NULL_TREE
);
4169 if (!literal_type_p (TREE_TYPE (t
)))
4173 error ("temporary of non-literal type %qT in a "
4174 "constant expression", TREE_TYPE (t
));
4175 explain_non_literal_class (TREE_TYPE (t
));
4177 *non_constant_p
= true;
4180 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4182 /* We're being expanded without an explicit target, so start
4183 initializing a new object; expansion with an explicit target
4184 strips the TARGET_EXPR before we get here. */
4186 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4187 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4188 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4189 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4192 /* Pass false for 'lval' because this indicates
4193 initialization of a temporary. */
4194 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4196 non_constant_p
, overflow_p
);
4197 if (!*non_constant_p
)
4198 /* Adjust the type of the result to the type of the temporary. */
4199 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4202 tree slot
= TARGET_EXPR_SLOT (t
);
4203 r
= unshare_constructor (r
);
4204 ctx
->values
->put (slot
, r
);
4211 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4212 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4213 non_constant_p
, overflow_p
);
4217 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4219 non_constant_p
, overflow_p
);
4223 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4224 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4226 non_constant_p
, overflow_p
);
4231 /* Avoid evaluating a SAVE_EXPR more than once. */
4232 if (tree
*p
= ctx
->values
->get (t
))
4236 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4237 non_constant_p
, overflow_p
);
4238 ctx
->values
->put (t
, r
);
4239 if (ctx
->save_exprs
)
4240 ctx
->save_exprs
->add (t
);
4244 case NON_LVALUE_EXPR
:
4245 case TRY_CATCH_EXPR
:
4247 case CLEANUP_POINT_EXPR
:
4248 case MUST_NOT_THROW_EXPR
:
4251 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4253 non_constant_p
, overflow_p
,
4257 case TRY_FINALLY_EXPR
:
4258 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4259 non_constant_p
, overflow_p
,
4261 if (!*non_constant_p
)
4262 /* Also evaluate the cleanup. */
4263 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4264 non_constant_p
, overflow_p
,
4268 /* These differ from cxx_eval_unary_expression in that this doesn't
4269 check for a constant operand or result; an address can be
4270 constant without its operand being, and vice versa. */
4273 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4274 non_constant_p
, overflow_p
);
4279 tree oldop
= TREE_OPERAND (t
, 0);
4280 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4282 non_constant_p
, overflow_p
);
4283 /* Don't VERIFY_CONSTANT here. */
4284 if (*non_constant_p
)
4286 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4287 /* This function does more aggressive folding than fold itself. */
4288 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4289 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4298 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4299 non_constant_p
, overflow_p
);
4300 if (r
== error_mark_node
)
4302 else if (r
== TREE_OPERAND (t
, 0))
4305 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4310 case FIX_TRUNC_EXPR
:
4315 case TRUTH_NOT_EXPR
:
4316 case FIXED_CONVERT_EXPR
:
4317 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4318 non_constant_p
, overflow_p
);
4322 r
= fold_sizeof_expr (t
);
4323 VERIFY_CONSTANT (r
);
4328 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4329 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4330 introduced by build_call_a. */
4331 tree op0
= TREE_OPERAND (t
, 0);
4332 tree op1
= TREE_OPERAND (t
, 1);
4334 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4335 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4336 r
= cxx_eval_constant_expression (ctx
, op0
,
4337 lval
, non_constant_p
, overflow_p
,
4341 /* Check that the LHS is constant and then discard it. */
4342 cxx_eval_constant_expression (ctx
, op0
,
4343 true, non_constant_p
, overflow_p
,
4345 if (*non_constant_p
)
4347 op1
= TREE_OPERAND (t
, 1);
4348 r
= cxx_eval_constant_expression (ctx
, op1
,
4349 lval
, non_constant_p
, overflow_p
,
4355 case POINTER_PLUS_EXPR
:
4356 case POINTER_DIFF_EXPR
:
4360 case TRUNC_DIV_EXPR
:
4362 case FLOOR_DIV_EXPR
:
4363 case ROUND_DIV_EXPR
:
4364 case TRUNC_MOD_EXPR
:
4366 case ROUND_MOD_EXPR
:
4368 case EXACT_DIV_EXPR
:
4378 case TRUTH_XOR_EXPR
:
4385 case UNORDERED_EXPR
:
4395 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4396 non_constant_p
, overflow_p
);
4399 /* fold can introduce non-IF versions of these; still treat them as
4400 short-circuiting. */
4401 case TRUTH_AND_EXPR
:
4402 case TRUTH_ANDIF_EXPR
:
4403 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4406 non_constant_p
, overflow_p
);
4410 case TRUTH_ORIF_EXPR
:
4411 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4414 non_constant_p
, overflow_p
);
4418 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4419 non_constant_p
, overflow_p
);
4423 if (is_overloaded_fn (t
))
4425 /* We can only get here in checking mode via
4426 build_non_dependent_expr, because any expression that
4427 calls or takes the address of the function will have
4428 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4429 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4430 *non_constant_p
= true;
4433 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4434 non_constant_p
, overflow_p
);
4438 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4439 non_constant_p
, overflow_p
);
4443 if (jump_target
&& *jump_target
)
4445 /* When jumping to a label, the label might be either in the
4446 then or else blocks, so process then block first in skipping
4447 mode first, and if we are still in the skipping mode at its end,
4448 process the else block too. */
4449 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4450 lval
, non_constant_p
, overflow_p
,
4453 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4454 lval
, non_constant_p
, overflow_p
,
4458 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4459 non_constant_p
, overflow_p
,
4463 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4468 if (TREE_CONSTANT (t
))
4470 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4471 VECTOR_CST if applicable. */
4472 /* FIXME after GCC 6 branches, make the verify unconditional. */
4474 verify_constructor_flags (t
);
4476 recompute_constructor_flags (t
);
4477 if (TREE_CONSTANT (t
))
4480 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4481 non_constant_p
, overflow_p
);
4485 /* We can get this in a defaulted constructor for a class with a
4486 non-static data member of array type. Either the initializer will
4487 be NULL, meaning default-initialization, or it will be an lvalue
4488 or xvalue of the same type, meaning direct-initialization from the
4489 corresponding member. */
4490 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4491 non_constant_p
, overflow_p
);
4496 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4497 non_constant_p
, overflow_p
);
4501 case VIEW_CONVERT_EXPR
:
4503 case UNARY_PLUS_EXPR
:
4505 tree oldop
= TREE_OPERAND (t
, 0);
4507 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4509 non_constant_p
, overflow_p
);
4510 if (*non_constant_p
)
4512 tree type
= TREE_TYPE (t
);
4513 if (TREE_CODE (op
) == PTRMEM_CST
4514 && !TYPE_PTRMEM_P (type
))
4515 op
= cplus_expand_constant (op
);
4516 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4518 if (same_type_ignoring_top_level_qualifiers_p (type
,
4520 || can_convert_qual (type
, op
))
4521 return cp_fold_convert (type
, op
);
4525 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4526 "a reinterpret_cast is not a constant expression");
4527 *non_constant_p
= true;
4532 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4534 if (integer_zerop (op
))
4536 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4539 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4540 "dereferencing a null pointer");
4541 *non_constant_p
= true;
4544 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4546 tree from
= TREE_TYPE (op
);
4548 if (!can_convert (type
, from
, tf_none
))
4551 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4552 "conversion of %qT null pointer to %qT "
4553 "is not a constant expression",
4555 *non_constant_p
= true;
4562 /* This detects for example:
4563 reinterpret_cast<void*>(sizeof 0)
4566 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4567 "%<reinterpret_cast<%T>(%E)%> is not "
4568 "a constant expression",
4570 *non_constant_p
= true;
4574 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4575 /* We didn't fold at the top so we could check for ptr-int
4578 if (tcode
== UNARY_PLUS_EXPR
)
4579 r
= fold_convert (TREE_TYPE (t
), op
);
4581 r
= fold_build1 (tcode
, type
, op
);
4582 /* Conversion of an out-of-range value has implementation-defined
4583 behavior; the language considers it different from arithmetic
4584 overflow, which is undefined. */
4585 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4586 TREE_OVERFLOW (r
) = false;
4590 case EMPTY_CLASS_EXPR
:
4591 /* This is good enough for a function argument that might not get
4592 used, and they can't do anything with it, so just return it. */
4595 case STATEMENT_LIST
:
4597 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4598 return cxx_eval_statement_list (&new_ctx
, t
,
4599 non_constant_p
, overflow_p
, jump_target
);
4602 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4604 non_constant_p
, overflow_p
,
4607 case PREINCREMENT_EXPR
:
4608 case POSTINCREMENT_EXPR
:
4609 case PREDECREMENT_EXPR
:
4610 case POSTDECREMENT_EXPR
:
4611 return cxx_eval_increment_expression (ctx
, t
,
4612 lval
, non_constant_p
, overflow_p
);
4618 case VEC_DELETE_EXPR
:
4621 /* GCC internal stuff. */
4624 case NON_DEPENDENT_EXPR
:
4628 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4629 "expression %qE is not a constant expression", t
);
4630 *non_constant_p
= true;
4633 case PLACEHOLDER_EXPR
:
4634 /* Use of the value or address of the current object. */
4635 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4636 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4637 non_constant_p
, overflow_p
);
4638 /* A placeholder without a referent. We can get here when
4639 checking whether NSDMIs are noexcept, or in massage_init_elt;
4640 just say it's non-constant for now. */
4641 gcc_assert (ctx
->quiet
);
4642 *non_constant_p
= true;
4647 tree cond
= TREE_OPERAND (t
, 0);
4648 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4649 non_constant_p
, overflow_p
);
4650 VERIFY_CONSTANT (cond
);
4651 if (integer_nonzerop (cond
))
4657 *jump_target
= TREE_OPERAND (t
, 0);
4658 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4659 /* Allow for jumping to a cdtor_label. */
4660 || returns (jump_target
));
4664 cxx_eval_loop_expr (ctx
, t
,
4665 non_constant_p
, overflow_p
, jump_target
);
4669 cxx_eval_switch_expr (ctx
, t
,
4670 non_constant_p
, overflow_p
, jump_target
);
4674 /* It's possible to get a requires-expression in a constant
4675 expression. For example:
4677 template<typename T> concept bool C() {
4678 return requires (T t) { t; };
4681 template<typename T> requires !C<T>() void f(T);
4683 Normalization leaves f with the associated constraint
4684 '!requires (T t) { ... }' which is not transformed into
4686 if (!processing_template_decl
)
4687 return evaluate_constraint_expression (t
, NULL_TREE
);
4689 *non_constant_p
= true;
4693 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4695 non_constant_p
, overflow_p
,
4700 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4702 /* This function doesn't know how to deal with pre-genericize
4703 statements; this can only happen with statement-expressions,
4704 so for now just fail. */
4706 error_at (EXPR_LOCATION (t
),
4707 "statement is not a constant expression");
4710 internal_error ("unexpected expression %qE of kind %s", t
,
4711 get_tree_code_name (TREE_CODE (t
)));
4712 *non_constant_p
= true;
4716 if (r
== error_mark_node
)
4717 *non_constant_p
= true;
4719 if (*non_constant_p
)
4726 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4727 bool strict
= true, tree object
= NULL_TREE
)
4729 auto_timevar
time (TV_CONSTEXPR
);
4731 bool non_constant_p
= false;
4732 bool overflow_p
= false;
4733 hash_map
<tree
,tree
> map
;
4735 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4736 allow_non_constant
, strict
};
4738 tree type
= initialized_type (t
);
4740 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4742 /* In C++14 an NSDMI can participate in aggregate initialization,
4743 and can refer to the address of the object being initialized, so
4744 we need to pass in the relevant VAR_DECL if we want to do the
4745 evaluation in a single pass. The evaluation will dynamically
4746 update ctx.values for the VAR_DECL. We use the same strategy
4747 for C++11 constexpr constructors that refer to the object being
4749 ctx
.ctor
= build_constructor (type
, NULL
);
4750 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4753 if (TREE_CODE (t
) == TARGET_EXPR
)
4754 object
= TARGET_EXPR_SLOT (t
);
4755 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4756 object
= AGGR_INIT_EXPR_SLOT (t
);
4758 ctx
.object
= object
;
4760 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4761 (type
, TREE_TYPE (object
)));
4762 if (object
&& DECL_P (object
))
4763 map
.put (object
, ctx
.ctor
);
4764 if (TREE_CODE (r
) == TARGET_EXPR
)
4765 /* Avoid creating another CONSTRUCTOR when we expand the
4767 r
= TARGET_EXPR_INITIAL (r
);
4770 r
= cxx_eval_constant_expression (&ctx
, r
,
4771 false, &non_constant_p
, &overflow_p
);
4773 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4775 /* Mutable logic is a bit tricky: we want to allow initialization of
4776 constexpr variables with mutable members, but we can't copy those
4777 members to another constexpr variable. */
4778 if (TREE_CODE (r
) == CONSTRUCTOR
4779 && CONSTRUCTOR_MUTABLE_POISON (r
))
4781 if (!allow_non_constant
)
4782 error ("%qE is not a constant expression because it refers to "
4783 "mutable subobjects of %qT", t
, type
);
4784 non_constant_p
= true;
4787 if (TREE_CODE (r
) == CONSTRUCTOR
4788 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4790 if (!allow_non_constant
)
4791 error ("%qE is not a constant expression because it refers to "
4792 "an incompletely initialized variable", t
);
4793 TREE_CONSTANT (r
) = false;
4794 non_constant_p
= true;
4797 /* Technically we should check this for all subexpressions, but that
4798 runs into problems with our internal representation of pointer
4799 subtraction and the 5.19 rules are still in flux. */
4800 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4801 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4802 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4804 if (!allow_non_constant
)
4805 error ("conversion from pointer type %qT "
4806 "to arithmetic type %qT in a constant expression",
4807 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4808 non_constant_p
= true;
4811 if (!non_constant_p
&& overflow_p
)
4812 non_constant_p
= true;
4814 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4816 bool should_unshare
= true;
4817 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4818 should_unshare
= false;
4820 if (non_constant_p
&& !allow_non_constant
)
4821 return error_mark_node
;
4822 else if (non_constant_p
&& TREE_CONSTANT (r
))
4824 /* This isn't actually constant, so unset TREE_CONSTANT. */
4827 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4828 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4830 r
= build_nop (TREE_TYPE (r
), r
);
4831 TREE_CONSTANT (r
) = false;
4833 else if (non_constant_p
|| r
== t
)
4837 r
= unshare_expr (r
);
4839 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4841 if (TREE_CODE (t
) == TARGET_EXPR
4842 && TARGET_EXPR_INITIAL (t
) == r
)
4846 r
= get_target_expr (r
);
4847 TREE_CONSTANT (r
) = true;
4855 /* Returns true if T is a valid subexpression of a constant expression,
4856 even if it isn't itself a constant expression. */
4859 is_sub_constant_expr (tree t
)
4861 bool non_constant_p
= false;
4862 bool overflow_p
= false;
4863 hash_map
<tree
, tree
> map
;
4865 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4867 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4869 return !non_constant_p
&& !overflow_p
;
4872 /* If T represents a constant expression returns its reduced value.
4873 Otherwise return error_mark_node. If T is dependent, then
4877 cxx_constant_value (tree t
, tree decl
)
4879 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4882 /* Helper routine for fold_simple function. Either return simplified
4883 expression T, otherwise NULL_TREE.
4884 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4885 even if we are within template-declaration. So be careful on call, as in
4886 such case types can be undefined. */
4889 fold_simple_1 (tree t
)
4892 enum tree_code code
= TREE_CODE (t
);
4904 return fold_sizeof_expr (t
);
4912 case TRUTH_NOT_EXPR
:
4914 case VIEW_CONVERT_EXPR
:
4917 case FIX_TRUNC_EXPR
:
4918 case FIXED_CONVERT_EXPR
:
4919 case ADDR_SPACE_CONVERT_EXPR
:
4921 op1
= TREE_OPERAND (t
, 0);
4923 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4927 if (CONVERT_EXPR_CODE_P (code
)
4928 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4929 TREE_OVERFLOW (t
) = false;
4937 /* If T is a simple constant expression, returns its simplified value.
4938 Otherwise returns T. In contrast to maybe_constant_value do we
4939 simplify only few operations on constant-expressions, and we don't
4940 try to simplify constexpressions. */
4943 fold_simple (tree t
)
4946 if (processing_template_decl
)
4949 r
= fold_simple_1 (t
);
4956 /* If T is a constant expression, returns its reduced value.
4957 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4958 Otherwise, returns a version of T without TREE_CONSTANT. */
4960 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4963 maybe_constant_value (tree t
, tree decl
)
4967 if (!is_nondependent_constant_expression (t
))
4969 if (TREE_OVERFLOW_P (t
))
4971 t
= build_nop (TREE_TYPE (t
), t
);
4972 TREE_CONSTANT (t
) = false;
4976 else if (CONSTANT_CLASS_P (t
))
4977 /* No caching or evaluation needed. */
4980 if (cv_cache
== NULL
)
4981 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4982 if (tree
*cached
= cv_cache
->get (t
))
4985 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4986 gcc_checking_assert (r
== t
4987 || CONVERT_EXPR_P (t
)
4988 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4989 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4990 || !cp_tree_equal (r
, t
));
4991 cv_cache
->put (t
, r
);
4995 /* Dispose of the whole CV_CACHE. */
4998 clear_cv_cache (void)
5000 if (cv_cache
!= NULL
)
5004 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5007 clear_cv_and_fold_caches (void)
5010 clear_fold_cache ();
5013 /* Like maybe_constant_value but first fully instantiate the argument.
5015 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5016 (t, tf_none) followed by maybe_constant_value but is more efficient,
5017 because calls instantiation_dependent_expression_p and
5018 potential_constant_expression at most once. */
5021 fold_non_dependent_expr (tree t
)
5026 /* If we're in a template, but T isn't value dependent, simplify
5027 it. We're supposed to treat:
5029 template <typename T> void f(T[1 + 1]);
5030 template <typename T> void f(T[2]);
5032 as two declarations of the same function, for example. */
5033 if (processing_template_decl
)
5035 if (is_nondependent_constant_expression (t
))
5037 processing_template_decl_sentinel s
;
5038 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
5040 if (type_unknown_p (t
)
5041 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5043 if (TREE_OVERFLOW_P (t
))
5045 t
= build_nop (TREE_TYPE (t
), t
);
5046 TREE_CONSTANT (t
) = false;
5051 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
5052 /* cp_tree_equal looks through NOPs, so allow them. */
5053 gcc_checking_assert (r
== t
5054 || CONVERT_EXPR_P (t
)
5055 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5056 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5057 || !cp_tree_equal (r
, t
));
5060 else if (TREE_OVERFLOW_P (t
))
5062 t
= build_nop (TREE_TYPE (t
), t
);
5063 TREE_CONSTANT (t
) = false;
5068 return maybe_constant_value (t
);
5071 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5072 than wrapped in a TARGET_EXPR. */
5075 maybe_constant_init (tree t
, tree decl
)
5079 if (TREE_CODE (t
) == EXPR_STMT
)
5080 t
= TREE_OPERAND (t
, 0);
5081 if (TREE_CODE (t
) == CONVERT_EXPR
5082 && VOID_TYPE_P (TREE_TYPE (t
)))
5083 t
= TREE_OPERAND (t
, 0);
5084 if (TREE_CODE (t
) == INIT_EXPR
)
5085 t
= TREE_OPERAND (t
, 1);
5086 if (TREE_CODE (t
) == TARGET_EXPR
)
5087 t
= TARGET_EXPR_INITIAL (t
);
5088 if (!is_nondependent_static_init_expression (t
))
5089 /* Don't try to evaluate it. */;
5090 else if (CONSTANT_CLASS_P (t
))
5091 /* No evaluation needed. */;
5093 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
5094 if (TREE_CODE (t
) == TARGET_EXPR
)
5096 tree init
= TARGET_EXPR_INITIAL (t
);
5097 if (TREE_CODE (init
) == CONSTRUCTOR
)
5104 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5105 /* Return true if the object referred to by REF has automatic or thread
5108 enum { ck_ok
, ck_bad
, ck_unknown
};
5110 check_automatic_or_tls (tree ref
)
5113 poly_int64 bitsize
, bitpos
;
5115 int volatilep
= 0, unsignedp
= 0;
5116 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5117 &mode
, &unsignedp
, &volatilep
, false);
5120 /* If there isn't a decl in the middle, we don't know the linkage here,
5121 and this isn't a constant expression anyway. */
5124 dk
= decl_storage_duration (decl
);
5125 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5129 /* Return true if T denotes a potentially constant expression. Issue
5130 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5131 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5132 consider the expression in the current context, independent of constexpr
5135 C++0x [expr.const] used to say
5137 6 An expression is a potential constant expression if it is
5138 a constant expression where all occurrences of function
5139 parameters are replaced by arbitrary constant expressions
5140 of the appropriate type.
5142 2 A conditional expression is a constant expression unless it
5143 involves one of the following as a potentially evaluated
5144 subexpression (3.2), but subexpressions of logical AND (5.14),
5145 logical OR (5.15), and conditional (5.16) operations that are
5146 not evaluated are not considered. */
5149 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5150 tsubst_flags_t flags
)
5152 #define RECUR(T,RV) \
5153 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5155 enum { any
= false, rval
= true };
5159 if (t
== error_mark_node
)
5163 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5164 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5166 if (flags
& tf_error
)
5167 error_at (loc
, "expression %qE has side-effects", t
);
5170 if (CONSTANT_CLASS_P (t
))
5172 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5173 && TREE_TYPE (t
) == error_mark_node
)
5176 switch (TREE_CODE (t
))
5182 case TEMPLATE_ID_EXPR
:
5185 case CASE_LABEL_EXPR
:
5191 case TEMPLATE_PARM_INDEX
:
5193 case IDENTIFIER_NODE
:
5194 case USERDEF_LITERAL
:
5195 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5200 case PLACEHOLDER_EXPR
:
5205 case DEBUG_BEGIN_STMT
:
5211 if (flags
& tf_error
)
5212 error ("%qE is not a constant expression", t
);
5217 case AGGR_INIT_EXPR
:
5219 /* -- an invocation of a function other than a constexpr function
5220 or a constexpr constructor. */
5222 tree fun
= get_function_named_in_call (t
);
5223 const int nargs
= call_expr_nargs (t
);
5226 if (fun
== NULL_TREE
)
5228 /* Reset to allow the function to continue past the end
5229 of the block below. Otherwise return early. */
5232 if (TREE_CODE (t
) == CALL_EXPR
5233 && CALL_EXPR_FN (t
) == NULL_TREE
)
5234 switch (CALL_EXPR_IFN (t
))
5236 /* These should be ignored, they are optimized away from
5237 constexpr functions. */
5238 case IFN_UBSAN_NULL
:
5239 case IFN_UBSAN_BOUNDS
:
5240 case IFN_UBSAN_VPTR
:
5241 case IFN_FALLTHROUGH
:
5244 case IFN_ADD_OVERFLOW
:
5245 case IFN_SUB_OVERFLOW
:
5246 case IFN_MUL_OVERFLOW
:
5256 /* fold_call_expr can't do anything with IFN calls. */
5257 if (flags
& tf_error
)
5258 error_at (loc
, "call to internal function %qE", t
);
5263 if (fun
&& is_overloaded_fn (fun
))
5265 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5267 if (builtin_valid_in_constant_expr_p (fun
))
5269 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5270 /* Allow any built-in function; if the expansion
5271 isn't constant, we'll deal with that then. */
5272 && !is_builtin_fn (fun
))
5274 if (flags
& tf_error
)
5276 error_at (loc
, "call to non-%<constexpr%> function %qD",
5278 explain_invalid_constexpr_fn (fun
);
5282 /* A call to a non-static member function takes the address
5283 of the object as the first argument. But in a constant
5284 expression the address will be folded away, so look
5286 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5287 && !DECL_CONSTRUCTOR_P (fun
))
5289 tree x
= get_nth_callarg (t
, 0);
5290 if (is_this_parameter (x
))
5292 /* Don't require an immediately constant value, as
5293 constexpr substitution might not use the value. */
5294 bool sub_now
= false;
5295 if (!potential_constant_expression_1 (x
, rval
, strict
,
5303 if (!RECUR (fun
, true))
5305 fun
= get_first_fn (fun
);
5307 /* Skip initial arguments to base constructors. */
5308 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5309 i
= num_artificial_parms_for (fun
);
5310 fun
= DECL_ORIGIN (fun
);
5314 if (RECUR (fun
, rval
))
5315 /* Might end up being a constant function pointer. */;
5319 for (; i
< nargs
; ++i
)
5321 tree x
= get_nth_callarg (t
, i
);
5322 /* In a template, reference arguments haven't been converted to
5323 REFERENCE_TYPE and we might not even know if the parameter
5324 is a reference, so accept lvalue constants too. */
5325 bool rv
= processing_template_decl
? any
: rval
;
5326 /* Don't require an immediately constant value, as constexpr
5327 substitution might not use the value of the argument. */
5328 bool sub_now
= false;
5329 if (!potential_constant_expression_1 (x
, rv
, strict
,
5336 case NON_LVALUE_EXPR
:
5337 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5338 -- an lvalue of integral type that refers to a non-volatile
5339 const variable or static data member initialized with
5340 constant expressions, or
5342 -- an lvalue of literal type that refers to non-volatile
5343 object defined with constexpr, or that refers to a
5344 sub-object of such an object; */
5345 return RECUR (TREE_OPERAND (t
, 0), rval
);
5348 if (DECL_HAS_VALUE_EXPR_P (t
))
5350 if (now
&& is_normal_capture_proxy (t
))
5352 /* -- in a lambda-expression, a reference to this or to a
5353 variable with automatic storage duration defined outside that
5354 lambda-expression, where the reference would be an
5356 if (flags
& tf_error
)
5358 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5359 error ("lambda capture of %qE is not a constant expression",
5361 if (!want_rval
&& decl_constant_var_p (cap
))
5362 inform (input_location
, "because it is used as a glvalue");
5366 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5369 && !var_in_maybe_constexpr_fn (t
)
5370 && !type_dependent_expression_p (t
)
5371 && !decl_maybe_constant_var_p (t
)
5373 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5374 || (DECL_INITIAL (t
)
5375 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5376 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5377 && !is_really_empty_class (TREE_TYPE (t
)))
5379 if (flags
& tf_error
)
5380 non_const_var_error (t
);
5387 case VIEW_CONVERT_EXPR
:
5388 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5389 may change to something more specific to type-punning (DR 1312). */
5391 tree from
= TREE_OPERAND (t
, 0);
5392 if (POINTER_TYPE_P (TREE_TYPE (t
))
5393 && TREE_CODE (from
) == INTEGER_CST
5394 && !integer_zerop (from
))
5396 if (flags
& tf_error
)
5397 error_at (loc
, "reinterpret_cast from integer to pointer");
5400 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5403 case ADDRESSOF_EXPR
:
5404 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5405 t
= TREE_OPERAND (t
, 0);
5406 goto handle_addr_expr
;
5409 /* -- a unary operator & that is applied to an lvalue that
5410 designates an object with thread or automatic storage
5412 t
= TREE_OPERAND (t
, 0);
5414 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5415 /* A pointer-to-member constant. */
5420 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5421 any checking here, as we might dereference the pointer later. If
5422 we remove this code, also remove check_automatic_or_tls. */
5423 i
= check_automatic_or_tls (t
);
5428 if (flags
& tf_error
)
5429 error ("address-of an object %qE with thread local or "
5430 "automatic storage is not a constant expression", t
);
5434 return RECUR (t
, any
);
5442 /* -- a class member access unless its postfix-expression is
5443 of literal type or of pointer to literal type. */
5444 /* This test would be redundant, as it follows from the
5445 postfix-expression being a potential constant expression. */
5446 if (type_unknown_p (t
))
5448 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5450 case EXPR_PACK_EXPANSION
:
5451 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5455 tree x
= TREE_OPERAND (t
, 0);
5457 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5459 if (!var_in_maybe_constexpr_fn (x
))
5461 if (flags
& tf_error
)
5462 error_at (loc
, "use of %<this%> in a constant expression");
5467 return RECUR (x
, rval
);
5470 case STATEMENT_LIST
:
5472 tree_stmt_iterator i
;
5473 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5475 if (!RECUR (tsi_stmt (i
), any
))
5483 if (cxx_dialect
< cxx14
)
5485 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5487 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5492 if (cxx_dialect
< cxx14
)
5494 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5496 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5501 if (!RECUR (DO_COND (t
), rval
))
5503 if (!RECUR (DO_BODY (t
), any
))
5508 if (!RECUR (FOR_INIT_STMT (t
), any
))
5510 if (!RECUR (FOR_COND (t
), rval
))
5512 if (!RECUR (FOR_EXPR (t
), any
))
5514 if (!RECUR (FOR_BODY (t
), any
))
5518 case RANGE_FOR_STMT
:
5519 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5521 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5526 if (!RECUR (WHILE_COND (t
), rval
))
5528 if (!RECUR (WHILE_BODY (t
), any
))
5533 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5535 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5536 unreachable labels would be checked. */
5540 return RECUR (STMT_EXPR_STMT (t
), rval
);
5543 if (cxx_dialect
>= cxx17
)
5544 /* In C++17 lambdas can be constexpr, don't give up yet. */
5546 else if (flags
& tf_error
)
5547 error_at (loc
, "lambda-expression is not a constant expression "
5551 case DYNAMIC_CAST_EXPR
:
5552 case PSEUDO_DTOR_EXPR
:
5556 case VEC_DELETE_EXPR
:
5561 case OMP_DISTRIBUTE
:
5564 case OMP_TARGET_DATA
:
5573 case OMP_TARGET_UPDATE
:
5574 case OMP_TARGET_ENTER_DATA
:
5575 case OMP_TARGET_EXIT_DATA
:
5577 case OMP_ATOMIC_READ
:
5578 case OMP_ATOMIC_CAPTURE_OLD
:
5579 case OMP_ATOMIC_CAPTURE_NEW
:
5583 case OACC_HOST_DATA
:
5587 case OACC_ENTER_DATA
:
5588 case OACC_EXIT_DATA
:
5590 /* GCC internal stuff. */
5593 case TRANSACTION_EXPR
:
5595 case AT_ENCODE_EXPR
:
5597 if (flags
& tf_error
)
5598 error_at (loc
, "expression %qE is not a constant expression", t
);
5602 /* -- a typeid expression whose operand is of polymorphic
5605 tree e
= TREE_OPERAND (t
, 0);
5606 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5607 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5609 if (flags
& tf_error
)
5610 error_at (loc
, "typeid-expression is not a constant expression "
5611 "because %qE is of polymorphic type", e
);
5617 case POINTER_DIFF_EXPR
:
5631 case PREINCREMENT_EXPR
:
5632 case POSTINCREMENT_EXPR
:
5633 case PREDECREMENT_EXPR
:
5634 case POSTDECREMENT_EXPR
:
5635 if (cxx_dialect
< cxx14
)
5641 if (TYPE_P (TREE_OPERAND (t
, 0)))
5647 case FIX_TRUNC_EXPR
:
5651 case TRUTH_NOT_EXPR
:
5652 case FIXED_CONVERT_EXPR
:
5653 case UNARY_PLUS_EXPR
:
5654 case UNARY_LEFT_FOLD_EXPR
:
5655 case UNARY_RIGHT_FOLD_EXPR
:
5657 return RECUR (TREE_OPERAND (t
, 0), rval
);
5660 case CONST_CAST_EXPR
:
5661 case STATIC_CAST_EXPR
:
5662 case REINTERPRET_CAST_EXPR
:
5663 case IMPLICIT_CONV_EXPR
:
5664 if (cxx_dialect
< cxx11
5665 && !dependent_type_p (TREE_TYPE (t
))
5666 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5667 /* In C++98, a conversion to non-integral type can't be part of a
5668 constant expression. */
5670 if (flags
& tf_error
)
5672 "cast to non-integral type %qT in a constant expression",
5677 return (RECUR (TREE_OPERAND (t
, 0),
5678 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5681 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5683 case CLEANUP_POINT_EXPR
:
5684 case MUST_NOT_THROW_EXPR
:
5685 case TRY_CATCH_EXPR
:
5690 case NON_DEPENDENT_EXPR
:
5691 /* For convenience. */
5695 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5698 tmp
= DECL_EXPR_DECL (t
);
5699 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5701 if (TREE_STATIC (tmp
))
5703 if (flags
& tf_error
)
5704 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5705 "%<static%> in %<constexpr%> context", tmp
);
5708 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5710 if (flags
& tf_error
)
5711 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5712 "%<thread_local%> in %<constexpr%> context", tmp
);
5715 else if (!DECL_NONTRIVIALLY_INITIALIZED_P (tmp
))
5717 if (flags
& tf_error
)
5718 error_at (DECL_SOURCE_LOCATION (tmp
), "uninitialized "
5719 "variable %qD in %<constexpr%> context", tmp
);
5723 return RECUR (tmp
, want_rval
);
5725 case TRY_FINALLY_EXPR
:
5726 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5727 && RECUR (TREE_OPERAND (t
, 1), any
));
5730 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5733 if (!literal_type_p (TREE_TYPE (t
)))
5735 if (flags
& tf_error
)
5737 error_at (loc
, "temporary of non-literal type %qT in a "
5738 "constant expression", TREE_TYPE (t
));
5739 explain_non_literal_class (TREE_TYPE (t
));
5745 return RECUR (TREE_OPERAND (t
, 1), rval
);
5749 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5750 constructor_elt
*ce
;
5751 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5752 if (!RECUR (ce
->value
, want_rval
))
5759 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5760 || DECL_P (TREE_PURPOSE (t
)));
5761 if (!RECUR (TREE_VALUE (t
), want_rval
))
5763 if (TREE_CHAIN (t
) == NULL_TREE
)
5765 return RECUR (TREE_CHAIN (t
), want_rval
);
5768 case TRUNC_DIV_EXPR
:
5770 case FLOOR_DIV_EXPR
:
5771 case ROUND_DIV_EXPR
:
5772 case TRUNC_MOD_EXPR
:
5774 case ROUND_MOD_EXPR
:
5776 tree denom
= TREE_OPERAND (t
, 1);
5777 if (!RECUR (denom
, rval
))
5779 /* We can't call cxx_eval_outermost_constant_expr on an expression
5780 that hasn't been through instantiate_non_dependent_expr yet. */
5781 if (!processing_template_decl
)
5782 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5783 if (integer_zerop (denom
))
5785 if (flags
& tf_error
)
5786 error ("division by zero is not a constant expression");
5792 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5798 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5799 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5800 introduced by build_call_a. */
5801 tree op0
= TREE_OPERAND (t
, 0);
5802 tree op1
= TREE_OPERAND (t
, 1);
5804 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5805 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5806 return RECUR (op0
, want_rval
);
5811 /* If the first operand is the non-short-circuit constant, look at
5812 the second operand; otherwise we only care about the first one for
5814 case TRUTH_AND_EXPR
:
5815 case TRUTH_ANDIF_EXPR
:
5816 tmp
= boolean_true_node
;
5819 case TRUTH_ORIF_EXPR
:
5820 tmp
= boolean_false_node
;
5823 tree op
= TREE_OPERAND (t
, 0);
5824 if (!RECUR (op
, rval
))
5826 if (!processing_template_decl
)
5827 op
= cxx_eval_outermost_constant_expr (op
, true);
5828 if (tree_int_cst_equal (op
, tmp
))
5829 return RECUR (TREE_OPERAND (t
, 1), rval
);
5836 case POINTER_PLUS_EXPR
:
5838 case EXACT_DIV_EXPR
:
5848 case TRUTH_XOR_EXPR
:
5849 case UNORDERED_EXPR
:
5862 case ARRAY_RANGE_REF
:
5866 case BINARY_LEFT_FOLD_EXPR
:
5867 case BINARY_RIGHT_FOLD_EXPR
:
5869 for (i
= 0; i
< 2; ++i
)
5870 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5876 for (i
= 0; i
< 3; ++i
)
5877 if (!RECUR (TREE_OPERAND (t
, i
), true))
5882 if (COND_EXPR_IS_VEC_DELETE (t
))
5884 if (flags
& tf_error
)
5885 error_at (loc
, "%<delete[]%> is not a constant expression");
5891 /* If the condition is a known constant, we know which of the legs we
5892 care about; otherwise we only require that the condition and
5893 either of the legs be potentially constant. */
5894 tmp
= TREE_OPERAND (t
, 0);
5895 if (!RECUR (tmp
, rval
))
5897 if (!processing_template_decl
)
5898 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5899 if (integer_zerop (tmp
))
5900 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5901 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5902 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5903 for (i
= 1; i
< 3; ++i
)
5904 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5905 want_rval
, strict
, now
, tf_none
))
5907 if (flags
& tf_error
)
5908 error_at (loc
, "expression %qE is not a constant expression", t
);
5912 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5914 if (flags
& tf_error
)
5916 error_at (loc
, "non-constant array initialization");
5917 diagnose_non_constexpr_vec_init (t
);
5923 /* We can see these in statement-expressions. */
5927 case EMPTY_CLASS_EXPR
:
5933 tree
*target
= &TREE_OPERAND (t
, 0);
5934 /* Gotos representing break and continue are OK. */
5935 if (breaks (target
) || continues (target
))
5937 if (flags
& tf_error
)
5938 error_at (loc
, "%<goto%> is not a constant expression");
5943 return RECUR (TREE_OPERAND (t
, 0), rval
);
5946 if (objc_is_property_ref (t
))
5949 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5956 /* The main entry point to the above. */
5959 potential_constant_expression (tree t
)
5961 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
5964 /* As above, but require a constant rvalue. */
5967 potential_rvalue_constant_expression (tree t
)
5969 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
5972 /* Like above, but complain about non-constant expressions. */
5975 require_potential_constant_expression (tree t
)
5977 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
5980 /* Cross product of the above. */
5983 require_potential_rvalue_constant_expression (tree t
)
5985 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
5988 /* Like potential_constant_expression, but don't consider possible constexpr
5989 substitution of the current function. That is, PARM_DECL qualifies under
5990 potential_constant_expression, but not here.
5992 This is basically what you can check when any actual constant values might
5993 be value-dependent. */
5996 is_constant_expression (tree t
)
5998 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6001 /* Like above, but complain about non-constant expressions. */
6004 require_constant_expression (tree t
)
6006 return potential_constant_expression_1 (t
, false, true, true,
6007 tf_warning_or_error
);
6010 /* Like is_constant_expression, but allow const variables that are not allowed
6011 under constexpr rules. */
6014 is_static_init_expression (tree t
)
6016 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6019 /* Returns true if T is a potential constant expression that is not
6020 instantiation-dependent, and therefore a candidate for constant folding even
6024 is_nondependent_constant_expression (tree t
)
6026 return (!type_unknown_p (t
)
6027 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6028 && is_constant_expression (t
)
6029 && !instantiation_dependent_expression_p (t
));
6032 /* Returns true if T is a potential static initializer expression that is not
6033 instantiation-dependent. */
6036 is_nondependent_static_init_expression (tree t
)
6038 return (!type_unknown_p (t
)
6039 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6040 && is_static_init_expression (t
)
6041 && !instantiation_dependent_expression_p (t
));
6044 /* Finalize constexpr processing after parsing. */
6047 fini_constexpr (void)
6049 /* The contexpr call and fundef copies tables are no longer needed. */
6050 constexpr_call_table
= NULL
;
6051 fundef_copies_table
= NULL
;
6054 #include "gt-cp-constexpr.h"