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 static HOST_WIDE_INT
find_array_ctor_elt (tree ary
, tree dindex
,
47 /* Returns true iff FUN is an instantiation of a constexpr function
48 template or a defaulted constexpr function. */
51 is_instantiation_of_constexpr (tree fun
)
53 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
54 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
55 || (DECL_DEFAULTED_FN (fun
)
56 && DECL_DECLARED_CONSTEXPR_P (fun
)));
59 /* Return true if T is a literal type. */
62 literal_type_p (tree t
)
67 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
71 t
= complete_type (t
);
72 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
73 return CLASSTYPE_LITERAL_P (t
);
75 if (TREE_CODE (t
) == ARRAY_TYPE
)
76 return literal_type_p (strip_array_types (t
));
80 /* If DECL is a variable declared `constexpr', require its type
81 be literal. Return error_mark_node if we give an error, the
85 ensure_literal_type_for_constexpr_object (tree decl
)
87 tree type
= TREE_TYPE (decl
);
89 && (DECL_DECLARED_CONSTEXPR_P (decl
)
90 || var_in_constexpr_fn (decl
))
91 && !processing_template_decl
)
93 tree stype
= strip_array_types (type
);
94 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
95 /* Don't complain here, we'll complain about incompleteness
96 when we try to initialize the variable. */;
97 else if (type_uses_auto (type
))
98 /* We don't know the actual type yet. */;
99 else if (!literal_type_p (type
))
101 if (DECL_DECLARED_CONSTEXPR_P (decl
))
103 auto_diagnostic_group d
;
104 error_at (DECL_SOURCE_LOCATION (decl
),
105 "the type %qT of %<constexpr%> variable %qD "
106 "is not literal", type
, decl
);
107 explain_non_literal_class (type
);
108 decl
= error_mark_node
;
112 if (!is_instantiation_of_constexpr (current_function_decl
))
114 auto_diagnostic_group d
;
115 error_at (DECL_SOURCE_LOCATION (decl
),
116 "variable %qD of non-literal type %qT in "
117 "%<constexpr%> function", decl
, type
);
118 explain_non_literal_class (type
);
119 decl
= error_mark_node
;
121 cp_function_chain
->invalid_constexpr
= true;
124 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
125 && variably_modified_type_p (type
, NULL_TREE
))
127 error_at (DECL_SOURCE_LOCATION (decl
),
128 "%<constexpr%> variable %qD has variably-modified "
129 "type %qT", decl
, type
);
130 decl
= error_mark_node
;
136 /* Representation of entries in the constexpr function definition table. */
138 struct GTY((for_user
)) constexpr_fundef
{
143 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
145 static hashval_t
hash (constexpr_fundef
*);
146 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
149 /* This table holds all constexpr function definitions seen in
150 the current translation unit. */
152 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
154 /* Utility function used for managing the constexpr function table.
155 Return true if the entries pointed to by P and Q are for the
156 same constexpr function. */
159 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
161 return lhs
->decl
== rhs
->decl
;
164 /* Utility function used for managing the constexpr function table.
165 Return a hash value for the entry pointed to by Q. */
168 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
170 return DECL_UID (fundef
->decl
);
173 /* Return a previously saved definition of function FUN. */
175 static constexpr_fundef
*
176 retrieve_constexpr_fundef (tree fun
)
178 constexpr_fundef fundef
= { NULL
, NULL
};
179 if (constexpr_fundef_table
== NULL
)
183 return constexpr_fundef_table
->find (&fundef
);
186 /* Check whether the parameter and return types of FUN are valid for a
187 constexpr function, and complain if COMPLAIN. */
190 is_valid_constexpr_fn (tree fun
, bool complain
)
194 if (DECL_INHERITED_CTOR (fun
)
195 && TREE_CODE (fun
) == TEMPLATE_DECL
)
199 error ("inherited constructor %qD is not %<constexpr%>",
200 DECL_INHERITED_CTOR (fun
));
204 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
205 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
206 if (!literal_type_p (TREE_TYPE (parm
)))
211 auto_diagnostic_group d
;
212 error ("invalid type for parameter %d of %<constexpr%> "
213 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
214 explain_non_literal_class (TREE_TYPE (parm
));
219 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
223 inform (DECL_SOURCE_LOCATION (fun
),
224 "lambdas are implicitly %<constexpr%> only in C++17 and later");
226 else if (!DECL_CONSTRUCTOR_P (fun
))
228 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
229 if (!literal_type_p (rettype
))
234 auto_diagnostic_group d
;
235 error ("invalid return type %qT of %<constexpr%> function %q+D",
237 explain_non_literal_class (rettype
);
241 /* C++14 DR 1684 removed this restriction. */
242 if (cxx_dialect
< cxx14
243 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
244 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
249 auto_diagnostic_group d
;
250 if (pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
251 "enclosing class of %<constexpr%> non-static"
252 " member function %q+#D is not a literal type",
254 explain_non_literal_class (DECL_CONTEXT (fun
));
258 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
262 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
268 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
269 for a member of an anonymous aggregate, INIT is the initializer for that
270 member, and VEC_OUTER is the vector of constructor elements for the class
271 whose constructor we are processing. Add the initializer to the vector
272 and return true to indicate success. */
275 build_anon_member_initialization (tree member
, tree init
,
276 vec
<constructor_elt
, va_gc
> **vec_outer
)
278 /* MEMBER presents the relevant fields from the inside out, but we need
279 to build up the initializer from the outside in so that we can reuse
280 previously built CONSTRUCTORs if this is, say, the second field in an
281 anonymous struct. So we use a vec as a stack. */
282 auto_vec
<tree
, 2> fields
;
285 fields
.safe_push (TREE_OPERAND (member
, 1));
286 member
= TREE_OPERAND (member
, 0);
288 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
289 && TREE_CODE (member
) == COMPONENT_REF
);
291 /* VEC has the constructor elements vector for the context of FIELD.
292 If FIELD is an anonymous aggregate, we will push inside it. */
293 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
295 while (field
= fields
.pop(),
296 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
299 /* If there is already an outer constructor entry for the anonymous
300 aggregate FIELD, use it; otherwise, insert one. */
301 if (vec_safe_is_empty (*vec
)
302 || (*vec
)->last().index
!= field
)
304 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
305 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
308 ctor
= (*vec
)->last().value
;
309 vec
= &CONSTRUCTOR_ELTS (ctor
);
312 /* Now we're at the innermost field, the one that isn't an anonymous
313 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
314 gcc_assert (fields
.is_empty());
315 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
320 /* Subroutine of build_constexpr_constructor_member_initializers.
321 The expression tree T represents a data member initialization
322 in a (constexpr) constructor definition. Build a pairing of
323 the data member with its initializer, and prepend that pair
324 to the existing initialization pair INITS. */
327 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
330 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
331 t
= TREE_OPERAND (t
, 0);
332 if (TREE_CODE (t
) == EXPR_STMT
)
333 t
= TREE_OPERAND (t
, 0);
334 if (t
== error_mark_node
)
336 if (TREE_CODE (t
) == STATEMENT_LIST
)
338 tree_stmt_iterator i
;
339 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
341 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
346 if (TREE_CODE (t
) == CLEANUP_STMT
)
348 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
349 but we can in a constexpr constructor for a non-literal class. Just
350 ignore it; either all the initialization will be constant, in which
351 case the cleanup can't run, or it can't be constexpr.
352 Still recurse into CLEANUP_BODY. */
353 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
355 if (TREE_CODE (t
) == CONVERT_EXPR
)
356 t
= TREE_OPERAND (t
, 0);
357 if (TREE_CODE (t
) == INIT_EXPR
358 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
359 use what this function builds for cx_check_missing_mem_inits, and
360 assignment in the ctor body doesn't count. */
361 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
363 member
= TREE_OPERAND (t
, 0);
364 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
366 else if (TREE_CODE (t
) == CALL_EXPR
)
368 tree fn
= get_callee_fndecl (t
);
369 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
370 /* We're only interested in calls to subobject constructors. */
372 member
= CALL_EXPR_ARG (t
, 0);
373 /* We don't use build_cplus_new here because it complains about
374 abstract bases. Leaving the call unwrapped means that it has the
375 wrong type, but cxx_eval_constant_expression doesn't care. */
376 init
= break_out_target_exprs (t
);
378 else if (TREE_CODE (t
) == BIND_EXPR
)
379 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
381 /* Don't add anything else to the CONSTRUCTOR. */
383 if (INDIRECT_REF_P (member
))
384 member
= TREE_OPERAND (member
, 0);
385 if (TREE_CODE (member
) == NOP_EXPR
)
389 if (TREE_CODE (op
) == ADDR_EXPR
)
391 gcc_assert (same_type_ignoring_top_level_qualifiers_p
392 (TREE_TYPE (TREE_TYPE (op
)),
393 TREE_TYPE (TREE_TYPE (member
))));
394 /* Initializing a cv-qualified member; we need to look through
398 else if (op
== current_class_ptr
399 && (same_type_ignoring_top_level_qualifiers_p
400 (TREE_TYPE (TREE_TYPE (member
)),
401 current_class_type
)))
402 /* Delegating constructor. */
406 /* This is an initializer for an empty base; keep it for now so
407 we can check it in cxx_eval_bare_aggregate. */
408 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
411 if (TREE_CODE (member
) == ADDR_EXPR
)
412 member
= TREE_OPERAND (member
, 0);
413 if (TREE_CODE (member
) == COMPONENT_REF
)
415 tree aggr
= TREE_OPERAND (member
, 0);
416 if (TREE_CODE (aggr
) == VAR_DECL
)
417 /* Initializing a local variable, don't add anything. */
419 if (TREE_CODE (aggr
) != COMPONENT_REF
)
420 /* Normal member initialization. */
421 member
= TREE_OPERAND (member
, 1);
422 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
423 /* Initializing a member of an anonymous union. */
424 return build_anon_member_initialization (member
, init
, vec
);
426 /* We're initializing a vtable pointer in a base. Leave it as
427 COMPONENT_REF so we remember the path to get to the vfield. */
428 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
431 /* Value-initialization can produce multiple initializers for the
432 same field; use the last one. */
433 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
434 (*vec
)->last().value
= init
;
436 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
440 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
441 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
442 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
445 check_constexpr_bind_expr_vars (tree t
)
447 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
449 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
450 if (TREE_CODE (var
) == TYPE_DECL
451 && DECL_IMPLICIT_TYPEDEF_P (var
)
452 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
457 /* Subroutine of check_constexpr_ctor_body. */
460 check_constexpr_ctor_body_1 (tree last
, tree list
)
462 switch (TREE_CODE (list
))
465 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
466 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
470 case CLEANUP_POINT_EXPR
:
471 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
475 if (!check_constexpr_bind_expr_vars (list
)
476 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
483 case DEBUG_BEGIN_STMT
:
491 /* Make sure that there are no statements after LAST in the constructor
492 body represented by LIST. */
495 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
497 /* C++14 doesn't require a constexpr ctor to have an empty body. */
498 if (cxx_dialect
>= cxx14
)
502 if (TREE_CODE (list
) == STATEMENT_LIST
)
504 tree_stmt_iterator i
= tsi_last (list
);
505 for (; !tsi_end_p (i
); tsi_prev (&i
))
507 tree t
= tsi_stmt (i
);
510 if (!check_constexpr_ctor_body_1 (last
, t
))
517 else if (list
!= last
518 && !check_constexpr_ctor_body_1 (last
, list
))
523 error ("%<constexpr%> constructor does not have empty body");
524 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
529 /* V is a vector of constructor elements built up for the base and member
530 initializers of a constructor for TYPE. They need to be in increasing
531 offset order, which they might not be yet if TYPE has a primary base
532 which is not first in the base-clause or a vptr and at least one base
533 all of which are non-primary. */
535 static vec
<constructor_elt
, va_gc
> *
536 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
538 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
544 field_type
= BINFO_TYPE (pri
);
545 else if (TYPE_CONTAINS_VPTR_P (type
))
546 field_type
= vtbl_ptr_type_node
;
550 /* Find the element for the primary base or vptr and move it to the
551 beginning of the vec. */
552 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
553 if (TREE_TYPE (ce
->index
) == field_type
)
556 if (i
> 0 && i
< vec_safe_length (v
))
558 vec
<constructor_elt
, va_gc
> &vref
= *v
;
559 constructor_elt elt
= vref
[i
];
568 /* Build compile-time evalable representations of member-initializer list
569 for a constexpr constructor. */
572 build_constexpr_constructor_member_initializers (tree type
, tree body
)
574 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
577 switch (TREE_CODE (body
))
579 case MUST_NOT_THROW_EXPR
:
581 body
= TREE_OPERAND (body
, 0);
585 for (tree_stmt_iterator i
= tsi_start (body
);
586 !tsi_end_p (i
); tsi_next (&i
))
589 if (TREE_CODE (body
) == BIND_EXPR
)
595 body
= BIND_EXPR_BODY (body
);
602 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
604 body
= TREE_OPERAND (body
, 0);
605 if (TREE_CODE (body
) == EXPR_STMT
)
606 body
= TREE_OPERAND (body
, 0);
607 if (TREE_CODE (body
) == INIT_EXPR
608 && (same_type_ignoring_top_level_qualifiers_p
609 (TREE_TYPE (TREE_OPERAND (body
, 0)),
610 current_class_type
)))
613 return TREE_OPERAND (body
, 1);
615 ok
= build_data_member_initialization (body
, &vec
);
617 else if (TREE_CODE (body
) == STATEMENT_LIST
)
619 tree_stmt_iterator i
;
620 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
622 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
627 else if (TREE_CODE (body
) == TRY_BLOCK
)
629 error ("body of %<constexpr%> constructor cannot be "
630 "a function-try-block");
631 return error_mark_node
;
633 else if (EXPR_P (body
))
634 ok
= build_data_member_initialization (body
, &vec
);
636 gcc_assert (errorcount
> 0);
639 if (vec_safe_length (vec
) > 0)
641 /* In a delegating constructor, return the target. */
642 constructor_elt
*ce
= &(*vec
)[0];
643 if (ce
->index
== current_class_ptr
)
650 vec
= sort_constexpr_mem_initializers (type
, vec
);
651 return build_constructor (type
, vec
);
654 return error_mark_node
;
657 /* We have an expression tree T that represents a call, either CALL_EXPR
658 or AGGR_INIT_EXPR. If the call is lexically to a named function,
659 retrun the _DECL for that function. */
662 get_function_named_in_call (tree t
)
664 tree fun
= cp_get_callee (t
);
665 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
666 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
667 fun
= TREE_OPERAND (fun
, 0);
671 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
672 declared to be constexpr, or a sub-statement thereof. Returns the
673 return value if suitable, error_mark_node for a statement not allowed in
674 a constexpr function, or NULL_TREE if no return value was found. */
677 constexpr_fn_retval (tree body
)
679 switch (TREE_CODE (body
))
683 tree_stmt_iterator i
;
684 tree expr
= NULL_TREE
;
685 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
687 tree s
= constexpr_fn_retval (tsi_stmt (i
));
688 if (s
== error_mark_node
)
689 return error_mark_node
;
690 else if (s
== NULL_TREE
)
691 /* Keep iterating. */;
693 /* Multiple return statements. */
694 return error_mark_node
;
702 return break_out_target_exprs (TREE_OPERAND (body
, 0));
706 tree decl
= DECL_EXPR_DECL (body
);
707 if (TREE_CODE (decl
) == USING_DECL
708 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
709 || DECL_ARTIFICIAL (decl
))
711 return error_mark_node
;
714 case CLEANUP_POINT_EXPR
:
715 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
718 if (!check_constexpr_bind_expr_vars (body
))
719 return error_mark_node
;
720 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
723 case DEBUG_BEGIN_STMT
:
728 tree fun
= get_function_named_in_call (body
);
730 && fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
))
736 return error_mark_node
;
740 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
741 FUN; do the necessary transformations to turn it into a single expression
742 that we can store in the hash table. */
745 massage_constexpr_body (tree fun
, tree body
)
747 if (DECL_CONSTRUCTOR_P (fun
))
748 body
= build_constexpr_constructor_member_initializers
749 (DECL_CONTEXT (fun
), body
);
750 else if (cxx_dialect
< cxx14
)
752 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
753 body
= EH_SPEC_STMTS (body
);
754 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
755 body
= TREE_OPERAND (body
, 0);
756 body
= constexpr_fn_retval (body
);
761 /* CTYPE is a type constructed from BODY. Return true if some
762 bases/fields are uninitialized, and complain if COMPLAIN. */
765 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
771 if (TREE_CODE (body
) != CONSTRUCTOR
)
773 nelts
= CONSTRUCTOR_NELTS (body
);
775 tree field
= TYPE_FIELDS (ctype
);
777 if (TREE_CODE (ctype
) == UNION_TYPE
)
779 if (nelts
== 0 && next_initializable_field (field
))
782 error ("%<constexpr%> constructor for union %qT must "
783 "initialize exactly one non-static data member", ctype
);
789 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
790 need an explicit initialization. */
792 for (unsigned i
= 0; i
<= nelts
; ++i
)
794 tree index
= NULL_TREE
;
797 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
798 /* Skip base and vtable inits. */
799 if (TREE_CODE (index
) != FIELD_DECL
800 || DECL_ARTIFICIAL (index
))
804 for (; field
!= index
; field
= DECL_CHAIN (field
))
807 if (TREE_CODE (field
) != FIELD_DECL
)
809 if (DECL_UNNAMED_BIT_FIELD (field
))
811 if (DECL_ARTIFICIAL (field
))
813 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
815 /* Recurse to check the anonummous aggregate member. */
816 bad
|= cx_check_missing_mem_inits
817 (TREE_TYPE (field
), NULL_TREE
, complain
);
818 if (bad
&& !complain
)
822 ftype
= strip_array_types (TREE_TYPE (field
));
823 if (type_has_constexpr_default_constructor (ftype
))
825 /* It's OK to skip a member with a trivial constexpr ctor.
826 A constexpr ctor that isn't trivial should have been
828 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
834 auto_diagnostic_group d
;
835 error ("member %qD must be initialized by mem-initializer "
836 "in %<constexpr%> constructor", field
);
837 inform (DECL_SOURCE_LOCATION (field
), "declared here");
840 if (field
== NULL_TREE
)
843 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
845 /* Check the anonymous aggregate initializer is valid. */
846 bad
|= cx_check_missing_mem_inits
847 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
848 if (bad
&& !complain
)
851 field
= DECL_CHAIN (field
);
857 /* We are processing the definition of the constexpr function FUN.
858 Check that its BODY fulfills the propriate requirements and
859 enter it in the constexpr function definition table.
860 For constructor BODY is actually the TREE_LIST of the
861 member-initializer list. */
864 register_constexpr_fundef (tree fun
, tree body
)
866 constexpr_fundef entry
;
867 constexpr_fundef
**slot
;
869 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
872 tree massaged
= massage_constexpr_body (fun
, body
);
873 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
875 if (!DECL_CONSTRUCTOR_P (fun
))
876 error ("body of %<constexpr%> function %qD not a return-statement",
881 if (!potential_rvalue_constant_expression (massaged
))
883 if (!DECL_GENERATED_P (fun
))
884 require_potential_rvalue_constant_expression (massaged
);
888 if (DECL_CONSTRUCTOR_P (fun
)
889 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
890 massaged
, !DECL_GENERATED_P (fun
)))
893 /* Create the constexpr function table if necessary. */
894 if (constexpr_fundef_table
== NULL
)
895 constexpr_fundef_table
896 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
900 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
902 gcc_assert (*slot
== NULL
);
903 *slot
= ggc_alloc
<constexpr_fundef
> ();
909 /* FUN is a non-constexpr function called in a context that requires a
910 constant expression. If it comes from a constexpr template, explain why
911 the instantiation isn't constexpr. */
914 explain_invalid_constexpr_fn (tree fun
)
916 static hash_set
<tree
> *diagnosed
;
919 /* Only diagnose defaulted functions, lambdas, or instantiations. */
920 if (!DECL_DEFAULTED_FN (fun
)
921 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
922 && !is_instantiation_of_constexpr (fun
))
924 if (diagnosed
== NULL
)
925 diagnosed
= new hash_set
<tree
>;
926 if (diagnosed
->add (fun
))
927 /* Already explained. */
930 save_loc
= input_location
;
931 if (!lambda_static_thunk_p (fun
))
933 /* Diagnostics should completely ignore the static thunk, so leave
934 input_location set to our caller's location. */
935 input_location
= DECL_SOURCE_LOCATION (fun
);
936 inform (input_location
,
937 "%qD is not usable as a %<constexpr%> function because:", fun
);
939 /* First check the declaration. */
940 if (is_valid_constexpr_fn (fun
, true))
942 /* Then if it's OK, the body. */
943 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
944 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
945 explain_implicit_non_constexpr (fun
);
948 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
949 require_potential_rvalue_constant_expression (body
);
950 if (DECL_CONSTRUCTOR_P (fun
))
951 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
954 input_location
= save_loc
;
957 /* Objects of this type represent calls to constexpr functions
958 along with the bindings of parameters to their arguments, for
959 the purpose of compile time evaluation. */
961 struct GTY((for_user
)) constexpr_call
{
962 /* Description of the constexpr function definition. */
963 constexpr_fundef
*fundef
;
964 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
965 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
966 Note: This arrangement is made to accommodate the use of
967 iterative_hash_template_arg (see pt.c). If you change this
968 representation, also change the hash calculation in
969 cxx_eval_call_expression. */
971 /* Result of the call.
972 NULL means the call is being evaluated.
973 error_mark_node means that the evaluation was erroneous;
974 otherwise, the actuall value of the call. */
976 /* The hash of this call; we remember it here to avoid having to
977 recalculate it when expanding the hash table. */
979 /* Whether __builtin_is_constant_evaluated() should evaluate to true. */
980 bool manifestly_const_eval
;
983 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
985 static hashval_t
hash (constexpr_call
*);
986 static bool equal (constexpr_call
*, constexpr_call
*);
989 enum constexpr_switch_state
{
990 /* Used when processing a switch for the first time by cxx_eval_switch_expr
991 and default: label for that switch has not been seen yet. */
992 css_default_not_seen
,
993 /* Used when processing a switch for the first time by cxx_eval_switch_expr
994 and default: label for that switch has been seen already. */
996 /* Used when processing a switch for the second time by
997 cxx_eval_switch_expr, where default: label should match. */
998 css_default_processing
1001 /* The constexpr expansion context. CALL is the current function
1002 expansion, CTOR is the current aggregate initializer, OBJECT is the
1003 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
1004 is a map of values of variables initialized within the expression. */
1006 struct constexpr_ctx
{
1007 /* The innermost call we're evaluating. */
1008 constexpr_call
*call
;
1009 /* Values for any temporaries or local variables within the
1010 constant-expression. */
1011 hash_map
<tree
,tree
> *values
;
1012 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
1013 aren't inside a loop. */
1014 hash_set
<tree
> *save_exprs
;
1015 /* The CONSTRUCTOR we're currently building up for an aggregate
1018 /* The object we're building the CONSTRUCTOR for. */
1020 /* If inside SWITCH_EXPR. */
1021 constexpr_switch_state
*css_state
;
1022 /* Whether we should error on a non-constant expression or fail quietly. */
1024 /* Whether we are strictly conforming to constant expression rules or
1025 trying harder to get a constant value. */
1027 /* Whether __builtin_is_constant_evaluated () should be true. */
1028 bool manifestly_const_eval
;
1031 /* A table of all constexpr calls that have been evaluated by the
1032 compiler in this translation unit. */
1034 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1036 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1037 bool, bool *, bool *, tree
* = NULL
);
1039 /* Compute a hash value for a constexpr call representation. */
1042 constexpr_call_hasher::hash (constexpr_call
*info
)
1047 /* Return true if the objects pointed to by P and Q represent calls
1048 to the same constexpr function with the same arguments.
1049 Otherwise, return false. */
1052 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1058 if (lhs
->hash
!= rhs
->hash
)
1060 if (lhs
->manifestly_const_eval
!= rhs
->manifestly_const_eval
)
1062 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1064 lhs_bindings
= lhs
->bindings
;
1065 rhs_bindings
= rhs
->bindings
;
1066 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1068 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1069 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1070 gcc_assert (same_type_p (TREE_TYPE (lhs_arg
), TREE_TYPE (rhs_arg
)));
1071 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1073 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1074 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1076 return lhs_bindings
== rhs_bindings
;
1079 /* Initialize the constexpr call table, if needed. */
1082 maybe_initialize_constexpr_call_table (void)
1084 if (constexpr_call_table
== NULL
)
1085 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1088 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1089 a function happens to get called recursively, we unshare the callee
1090 function's body and evaluate this unshared copy instead of evaluating the
1093 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1094 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1095 that's keyed off of the original FUNCTION_DECL and whose value is a
1096 TREE_LIST of this function's unused copies awaiting reuse.
1098 This is not GC-deletable to avoid GC affecting UID generation. */
1100 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1102 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1105 maybe_initialize_fundef_copies_table ()
1107 if (fundef_copies_table
== NULL
)
1108 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1111 /* Reuse a copy or create a new unshared copy of the function FUN.
1112 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1113 is parms, TYPE is result. */
1116 get_fundef_copy (tree fun
)
1118 maybe_initialize_fundef_copies_table ();
1122 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1126 /* There is no cached function available, or in use. We can use
1127 the function directly. That the slot is now created records
1128 that this function is now in use. */
1129 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1130 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1132 else if (*slot
== NULL_TREE
)
1134 /* We've already used the function itself, so make a copy. */
1135 copy
= build_tree_list (NULL
, NULL
);
1136 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1140 /* We have a cached function available. */
1142 *slot
= TREE_CHAIN (copy
);
1148 /* Save the copy COPY of function FUN for later reuse by
1149 get_fundef_copy(). By construction, there will always be an entry
1153 save_fundef_copy (tree fun
, tree copy
)
1155 tree
*slot
= fundef_copies_table
->get (fun
);
1156 TREE_CHAIN (copy
) = *slot
;
1160 /* We have an expression tree T that represents a call, either CALL_EXPR
1161 or AGGR_INIT_EXPR. Return the Nth argument. */
1164 get_nth_callarg (tree t
, int n
)
1166 switch (TREE_CODE (t
))
1169 return CALL_EXPR_ARG (t
, n
);
1171 case AGGR_INIT_EXPR
:
1172 return AGGR_INIT_EXPR_ARG (t
, n
);
1180 /* Attempt to evaluate T which represents a call to a builtin function.
1181 We assume here that all builtin functions evaluate to scalar types
1182 represented by _CST nodes. */
1185 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1187 bool *non_constant_p
, bool *overflow_p
)
1189 const int nargs
= call_expr_nargs (t
);
1190 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1194 /* Don't fold __builtin_constant_p within a constexpr function. */
1195 bool bi_const_p
= DECL_IS_BUILTIN_CONSTANT_P (fun
);
1197 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1198 in a constexpr function until we have values for the parameters. */
1201 && current_function_decl
1202 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1204 *non_constant_p
= true;
1208 /* For __builtin_is_constant_evaluated, defer it if not
1209 ctx->manifestly_const_eval, otherwise fold it to true. */
1210 if (fndecl_built_in_p (fun
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
1213 if (!ctx
->manifestly_const_eval
)
1215 *non_constant_p
= true;
1218 return boolean_true_node
;
1221 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1222 return constant false for a non-constant argument. */
1223 constexpr_ctx new_ctx
= *ctx
;
1224 new_ctx
.quiet
= true;
1225 bool dummy1
= false, dummy2
= false;
1226 for (i
= 0; i
< nargs
; ++i
)
1228 args
[i
] = CALL_EXPR_ARG (t
, i
);
1229 /* If builtin_valid_in_constant_expr_p is true,
1230 potential_constant_expression_1 has not recursed into the arguments
1231 of the builtin, verify it here. */
1232 if (!builtin_valid_in_constant_expr_p (fun
)
1233 || potential_constant_expression (args
[i
]))
1234 args
[i
] = cxx_eval_constant_expression (&new_ctx
, args
[i
], false,
1237 /* For __built_in_constant_p, fold all expressions with constant values
1238 even if they aren't C++ constant-expressions. */
1239 args
[i
] = cp_fully_fold (args
[i
]);
1242 bool save_ffbcp
= force_folding_builtin_constant_p
;
1243 force_folding_builtin_constant_p
= true;
1244 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1245 CALL_EXPR_FN (t
), nargs
, args
);
1246 force_folding_builtin_constant_p
= save_ffbcp
;
1247 if (new_call
== NULL
)
1249 if (!*non_constant_p
&& !ctx
->quiet
)
1251 /* Do not allow__builtin_unreachable in constexpr function.
1252 The __builtin_unreachable call with BUILTINS_LOCATION
1253 comes from cp_maybe_instrument_return. */
1254 if (fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
)
1255 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1256 error ("%<constexpr%> call flows off the end of the function");
1259 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1260 CALL_EXPR_FN (t
), nargs
, args
);
1261 error ("%q+E is not a constant expression", new_call
);
1264 *non_constant_p
= true;
1268 if (!is_constant_expression (new_call
))
1270 if (!*non_constant_p
&& !ctx
->quiet
)
1271 error ("%q+E is not a constant expression", new_call
);
1272 *non_constant_p
= true;
1276 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1277 non_constant_p
, overflow_p
);
1280 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1281 the type of the value to match. */
1284 adjust_temp_type (tree type
, tree temp
)
1286 if (same_type_p (TREE_TYPE (temp
), type
))
1288 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1289 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1290 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1291 if (TREE_CODE (temp
) == EMPTY_CLASS_EXPR
)
1292 return build0 (EMPTY_CLASS_EXPR
, type
);
1293 gcc_assert (scalarish_type_p (type
));
1294 return cp_fold_convert (type
, temp
);
1297 /* Callback for walk_tree used by unshare_constructor. */
1300 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1304 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1309 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1310 subexpression, return an unshared copy of T. Otherwise return T. */
1313 unshare_constructor (tree t
)
1315 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1316 if (ctor
!= NULL_TREE
)
1317 return unshare_expr (t
);
1321 /* Subroutine of cxx_eval_call_expression.
1322 We are processing a call expression (either CALL_EXPR or
1323 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1324 all arguments and bind their values to correspondings
1325 parameters, making up the NEW_CALL context. */
1328 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1329 constexpr_call
*new_call
,
1330 bool *non_constant_p
, bool *overflow_p
,
1331 bool *non_constant_args
)
1333 const int nargs
= call_expr_nargs (t
);
1334 tree fun
= new_call
->fundef
->decl
;
1335 tree parms
= DECL_ARGUMENTS (fun
);
1337 tree
*p
= &new_call
->bindings
;
1338 for (i
= 0; i
< nargs
; ++i
)
1341 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1342 x
= get_nth_callarg (t
, i
);
1343 /* For member function, the first argument is a pointer to the implied
1344 object. For a constructor, it might still be a dummy object, in
1345 which case we get the real argument from ctx. */
1346 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1347 && is_dummy_object (x
))
1350 x
= build_address (x
);
1352 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1353 non_constant_p
, overflow_p
);
1354 /* Don't VERIFY_CONSTANT here. */
1355 if (*non_constant_p
&& ctx
->quiet
)
1357 /* Just discard ellipsis args after checking their constantitude. */
1361 if (!*non_constant_p
)
1363 /* Don't share a CONSTRUCTOR that might be changed. */
1364 arg
= unshare_constructor (arg
);
1365 /* Make sure the binding has the same type as the parm. But
1366 only for constant args. */
1367 if (!TYPE_REF_P (type
))
1368 arg
= adjust_temp_type (type
, arg
);
1369 if (!TREE_CONSTANT (arg
))
1370 *non_constant_args
= true;
1371 *p
= build_tree_list (parms
, arg
);
1372 p
= &TREE_CHAIN (*p
);
1374 parms
= TREE_CHAIN (parms
);
1378 /* Variables and functions to manage constexpr call expansion context.
1379 These do not need to be marked for PCH or GC. */
1381 /* FIXME remember and print actual constant arguments. */
1382 static vec
<tree
> call_stack
;
1383 static int call_stack_tick
;
1384 static int last_cx_error_tick
;
1387 push_cx_call_context (tree call
)
1390 if (!EXPR_HAS_LOCATION (call
))
1391 SET_EXPR_LOCATION (call
, input_location
);
1392 call_stack
.safe_push (call
);
1393 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1399 pop_cx_call_context (void)
1406 cx_error_context (void)
1408 vec
<tree
> r
= vNULL
;
1409 if (call_stack_tick
!= last_cx_error_tick
1410 && !call_stack
.is_empty ())
1412 last_cx_error_tick
= call_stack_tick
;
1416 /* Evaluate a call T to a GCC internal function when possible and return
1417 the evaluated result or, under the control of CTX, give an error, set
1418 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1421 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1423 bool *non_constant_p
, bool *overflow_p
)
1425 enum tree_code opcode
= ERROR_MARK
;
1427 switch (CALL_EXPR_IFN (t
))
1429 case IFN_UBSAN_NULL
:
1430 case IFN_UBSAN_BOUNDS
:
1431 case IFN_UBSAN_VPTR
:
1432 case IFN_FALLTHROUGH
:
1435 case IFN_ADD_OVERFLOW
:
1438 case IFN_SUB_OVERFLOW
:
1439 opcode
= MINUS_EXPR
;
1441 case IFN_MUL_OVERFLOW
:
1446 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1447 false, non_constant_p
, overflow_p
);
1451 error_at (cp_expr_loc_or_loc (t
, input_location
),
1452 "call to internal function %qE", t
);
1453 *non_constant_p
= true;
1457 /* Evaluate constant arguments using OPCODE and return a complex
1458 number containing the result and the overflow bit. */
1459 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1460 non_constant_p
, overflow_p
);
1461 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1462 non_constant_p
, overflow_p
);
1464 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1466 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1467 tree type
= TREE_TYPE (TREE_TYPE (t
));
1468 tree result
= fold_binary_loc (loc
, opcode
, type
,
1469 fold_convert_loc (loc
, type
, arg0
),
1470 fold_convert_loc (loc
, type
, arg1
));
1472 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1473 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1474 if (TREE_OVERFLOW (result
))
1475 TREE_OVERFLOW (result
) = 0;
1477 return build_complex (TREE_TYPE (t
), result
, ovf
);
1480 *non_constant_p
= true;
1484 /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */
1487 clear_no_implicit_zero (tree ctor
)
1489 if (CONSTRUCTOR_NO_CLEARING (ctor
))
1491 CONSTRUCTOR_NO_CLEARING (ctor
) = false;
1492 tree elt
; unsigned HOST_WIDE_INT idx
;
1493 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1494 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1495 clear_no_implicit_zero (elt
);
1499 /* Subroutine of cxx_eval_constant_expression.
1500 Evaluate the call expression tree T in the context of OLD_CALL expression
1504 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1506 bool *non_constant_p
, bool *overflow_p
)
1508 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1509 tree fun
= get_function_named_in_call (t
);
1510 constexpr_call new_call
1511 = { NULL
, NULL
, NULL
, 0, ctx
->manifestly_const_eval
};
1514 if (fun
== NULL_TREE
)
1515 return cxx_eval_internal_function (ctx
, t
, lval
,
1516 non_constant_p
, overflow_p
);
1518 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1520 /* Might be a constexpr function pointer. */
1521 fun
= cxx_eval_constant_expression (ctx
, fun
,
1522 /*lval*/false, non_constant_p
,
1525 if (TREE_CODE (fun
) == ADDR_EXPR
)
1526 fun
= TREE_OPERAND (fun
, 0);
1527 /* For TARGET_VTABLE_USES_DESCRIPTORS targets, there is no
1528 indirection, the called expression is a pointer into the
1529 virtual table which should contain FDESC_EXPR. Extract the
1530 FUNCTION_DECL from there. */
1531 else if (TARGET_VTABLE_USES_DESCRIPTORS
1532 && TREE_CODE (fun
) == POINTER_PLUS_EXPR
1533 && TREE_CODE (TREE_OPERAND (fun
, 0)) == ADDR_EXPR
1534 && TREE_CODE (TREE_OPERAND (fun
, 1)) == INTEGER_CST
)
1536 tree d
= TREE_OPERAND (TREE_OPERAND (fun
, 0), 0);
1538 && DECL_VTABLE_OR_VTT_P (d
)
1539 && TREE_CODE (TREE_TYPE (d
)) == ARRAY_TYPE
1540 && TREE_TYPE (TREE_TYPE (d
)) == vtable_entry_type
1542 && TREE_CODE (DECL_INITIAL (d
)) == CONSTRUCTOR
)
1544 tree i
= int_const_binop (TRUNC_DIV_EXPR
, TREE_OPERAND (fun
, 1),
1545 TYPE_SIZE_UNIT (vtable_entry_type
));
1546 HOST_WIDE_INT idx
= find_array_ctor_elt (DECL_INITIAL (d
), i
);
1550 = (*CONSTRUCTOR_ELTS (DECL_INITIAL (d
)))[idx
].value
;
1551 if (TREE_CODE (fdesc
) == FDESC_EXPR
1552 && integer_zerop (TREE_OPERAND (fdesc
, 1)))
1553 fun
= TREE_OPERAND (fdesc
, 0);
1558 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1560 if (!ctx
->quiet
&& !*non_constant_p
)
1561 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1563 *non_constant_p
= true;
1566 if (DECL_CLONED_FUNCTION_P (fun
))
1567 fun
= DECL_CLONED_FUNCTION (fun
);
1569 if (is_ubsan_builtin_p (fun
))
1572 if (fndecl_built_in_p (fun
))
1573 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1574 lval
, non_constant_p
, overflow_p
);
1575 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1579 if (!lambda_static_thunk_p (fun
))
1580 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1581 explain_invalid_constexpr_fn (fun
);
1583 *non_constant_p
= true;
1587 constexpr_ctx new_ctx
= *ctx
;
1588 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1589 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1591 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1592 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1593 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1594 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1595 CONSTRUCTOR_NO_CLEARING (ctor
) = true;
1596 ctx
->values
->put (new_ctx
.object
, ctor
);
1600 /* Shortcut trivial constructor/op=. */
1601 if (trivial_fn_p (fun
))
1603 tree init
= NULL_TREE
;
1604 if (call_expr_nargs (t
) == 2)
1605 init
= convert_from_reference (get_nth_callarg (t
, 1));
1606 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1607 && AGGR_INIT_ZERO_FIRST (t
))
1608 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1611 tree op
= get_nth_callarg (t
, 0);
1612 if (is_dummy_object (op
))
1615 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1616 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1617 new_ctx
.call
= &new_call
;
1618 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1619 non_constant_p
, overflow_p
);
1623 /* We can't defer instantiating the function any longer. */
1624 if (!DECL_INITIAL (fun
)
1625 && DECL_TEMPLOID_INSTANTIATION (fun
))
1627 location_t save_loc
= input_location
;
1628 input_location
= loc
;
1630 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1632 input_location
= save_loc
;
1635 /* If in direct recursive call, optimize definition search. */
1636 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1637 new_call
.fundef
= ctx
->call
->fundef
;
1640 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1641 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1642 || fun
== current_function_decl
)
1646 /* We need to check for current_function_decl here in case we're
1647 being called during cp_fold_function, because at that point
1648 DECL_INITIAL is set properly and we have a fundef but we
1649 haven't lowered invisirefs yet (c++/70344). */
1650 if (DECL_INITIAL (fun
) == error_mark_node
1651 || fun
== current_function_decl
)
1652 error_at (loc
, "%qD called in a constant expression before its "
1653 "definition is complete", fun
);
1654 else if (DECL_INITIAL (fun
))
1656 /* The definition of fun was somehow unsuitable. But pretend
1657 that lambda static thunks don't exist. */
1658 if (!lambda_static_thunk_p (fun
))
1659 error_at (loc
, "%qD called in a constant expression", fun
);
1660 explain_invalid_constexpr_fn (fun
);
1663 error_at (loc
, "%qD used before its definition", fun
);
1665 *non_constant_p
= true;
1670 bool non_constant_args
= false;
1671 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1672 non_constant_p
, overflow_p
, &non_constant_args
);
1673 if (*non_constant_p
)
1676 depth_ok
= push_cx_call_context (t
);
1678 tree result
= NULL_TREE
;
1680 constexpr_call
*entry
= NULL
;
1681 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1683 new_call
.hash
= constexpr_fundef_hasher::hash (new_call
.fundef
);
1685 = iterative_hash_template_arg (new_call
.bindings
, new_call
.hash
);
1687 = iterative_hash_object (ctx
->manifestly_const_eval
, new_call
.hash
);
1689 /* If we have seen this call before, we are done. */
1690 maybe_initialize_constexpr_call_table ();
1691 constexpr_call
**slot
1692 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1696 /* We need to keep a pointer to the entry, not just the slot, as the
1697 slot can move in the call to cxx_eval_builtin_function_call. */
1698 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1701 /* Calls that are in progress have their result set to NULL,
1702 so that we can detect circular dependencies. */
1703 else if (entry
->result
== NULL
)
1706 error ("call has circular dependency");
1707 *non_constant_p
= true;
1708 entry
->result
= result
= error_mark_node
;
1711 result
= entry
->result
;
1717 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1718 "%<-fconstexpr-depth=%> to increase the maximum)",
1719 max_constexpr_depth
);
1720 *non_constant_p
= true;
1721 result
= error_mark_node
;
1725 if (result
&& result
!= error_mark_node
)
1727 else if (!DECL_SAVED_TREE (fun
))
1729 /* When at_eof >= 2, cgraph has started throwing away
1730 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1731 late code generation for VEC_INIT_EXPR, which needs to be
1732 completely reconsidered. */
1733 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1734 *non_constant_p
= true;
1738 tree body
, parms
, res
;
1740 /* Reuse or create a new unshared copy of this function's body. */
1741 tree copy
= get_fundef_copy (fun
);
1742 body
= TREE_PURPOSE (copy
);
1743 parms
= TREE_VALUE (copy
);
1744 res
= TREE_TYPE (copy
);
1746 /* Associate the bindings with the remapped parms. */
1747 tree bound
= new_call
.bindings
;
1748 tree remapped
= parms
;
1751 tree oparm
= TREE_PURPOSE (bound
);
1752 tree arg
= TREE_VALUE (bound
);
1753 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1754 /* Don't share a CONSTRUCTOR that might be changed. */
1755 arg
= unshare_constructor (arg
);
1756 ctx
->values
->put (remapped
, arg
);
1757 bound
= TREE_CHAIN (bound
);
1758 remapped
= DECL_CHAIN (remapped
);
1760 /* Add the RESULT_DECL to the values map, too. */
1761 tree slot
= NULL_TREE
;
1762 if (DECL_BY_REFERENCE (res
))
1764 slot
= AGGR_INIT_EXPR_SLOT (t
);
1765 tree addr
= build_address (slot
);
1766 addr
= build_nop (TREE_TYPE (res
), addr
);
1767 ctx
->values
->put (res
, addr
);
1768 ctx
->values
->put (slot
, NULL_TREE
);
1771 ctx
->values
->put (res
, NULL_TREE
);
1773 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1774 their values after the call. */
1775 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1776 hash_set
<tree
> save_exprs
;
1777 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1778 ctx_with_save_exprs
.call
= &new_call
;
1780 tree jump_target
= NULL_TREE
;
1781 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1782 lval
, non_constant_p
, overflow_p
,
1785 if (DECL_CONSTRUCTOR_P (fun
))
1786 /* This can be null for a subobject constructor call, in
1787 which case what we care about is the initialization
1788 side-effects rather than the value. We could get at the
1789 value by evaluating *this, but we don't bother; there's
1790 no need to put such a call in the hash table. */
1791 result
= lval
? ctx
->object
: ctx
->ctor
;
1792 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1796 result
= *ctx
->values
->get (slot
? slot
: res
);
1797 if (result
== NULL_TREE
&& !*non_constant_p
)
1800 error ("%<constexpr%> call flows off the end "
1802 *non_constant_p
= true;
1806 /* Forget the saved values of the callee's SAVE_EXPRs. */
1807 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1808 iter
!= save_exprs
.end(); ++iter
)
1809 ctx_with_save_exprs
.values
->remove (*iter
);
1811 /* Remove the parms/result from the values map. Is it worth
1812 bothering to do this when the map itself is only live for
1813 one constexpr evaluation? If so, maybe also clear out
1814 other vars from call, maybe in BIND_EXPR handling? */
1815 ctx
->values
->remove (res
);
1817 ctx
->values
->remove (slot
);
1818 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1819 ctx
->values
->remove (parm
);
1821 /* Make the unshared function copy we used available for re-use. */
1822 save_fundef_copy (fun
, copy
);
1825 if (result
== error_mark_node
)
1826 *non_constant_p
= true;
1827 if (*non_constant_p
|| *overflow_p
)
1828 result
= error_mark_node
;
1832 entry
->result
= result
;
1835 /* The result of a constexpr function must be completely initialized. */
1836 if (TREE_CODE (result
) == CONSTRUCTOR
)
1837 clear_no_implicit_zero (result
);
1839 pop_cx_call_context ();
1840 return unshare_constructor (result
);
1843 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1846 reduced_constant_expression_p (tree t
)
1851 switch (TREE_CODE (t
))
1854 /* Even if we can't lower this yet, it's constant. */
1858 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1859 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1860 if (CONSTRUCTOR_NO_CLEARING (t
))
1862 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1863 /* An initialized vector would have a VECTOR_CST. */
1866 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1870 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1872 /* If VAL is null, we're in the middle of initializing this
1874 if (!reduced_constant_expression_p (val
))
1880 field
= next_initializable_field (DECL_CHAIN (field
));
1885 else if (CONSTRUCTOR_NO_CLEARING (t
))
1886 /* All the fields are initialized. */
1887 CONSTRUCTOR_NO_CLEARING (t
) = false;
1891 /* FIXME are we calling this too much? */
1892 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1896 /* Some expressions may have constant operands but are not constant
1897 themselves, such as 1/0. Call this function to check for that
1900 We only call this in places that require an arithmetic constant, not in
1901 places where we might have a non-constant expression that can be a
1902 component of a constant expression, such as the address of a constexpr
1903 variable that might be dereferenced later. */
1906 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1909 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1911 if (!allow_non_constant
)
1912 error ("%q+E is not a constant expression", t
);
1913 *non_constant_p
= true;
1915 if (TREE_OVERFLOW_P (t
))
1917 if (!allow_non_constant
)
1919 permerror (input_location
, "overflow in constant expression");
1920 /* If we're being permissive (and are in an enforcing
1921 context), ignore the overflow. */
1922 if (flag_permissive
)
1923 return *non_constant_p
;
1927 return *non_constant_p
;
1930 /* Check whether the shift operation with code CODE and type TYPE on LHS
1931 and RHS is undefined. If it is, give an error with an explanation,
1932 and return true; return false otherwise. */
1935 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1936 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1938 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1939 || TREE_CODE (lhs
) != INTEGER_CST
1940 || TREE_CODE (rhs
) != INTEGER_CST
)
1943 tree lhstype
= TREE_TYPE (lhs
);
1944 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1946 /* [expr.shift] The behavior is undefined if the right operand
1947 is negative, or greater than or equal to the length in bits
1948 of the promoted left operand. */
1949 if (tree_int_cst_sgn (rhs
) == -1)
1952 permerror (loc
, "right operand of shift expression %q+E is negative",
1953 build2_loc (loc
, code
, type
, lhs
, rhs
));
1954 return (!flag_permissive
|| ctx
->quiet
);
1956 if (compare_tree_int (rhs
, uprec
) >= 0)
1959 permerror (loc
, "right operand of shift expression %q+E is >= than "
1960 "the precision of the left operand",
1961 build2_loc (loc
, code
, type
, lhs
, rhs
));
1962 return (!flag_permissive
|| ctx
->quiet
);
1965 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1966 if E1 has a signed type and non-negative value, and E1x2^E2 is
1967 representable in the corresponding unsigned type of the result type,
1968 then that value, converted to the result type, is the resulting value;
1969 otherwise, the behavior is undefined.
1971 The value of E1 << E2 is the unique value congruent to E1 x 2^E2 modulo
1972 2^N, where N is the range exponent of the type of the result. */
1973 if (code
== LSHIFT_EXPR
1974 && !TYPE_UNSIGNED (lhstype
)
1975 && cxx_dialect
>= cxx11
1976 && cxx_dialect
< cxx2a
)
1978 if (tree_int_cst_sgn (lhs
) == -1)
1982 "left operand of shift expression %q+E is negative",
1983 build2_loc (loc
, code
, type
, lhs
, rhs
));
1984 return (!flag_permissive
|| ctx
->quiet
);
1986 /* For signed x << y the following:
1987 (unsigned) x >> ((prec (lhs) - 1) - y)
1988 if > 1, is undefined. The right-hand side of this formula
1989 is the highest bit of the LHS that can be set (starting from 0),
1990 so that the shift doesn't overflow. We then right-shift the LHS
1991 to see whether any other bit is set making the original shift
1992 undefined -- the result is not representable in the corresponding
1994 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1995 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1996 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1997 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1998 if (tree_int_cst_lt (integer_one_node
, t
))
2001 permerror (loc
, "shift expression %q+E overflows",
2002 build2_loc (loc
, code
, type
, lhs
, rhs
));
2003 return (!flag_permissive
|| ctx
->quiet
);
2009 /* Subroutine of cxx_eval_constant_expression.
2010 Attempt to reduce the unary expression tree T to a compile time value.
2011 If successful, return the value. Otherwise issue a diagnostic
2012 and return error_mark_node. */
2015 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
2017 bool *non_constant_p
, bool *overflow_p
)
2020 tree orig_arg
= TREE_OPERAND (t
, 0);
2021 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
2022 non_constant_p
, overflow_p
);
2023 VERIFY_CONSTANT (arg
);
2024 location_t loc
= EXPR_LOCATION (t
);
2025 enum tree_code code
= TREE_CODE (t
);
2026 tree type
= TREE_TYPE (t
);
2027 r
= fold_unary_loc (loc
, code
, type
, arg
);
2030 if (arg
== orig_arg
)
2033 r
= build1_loc (loc
, code
, type
, arg
);
2035 VERIFY_CONSTANT (r
);
2039 /* Helper function for cxx_eval_binary_expression. Try to optimize
2040 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
2041 generic folding should be used. */
2044 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
2045 tree lhs
, tree rhs
, bool *non_constant_p
,
2049 if (TREE_CODE (lhs
) != ADDR_EXPR
)
2052 lhs
= TREE_OPERAND (lhs
, 0);
2054 /* &A[i] p+ j => &A[i + j] */
2055 if (TREE_CODE (lhs
) == ARRAY_REF
2056 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
2057 && TREE_CODE (rhs
) == INTEGER_CST
2058 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
2059 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
2061 tree orig_type
= TREE_TYPE (t
);
2062 location_t loc
= EXPR_LOCATION (t
);
2063 tree type
= TREE_TYPE (lhs
);
2065 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
2066 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
2067 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2069 if (*non_constant_p
)
2071 /* Don't fold an out-of-bound access. */
2072 if (!tree_int_cst_le (t
, nelts
))
2074 rhs
= cp_fold_convert (ssizetype
, rhs
);
2075 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
2076 constexpr int A[1]; ... (char *)&A[0] + 1 */
2077 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
2078 rhs
, TYPE_SIZE_UNIT (type
))))
2080 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2082 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
2083 TYPE_SIZE_UNIT (type
));
2084 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
2085 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
2086 t
, NULL_TREE
, NULL_TREE
);
2087 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2088 t
= cp_fold_convert (orig_type
, t
);
2089 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2090 non_constant_p
, overflow_p
);
2096 /* Subroutine of cxx_eval_constant_expression.
2097 Like cxx_eval_unary_expression, except for binary expressions. */
2100 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2102 bool *non_constant_p
, bool *overflow_p
)
2105 tree orig_lhs
= TREE_OPERAND (t
, 0);
2106 tree orig_rhs
= TREE_OPERAND (t
, 1);
2108 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2109 non_constant_p
, overflow_p
);
2110 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2112 if (*non_constant_p
)
2114 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2115 non_constant_p
, overflow_p
);
2116 if (*non_constant_p
)
2119 location_t loc
= EXPR_LOCATION (t
);
2120 enum tree_code code
= TREE_CODE (t
);
2121 tree type
= TREE_TYPE (t
);
2123 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2125 bool is_code_eq
= (code
== EQ_EXPR
);
2127 if (TREE_CODE (lhs
) == PTRMEM_CST
2128 && TREE_CODE (rhs
) == PTRMEM_CST
)
2130 tree lmem
= PTRMEM_CST_MEMBER (lhs
);
2131 tree rmem
= PTRMEM_CST_MEMBER (rhs
);
2133 if (TREE_CODE (lmem
) == TREE_CODE (rmem
)
2134 && TREE_CODE (lmem
) == FIELD_DECL
2135 && TREE_CODE (DECL_CONTEXT (lmem
)) == UNION_TYPE
2136 && same_type_p (DECL_CONTEXT (lmem
),
2137 DECL_CONTEXT (rmem
)))
2138 /* If both refer to (possibly different) members of the same union
2139 (12.3), they compare equal. */
2142 eq
= cp_tree_equal (lhs
, rhs
);
2143 r
= constant_boolean_node (eq
== is_code_eq
, type
);
2145 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2146 || TREE_CODE (rhs
) == PTRMEM_CST
)
2147 && (null_member_pointer_value_p (lhs
)
2148 || null_member_pointer_value_p (rhs
)))
2149 r
= constant_boolean_node (!is_code_eq
, type
);
2150 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2151 lhs
= cplus_expand_constant (lhs
);
2152 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2153 rhs
= cplus_expand_constant (rhs
);
2155 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2156 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2159 error ("arithmetic involving a null pointer in %qE", lhs
);
2160 *non_constant_p
= true;
2163 else if (code
== POINTER_PLUS_EXPR
)
2164 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2168 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2172 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2175 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2177 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2178 *non_constant_p
= true;
2179 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2180 a local array in a constexpr function. */
2181 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (lhs
));
2183 VERIFY_CONSTANT (r
);
2187 /* Subroutine of cxx_eval_constant_expression.
2188 Attempt to evaluate condition expressions. Dead branches are not
2192 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2194 bool *non_constant_p
, bool *overflow_p
,
2197 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2199 non_constant_p
, overflow_p
);
2200 VERIFY_CONSTANT (val
);
2201 /* Don't VERIFY_CONSTANT the other operands. */
2202 if (integer_zerop (val
))
2203 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2205 non_constant_p
, overflow_p
,
2207 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2209 non_constant_p
, overflow_p
,
2213 /* Subroutine of cxx_eval_constant_expression.
2214 Attempt to evaluate vector condition expressions. Unlike
2215 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2216 ternary arithmetics operation, where all 3 arguments have to be
2217 evaluated as constants and then folding computes the result from
2221 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2222 bool *non_constant_p
, bool *overflow_p
)
2224 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2226 non_constant_p
, overflow_p
);
2227 VERIFY_CONSTANT (arg1
);
2228 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2230 non_constant_p
, overflow_p
);
2231 VERIFY_CONSTANT (arg2
);
2232 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2234 non_constant_p
, overflow_p
);
2235 VERIFY_CONSTANT (arg3
);
2236 location_t loc
= EXPR_LOCATION (t
);
2237 tree type
= TREE_TYPE (t
);
2238 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2241 if (arg1
== TREE_OPERAND (t
, 0)
2242 && arg2
== TREE_OPERAND (t
, 1)
2243 && arg3
== TREE_OPERAND (t
, 2))
2246 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2248 VERIFY_CONSTANT (r
);
2252 /* Returns less than, equal to, or greater than zero if KEY is found to be
2253 less than, to match, or to be greater than the constructor_elt's INDEX. */
2256 array_index_cmp (tree key
, tree index
)
2258 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2260 switch (TREE_CODE (index
))
2263 return tree_int_cst_compare (key
, index
);
2266 tree lo
= TREE_OPERAND (index
, 0);
2267 tree hi
= TREE_OPERAND (index
, 1);
2268 if (tree_int_cst_lt (key
, lo
))
2270 else if (tree_int_cst_lt (hi
, key
))
2280 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2281 if none. If INSERT is true, insert a matching element rather than fail. */
2283 static HOST_WIDE_INT
2284 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
)
2286 if (tree_int_cst_sgn (dindex
) < 0)
2289 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2290 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2291 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2293 unsigned HOST_WIDE_INT end
= len
;
2294 unsigned HOST_WIDE_INT begin
= 0;
2296 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2297 that the same is true of the other elements and index directly. */
2300 tree cindex
= (*elts
)[end
- 1].index
;
2301 if (TREE_CODE (cindex
) == INTEGER_CST
2302 && compare_tree_int (cindex
, end
- 1) == 0)
2311 /* Otherwise, find a matching index by means of a binary search. */
2312 while (begin
!= end
)
2314 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2315 constructor_elt
&elt
= (*elts
)[middle
];
2316 tree idx
= elt
.index
;
2318 int cmp
= array_index_cmp (dindex
, idx
);
2325 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2327 /* We need to split the range. */
2329 tree lo
= TREE_OPERAND (idx
, 0);
2330 tree hi
= TREE_OPERAND (idx
, 1);
2331 tree value
= elt
.value
;
2332 dindex
= fold_convert (sizetype
, dindex
);
2333 if (tree_int_cst_lt (lo
, dindex
))
2335 /* There are still some lower elts; shorten the range. */
2336 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2338 if (tree_int_cst_equal (lo
, new_hi
))
2339 /* Only one element left, no longer a range. */
2342 TREE_OPERAND (idx
, 1) = new_hi
;
2343 /* Append the element we want to insert. */
2346 e
.value
= unshare_constructor (value
);
2347 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2350 /* No lower elts, the range elt is now ours. */
2353 if (tree_int_cst_lt (dindex
, hi
))
2355 /* There are still some higher elts; append a range. */
2356 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2358 if (tree_int_cst_equal (new_lo
, hi
))
2361 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2362 e
.value
= unshare_constructor (value
);
2363 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2372 constructor_elt e
= { dindex
, NULL_TREE
};
2373 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2380 /* Under the control of CTX, issue a detailed diagnostic for
2381 an out-of-bounds subscript INDEX into the expression ARRAY. */
2384 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2388 tree arraytype
= TREE_TYPE (array
);
2390 /* Convert the unsigned array subscript to a signed integer to avoid
2391 printing huge numbers for small negative values. */
2392 tree sidx
= fold_convert (ssizetype
, index
);
2395 if (TYPE_DOMAIN (arraytype
))
2396 error ("array subscript value %qE is outside the bounds "
2397 "of array %qD of type %qT", sidx
, array
, arraytype
);
2399 error ("non-zero array subscript %qE is used with array %qD of "
2400 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2401 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2403 else if (TYPE_DOMAIN (arraytype
))
2404 error ("array subscript value %qE is outside the bounds "
2405 "of array type %qT", sidx
, arraytype
);
2407 error ("non-zero array subscript %qE is used with array of type %qT "
2408 "with unknown bounds", sidx
, arraytype
);
2412 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2416 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2417 bool *non_constant_p
, bool *overflow_p
)
2420 if (TREE_CODE (type
) == ARRAY_TYPE
)
2422 if (TYPE_DOMAIN (type
))
2423 nelts
= array_type_nelts_top (type
);
2425 nelts
= size_zero_node
;
2427 else if (VECTOR_TYPE_P (type
))
2428 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2432 /* For VLAs, the number of elements won't be an integer constant. */
2433 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2434 non_constant_p
, overflow_p
);
2438 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2439 STRING_CST STRING. */
2442 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2444 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2447 if (chars_per_elt
== 1)
2448 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2451 const unsigned char *ptr
2452 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2453 + index
* chars_per_elt
);
2454 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2459 /* Subroutine of cxx_eval_constant_expression.
2460 Attempt to reduce a reference to an array slot. */
2463 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2465 bool *non_constant_p
, bool *overflow_p
)
2467 tree oldary
= TREE_OPERAND (t
, 0);
2468 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2470 non_constant_p
, overflow_p
);
2472 HOST_WIDE_INT i
= 0;
2473 tree elem_type
= NULL_TREE
;
2474 unsigned len
= 0, elem_nchars
= 1;
2475 if (*non_constant_p
)
2477 oldidx
= TREE_OPERAND (t
, 1);
2478 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2480 non_constant_p
, overflow_p
);
2481 VERIFY_CONSTANT (index
);
2484 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2485 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2486 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2487 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2488 ary
= TREE_OPERAND (ary
, 0);
2489 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2490 len
= CONSTRUCTOR_NELTS (ary
);
2491 else if (TREE_CODE (ary
) == STRING_CST
)
2493 elem_nchars
= (TYPE_PRECISION (elem_type
)
2494 / TYPE_PRECISION (char_type_node
));
2495 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2497 else if (TREE_CODE (ary
) == VECTOR_CST
)
2498 /* We don't create variable-length VECTOR_CSTs. */
2499 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2502 /* We can't do anything with other tree codes, so use
2503 VERIFY_CONSTANT to complain and fail. */
2504 VERIFY_CONSTANT (ary
);
2508 if (!tree_fits_shwi_p (index
)
2509 || (i
= tree_to_shwi (index
)) < 0)
2511 diag_array_subscript (ctx
, ary
, index
);
2512 *non_constant_p
= true;
2517 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2519 VERIFY_CONSTANT (nelts
);
2521 ? !tree_int_cst_le (index
, nelts
)
2522 : !tree_int_cst_lt (index
, nelts
))
2523 || tree_int_cst_sgn (index
) < 0)
2525 diag_array_subscript (ctx
, ary
, index
);
2526 *non_constant_p
= true;
2530 if (lval
&& ary
== oldary
&& index
== oldidx
)
2533 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2536 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2538 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2549 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2550 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2551 else if (TREE_CODE (ary
) == VECTOR_CST
)
2552 r
= VECTOR_CST_ELT (ary
, i
);
2554 r
= extract_string_elt (ary
, elem_nchars
, i
);
2557 /* Don't VERIFY_CONSTANT here. */
2560 /* Otherwise the element doesn't have a value yet. */
2565 if (TREE_CODE (ary
) == CONSTRUCTOR
2566 && CONSTRUCTOR_NO_CLEARING (ary
))
2568 /* 'ary' is part of the aggregate initializer we're currently
2569 building; if there's no initializer for this element yet,
2572 error ("accessing uninitialized array element");
2573 *non_constant_p
= true;
2577 /* If it's within the array bounds but doesn't have an explicit
2578 initializer, it's value-initialized. */
2579 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2580 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2584 /* Subroutine of cxx_eval_constant_expression.
2585 Attempt to reduce a field access of a value of class type. */
2588 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2590 bool *non_constant_p
, bool *overflow_p
)
2592 unsigned HOST_WIDE_INT i
;
2595 tree part
= TREE_OPERAND (t
, 1);
2596 tree orig_whole
= TREE_OPERAND (t
, 0);
2597 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2599 non_constant_p
, overflow_p
);
2600 if (INDIRECT_REF_P (whole
)
2601 && integer_zerop (TREE_OPERAND (whole
, 0)))
2604 error ("dereferencing a null pointer in %qE", orig_whole
);
2605 *non_constant_p
= true;
2609 if (TREE_CODE (whole
) == PTRMEM_CST
)
2610 whole
= cplus_expand_constant (whole
);
2611 if (whole
== orig_whole
)
2614 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2615 whole
, part
, NULL_TREE
);
2616 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2618 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2621 error ("%qE is not a constant expression", orig_whole
);
2622 *non_constant_p
= true;
2624 if (DECL_MUTABLE_P (part
))
2627 error ("mutable %qD is not usable in a constant expression", part
);
2628 *non_constant_p
= true;
2630 if (*non_constant_p
)
2632 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2633 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2635 /* Use name match for PMF fields, as a variant will have a
2636 different FIELD_DECL with a different type. */
2637 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2643 /* We're in the middle of initializing it. */
2647 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2648 && CONSTRUCTOR_NELTS (whole
) > 0)
2650 /* DR 1188 says we don't have to deal with this. */
2652 error ("accessing %qD member instead of initialized %qD member in "
2653 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2654 *non_constant_p
= true;
2658 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2659 classes never get represented; throw together a value now. */
2660 if (is_really_empty_class (TREE_TYPE (t
)))
2661 return build_constructor (TREE_TYPE (t
), NULL
);
2663 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2665 if (CONSTRUCTOR_NO_CLEARING (whole
))
2667 /* 'whole' is part of the aggregate initializer we're currently
2668 building; if there's no initializer for this member yet, that's an
2671 error ("accessing uninitialized member %qD", part
);
2672 *non_constant_p
= true;
2676 /* If there's no explicit init for this field, it's value-initialized. */
2677 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2678 return cxx_eval_constant_expression (ctx
, value
,
2680 non_constant_p
, overflow_p
);
2683 /* Subroutine of cxx_eval_constant_expression.
2684 Attempt to reduce a field access of a value of class type that is
2685 expressed as a BIT_FIELD_REF. */
2688 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2690 bool *non_constant_p
, bool *overflow_p
)
2692 tree orig_whole
= TREE_OPERAND (t
, 0);
2693 tree retval
, fldval
, utype
, mask
;
2694 bool fld_seen
= false;
2695 HOST_WIDE_INT istart
, isize
;
2696 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2698 non_constant_p
, overflow_p
);
2699 tree start
, field
, value
;
2700 unsigned HOST_WIDE_INT i
;
2702 if (whole
== orig_whole
)
2704 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2706 if (!*non_constant_p
2707 && TREE_CODE (whole
) != VECTOR_CST
2708 && TREE_CODE (whole
) != CONSTRUCTOR
)
2711 error ("%qE is not a constant expression", orig_whole
);
2712 *non_constant_p
= true;
2714 if (*non_constant_p
)
2717 if (TREE_CODE (whole
) == VECTOR_CST
)
2718 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2719 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2721 start
= TREE_OPERAND (t
, 2);
2722 istart
= tree_to_shwi (start
);
2723 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2724 utype
= TREE_TYPE (t
);
2725 if (!TYPE_UNSIGNED (utype
))
2726 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2727 retval
= build_int_cst (utype
, 0);
2728 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2730 tree bitpos
= bit_position (field
);
2731 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2733 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2734 && TREE_CODE (value
) == INTEGER_CST
2735 && tree_fits_shwi_p (bitpos
)
2736 && tree_fits_shwi_p (DECL_SIZE (field
)))
2738 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2739 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2740 HOST_WIDE_INT shift
;
2741 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2743 fldval
= fold_convert (utype
, value
);
2744 mask
= build_int_cst_type (utype
, -1);
2745 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2746 size_int (TYPE_PRECISION (utype
) - sz
));
2747 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2748 size_int (TYPE_PRECISION (utype
) - sz
));
2749 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2750 shift
= bit
- istart
;
2751 if (BYTES_BIG_ENDIAN
)
2752 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2753 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2755 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2761 return fold_convert (TREE_TYPE (t
), retval
);
2763 return error_mark_node
;
2766 /* Subroutine of cxx_eval_constant_expression.
2767 Evaluate a short-circuited logical expression T in the context
2768 of a given constexpr CALL. BAILOUT_VALUE is the value for
2769 early return. CONTINUE_VALUE is used here purely for
2770 sanity check purposes. */
2773 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2774 tree bailout_value
, tree continue_value
,
2776 bool *non_constant_p
, bool *overflow_p
)
2779 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2781 non_constant_p
, overflow_p
);
2782 VERIFY_CONSTANT (lhs
);
2783 if (tree_int_cst_equal (lhs
, bailout_value
))
2785 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2786 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2787 lval
, non_constant_p
,
2789 VERIFY_CONSTANT (r
);
2793 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2794 CONSTRUCTOR elements to initialize (part of) an object containing that
2795 field. Return a pointer to the constructor_elt corresponding to the
2796 initialization of the field. */
2798 static constructor_elt
*
2799 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2801 tree aggr
= TREE_OPERAND (ref
, 0);
2802 tree field
= TREE_OPERAND (ref
, 1);
2804 constructor_elt
*ce
;
2806 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2808 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2810 constructor_elt
*base_ce
2811 = base_field_constructor_elt (v
, aggr
);
2812 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2815 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2816 if (ce
->index
== field
)
2823 /* Some of the expressions fed to the constexpr mechanism are calls to
2824 constructors, which have type void. In that case, return the type being
2825 initialized by the constructor. */
2828 initialized_type (tree t
)
2832 tree type
= TREE_TYPE (t
);
2833 if (!VOID_TYPE_P (type
))
2834 /* No need to look deeper. */;
2835 else if (TREE_CODE (t
) == CALL_EXPR
)
2837 /* A constructor call has void type, so we need to look deeper. */
2838 tree fn
= get_function_named_in_call (t
);
2839 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2840 && DECL_CXX_CONSTRUCTOR_P (fn
))
2841 type
= DECL_CONTEXT (fn
);
2843 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
2844 type
= TREE_TYPE (AGGR_INIT_EXPR_SLOT (t
));
2845 return cv_unqualified (type
);
2848 /* We're about to initialize element INDEX of an array or class from VALUE.
2849 Set up NEW_CTX appropriately by adjusting .object to refer to the
2850 subobject and creating a new CONSTRUCTOR if the element is itself
2851 a class or array. */
2854 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2855 tree index
, tree
&value
)
2859 if (index
&& TREE_CODE (index
) != INTEGER_CST
2860 && TREE_CODE (index
) != FIELD_DECL
)
2861 /* This won't have an element in the new CONSTRUCTOR. */
2864 tree type
= initialized_type (value
);
2865 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2866 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2869 /* The sub-aggregate initializer might contain a placeholder;
2870 update object to refer to the subobject and ctor to refer to
2871 the (newly created) sub-initializer. */
2873 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2874 tree elt
= build_constructor (type
, NULL
);
2875 CONSTRUCTOR_NO_CLEARING (elt
) = true;
2878 if (TREE_CODE (value
) == TARGET_EXPR
)
2879 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2880 value
= TARGET_EXPR_INITIAL (value
);
2883 /* We're about to process an initializer for a class or array TYPE. Make
2884 sure that CTX is set up appropriately. */
2887 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2889 /* We don't bother building a ctor for an empty base subobject. */
2890 if (is_empty_class (type
))
2893 /* We're in the middle of an initializer that might involve placeholders;
2894 our caller should have created a CONSTRUCTOR for us to put the
2895 initializer into. We will either return that constructor or T. */
2896 gcc_assert (ctx
->ctor
);
2897 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2898 (type
, TREE_TYPE (ctx
->ctor
)));
2899 /* We used to check that ctx->ctor was empty, but that isn't the case when
2900 the object is zero-initialized before calling the constructor. */
2903 tree otype
= TREE_TYPE (ctx
->object
);
2904 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2905 /* Handle flexible array members. */
2906 || (TREE_CODE (otype
) == ARRAY_TYPE
2907 && TYPE_DOMAIN (otype
) == NULL_TREE
2908 && TREE_CODE (type
) == ARRAY_TYPE
2909 && (same_type_ignoring_top_level_qualifiers_p
2910 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2912 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2913 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2916 /* Subroutine of cxx_eval_constant_expression.
2917 The expression tree T denotes a C-style array or a C-style
2918 aggregate. Reduce it to a constant expression. */
2921 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2923 bool *non_constant_p
, bool *overflow_p
)
2925 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2926 bool changed
= false;
2927 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2928 tree type
= TREE_TYPE (t
);
2930 constexpr_ctx new_ctx
;
2931 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2933 /* We don't really need the ctx->ctor business for a PMF or
2934 vector, but it's simpler to use the same code. */
2936 new_ctx
.ctor
= build_constructor (type
, NULL
);
2937 new_ctx
.object
= NULL_TREE
;
2940 verify_ctor_sanity (ctx
, type
);
2941 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2942 vec_alloc (*p
, vec_safe_length (v
));
2946 bool constant_p
= true;
2947 bool side_effects_p
= false;
2948 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2950 tree orig_value
= value
;
2951 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2952 if (new_ctx
.ctor
!= ctx
->ctor
)
2953 /* If we built a new CONSTRUCTOR, attach it now so that other
2954 initializers can refer to it. */
2955 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2956 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2958 non_constant_p
, overflow_p
);
2959 /* Don't VERIFY_CONSTANT here. */
2960 if (ctx
->quiet
&& *non_constant_p
)
2962 if (elt
!= orig_value
)
2965 if (!TREE_CONSTANT (elt
))
2967 if (TREE_SIDE_EFFECTS (elt
))
2968 side_effects_p
= true;
2969 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2971 /* This is an initialization of a vfield inside a base
2972 subaggregate that we already initialized; push this
2973 initialization into the previous initialization. */
2974 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2979 && (TREE_CODE (index
) == NOP_EXPR
2980 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2982 /* This is an initializer for an empty base; now that we've
2983 checked that it's constant, we can ignore it. */
2984 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2989 if (new_ctx
.ctor
!= ctx
->ctor
)
2991 /* We appended this element above; update the value. */
2992 gcc_assert ((*p
)->last().index
== index
);
2993 (*p
)->last().value
= elt
;
2996 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2997 /* Adding or replacing an element might change the ctor's flags. */
2998 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
2999 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
3002 if (*non_constant_p
|| !changed
)
3005 /* We're done building this CONSTRUCTOR, so now we can interpret an
3006 element without an explicit initializer as value-initialized. */
3007 CONSTRUCTOR_NO_CLEARING (t
) = false;
3008 TREE_CONSTANT (t
) = constant_p
;
3009 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
3010 if (VECTOR_TYPE_P (type
))
3015 /* Subroutine of cxx_eval_constant_expression.
3016 The expression tree T is a VEC_INIT_EXPR which denotes the desired
3017 initialization of a non-static data member of array type. Reduce it to a
3020 Note that apart from value-initialization (when VALUE_INIT is true),
3021 this is only intended to support value-initialization and the
3022 initializations done by defaulted constructors for classes with
3023 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
3024 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
3025 for the copy/move constructor. */
3028 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
3029 bool value_init
, bool lval
,
3030 bool *non_constant_p
, bool *overflow_p
)
3032 tree elttype
= TREE_TYPE (atype
);
3033 verify_ctor_sanity (ctx
, atype
);
3034 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
3035 bool pre_init
= false;
3036 unsigned HOST_WIDE_INT i
;
3037 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
3039 /* For the default constructor, build up a call to the default
3040 constructor of the element type. We only need to handle class types
3041 here, as for a constructor to be constexpr, all members must be
3042 initialized, which for a defaulted default constructor means they must
3043 be of a class type with a constexpr default constructor. */
3044 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3045 /* We only do this at the lowest level. */;
3046 else if (value_init
)
3048 init
= build_value_init (elttype
, complain
);
3053 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
3054 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
3055 &argvec
, elttype
, LOOKUP_NORMAL
,
3057 release_tree_vector (argvec
);
3058 init
= build_aggr_init_expr (elttype
, init
);
3062 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
3064 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
3065 for (i
= 0; i
< max
; ++i
)
3067 tree idx
= build_int_cst (size_type_node
, i
);
3070 constexpr_ctx new_ctx
;
3071 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
3072 if (new_ctx
.ctor
!= ctx
->ctor
)
3073 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
3074 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3076 /* A multidimensional array; recurse. */
3077 if (value_init
|| init
== NULL_TREE
)
3079 eltinit
= NULL_TREE
;
3083 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3084 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
3086 non_constant_p
, overflow_p
);
3090 /* Initializing an element using value or default initialization
3091 we just pre-built above. */
3092 if (init
== void_node
)
3093 /* Trivial default-init, don't do anything to the CONSTRUCTOR. */
3095 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
3096 non_constant_p
, overflow_p
);
3101 /* Copying an element. */
3102 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3103 (atype
, TREE_TYPE (init
)));
3104 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3105 if (!lvalue_p (init
))
3106 eltinit
= move (eltinit
);
3107 eltinit
= force_rvalue (eltinit
, complain
);
3108 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
3109 non_constant_p
, overflow_p
);
3111 if (*non_constant_p
&& !ctx
->quiet
)
3113 if (new_ctx
.ctor
!= ctx
->ctor
)
3115 /* We appended this element above; update the value. */
3116 gcc_assert ((*p
)->last().index
== idx
);
3117 (*p
)->last().value
= eltinit
;
3120 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3121 /* Reuse the result of cxx_eval_constant_expression call
3122 from the first iteration to all others if it is a constant
3123 initializer that doesn't require relocations. */
3126 && (eltinit
== NULL_TREE
3127 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3128 == null_pointer_node
)))
3130 if (new_ctx
.ctor
!= ctx
->ctor
)
3131 eltinit
= new_ctx
.ctor
;
3132 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3133 build_int_cst (size_type_node
, 1),
3134 build_int_cst (size_type_node
, max
- 1));
3135 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3139 vec_safe_reserve (*p
, max
);
3142 if (!*non_constant_p
)
3145 CONSTRUCTOR_NO_CLEARING (init
) = false;
3151 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3153 bool *non_constant_p
, bool *overflow_p
)
3155 tree atype
= TREE_TYPE (t
);
3156 tree init
= VEC_INIT_EXPR_INIT (t
);
3157 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3158 VEC_INIT_EXPR_VALUE_INIT (t
),
3159 lval
, non_constant_p
, overflow_p
);
3160 if (*non_constant_p
)
3166 /* Like same_type_ignoring_top_level_qualifiers_p, but also handle the case
3167 where the desired type is an array of unknown bounds because the variable
3168 has had its bounds deduced since the wrapping expression was created. */
3171 same_type_ignoring_tlq_and_bounds_p (tree type1
, tree type2
)
3173 while (TREE_CODE (type1
) == ARRAY_TYPE
3174 && TREE_CODE (type2
) == ARRAY_TYPE
3175 && (!TYPE_DOMAIN (type1
) || !TYPE_DOMAIN (type2
)))
3177 type1
= TREE_TYPE (type1
);
3178 type2
= TREE_TYPE (type2
);
3180 return same_type_ignoring_top_level_qualifiers_p (type1
, type2
);
3183 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3184 match. We want to be less strict for simple *& folding; if we have a
3185 non-const temporary that we access through a const pointer, that should
3186 work. We handle this here rather than change fold_indirect_ref_1
3187 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3188 don't really make sense outside of constant expression evaluation. Also
3189 we want to allow folding to COMPONENT_REF, which could cause trouble
3190 with TBAA in fold_indirect_ref_1.
3192 Try to keep this function synced with fold_indirect_ref_1. */
3195 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3199 poly_uint64 const_op01
;
3202 subtype
= TREE_TYPE (sub
);
3203 if (!INDIRECT_TYPE_P (subtype
))
3206 if (TREE_CODE (sub
) == ADDR_EXPR
)
3208 tree op
= TREE_OPERAND (sub
, 0);
3209 tree optype
= TREE_TYPE (op
);
3211 /* *&CONST_DECL -> to the value of the const decl. */
3212 if (TREE_CODE (op
) == CONST_DECL
)
3213 return DECL_INITIAL (op
);
3214 /* *&p => p; make sure to handle *&"str"[cst] here. */
3215 if (same_type_ignoring_tlq_and_bounds_p (optype
, type
))
3217 tree fop
= fold_read_from_constant_string (op
);
3223 /* *(foo *)&fooarray => fooarray[0] */
3224 else if (TREE_CODE (optype
) == ARRAY_TYPE
3225 && (same_type_ignoring_top_level_qualifiers_p
3226 (type
, TREE_TYPE (optype
))))
3228 tree type_domain
= TYPE_DOMAIN (optype
);
3229 tree min_val
= size_zero_node
;
3230 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3231 min_val
= TYPE_MIN_VALUE (type_domain
);
3232 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3233 NULL_TREE
, NULL_TREE
);
3235 /* *(foo *)&complexfoo => __real__ complexfoo */
3236 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3237 && (same_type_ignoring_top_level_qualifiers_p
3238 (type
, TREE_TYPE (optype
))))
3239 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3240 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3241 else if (VECTOR_TYPE_P (optype
)
3242 && (same_type_ignoring_top_level_qualifiers_p
3243 (type
, TREE_TYPE (optype
))))
3245 tree part_width
= TYPE_SIZE (type
);
3246 tree index
= bitsize_int (0);
3247 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3250 /* Also handle conversion to an empty base class, which
3251 is represented with a NOP_EXPR. */
3252 else if (is_empty_class (type
)
3253 && CLASS_TYPE_P (optype
)
3254 && DERIVED_FROM_P (type
, optype
))
3259 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3260 else if (RECORD_OR_UNION_TYPE_P (optype
))
3262 tree field
= TYPE_FIELDS (optype
);
3263 for (; field
; field
= DECL_CHAIN (field
))
3264 if (TREE_CODE (field
) == FIELD_DECL
3265 && TREE_TYPE (field
) != error_mark_node
3266 && integer_zerop (byte_position (field
))
3267 && (same_type_ignoring_top_level_qualifiers_p
3268 (TREE_TYPE (field
), type
)))
3269 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3272 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3273 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3275 tree op00
= TREE_OPERAND (sub
, 0);
3276 tree op01
= TREE_OPERAND (sub
, 1);
3279 if (TREE_CODE (op00
) == ADDR_EXPR
)
3282 op00
= TREE_OPERAND (op00
, 0);
3283 op00type
= TREE_TYPE (op00
);
3285 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3286 if (VECTOR_TYPE_P (op00type
)
3287 && same_type_ignoring_top_level_qualifiers_p
3288 (type
, TREE_TYPE (op00type
))
3289 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3290 but we want to treat offsets with MSB set as negative.
3291 For the code below negative offsets are invalid and
3292 TYPE_SIZE of the element is something unsigned, so
3293 check whether op01 fits into poly_int64, which implies
3294 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3295 then just use poly_uint64 because we want to treat the
3296 value as unsigned. */
3297 && tree_fits_poly_int64_p (op01
))
3299 tree part_width
= TYPE_SIZE (type
);
3300 poly_uint64 max_offset
3301 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3302 * TYPE_VECTOR_SUBPARTS (op00type
));
3303 if (known_lt (const_op01
, max_offset
))
3305 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3306 return fold_build3_loc (loc
,
3307 BIT_FIELD_REF
, type
, op00
,
3311 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3312 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3313 && (same_type_ignoring_top_level_qualifiers_p
3314 (type
, TREE_TYPE (op00type
))))
3316 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3318 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3320 /* ((foo *)&fooarray)[1] => fooarray[1] */
3321 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3322 && (same_type_ignoring_top_level_qualifiers_p
3323 (type
, TREE_TYPE (op00type
))))
3325 tree type_domain
= TYPE_DOMAIN (op00type
);
3326 tree min_val
= size_zero_node
;
3327 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3328 min_val
= TYPE_MIN_VALUE (type_domain
);
3329 offset_int off
= wi::to_offset (op01
);
3330 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3331 offset_int remainder
;
3332 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3333 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3335 off
= off
+ wi::to_offset (min_val
);
3336 op01
= wide_int_to_tree (sizetype
, off
);
3337 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3338 NULL_TREE
, NULL_TREE
);
3341 /* Also handle conversion to an empty base class, which
3342 is represented with a NOP_EXPR. */
3343 else if (is_empty_class (type
)
3344 && CLASS_TYPE_P (op00type
)
3345 && DERIVED_FROM_P (type
, op00type
))
3350 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3351 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3353 tree field
= TYPE_FIELDS (op00type
);
3354 for (; field
; field
= DECL_CHAIN (field
))
3355 if (TREE_CODE (field
) == FIELD_DECL
3356 && TREE_TYPE (field
) != error_mark_node
3357 && tree_int_cst_equal (byte_position (field
), op01
)
3358 && (same_type_ignoring_top_level_qualifiers_p
3359 (TREE_TYPE (field
), type
)))
3360 return fold_build3 (COMPONENT_REF
, type
, op00
,
3365 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3366 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3367 && (same_type_ignoring_top_level_qualifiers_p
3368 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3371 tree min_val
= size_zero_node
;
3373 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3377 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3378 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3379 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3380 min_val
= TYPE_MIN_VALUE (type_domain
);
3381 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3389 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3391 bool *non_constant_p
, bool *overflow_p
)
3393 tree orig_op0
= TREE_OPERAND (t
, 0);
3394 bool empty_base
= false;
3396 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3397 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3399 if (TREE_CODE (t
) == MEM_REF
3400 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3402 gcc_assert (ctx
->quiet
);
3403 *non_constant_p
= true;
3407 /* First try to simplify it directly. */
3408 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3412 /* If that didn't work, evaluate the operand first. */
3413 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3414 /*lval*/false, non_constant_p
,
3416 /* Don't VERIFY_CONSTANT here. */
3417 if (*non_constant_p
)
3420 if (!lval
&& integer_zerop (op0
))
3423 error ("dereferencing a null pointer");
3424 *non_constant_p
= true;
3428 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3432 /* We couldn't fold to a constant value. Make sure it's not
3433 something we should have been able to fold. */
3436 if (TREE_CODE (sub
) == ADDR_EXPR
)
3438 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3439 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3440 /* DR 1188 says we don't have to deal with this. */
3442 error ("accessing value of %qE through a %qT glvalue in a "
3443 "constant expression", build_fold_indirect_ref (sub
),
3445 *non_constant_p
= true;
3449 if (lval
&& op0
!= orig_op0
)
3450 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3452 VERIFY_CONSTANT (t
);
3457 r
= cxx_eval_constant_expression (ctx
, r
,
3458 lval
, non_constant_p
, overflow_p
);
3459 if (*non_constant_p
)
3462 /* If we're pulling out the value of an empty base, just return an empty
3464 if (empty_base
&& !lval
)
3466 r
= build_constructor (TREE_TYPE (t
), NULL
);
3467 TREE_CONSTANT (r
) = true;
3473 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3474 Shared between potential_constant_expression and
3475 cxx_eval_constant_expression. */
3478 non_const_var_error (tree r
)
3480 tree type
= TREE_TYPE (r
);
3481 error ("the value of %qD is not usable in a constant "
3483 /* Avoid error cascade. */
3484 if (DECL_INITIAL (r
) == error_mark_node
)
3486 if (DECL_DECLARED_CONSTEXPR_P (r
))
3487 inform (DECL_SOURCE_LOCATION (r
),
3488 "%qD used in its own initializer", r
);
3489 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3491 if (!CP_TYPE_CONST_P (type
))
3492 inform (DECL_SOURCE_LOCATION (r
),
3493 "%q#D is not const", r
);
3494 else if (CP_TYPE_VOLATILE_P (type
))
3495 inform (DECL_SOURCE_LOCATION (r
),
3496 "%q#D is volatile", r
);
3497 else if (!DECL_INITIAL (r
)
3498 || !TREE_CONSTANT (DECL_INITIAL (r
))
3499 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3500 inform (DECL_SOURCE_LOCATION (r
),
3501 "%qD was not initialized with a constant "
3506 else if (TYPE_REF_P (type
))
3507 inform (DECL_SOURCE_LOCATION (r
),
3508 "%qD was not initialized with a constant "
3512 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3513 inform (DECL_SOURCE_LOCATION (r
),
3514 "%qD was not declared %<constexpr%>", r
);
3516 inform (DECL_SOURCE_LOCATION (r
),
3517 "%qD does not have integral or enumeration type",
3522 /* Subroutine of cxx_eval_constant_expression.
3523 Like cxx_eval_unary_expression, except for trinary expressions. */
3526 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3528 bool *non_constant_p
, bool *overflow_p
)
3534 for (i
= 0; i
< 3; i
++)
3536 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3538 non_constant_p
, overflow_p
);
3539 VERIFY_CONSTANT (args
[i
]);
3542 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3543 args
[0], args
[1], args
[2]);
3544 if (val
== NULL_TREE
)
3546 VERIFY_CONSTANT (val
);
3550 /* True if T was declared in a function declared to be constexpr, and
3551 therefore potentially constant in C++14. */
3554 var_in_constexpr_fn (tree t
)
3556 tree ctx
= DECL_CONTEXT (t
);
3557 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3558 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3561 /* True if T was declared in a function that might be constexpr: either a
3562 function that was declared constexpr, or a C++17 lambda op(). */
3565 var_in_maybe_constexpr_fn (tree t
)
3567 if (cxx_dialect
>= cxx17
3568 && DECL_FUNCTION_SCOPE_P (t
)
3569 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3571 return var_in_constexpr_fn (t
);
3574 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3575 build_over_call we implement trivial copy of a class with tail padding using
3576 assignment of character arrays, which is valid in normal code, but not in
3577 constexpr evaluation. We don't need to worry about clobbering tail padding
3578 in constexpr evaluation, so strip the type punning. */
3581 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3583 if (TREE_CODE (target
) == MEM_REF
3584 && TREE_CODE (init
) == MEM_REF
3585 && TREE_TYPE (target
) == TREE_TYPE (init
)
3586 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3587 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3589 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3590 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3594 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3597 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3599 bool *non_constant_p
, bool *overflow_p
)
3601 constexpr_ctx new_ctx
= *ctx
;
3603 tree init
= TREE_OPERAND (t
, 1);
3604 if (TREE_CLOBBER_P (init
))
3605 /* Just ignore clobbers. */
3608 /* First we figure out where we're storing to. */
3609 tree target
= TREE_OPERAND (t
, 0);
3611 maybe_simplify_trivial_copy (target
, init
);
3613 tree type
= TREE_TYPE (target
);
3614 target
= cxx_eval_constant_expression (ctx
, target
,
3616 non_constant_p
, overflow_p
);
3617 if (*non_constant_p
)
3620 /* cxx_eval_array_reference for lval = true allows references one past
3621 end of array, because it does not know if it is just taking address
3622 (which is valid), or actual dereference. Here we know it is
3623 a dereference, so diagnose it here. */
3624 for (tree probe
= target
; probe
; )
3626 switch (TREE_CODE (probe
))
3630 ary
= TREE_OPERAND (probe
, 0);
3631 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3632 non_constant_p
, overflow_p
);
3633 VERIFY_CONSTANT (nelts
);
3634 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3635 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3636 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3638 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3639 *non_constant_p
= true;
3646 probe
= TREE_OPERAND (probe
, 0);
3655 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3657 /* For initialization of an empty base, the original target will be
3658 *(base*)this, which the above evaluation resolves to the object
3659 argument, which has the derived type rather than the base type. In
3660 this situation, just evaluate the initializer and return, since
3661 there's no actual data to store. */
3662 gcc_assert (is_empty_class (type
));
3663 return cxx_eval_constant_expression (ctx
, init
, false,
3664 non_constant_p
, overflow_p
);
3667 /* And then find the underlying variable. */
3668 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3669 tree object
= NULL_TREE
;
3670 for (tree probe
= target
; object
== NULL_TREE
; )
3672 switch (TREE_CODE (probe
))
3677 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3678 vec_safe_push (refs
, TREE_TYPE (probe
));
3679 probe
= TREE_OPERAND (probe
, 0);
3687 /* And then find/build up our initializer for the path to the subobject
3688 we're initializing. */
3690 if (object
== ctx
->object
&& VAR_P (object
)
3691 && DECL_NAME (object
) && ctx
->call
== NULL
)
3692 /* The variable we're building up an aggregate initializer for is outside
3693 the constant-expression, so don't evaluate the store. We check
3694 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3696 else if (DECL_P (object
))
3697 valp
= ctx
->values
->get (object
);
3702 /* A constant-expression cannot modify objects from outside the
3703 constant-expression. */
3705 error ("modification of %qE is not a constant expression", object
);
3706 *non_constant_p
= true;
3709 type
= TREE_TYPE (object
);
3710 bool no_zero_init
= true;
3712 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3713 while (!refs
->is_empty())
3715 if (*valp
== NULL_TREE
)
3717 *valp
= build_constructor (type
, NULL
);
3718 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3720 else if (TREE_CODE (*valp
) == STRING_CST
)
3722 /* An array was initialized with a string constant, and now
3723 we're writing into one of its elements. Explode the
3724 single initialization into a set of element
3726 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3728 tree string
= *valp
;
3729 tree elt_type
= TREE_TYPE (type
);
3730 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3731 / TYPE_PRECISION (char_type_node
));
3732 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3733 tree ary_ctor
= build_constructor (type
, NULL
);
3735 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3736 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3738 constructor_elt elt
=
3740 build_int_cst (size_type_node
, ix
),
3741 extract_string_elt (string
, chars_per_elt
, ix
)
3743 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3749 /* If the value of object is already zero-initialized, any new ctors for
3750 subobjects will also be zero-initialized. */
3751 no_zero_init
= CONSTRUCTOR_NO_CLEARING (*valp
);
3753 vec_safe_push (ctors
, *valp
);
3755 enum tree_code code
= TREE_CODE (type
);
3757 tree index
= refs
->pop();
3759 constructor_elt
*cep
= NULL
;
3760 if (code
== ARRAY_TYPE
)
3763 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3764 gcc_assert (i
>= 0);
3765 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3766 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3770 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3772 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3773 Usually we meet initializers in that order, but it is
3774 possible for base types to be placed not in program
3776 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3777 unsigned HOST_WIDE_INT idx
;
3779 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3780 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3781 /* Changing active member. */
3782 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3785 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3786 idx
++, fields
= DECL_CHAIN (fields
))
3788 if (index
== cep
->index
)
3791 /* The field we're initializing must be on the field
3792 list. Look to see if it is present before the
3793 field the current ELT initializes. */
3794 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3795 if (index
== fields
)
3799 /* We fell off the end of the CONSTRUCTOR, so insert a new
3800 entry at the end. */
3803 constructor_elt ce
= { index
, NULL_TREE
};
3805 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3806 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3812 release_tree_vector (refs
);
3814 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3816 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3817 wants to modify it. */
3818 if (*valp
== NULL_TREE
)
3820 *valp
= build_constructor (type
, NULL
);
3821 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3823 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3824 *valp
= cplus_expand_constant (*valp
);
3825 new_ctx
.ctor
= *valp
;
3826 new_ctx
.object
= target
;
3829 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3830 non_constant_p
, overflow_p
);
3831 /* Don't share a CONSTRUCTOR that might be changed later. */
3832 init
= unshare_constructor (init
);
3833 if (target
== object
)
3834 /* The hash table might have moved since the get earlier. */
3835 valp
= ctx
->values
->get (object
);
3837 if (TREE_CODE (init
) == CONSTRUCTOR
)
3839 /* An outer ctx->ctor might be pointing to *valp, so replace
3841 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3842 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3843 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3844 CONSTRUCTOR_NO_CLEARING (*valp
)
3845 = CONSTRUCTOR_NO_CLEARING (init
);
3850 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3851 CONSTRUCTORs, if any. */
3854 bool c
= TREE_CONSTANT (init
);
3855 bool s
= TREE_SIDE_EFFECTS (init
);
3857 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3860 TREE_CONSTANT (elt
) = false;
3862 TREE_SIDE_EFFECTS (elt
) = true;
3864 release_tree_vector (ctors
);
3866 if (*non_constant_p
)
3874 /* Evaluate a ++ or -- expression. */
3877 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3879 bool *non_constant_p
, bool *overflow_p
)
3881 enum tree_code code
= TREE_CODE (t
);
3882 tree type
= TREE_TYPE (t
);
3883 tree op
= TREE_OPERAND (t
, 0);
3884 tree offset
= TREE_OPERAND (t
, 1);
3885 gcc_assert (TREE_CONSTANT (offset
));
3887 /* The operand as an lvalue. */
3888 op
= cxx_eval_constant_expression (ctx
, op
, true,
3889 non_constant_p
, overflow_p
);
3891 /* The operand as an rvalue. */
3893 = cxx_eval_constant_expression (ctx
, op
, false,
3894 non_constant_p
, overflow_p
);
3895 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3896 a local array in a constexpr function. */
3897 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (val
));
3899 VERIFY_CONSTANT (val
);
3901 /* The modified value. */
3902 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3904 if (INDIRECT_TYPE_P (type
))
3906 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3907 offset
= convert_to_ptrofftype (offset
);
3909 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3910 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3913 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3915 VERIFY_CONSTANT (mod
);
3917 /* Storing the modified value. */
3918 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3919 cxx_eval_constant_expression (ctx
, store
,
3920 true, non_constant_p
, overflow_p
);
3922 /* And the value of the expression. */
3923 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3925 /* Prefix ops are lvalues. */
3929 /* But we optimize when the caller wants an rvalue. */
3933 /* Postfix ops are rvalues. */
3937 /* Predicates for the meaning of *jump_target. */
3940 returns (tree
*jump_target
)
3943 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3944 || (TREE_CODE (*jump_target
) == LABEL_DECL
3945 && LABEL_DECL_CDTOR (*jump_target
)));
3949 breaks (tree
*jump_target
)
3952 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3953 && LABEL_DECL_BREAK (*jump_target
))
3954 || TREE_CODE (*jump_target
) == BREAK_STMT
3955 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3959 continues (tree
*jump_target
)
3962 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3963 && LABEL_DECL_CONTINUE (*jump_target
))
3964 || TREE_CODE (*jump_target
) == CONTINUE_STMT
);
3969 switches (tree
*jump_target
)
3972 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3975 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3976 STMT matches *jump_target. If we're looking for a case label and we see
3977 the default label, note it in ctx->css_state. */
3980 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3982 switch (TREE_CODE (*jump_target
))
3985 if (TREE_CODE (stmt
) == LABEL_EXPR
3986 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3991 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3993 gcc_assert (ctx
->css_state
!= NULL
);
3994 if (!CASE_LOW (stmt
))
3996 /* default: should appear just once in a SWITCH_EXPR
3997 body (excluding nested SWITCH_EXPR). */
3998 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3999 /* When evaluating SWITCH_EXPR body for the second time,
4000 return true for the default: label. */
4001 if (*ctx
->css_state
== css_default_processing
)
4003 *ctx
->css_state
= css_default_seen
;
4005 else if (CASE_HIGH (stmt
))
4007 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
4008 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
4011 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
4022 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
4023 semantics, for switch, break, continue, and return. */
4026 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
4027 bool *non_constant_p
, bool *overflow_p
,
4030 tree_stmt_iterator i
;
4032 /* In a statement-expression we want to return the last value.
4033 For empty statement expression return void_node. */
4037 local_target
= NULL_TREE
;
4038 jump_target
= &local_target
;
4040 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4042 tree stmt
= tsi_stmt (i
);
4043 /* We've found a continue, so skip everything until we reach
4044 the label its jumping to. */
4045 if (continues (jump_target
))
4047 if (label_matches (ctx
, jump_target
, stmt
))
4049 *jump_target
= NULL_TREE
;
4053 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
4055 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
4056 non_constant_p
, overflow_p
,
4058 if (*non_constant_p
)
4060 if (returns (jump_target
) || breaks (jump_target
))
4066 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
4067 semantics; continue semantics are covered by cxx_eval_statement_list. */
4070 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
4071 bool *non_constant_p
, bool *overflow_p
,
4074 constexpr_ctx new_ctx
= *ctx
;
4076 tree body
= TREE_OPERAND (t
, 0);
4080 hash_set
<tree
> save_exprs
;
4081 new_ctx
.save_exprs
= &save_exprs
;
4083 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
4084 non_constant_p
, overflow_p
, jump_target
);
4086 /* Forget saved values of SAVE_EXPRs. */
4087 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
4088 iter
!= save_exprs
.end(); ++iter
)
4089 new_ctx
.values
->remove (*iter
);
4090 if (++count
>= constexpr_loop_limit
)
4093 error_at (cp_expr_loc_or_loc (t
, input_location
),
4094 "%<constexpr%> loop iteration count exceeds limit of %d "
4095 "(use -fconstexpr-loop-limit= to increase the limit)",
4096 constexpr_loop_limit
);
4097 *non_constant_p
= true;
4101 while (!returns (jump_target
)
4102 && !breaks (jump_target
)
4103 && !switches (jump_target
)
4104 && !*non_constant_p
);
4106 if (breaks (jump_target
))
4107 *jump_target
= NULL_TREE
;
4112 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
4116 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
4117 bool *non_constant_p
, bool *overflow_p
,
4120 tree cond
= TREE_OPERAND (t
, 0);
4121 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
4122 non_constant_p
, overflow_p
);
4123 VERIFY_CONSTANT (cond
);
4124 *jump_target
= cond
;
4126 tree body
= TREE_OPERAND (t
, 1);
4127 constexpr_ctx new_ctx
= *ctx
;
4128 constexpr_switch_state css
= css_default_not_seen
;
4129 new_ctx
.css_state
= &css
;
4130 cxx_eval_constant_expression (&new_ctx
, body
, false,
4131 non_constant_p
, overflow_p
, jump_target
);
4132 if (switches (jump_target
) && css
== css_default_seen
)
4134 /* If the SWITCH_EXPR body has default: label, process it once again,
4135 this time instructing label_matches to return true for default:
4136 label on switches (jump_target). */
4137 css
= css_default_processing
;
4138 cxx_eval_constant_expression (&new_ctx
, body
, false,
4139 non_constant_p
, overflow_p
, jump_target
);
4141 if (breaks (jump_target
) || switches (jump_target
))
4142 *jump_target
= NULL_TREE
;
4146 /* Find the object of TYPE under initialization in CTX. */
4149 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4154 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4155 can is a minor optimization. */
4156 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4162 /* Since an object cannot have a field of its own type, we can search outward
4163 from ctx->object to find the unique containing object of TYPE. */
4164 tree ob
= ctx
->object
;
4167 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4169 if (handled_component_p (ob
))
4170 ob
= TREE_OPERAND (ob
, 0);
4178 /* Attempt to reduce the expression T to a constant value.
4179 On failure, issue diagnostic and return error_mark_node. */
4180 /* FIXME unify with c_fully_fold */
4181 /* FIXME overflow_p is too global */
4184 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4186 bool *non_constant_p
, bool *overflow_p
,
4187 tree
*jump_target
/* = NULL */)
4189 constexpr_ctx new_ctx
;
4192 if (jump_target
&& *jump_target
)
4194 /* If we are jumping, ignore all statements/expressions except those
4195 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4196 switch (TREE_CODE (t
))
4199 case STATEMENT_LIST
:
4204 case CASE_LABEL_EXPR
:
4205 if (label_matches (ctx
, jump_target
, t
))
4207 *jump_target
= NULL_TREE
;
4213 if (error_operand_p (t
))
4215 *non_constant_p
= true;
4218 if (CONSTANT_CLASS_P (t
))
4220 if (TREE_OVERFLOW (t
))
4223 permerror (input_location
, "overflow in constant expression");
4224 if (!flag_permissive
|| ctx
->quiet
)
4228 if (TREE_CODE (t
) == INTEGER_CST
4229 && TYPE_PTR_P (TREE_TYPE (t
))
4230 && !integer_zerop (t
))
4233 error ("value %qE of type %qT is not a constant expression",
4235 *non_constant_p
= true;
4241 tree_code tcode
= TREE_CODE (t
);
4247 /* We ask for an rvalue for the RESULT_DECL when indirecting
4248 through an invisible reference, or in named return value
4250 if (tree
*p
= ctx
->values
->get (t
))
4255 error ("%qE is not a constant expression", t
);
4256 *non_constant_p
= true;
4261 if (DECL_HAS_VALUE_EXPR_P (t
))
4262 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4263 lval
, non_constant_p
, overflow_p
);
4266 /* We used to not check lval for CONST_DECL, but darwin.c uses
4267 CONST_DECL for aggregate constants. */
4270 /* is_really_empty_class doesn't take into account _vptr, so initializing
4271 otherwise empty class with { } would overwrite the initializer that
4272 initialize_vtable created for us. */
4273 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4274 && !TYPE_POLYMORPHIC_P (TREE_TYPE (t
))
4275 && is_really_empty_class (TREE_TYPE (t
)))
4277 /* If the class is empty, we aren't actually loading anything. */
4278 r
= build_constructor (TREE_TYPE (t
), NULL
);
4279 TREE_CONSTANT (r
) = true;
4281 else if (ctx
->strict
)
4282 r
= decl_really_constant_value (t
);
4284 r
= decl_constant_value (t
);
4285 if (TREE_CODE (r
) == TARGET_EXPR
4286 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4287 r
= TARGET_EXPR_INITIAL (r
);
4289 if (tree
*p
= ctx
->values
->get (r
))
4290 if (*p
!= NULL_TREE
)
4295 non_const_var_error (r
);
4296 *non_constant_p
= true;
4300 case DEBUG_BEGIN_STMT
:
4301 /* ??? It might be nice to retain this information somehow, so
4302 as to be able to step into a constexpr function call. */
4309 case CASE_LABEL_EXPR
:
4314 if (lval
&& !TYPE_REF_P (TREE_TYPE (t
)))
4316 else if (tree
*p
= ctx
->values
->get (r
))
4319 /* Defer in case this is only used for its type. */;
4320 else if (TYPE_REF_P (TREE_TYPE (t
)))
4321 /* Defer, there's no lvalue->rvalue conversion. */;
4322 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4323 && is_really_empty_class (TREE_TYPE (t
)))
4325 /* If the class is empty, we aren't actually loading anything. */
4326 r
= build_constructor (TREE_TYPE (t
), NULL
);
4327 TREE_CONSTANT (r
) = true;
4332 error ("%qE is not a constant expression", t
);
4333 *non_constant_p
= true;
4338 case AGGR_INIT_EXPR
:
4339 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4340 non_constant_p
, overflow_p
);
4345 r
= DECL_EXPR_DECL (t
);
4346 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4347 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4351 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4352 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4353 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4357 if (tree init
= DECL_INITIAL (r
))
4359 init
= cxx_eval_constant_expression (ctx
, init
,
4361 non_constant_p
, overflow_p
);
4362 /* Don't share a CONSTRUCTOR that might be changed. */
4363 init
= unshare_constructor (init
);
4364 ctx
->values
->put (r
, init
);
4366 else if (ctx
== &new_ctx
)
4367 /* We gave it a CONSTRUCTOR above. */;
4369 ctx
->values
->put (r
, NULL_TREE
);
4374 if (!literal_type_p (TREE_TYPE (t
)))
4378 auto_diagnostic_group d
;
4379 error ("temporary of non-literal type %qT in a "
4380 "constant expression", TREE_TYPE (t
));
4381 explain_non_literal_class (TREE_TYPE (t
));
4383 *non_constant_p
= true;
4386 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4388 /* We're being expanded without an explicit target, so start
4389 initializing a new object; expansion with an explicit target
4390 strips the TARGET_EXPR before we get here. */
4392 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4393 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4394 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4395 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4398 /* Pass false for 'lval' because this indicates
4399 initialization of a temporary. */
4400 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4402 non_constant_p
, overflow_p
);
4403 if (!*non_constant_p
)
4404 /* Adjust the type of the result to the type of the temporary. */
4405 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4408 tree slot
= TARGET_EXPR_SLOT (t
);
4409 r
= unshare_constructor (r
);
4410 ctx
->values
->put (slot
, r
);
4417 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4418 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4419 non_constant_p
, overflow_p
);
4423 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4425 non_constant_p
, overflow_p
);
4429 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4430 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4432 non_constant_p
, overflow_p
);
4437 /* Can happen with ({ return true; }) && false; passed to
4438 maybe_constant_value. There is nothing to jump over in this
4439 case, and the bug will be diagnosed later. */
4440 gcc_assert (ctx
->quiet
);
4441 *non_constant_p
= true;
4446 /* Avoid evaluating a SAVE_EXPR more than once. */
4447 if (tree
*p
= ctx
->values
->get (t
))
4451 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4452 non_constant_p
, overflow_p
);
4453 ctx
->values
->put (t
, r
);
4454 if (ctx
->save_exprs
)
4455 ctx
->save_exprs
->add (t
);
4459 case NON_LVALUE_EXPR
:
4460 case TRY_CATCH_EXPR
:
4462 case CLEANUP_POINT_EXPR
:
4463 case MUST_NOT_THROW_EXPR
:
4466 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4468 non_constant_p
, overflow_p
,
4472 case TRY_FINALLY_EXPR
:
4473 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4474 non_constant_p
, overflow_p
,
4476 if (!*non_constant_p
)
4477 /* Also evaluate the cleanup. */
4478 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4479 non_constant_p
, overflow_p
,
4483 /* These differ from cxx_eval_unary_expression in that this doesn't
4484 check for a constant operand or result; an address can be
4485 constant without its operand being, and vice versa. */
4488 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4489 non_constant_p
, overflow_p
);
4494 tree oldop
= TREE_OPERAND (t
, 0);
4495 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4497 non_constant_p
, overflow_p
);
4498 /* Don't VERIFY_CONSTANT here. */
4499 if (*non_constant_p
)
4501 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4502 /* This function does more aggressive folding than fold itself. */
4503 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4504 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4513 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4514 non_constant_p
, overflow_p
);
4515 if (r
== error_mark_node
)
4517 else if (r
== TREE_OPERAND (t
, 0))
4520 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4525 case FIX_TRUNC_EXPR
:
4531 case TRUTH_NOT_EXPR
:
4532 case FIXED_CONVERT_EXPR
:
4533 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4534 non_constant_p
, overflow_p
);
4538 r
= fold_sizeof_expr (t
);
4539 VERIFY_CONSTANT (r
);
4544 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4545 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4546 introduced by build_call_a. */
4547 tree op0
= TREE_OPERAND (t
, 0);
4548 tree op1
= TREE_OPERAND (t
, 1);
4550 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4551 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4552 r
= cxx_eval_constant_expression (ctx
, op0
,
4553 lval
, non_constant_p
, overflow_p
,
4557 /* Check that the LHS is constant and then discard it. */
4558 cxx_eval_constant_expression (ctx
, op0
,
4559 true, non_constant_p
, overflow_p
,
4561 if (*non_constant_p
)
4563 op1
= TREE_OPERAND (t
, 1);
4564 r
= cxx_eval_constant_expression (ctx
, op1
,
4565 lval
, non_constant_p
, overflow_p
,
4571 case POINTER_PLUS_EXPR
:
4572 case POINTER_DIFF_EXPR
:
4576 case TRUNC_DIV_EXPR
:
4578 case FLOOR_DIV_EXPR
:
4579 case ROUND_DIV_EXPR
:
4580 case TRUNC_MOD_EXPR
:
4582 case ROUND_MOD_EXPR
:
4584 case EXACT_DIV_EXPR
:
4594 case TRUTH_XOR_EXPR
:
4601 case UNORDERED_EXPR
:
4611 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4612 non_constant_p
, overflow_p
);
4615 /* fold can introduce non-IF versions of these; still treat them as
4616 short-circuiting. */
4617 case TRUTH_AND_EXPR
:
4618 case TRUTH_ANDIF_EXPR
:
4619 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4622 non_constant_p
, overflow_p
);
4626 case TRUTH_ORIF_EXPR
:
4627 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4630 non_constant_p
, overflow_p
);
4634 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4635 non_constant_p
, overflow_p
);
4639 if (is_overloaded_fn (t
))
4641 /* We can only get here in checking mode via
4642 build_non_dependent_expr, because any expression that
4643 calls or takes the address of the function will have
4644 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4645 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4646 *non_constant_p
= true;
4649 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4650 non_constant_p
, overflow_p
);
4654 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4655 non_constant_p
, overflow_p
);
4659 if (jump_target
&& *jump_target
)
4661 /* When jumping to a label, the label might be either in the
4662 then or else blocks, so process then block first in skipping
4663 mode first, and if we are still in the skipping mode at its end,
4664 process the else block too. */
4665 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4666 lval
, non_constant_p
, overflow_p
,
4669 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4670 lval
, non_constant_p
, overflow_p
,
4674 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4675 non_constant_p
, overflow_p
,
4679 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4684 if (TREE_CONSTANT (t
) && reduced_constant_expression_p (t
))
4686 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4687 VECTOR_CST if applicable. */
4688 verify_constructor_flags (t
);
4689 if (TREE_CONSTANT (t
))
4692 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4693 non_constant_p
, overflow_p
);
4697 /* We can get this in a defaulted constructor for a class with a
4698 non-static data member of array type. Either the initializer will
4699 be NULL, meaning default-initialization, or it will be an lvalue
4700 or xvalue of the same type, meaning direct-initialization from the
4701 corresponding member. */
4702 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4703 non_constant_p
, overflow_p
);
4707 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4708 non_constant_p
, overflow_p
);
4712 if (REINTERPRET_CAST_P (t
))
4715 error_at (cp_expr_loc_or_loc (t
, input_location
),
4716 "a reinterpret_cast is not a constant expression");
4717 *non_constant_p
= true;
4722 case VIEW_CONVERT_EXPR
:
4723 case UNARY_PLUS_EXPR
:
4725 tree oldop
= TREE_OPERAND (t
, 0);
4727 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4729 non_constant_p
, overflow_p
);
4730 if (*non_constant_p
)
4732 tree type
= TREE_TYPE (t
);
4733 if (TREE_CODE (op
) == PTRMEM_CST
4734 && !TYPE_PTRMEM_P (type
))
4735 op
= cplus_expand_constant (op
);
4737 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4739 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (op
))
4740 && !can_convert_qual (type
, op
))
4741 op
= cplus_expand_constant (op
);
4742 return cp_fold_convert (type
, op
);
4745 if (INDIRECT_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4747 if (integer_zerop (op
))
4749 if (TYPE_REF_P (type
))
4752 error_at (cp_expr_loc_or_loc (t
, input_location
),
4753 "dereferencing a null pointer");
4754 *non_constant_p
= true;
4757 else if (TYPE_PTR_P (TREE_TYPE (op
)))
4759 tree from
= TREE_TYPE (op
);
4761 if (!can_convert (type
, from
, tf_none
))
4764 error_at (cp_expr_loc_or_loc (t
, input_location
),
4765 "conversion of %qT null pointer to %qT "
4766 "is not a constant expression",
4768 *non_constant_p
= true;
4775 /* This detects for example:
4776 reinterpret_cast<void*>(sizeof 0)
4779 error_at (cp_expr_loc_or_loc (t
, input_location
),
4780 "%<reinterpret_cast<%T>(%E)%> is not "
4781 "a constant expression",
4783 *non_constant_p
= true;
4788 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4789 /* We didn't fold at the top so we could check for ptr-int
4793 /* Handle an array's bounds having been deduced after we built
4794 the wrapping expression. */
4795 if (same_type_ignoring_tlq_and_bounds_p (type
, TREE_TYPE (op
)))
4797 else if (tcode
== UNARY_PLUS_EXPR
)
4798 r
= fold_convert (TREE_TYPE (t
), op
);
4800 r
= fold_build1 (tcode
, type
, op
);
4802 /* Conversion of an out-of-range value has implementation-defined
4803 behavior; the language considers it different from arithmetic
4804 overflow, which is undefined. */
4805 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4806 TREE_OVERFLOW (r
) = false;
4810 case EMPTY_CLASS_EXPR
:
4811 /* This is good enough for a function argument that might not get
4812 used, and they can't do anything with it, so just return it. */
4815 case STATEMENT_LIST
:
4817 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4818 return cxx_eval_statement_list (&new_ctx
, t
,
4819 non_constant_p
, overflow_p
, jump_target
);
4822 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4824 non_constant_p
, overflow_p
,
4827 case PREINCREMENT_EXPR
:
4828 case POSTINCREMENT_EXPR
:
4829 case PREDECREMENT_EXPR
:
4830 case POSTDECREMENT_EXPR
:
4831 return cxx_eval_increment_expression (ctx
, t
,
4832 lval
, non_constant_p
, overflow_p
);
4838 case VEC_DELETE_EXPR
:
4841 /* GCC internal stuff. */
4843 case NON_DEPENDENT_EXPR
:
4847 error_at (cp_expr_loc_or_loc (t
, input_location
),
4848 "expression %qE is not a constant expression", t
);
4849 *non_constant_p
= true;
4854 /* Virtual function call. Let the constexpr machinery figure out
4855 the dynamic type. */
4856 int token
= tree_to_shwi (OBJ_TYPE_REF_TOKEN (t
));
4857 tree obj
= OBJ_TYPE_REF_OBJECT (t
);
4858 obj
= cxx_eval_constant_expression (ctx
, obj
, lval
, non_constant_p
,
4860 /* We expect something in the form of &x.D.2103.D.2094; get x. */
4861 if (TREE_CODE (obj
) != ADDR_EXPR
4862 || !DECL_P (get_base_address (TREE_OPERAND (obj
, 0))))
4865 error_at (cp_expr_loc_or_loc (t
, input_location
),
4866 "expression %qE is not a constant expression", t
);
4867 *non_constant_p
= true;
4870 obj
= TREE_OPERAND (obj
, 0);
4871 while (TREE_CODE (obj
) == COMPONENT_REF
4872 && DECL_FIELD_IS_BASE (TREE_OPERAND (obj
, 1)))
4873 obj
= TREE_OPERAND (obj
, 0);
4874 tree objtype
= TREE_TYPE (obj
);
4875 /* Find the function decl in the virtual functions list. TOKEN is
4876 the DECL_VINDEX that says which function we're looking for. */
4877 tree virtuals
= BINFO_VIRTUALS (TYPE_BINFO (objtype
));
4878 if (TARGET_VTABLE_USES_DESCRIPTORS
)
4879 token
/= MAX (TARGET_VTABLE_USES_DESCRIPTORS
, 1);
4880 r
= TREE_VALUE (chain_index (token
, virtuals
));
4884 case PLACEHOLDER_EXPR
:
4885 /* Use of the value or address of the current object. */
4886 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4887 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4888 non_constant_p
, overflow_p
);
4889 /* A placeholder without a referent. We can get here when
4890 checking whether NSDMIs are noexcept, or in massage_init_elt;
4891 just say it's non-constant for now. */
4892 gcc_assert (ctx
->quiet
);
4893 *non_constant_p
= true;
4898 tree cond
= TREE_OPERAND (t
, 0);
4899 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4900 non_constant_p
, overflow_p
);
4901 VERIFY_CONSTANT (cond
);
4902 if (integer_nonzerop (cond
))
4908 *jump_target
= TREE_OPERAND (t
, 0);
4909 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4910 /* Allow for jumping to a cdtor_label. */
4911 || returns (jump_target
));
4915 cxx_eval_loop_expr (ctx
, t
,
4916 non_constant_p
, overflow_p
, jump_target
);
4920 cxx_eval_switch_expr (ctx
, t
,
4921 non_constant_p
, overflow_p
, jump_target
);
4925 /* It's possible to get a requires-expression in a constant
4926 expression. For example:
4928 template<typename T> concept bool C() {
4929 return requires (T t) { t; };
4932 template<typename T> requires !C<T>() void f(T);
4934 Normalization leaves f with the associated constraint
4935 '!requires (T t) { ... }' which is not transformed into
4937 if (!processing_template_decl
)
4938 return evaluate_constraint_expression (t
, NULL_TREE
);
4940 *non_constant_p
= true;
4944 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4946 non_constant_p
, overflow_p
,
4955 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4957 /* This function doesn't know how to deal with pre-genericize
4958 statements; this can only happen with statement-expressions,
4959 so for now just fail. */
4961 error_at (EXPR_LOCATION (t
),
4962 "statement is not a constant expression");
4965 internal_error ("unexpected expression %qE of kind %s", t
,
4966 get_tree_code_name (TREE_CODE (t
)));
4967 *non_constant_p
= true;
4971 if (r
== error_mark_node
)
4972 *non_constant_p
= true;
4974 if (*non_constant_p
)
4980 /* P0859: A function is needed for constant evaluation if it is a constexpr
4981 function that is named by an expression ([basic.def.odr]) that is
4982 potentially constant evaluated.
4984 So we need to instantiate any constexpr functions mentioned by the
4985 expression even if the definition isn't needed for evaluating the
4989 instantiate_cx_fn_r (tree
*tp
, int *walk_subtrees
, void */
*data*/
)
4991 if (TREE_CODE (*tp
) == FUNCTION_DECL
4992 && DECL_DECLARED_CONSTEXPR_P (*tp
)
4993 && !DECL_INITIAL (*tp
)
4994 && !trivial_fn_p (*tp
)
4995 && DECL_TEMPLOID_INSTANTIATION (*tp
))
4998 instantiate_decl (*tp
, /*defer_ok*/false, /*expl_inst*/false);
5001 else if (TREE_CODE (*tp
) == CALL_EXPR
5002 || TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
5004 if (EXPR_HAS_LOCATION (*tp
))
5005 input_location
= EXPR_LOCATION (*tp
);
5014 instantiate_constexpr_fns (tree t
)
5016 location_t loc
= input_location
;
5017 cp_walk_tree_without_duplicates (&t
, instantiate_cx_fn_r
, NULL
);
5018 input_location
= loc
;
5021 /* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5022 STRICT has the same sense as for constant_value_1: true if we only allow
5023 conforming C++ constant expressions, or false if we want a constant value
5024 even if it doesn't conform.
5025 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
5026 per P0595 even when ALLOW_NON_CONSTANT is true. */
5029 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
5031 bool manifestly_const_eval
= false,
5032 tree object
= NULL_TREE
)
5034 auto_timevar
time (TV_CONSTEXPR
);
5036 bool non_constant_p
= false;
5037 bool overflow_p
= false;
5038 hash_map
<tree
,tree
> map
;
5040 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
5041 allow_non_constant
, strict
,
5042 manifestly_const_eval
|| !allow_non_constant
};
5044 tree type
= initialized_type (t
);
5046 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5048 /* In C++14 an NSDMI can participate in aggregate initialization,
5049 and can refer to the address of the object being initialized, so
5050 we need to pass in the relevant VAR_DECL if we want to do the
5051 evaluation in a single pass. The evaluation will dynamically
5052 update ctx.values for the VAR_DECL. We use the same strategy
5053 for C++11 constexpr constructors that refer to the object being
5055 ctx
.ctor
= build_constructor (type
, NULL
);
5056 CONSTRUCTOR_NO_CLEARING (ctx
.ctor
) = true;
5059 if (TREE_CODE (t
) == TARGET_EXPR
)
5060 object
= TARGET_EXPR_SLOT (t
);
5061 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5062 object
= AGGR_INIT_EXPR_SLOT (t
);
5064 ctx
.object
= object
;
5066 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5067 (type
, TREE_TYPE (object
)));
5068 if (object
&& DECL_P (object
))
5069 map
.put (object
, ctx
.ctor
);
5070 if (TREE_CODE (r
) == TARGET_EXPR
)
5071 /* Avoid creating another CONSTRUCTOR when we expand the
5073 r
= TARGET_EXPR_INITIAL (r
);
5076 instantiate_constexpr_fns (r
);
5077 r
= cxx_eval_constant_expression (&ctx
, r
,
5078 false, &non_constant_p
, &overflow_p
);
5080 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
5082 /* Mutable logic is a bit tricky: we want to allow initialization of
5083 constexpr variables with mutable members, but we can't copy those
5084 members to another constexpr variable. */
5085 if (TREE_CODE (r
) == CONSTRUCTOR
5086 && CONSTRUCTOR_MUTABLE_POISON (r
))
5088 if (!allow_non_constant
)
5089 error ("%qE is not a constant expression because it refers to "
5090 "mutable subobjects of %qT", t
, type
);
5091 non_constant_p
= true;
5094 if (TREE_CODE (r
) == CONSTRUCTOR
5095 && CONSTRUCTOR_NO_CLEARING (r
))
5097 if (!allow_non_constant
)
5098 error ("%qE is not a constant expression because it refers to "
5099 "an incompletely initialized variable", t
);
5100 TREE_CONSTANT (r
) = false;
5101 non_constant_p
= true;
5104 /* Technically we should check this for all subexpressions, but that
5105 runs into problems with our internal representation of pointer
5106 subtraction and the 5.19 rules are still in flux. */
5107 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
5108 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
5109 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
5111 if (!allow_non_constant
)
5112 error ("conversion from pointer type %qT "
5113 "to arithmetic type %qT in a constant expression",
5114 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
5115 non_constant_p
= true;
5118 if (!non_constant_p
&& overflow_p
)
5119 non_constant_p
= true;
5121 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
5123 bool should_unshare
= true;
5124 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
5125 should_unshare
= false;
5127 if (non_constant_p
&& !allow_non_constant
)
5128 return error_mark_node
;
5129 else if (non_constant_p
&& TREE_CONSTANT (r
))
5131 /* If __builtin_is_constant_evaluated () was evaluated to true
5132 and the result is not a valid constant expression, we need to
5134 if (manifestly_const_eval
)
5135 return cxx_eval_outermost_constant_expr (t
, true, strict
,
5137 /* This isn't actually constant, so unset TREE_CONSTANT.
5138 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
5139 it to be set if it is invariant address, even when it is not
5140 a valid C++ constant expression. Wrap it with a NOP_EXPR
5142 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
5144 else if (TREE_CODE (r
) == CONSTRUCTOR
)
5145 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
5147 r
= build_nop (TREE_TYPE (r
), r
);
5148 TREE_CONSTANT (r
) = false;
5150 else if (non_constant_p
)
5154 r
= unshare_expr (r
);
5156 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
5158 r
= adjust_temp_type (type
, r
);
5159 if (TREE_CODE (t
) == TARGET_EXPR
5160 && TARGET_EXPR_INITIAL (t
) == r
)
5162 else if (TREE_CODE (t
) != CONSTRUCTOR
)
5164 r
= get_target_expr (r
);
5165 TREE_CONSTANT (r
) = true;
5172 /* Returns true if T is a valid subexpression of a constant expression,
5173 even if it isn't itself a constant expression. */
5176 is_sub_constant_expr (tree t
)
5178 bool non_constant_p
= false;
5179 bool overflow_p
= false;
5180 hash_map
<tree
, tree
> map
;
5183 = { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true, false };
5185 instantiate_constexpr_fns (t
);
5186 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
5188 return !non_constant_p
&& !overflow_p
;
5191 /* If T represents a constant expression returns its reduced value.
5192 Otherwise return error_mark_node. If T is dependent, then
5196 cxx_constant_value (tree t
, tree decl
)
5198 return cxx_eval_outermost_constant_expr (t
, false, true, true, decl
);
5201 /* Helper routine for fold_simple function. Either return simplified
5202 expression T, otherwise NULL_TREE.
5203 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
5204 even if we are within template-declaration. So be careful on call, as in
5205 such case types can be undefined. */
5208 fold_simple_1 (tree t
)
5211 enum tree_code code
= TREE_CODE (t
);
5223 return fold_sizeof_expr (t
);
5232 case TRUTH_NOT_EXPR
:
5234 case VIEW_CONVERT_EXPR
:
5237 case FIX_TRUNC_EXPR
:
5238 case FIXED_CONVERT_EXPR
:
5239 case ADDR_SPACE_CONVERT_EXPR
:
5241 op1
= TREE_OPERAND (t
, 0);
5243 t
= const_unop (code
, TREE_TYPE (t
), op1
);
5247 if (CONVERT_EXPR_CODE_P (code
)
5248 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
5249 TREE_OVERFLOW (t
) = false;
5257 /* If T is a simple constant expression, returns its simplified value.
5258 Otherwise returns T. In contrast to maybe_constant_value we
5259 simplify only few operations on constant-expressions, and we don't
5260 try to simplify constexpressions. */
5263 fold_simple (tree t
)
5265 if (processing_template_decl
)
5268 tree r
= fold_simple_1 (t
);
5275 /* If T is a constant expression, returns its reduced value.
5276 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5277 Otherwise, returns a version of T without TREE_CONSTANT.
5278 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated
5281 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5284 maybe_constant_value (tree t
, tree decl
, bool manifestly_const_eval
)
5288 if (!is_nondependent_constant_expression (t
))
5290 if (TREE_OVERFLOW_P (t
))
5292 t
= build_nop (TREE_TYPE (t
), t
);
5293 TREE_CONSTANT (t
) = false;
5297 else if (CONSTANT_CLASS_P (t
))
5298 /* No caching or evaluation needed. */
5301 if (manifestly_const_eval
)
5302 return cxx_eval_outermost_constant_expr (t
, true, true, true, decl
);
5304 if (cv_cache
== NULL
)
5305 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5306 if (tree
*cached
= cv_cache
->get (t
))
5309 r
= cxx_eval_outermost_constant_expr (t
, true, true, false, decl
);
5310 gcc_checking_assert (r
== t
5311 || CONVERT_EXPR_P (t
)
5312 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5313 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5314 || !cp_tree_equal (r
, t
));
5315 cv_cache
->put (t
, r
);
5319 /* Dispose of the whole CV_CACHE. */
5322 clear_cv_cache (void)
5324 if (cv_cache
!= NULL
)
5328 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5331 clear_cv_and_fold_caches (void)
5334 clear_fold_cache ();
5337 /* Like maybe_constant_value but first fully instantiate the argument.
5339 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5340 (t, complain) followed by maybe_constant_value but is more efficient,
5341 because it calls instantiation_dependent_expression_p and
5342 potential_constant_expression at most once.
5344 Callers should generally pass their active complain, or if they are in a
5345 non-template, diagnosing context, they can use the default of
5346 tf_warning_or_error. Callers that might be within a template context, don't
5347 have a complain parameter, and aren't going to remember the result for long
5348 (e.g. null_ptr_cst_p), can pass tf_none and deal with error_mark_node
5352 fold_non_dependent_expr (tree t
,
5353 tsubst_flags_t complain
/* = tf_warning_or_error */)
5358 /* If we're in a template, but T isn't value dependent, simplify
5359 it. We're supposed to treat:
5361 template <typename T> void f(T[1 + 1]);
5362 template <typename T> void f(T[2]);
5364 as two declarations of the same function, for example. */
5365 if (processing_template_decl
)
5367 if (is_nondependent_constant_expression (t
))
5369 processing_template_decl_sentinel s
;
5370 t
= instantiate_non_dependent_expr_internal (t
, complain
);
5372 if (type_unknown_p (t
)
5373 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5375 if (TREE_OVERFLOW_P (t
))
5377 t
= build_nop (TREE_TYPE (t
), t
);
5378 TREE_CONSTANT (t
) = false;
5383 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, false,
5385 /* cp_tree_equal looks through NOPs, so allow them. */
5386 gcc_checking_assert (r
== t
5387 || CONVERT_EXPR_P (t
)
5388 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5389 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5390 || !cp_tree_equal (r
, t
));
5393 else if (TREE_OVERFLOW_P (t
))
5395 t
= build_nop (TREE_TYPE (t
), t
);
5396 TREE_CONSTANT (t
) = false;
5401 return maybe_constant_value (t
);
5404 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5405 than wrapped in a TARGET_EXPR.
5406 ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5407 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
5408 per P0595 even when ALLOW_NON_CONSTANT is true. */
5411 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
,
5412 bool manifestly_const_eval
)
5416 if (TREE_CODE (t
) == EXPR_STMT
)
5417 t
= TREE_OPERAND (t
, 0);
5418 if (TREE_CODE (t
) == CONVERT_EXPR
5419 && VOID_TYPE_P (TREE_TYPE (t
)))
5420 t
= TREE_OPERAND (t
, 0);
5421 if (TREE_CODE (t
) == INIT_EXPR
)
5422 t
= TREE_OPERAND (t
, 1);
5423 if (TREE_CODE (t
) == TARGET_EXPR
)
5424 t
= TARGET_EXPR_INITIAL (t
);
5425 if (!is_nondependent_static_init_expression (t
))
5426 /* Don't try to evaluate it. */;
5427 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5428 /* No evaluation needed. */;
5430 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
,
5432 manifestly_const_eval
, decl
);
5433 if (TREE_CODE (t
) == TARGET_EXPR
)
5435 tree init
= TARGET_EXPR_INITIAL (t
);
5436 if (TREE_CODE (init
) == CONSTRUCTOR
)
5442 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5445 maybe_constant_init (tree t
, tree decl
, bool manifestly_const_eval
)
5447 return maybe_constant_init_1 (t
, decl
, true, manifestly_const_eval
);
5450 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5453 cxx_constant_init (tree t
, tree decl
)
5455 return maybe_constant_init_1 (t
, decl
, false, true);
5459 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5460 /* Return true if the object referred to by REF has automatic or thread
5463 enum { ck_ok
, ck_bad
, ck_unknown
};
5465 check_automatic_or_tls (tree ref
)
5468 poly_int64 bitsize
, bitpos
;
5470 int volatilep
= 0, unsignedp
= 0;
5471 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5472 &mode
, &unsignedp
, &volatilep
, false);
5475 /* If there isn't a decl in the middle, we don't know the linkage here,
5476 and this isn't a constant expression anyway. */
5479 dk
= decl_storage_duration (decl
);
5480 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5484 /* Return true if T denotes a potentially constant expression. Issue
5485 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5486 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5487 consider the expression in the current context, independent of constexpr
5490 C++0x [expr.const] used to say
5492 6 An expression is a potential constant expression if it is
5493 a constant expression where all occurrences of function
5494 parameters are replaced by arbitrary constant expressions
5495 of the appropriate type.
5497 2 A conditional expression is a constant expression unless it
5498 involves one of the following as a potentially evaluated
5499 subexpression (3.2), but subexpressions of logical AND (5.14),
5500 logical OR (5.15), and conditional (5.16) operations that are
5501 not evaluated are not considered. */
5504 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5505 tsubst_flags_t flags
, tree
*jump_target
)
5507 #define RECUR(T,RV) \
5508 potential_constant_expression_1 ((T), (RV), strict, now, flags, jump_target)
5510 enum { any
= false, rval
= true };
5514 if (t
== error_mark_node
)
5518 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
5521 /* If we are jumping, ignore everything. This is simpler than the
5522 cxx_eval_constant_expression handling because we only need to be
5523 conservatively correct, and we don't necessarily have a constant value
5524 available, so we don't bother with switch tracking. */
5527 if (TREE_THIS_VOLATILE (t
) && want_rval
)
5529 if (flags
& tf_error
)
5530 error_at (loc
, "lvalue-to-rvalue conversion of a volatile lvalue "
5531 "%qE with type %qT", t
, TREE_TYPE (t
));
5534 if (CONSTANT_CLASS_P (t
))
5536 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5537 && TREE_TYPE (t
) == error_mark_node
)
5540 switch (TREE_CODE (t
))
5546 case TEMPLATE_ID_EXPR
:
5549 case CASE_LABEL_EXPR
:
5555 case TEMPLATE_PARM_INDEX
:
5557 case IDENTIFIER_NODE
:
5558 case USERDEF_LITERAL
:
5559 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5564 case PLACEHOLDER_EXPR
:
5567 case DEBUG_BEGIN_STMT
:
5571 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5583 if (flags
& tf_error
)
5584 error ("%qE is not a constant expression", t
);
5589 case AGGR_INIT_EXPR
:
5591 /* -- an invocation of a function other than a constexpr function
5592 or a constexpr constructor. */
5594 tree fun
= get_function_named_in_call (t
);
5595 const int nargs
= call_expr_nargs (t
);
5598 if (fun
== NULL_TREE
)
5600 /* Reset to allow the function to continue past the end
5601 of the block below. Otherwise return early. */
5604 if (TREE_CODE (t
) == CALL_EXPR
5605 && CALL_EXPR_FN (t
) == NULL_TREE
)
5606 switch (CALL_EXPR_IFN (t
))
5608 /* These should be ignored, they are optimized away from
5609 constexpr functions. */
5610 case IFN_UBSAN_NULL
:
5611 case IFN_UBSAN_BOUNDS
:
5612 case IFN_UBSAN_VPTR
:
5613 case IFN_FALLTHROUGH
:
5616 case IFN_ADD_OVERFLOW
:
5617 case IFN_SUB_OVERFLOW
:
5618 case IFN_MUL_OVERFLOW
:
5628 /* fold_call_expr can't do anything with IFN calls. */
5629 if (flags
& tf_error
)
5630 error_at (loc
, "call to internal function %qE", t
);
5635 if (fun
&& is_overloaded_fn (fun
))
5637 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5639 if (builtin_valid_in_constant_expr_p (fun
))
5641 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5642 /* Allow any built-in function; if the expansion
5643 isn't constant, we'll deal with that then. */
5644 && !fndecl_built_in_p (fun
))
5646 if (flags
& tf_error
)
5648 error_at (loc
, "call to non-%<constexpr%> function %qD",
5650 explain_invalid_constexpr_fn (fun
);
5654 /* A call to a non-static member function takes the address
5655 of the object as the first argument. But in a constant
5656 expression the address will be folded away, so look
5658 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5659 && !DECL_CONSTRUCTOR_P (fun
))
5661 tree x
= get_nth_callarg (t
, 0);
5662 if (is_this_parameter (x
))
5664 /* Don't require an immediately constant value, as
5665 constexpr substitution might not use the value. */
5666 bool sub_now
= false;
5667 if (!potential_constant_expression_1 (x
, rval
, strict
,
5676 if (!RECUR (fun
, true))
5678 fun
= get_first_fn (fun
);
5680 /* Skip initial arguments to base constructors. */
5681 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5682 i
= num_artificial_parms_for (fun
);
5683 fun
= DECL_ORIGIN (fun
);
5687 if (RECUR (fun
, rval
))
5688 /* Might end up being a constant function pointer. */;
5692 for (; i
< nargs
; ++i
)
5694 tree x
= get_nth_callarg (t
, i
);
5695 /* In a template, reference arguments haven't been converted to
5696 REFERENCE_TYPE and we might not even know if the parameter
5697 is a reference, so accept lvalue constants too. */
5698 bool rv
= processing_template_decl
? any
: rval
;
5699 /* Don't require an immediately constant value, as constexpr
5700 substitution might not use the value of the argument. */
5701 bool sub_now
= false;
5702 if (!potential_constant_expression_1 (x
, rv
, strict
,
5703 sub_now
, flags
, jump_target
))
5709 case NON_LVALUE_EXPR
:
5710 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5711 -- an lvalue of integral type that refers to a non-volatile
5712 const variable or static data member initialized with
5713 constant expressions, or
5715 -- an lvalue of literal type that refers to non-volatile
5716 object defined with constexpr, or that refers to a
5717 sub-object of such an object; */
5718 return RECUR (TREE_OPERAND (t
, 0), rval
);
5721 if (DECL_HAS_VALUE_EXPR_P (t
))
5723 if (now
&& is_normal_capture_proxy (t
))
5725 /* -- in a lambda-expression, a reference to this or to a
5726 variable with automatic storage duration defined outside that
5727 lambda-expression, where the reference would be an
5729 if (flags
& tf_error
)
5731 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5732 error ("lambda capture of %qE is not a constant expression",
5734 if (!want_rval
&& decl_constant_var_p (cap
))
5735 inform (input_location
, "because it is used as a glvalue");
5739 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5742 && !var_in_maybe_constexpr_fn (t
)
5743 && !type_dependent_expression_p (t
)
5744 && !decl_maybe_constant_var_p (t
)
5746 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5747 || (DECL_INITIAL (t
)
5748 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5749 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5750 && !is_really_empty_class (TREE_TYPE (t
)))
5752 if (flags
& tf_error
)
5753 non_const_var_error (t
);
5760 case VIEW_CONVERT_EXPR
:
5761 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5762 may change to something more specific to type-punning (DR 1312). */
5764 tree from
= TREE_OPERAND (t
, 0);
5765 if (INDIRECT_TYPE_P (TREE_TYPE (t
))
5766 && TREE_CODE (from
) == INTEGER_CST
5767 && !integer_zerop (from
))
5769 if (flags
& tf_error
)
5770 error_at (loc
, "reinterpret_cast from integer to pointer");
5773 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5776 case ADDRESSOF_EXPR
:
5777 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5778 t
= TREE_OPERAND (t
, 0);
5779 goto handle_addr_expr
;
5782 /* -- a unary operator & that is applied to an lvalue that
5783 designates an object with thread or automatic storage
5785 t
= TREE_OPERAND (t
, 0);
5787 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5788 /* A pointer-to-member constant. */
5793 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5794 any checking here, as we might dereference the pointer later. If
5795 we remove this code, also remove check_automatic_or_tls. */
5796 i
= check_automatic_or_tls (t
);
5801 if (flags
& tf_error
)
5802 error ("address-of an object %qE with thread local or "
5803 "automatic storage is not a constant expression", t
);
5807 return RECUR (t
, any
);
5815 /* -- a class member access unless its postfix-expression is
5816 of literal type or of pointer to literal type. */
5817 /* This test would be redundant, as it follows from the
5818 postfix-expression being a potential constant expression. */
5819 if (type_unknown_p (t
))
5821 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5823 case EXPR_PACK_EXPANSION
:
5824 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5828 tree x
= TREE_OPERAND (t
, 0);
5830 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5832 if (!var_in_maybe_constexpr_fn (x
))
5834 if (flags
& tf_error
)
5835 error_at (loc
, "use of %<this%> in a constant expression");
5840 return RECUR (x
, rval
);
5843 case STATEMENT_LIST
:
5845 tree_stmt_iterator i
;
5846 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5848 if (!RECUR (tsi_stmt (i
), any
))
5856 if (cxx_dialect
< cxx14
)
5858 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5860 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5865 if (cxx_dialect
< cxx14
)
5867 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5869 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5874 if (!RECUR (DO_COND (t
), rval
))
5876 if (!RECUR (DO_BODY (t
), any
))
5878 if (breaks (jump_target
) || continues (jump_target
))
5879 *jump_target
= NULL_TREE
;
5883 if (!RECUR (FOR_INIT_STMT (t
), any
))
5886 if (!RECUR (tmp
, rval
))
5890 if (!processing_template_decl
)
5891 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5892 /* If we couldn't evaluate the condition, it might not ever be
5894 if (!integer_onep (tmp
))
5897 if (!RECUR (FOR_EXPR (t
), any
))
5899 if (!RECUR (FOR_BODY (t
), any
))
5901 if (breaks (jump_target
) || continues (jump_target
))
5902 *jump_target
= NULL_TREE
;
5905 case RANGE_FOR_STMT
:
5906 if (!RECUR (RANGE_FOR_INIT_STMT (t
), any
))
5908 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5910 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5912 if (breaks (jump_target
) || continues (jump_target
))
5913 *jump_target
= NULL_TREE
;
5917 tmp
= WHILE_COND (t
);
5918 if (!RECUR (tmp
, rval
))
5920 if (!processing_template_decl
)
5921 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5922 /* If we couldn't evaluate the condition, it might not ever be true. */
5923 if (!integer_onep (tmp
))
5925 if (!RECUR (WHILE_BODY (t
), any
))
5927 if (breaks (jump_target
) || continues (jump_target
))
5928 *jump_target
= NULL_TREE
;
5932 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5934 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5935 unreachable labels would be checked. */
5939 return RECUR (STMT_EXPR_STMT (t
), rval
);
5942 if (cxx_dialect
>= cxx17
)
5943 /* In C++17 lambdas can be constexpr, don't give up yet. */
5945 else if (flags
& tf_error
)
5946 error_at (loc
, "lambda-expression is not a constant expression "
5950 case DYNAMIC_CAST_EXPR
:
5951 case PSEUDO_DTOR_EXPR
:
5955 case VEC_DELETE_EXPR
:
5961 case OMP_DISTRIBUTE
:
5964 case OMP_TARGET_DATA
:
5973 case OMP_TARGET_UPDATE
:
5974 case OMP_TARGET_ENTER_DATA
:
5975 case OMP_TARGET_EXIT_DATA
:
5977 case OMP_ATOMIC_READ
:
5978 case OMP_ATOMIC_CAPTURE_OLD
:
5979 case OMP_ATOMIC_CAPTURE_NEW
:
5984 case OACC_HOST_DATA
:
5988 case OACC_ENTER_DATA
:
5989 case OACC_EXIT_DATA
:
5991 /* GCC internal stuff. */
5993 case TRANSACTION_EXPR
:
5995 case AT_ENCODE_EXPR
:
5997 if (flags
& tf_error
)
5998 error_at (loc
, "expression %qE is not a constant expression", t
);
6002 if (cxx_dialect
>= cxx2a
)
6003 /* In C++2a virtual calls can be constexpr, don't give up yet. */
6005 else if (flags
& tf_error
)
6006 error_at (loc
, "virtual functions cannot be constexpr before C++2a");
6010 /* -- a typeid expression whose operand is of polymorphic
6013 tree e
= TREE_OPERAND (t
, 0);
6014 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
6015 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
6017 if (flags
& tf_error
)
6018 error_at (loc
, "typeid-expression is not a constant expression "
6019 "because %qE is of polymorphic type", e
);
6025 case POINTER_DIFF_EXPR
:
6039 case PREINCREMENT_EXPR
:
6040 case POSTINCREMENT_EXPR
:
6041 case PREDECREMENT_EXPR
:
6042 case POSTDECREMENT_EXPR
:
6043 if (cxx_dialect
< cxx14
)
6049 if (TYPE_P (TREE_OPERAND (t
, 0)))
6055 case FIX_TRUNC_EXPR
:
6060 case TRUTH_NOT_EXPR
:
6061 case FIXED_CONVERT_EXPR
:
6062 case UNARY_PLUS_EXPR
:
6063 case UNARY_LEFT_FOLD_EXPR
:
6064 case UNARY_RIGHT_FOLD_EXPR
:
6066 return RECUR (TREE_OPERAND (t
, 0), rval
);
6069 case CONST_CAST_EXPR
:
6070 case STATIC_CAST_EXPR
:
6071 case REINTERPRET_CAST_EXPR
:
6072 case IMPLICIT_CONV_EXPR
:
6073 if (cxx_dialect
< cxx11
6074 && !dependent_type_p (TREE_TYPE (t
))
6075 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
6076 /* In C++98, a conversion to non-integral type can't be part of a
6077 constant expression. */
6079 if (flags
& tf_error
)
6081 "cast to non-integral type %qT in a constant expression",
6085 /* This might be a conversion from a class to a (potentially) literal
6086 type. Let's consider it potentially constant since the conversion
6087 might be a constexpr user-defined conversion. */
6088 else if (cxx_dialect
>= cxx11
6089 && (dependent_type_p (TREE_TYPE (t
))
6090 || !COMPLETE_TYPE_P (TREE_TYPE (t
))
6091 || literal_type_p (TREE_TYPE (t
)))
6092 && TREE_OPERAND (t
, 0))
6094 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6095 /* If this is a dependent type, it could end up being a class
6096 with conversions. */
6097 if (type
== NULL_TREE
|| WILDCARD_TYPE_P (type
))
6099 /* Or a non-dependent class which has conversions. */
6100 else if (CLASS_TYPE_P (type
)
6101 && (TYPE_HAS_CONVERSION (type
) || dependent_scope_p (type
)))
6105 return (RECUR (TREE_OPERAND (t
, 0),
6106 !TYPE_REF_P (TREE_TYPE (t
))));
6109 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
6111 case CLEANUP_POINT_EXPR
:
6112 case MUST_NOT_THROW_EXPR
:
6113 case TRY_CATCH_EXPR
:
6118 case NON_DEPENDENT_EXPR
:
6119 /* For convenience. */
6122 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6125 tmp
= DECL_EXPR_DECL (t
);
6126 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
6128 if (TREE_STATIC (tmp
))
6130 if (flags
& tf_error
)
6131 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6132 "%<static%> in %<constexpr%> context", tmp
);
6135 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
6137 if (flags
& tf_error
)
6138 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6139 "%<thread_local%> in %<constexpr%> context", tmp
);
6142 else if (!check_for_uninitialized_const_var
6143 (tmp
, /*constexpr_context_p=*/true, flags
))
6146 return RECUR (tmp
, want_rval
);
6148 case TRY_FINALLY_EXPR
:
6149 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
6150 && RECUR (TREE_OPERAND (t
, 1), any
));
6153 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6156 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
6157 && !literal_type_p (TREE_TYPE (t
)))
6159 if (flags
& tf_error
)
6161 auto_diagnostic_group d
;
6162 error_at (loc
, "temporary of non-literal type %qT in a "
6163 "constant expression", TREE_TYPE (t
));
6164 explain_non_literal_class (TREE_TYPE (t
));
6170 return RECUR (TREE_OPERAND (t
, 1), rval
);
6174 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
6175 constructor_elt
*ce
;
6176 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
6177 if (!RECUR (ce
->value
, want_rval
))
6184 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
6185 || DECL_P (TREE_PURPOSE (t
)));
6186 if (!RECUR (TREE_VALUE (t
), want_rval
))
6188 if (TREE_CHAIN (t
) == NULL_TREE
)
6190 return RECUR (TREE_CHAIN (t
), want_rval
);
6193 case TRUNC_DIV_EXPR
:
6195 case FLOOR_DIV_EXPR
:
6196 case ROUND_DIV_EXPR
:
6197 case TRUNC_MOD_EXPR
:
6199 case ROUND_MOD_EXPR
:
6201 tree denom
= TREE_OPERAND (t
, 1);
6202 if (!RECUR (denom
, rval
))
6204 /* We can't call cxx_eval_outermost_constant_expr on an expression
6205 that hasn't been through instantiate_non_dependent_expr yet. */
6206 if (!processing_template_decl
)
6207 denom
= cxx_eval_outermost_constant_expr (denom
, true);
6208 if (integer_zerop (denom
))
6210 if (flags
& tf_error
)
6211 error ("division by zero is not a constant expression");
6217 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6223 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6224 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6225 introduced by build_call_a. */
6226 tree op0
= TREE_OPERAND (t
, 0);
6227 tree op1
= TREE_OPERAND (t
, 1);
6229 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
6230 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
6231 return RECUR (op0
, want_rval
);
6236 /* If the first operand is the non-short-circuit constant, look at
6237 the second operand; otherwise we only care about the first one for
6239 case TRUTH_AND_EXPR
:
6240 case TRUTH_ANDIF_EXPR
:
6241 tmp
= boolean_true_node
;
6244 case TRUTH_ORIF_EXPR
:
6245 tmp
= boolean_false_node
;
6248 tree op
= TREE_OPERAND (t
, 0);
6249 if (!RECUR (op
, rval
))
6251 if (!processing_template_decl
)
6252 op
= cxx_eval_outermost_constant_expr (op
, true);
6253 if (tree_int_cst_equal (op
, tmp
))
6254 return RECUR (TREE_OPERAND (t
, 1), rval
);
6261 case POINTER_PLUS_EXPR
:
6263 case EXACT_DIV_EXPR
:
6273 case TRUTH_XOR_EXPR
:
6274 case UNORDERED_EXPR
:
6287 case ARRAY_RANGE_REF
:
6291 case BINARY_LEFT_FOLD_EXPR
:
6292 case BINARY_RIGHT_FOLD_EXPR
:
6294 for (i
= 0; i
< 2; ++i
)
6295 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
6300 for (i
= 0; i
< 3; ++i
)
6301 if (!RECUR (TREE_OPERAND (t
, i
), true))
6306 if (COND_EXPR_IS_VEC_DELETE (t
))
6308 if (flags
& tf_error
)
6309 error_at (loc
, "%<delete[]%> is not a constant expression");
6315 /* If the condition is a known constant, we know which of the legs we
6316 care about; otherwise we only require that the condition and
6317 either of the legs be potentially constant. */
6318 tmp
= TREE_OPERAND (t
, 0);
6319 if (!RECUR (tmp
, rval
))
6321 if (!processing_template_decl
)
6322 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6323 if (integer_zerop (tmp
))
6324 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
6325 else if (TREE_CODE (tmp
) == INTEGER_CST
)
6326 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6327 for (i
= 1; i
< 3; ++i
)
6328 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
6329 want_rval
, strict
, now
,
6330 tf_none
, jump_target
))
6332 if (flags
& tf_error
)
6333 error_at (loc
, "expression %qE is not a constant expression", t
);
6337 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
6339 if (flags
& tf_error
)
6341 error_at (loc
, "non-constant array initialization");
6342 diagnose_non_constexpr_vec_init (t
);
6348 /* We can see these in statement-expressions. */
6352 case EMPTY_CLASS_EXPR
:
6358 tree
*target
= &TREE_OPERAND (t
, 0);
6359 /* Gotos representing break and continue are OK. */
6360 if (breaks (target
) || continues (target
))
6362 *jump_target
= *target
;
6365 if (flags
& tf_error
)
6366 error_at (loc
, "%<goto%> is not a constant expression");
6371 return RECUR (TREE_OPERAND (t
, 0), rval
);
6374 if (objc_is_property_ref (t
))
6377 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6385 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
6386 tsubst_flags_t flags
)
6388 tree target
= NULL_TREE
;
6389 return potential_constant_expression_1 (t
, want_rval
, strict
, now
,
6393 /* The main entry point to the above. */
6396 potential_constant_expression (tree t
)
6398 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6401 /* As above, but require a constant rvalue. */
6404 potential_rvalue_constant_expression (tree t
)
6406 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6409 /* Like above, but complain about non-constant expressions. */
6412 require_potential_constant_expression (tree t
)
6414 return potential_constant_expression_1 (t
, false, true, false,
6415 tf_warning_or_error
);
6418 /* Cross product of the above. */
6421 require_potential_rvalue_constant_expression (tree t
)
6423 return potential_constant_expression_1 (t
, true, true, false,
6424 tf_warning_or_error
);
6427 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6430 require_rvalue_constant_expression (tree t
)
6432 return potential_constant_expression_1 (t
, true, true, true,
6433 tf_warning_or_error
);
6436 /* Like potential_constant_expression, but don't consider possible constexpr
6437 substitution of the current function. That is, PARM_DECL qualifies under
6438 potential_constant_expression, but not here.
6440 This is basically what you can check when any actual constant values might
6441 be value-dependent. */
6444 is_constant_expression (tree t
)
6446 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6449 /* Like above, but complain about non-constant expressions. */
6452 require_constant_expression (tree t
)
6454 return potential_constant_expression_1 (t
, false, true, true,
6455 tf_warning_or_error
);
6458 /* Like is_constant_expression, but allow const variables that are not allowed
6459 under constexpr rules. */
6462 is_static_init_expression (tree t
)
6464 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6467 /* Returns true if T is a potential constant expression that is not
6468 instantiation-dependent, and therefore a candidate for constant folding even
6472 is_nondependent_constant_expression (tree t
)
6474 return (!type_unknown_p (t
)
6475 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6476 && is_constant_expression (t
)
6477 && !instantiation_dependent_expression_p (t
));
6480 /* Returns true if T is a potential static initializer expression that is not
6481 instantiation-dependent. */
6484 is_nondependent_static_init_expression (tree t
)
6486 return (!type_unknown_p (t
)
6487 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6488 && is_static_init_expression (t
)
6489 && !instantiation_dependent_expression_p (t
));
6492 /* Finalize constexpr processing after parsing. */
6495 fini_constexpr (void)
6497 /* The contexpr call and fundef copies tables are no longer needed. */
6498 constexpr_call_table
= NULL
;
6499 fundef_copies_table
= NULL
;
6502 #include "gt-cp-constexpr.h"