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-2019 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"
36 #include "fold-const-call.h"
38 static bool verify_constant (tree
, bool, bool *, bool *);
39 #define VERIFY_CONSTANT(X) \
41 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
45 static HOST_WIDE_INT
find_array_ctor_elt (tree ary
, tree dindex
,
48 /* Returns true iff FUN is an instantiation of a constexpr function
49 template or a defaulted constexpr function. */
52 is_instantiation_of_constexpr (tree fun
)
54 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
55 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
56 || (DECL_DEFAULTED_FN (fun
)
57 && DECL_DECLARED_CONSTEXPR_P (fun
)));
60 /* Return true if T is a literal type. */
63 literal_type_p (tree t
)
68 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
72 t
= complete_type (t
);
73 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
74 return CLASSTYPE_LITERAL_P (t
);
76 if (TREE_CODE (t
) == ARRAY_TYPE
)
77 return literal_type_p (strip_array_types (t
));
81 /* If DECL is a variable declared `constexpr', require its type
82 be literal. Return error_mark_node if we give an error, the
86 ensure_literal_type_for_constexpr_object (tree decl
)
88 tree type
= TREE_TYPE (decl
);
90 && (DECL_DECLARED_CONSTEXPR_P (decl
)
91 || var_in_constexpr_fn (decl
))
92 && !processing_template_decl
)
94 tree stype
= strip_array_types (type
);
95 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
96 /* Don't complain here, we'll complain about incompleteness
97 when we try to initialize the variable. */;
98 else if (type_uses_auto (type
))
99 /* We don't know the actual type yet. */;
100 else if (!literal_type_p (type
))
102 if (DECL_DECLARED_CONSTEXPR_P (decl
))
104 auto_diagnostic_group d
;
105 error_at (DECL_SOURCE_LOCATION (decl
),
106 "the type %qT of %<constexpr%> variable %qD "
107 "is not literal", type
, decl
);
108 explain_non_literal_class (type
);
109 decl
= error_mark_node
;
113 if (!is_instantiation_of_constexpr (current_function_decl
))
115 auto_diagnostic_group d
;
116 error_at (DECL_SOURCE_LOCATION (decl
),
117 "variable %qD of non-literal type %qT in "
118 "%<constexpr%> function", decl
, type
);
119 explain_non_literal_class (type
);
120 decl
= error_mark_node
;
122 cp_function_chain
->invalid_constexpr
= true;
125 else if (DECL_DECLARED_CONSTEXPR_P (decl
)
126 && variably_modified_type_p (type
, NULL_TREE
))
128 error_at (DECL_SOURCE_LOCATION (decl
),
129 "%<constexpr%> variable %qD has variably-modified "
130 "type %qT", decl
, type
);
131 decl
= error_mark_node
;
137 /* Representation of entries in the constexpr function definition table. */
139 struct GTY((for_user
)) constexpr_fundef
{
146 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
148 static hashval_t
hash (constexpr_fundef
*);
149 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
152 /* This table holds all constexpr function definitions seen in
153 the current translation unit. */
155 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
157 /* Utility function used for managing the constexpr function table.
158 Return true if the entries pointed to by P and Q are for the
159 same constexpr function. */
162 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
164 return lhs
->decl
== rhs
->decl
;
167 /* Utility function used for managing the constexpr function table.
168 Return a hash value for the entry pointed to by Q. */
171 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
173 return DECL_UID (fundef
->decl
);
176 /* Return a previously saved definition of function FUN. */
178 static constexpr_fundef
*
179 retrieve_constexpr_fundef (tree fun
)
181 if (constexpr_fundef_table
== NULL
)
184 constexpr_fundef fundef
= { fun
, NULL
, NULL
, NULL
};
185 return constexpr_fundef_table
->find (&fundef
);
188 /* Check whether the parameter and return types of FUN are valid for a
189 constexpr function, and complain if COMPLAIN. */
192 is_valid_constexpr_fn (tree fun
, bool complain
)
196 if (DECL_INHERITED_CTOR (fun
)
197 && TREE_CODE (fun
) == TEMPLATE_DECL
)
201 error ("inherited constructor %qD is not %<constexpr%>",
202 DECL_INHERITED_CTOR (fun
));
206 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
207 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
208 if (!literal_type_p (TREE_TYPE (parm
)))
213 auto_diagnostic_group d
;
214 error ("invalid type for parameter %d of %<constexpr%> "
215 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
216 explain_non_literal_class (TREE_TYPE (parm
));
221 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
225 inform (DECL_SOURCE_LOCATION (fun
),
226 "lambdas are implicitly %<constexpr%> only in C++17 and later");
228 else if (!DECL_CONSTRUCTOR_P (fun
))
230 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
231 if (!literal_type_p (rettype
))
236 auto_diagnostic_group d
;
237 error ("invalid return type %qT of %<constexpr%> function %q+D",
239 explain_non_literal_class (rettype
);
243 /* C++14 DR 1684 removed this restriction. */
244 if (cxx_dialect
< cxx14
245 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
246 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
251 auto_diagnostic_group d
;
252 if (pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
253 "enclosing class of %<constexpr%> non-static"
254 " member function %q+#D is not a literal type",
256 explain_non_literal_class (DECL_CONTEXT (fun
));
260 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
264 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
270 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
271 for a member of an anonymous aggregate, INIT is the initializer for that
272 member, and VEC_OUTER is the vector of constructor elements for the class
273 whose constructor we are processing. Add the initializer to the vector
274 and return true to indicate success. */
277 build_anon_member_initialization (tree member
, tree init
,
278 vec
<constructor_elt
, va_gc
> **vec_outer
)
280 /* MEMBER presents the relevant fields from the inside out, but we need
281 to build up the initializer from the outside in so that we can reuse
282 previously built CONSTRUCTORs if this is, say, the second field in an
283 anonymous struct. So we use a vec as a stack. */
284 auto_vec
<tree
, 2> fields
;
287 fields
.safe_push (TREE_OPERAND (member
, 1));
288 member
= TREE_OPERAND (member
, 0);
290 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
291 && TREE_CODE (member
) == COMPONENT_REF
);
293 /* VEC has the constructor elements vector for the context of FIELD.
294 If FIELD is an anonymous aggregate, we will push inside it. */
295 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
297 while (field
= fields
.pop(),
298 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
301 /* If there is already an outer constructor entry for the anonymous
302 aggregate FIELD, use it; otherwise, insert one. */
303 if (vec_safe_is_empty (*vec
)
304 || (*vec
)->last().index
!= field
)
306 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
307 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
310 ctor
= (*vec
)->last().value
;
311 vec
= &CONSTRUCTOR_ELTS (ctor
);
314 /* Now we're at the innermost field, the one that isn't an anonymous
315 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
316 gcc_assert (fields
.is_empty());
317 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
322 /* Subroutine of build_constexpr_constructor_member_initializers.
323 The expression tree T represents a data member initialization
324 in a (constexpr) constructor definition. Build a pairing of
325 the data member with its initializer, and prepend that pair
326 to the existing initialization pair INITS. */
329 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
332 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
333 t
= TREE_OPERAND (t
, 0);
334 if (TREE_CODE (t
) == EXPR_STMT
)
335 t
= TREE_OPERAND (t
, 0);
336 if (t
== error_mark_node
)
338 if (TREE_CODE (t
) == STATEMENT_LIST
)
340 tree_stmt_iterator i
;
341 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
343 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
348 if (TREE_CODE (t
) == CLEANUP_STMT
)
350 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
351 but we can in a constexpr constructor for a non-literal class. Just
352 ignore it; either all the initialization will be constant, in which
353 case the cleanup can't run, or it can't be constexpr.
354 Still recurse into CLEANUP_BODY. */
355 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
357 if (TREE_CODE (t
) == CONVERT_EXPR
)
358 t
= TREE_OPERAND (t
, 0);
359 if (TREE_CODE (t
) == INIT_EXPR
360 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
361 use what this function builds for cx_check_missing_mem_inits, and
362 assignment in the ctor body doesn't count. */
363 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
365 member
= TREE_OPERAND (t
, 0);
366 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
368 else if (TREE_CODE (t
) == CALL_EXPR
)
370 tree fn
= get_callee_fndecl (t
);
371 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
372 /* We're only interested in calls to subobject constructors. */
374 member
= CALL_EXPR_ARG (t
, 0);
375 /* We don't use build_cplus_new here because it complains about
376 abstract bases. Leaving the call unwrapped means that it has the
377 wrong type, but cxx_eval_constant_expression doesn't care. */
378 init
= break_out_target_exprs (t
);
380 else if (TREE_CODE (t
) == BIND_EXPR
)
381 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
383 /* Don't add anything else to the CONSTRUCTOR. */
385 if (INDIRECT_REF_P (member
))
386 member
= TREE_OPERAND (member
, 0);
387 if (TREE_CODE (member
) == NOP_EXPR
)
391 if (TREE_CODE (op
) == ADDR_EXPR
)
393 gcc_assert (same_type_ignoring_top_level_qualifiers_p
394 (TREE_TYPE (TREE_TYPE (op
)),
395 TREE_TYPE (TREE_TYPE (member
))));
396 /* Initializing a cv-qualified member; we need to look through
400 else if (op
== current_class_ptr
401 && (same_type_ignoring_top_level_qualifiers_p
402 (TREE_TYPE (TREE_TYPE (member
)),
403 current_class_type
)))
404 /* Delegating constructor. */
408 /* This is an initializer for an empty base; keep it for now so
409 we can check it in cxx_eval_bare_aggregate. */
410 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
413 if (TREE_CODE (member
) == ADDR_EXPR
)
414 member
= TREE_OPERAND (member
, 0);
415 if (TREE_CODE (member
) == COMPONENT_REF
)
417 tree aggr
= TREE_OPERAND (member
, 0);
418 if (TREE_CODE (aggr
) == VAR_DECL
)
419 /* Initializing a local variable, don't add anything. */
421 if (TREE_CODE (aggr
) != COMPONENT_REF
)
422 /* Normal member initialization. */
423 member
= TREE_OPERAND (member
, 1);
424 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
425 /* Initializing a member of an anonymous union. */
426 return build_anon_member_initialization (member
, init
, vec
);
428 /* We're initializing a vtable pointer in a base. Leave it as
429 COMPONENT_REF so we remember the path to get to the vfield. */
430 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
433 /* Value-initialization can produce multiple initializers for the
434 same field; use the last one. */
435 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
436 (*vec
)->last().value
= init
;
438 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
442 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
443 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
444 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
447 check_constexpr_bind_expr_vars (tree t
)
449 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
451 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
452 if (TREE_CODE (var
) == TYPE_DECL
453 && DECL_IMPLICIT_TYPEDEF_P (var
)
454 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
459 /* Subroutine of check_constexpr_ctor_body. */
462 check_constexpr_ctor_body_1 (tree last
, tree list
)
464 switch (TREE_CODE (list
))
467 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
468 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
472 case CLEANUP_POINT_EXPR
:
473 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
477 if (!check_constexpr_bind_expr_vars (list
)
478 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
485 case DEBUG_BEGIN_STMT
:
493 /* Make sure that there are no statements after LAST in the constructor
494 body represented by LIST. */
497 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
499 /* C++14 doesn't require a constexpr ctor to have an empty body. */
500 if (cxx_dialect
>= cxx14
)
504 if (TREE_CODE (list
) == STATEMENT_LIST
)
506 tree_stmt_iterator i
= tsi_last (list
);
507 for (; !tsi_end_p (i
); tsi_prev (&i
))
509 tree t
= tsi_stmt (i
);
512 if (!check_constexpr_ctor_body_1 (last
, t
))
519 else if (list
!= last
520 && !check_constexpr_ctor_body_1 (last
, list
))
525 error ("%<constexpr%> constructor does not have empty body");
526 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
531 /* V is a vector of constructor elements built up for the base and member
532 initializers of a constructor for TYPE. They need to be in increasing
533 offset order, which they might not be yet if TYPE has a primary base
534 which is not first in the base-clause or a vptr and at least one base
535 all of which are non-primary. */
537 static vec
<constructor_elt
, va_gc
> *
538 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
540 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
546 field_type
= BINFO_TYPE (pri
);
547 else if (TYPE_CONTAINS_VPTR_P (type
))
548 field_type
= vtbl_ptr_type_node
;
552 /* Find the element for the primary base or vptr and move it to the
553 beginning of the vec. */
554 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
555 if (TREE_TYPE (ce
->index
) == field_type
)
558 if (i
> 0 && i
< vec_safe_length (v
))
560 vec
<constructor_elt
, va_gc
> &vref
= *v
;
561 constructor_elt elt
= vref
[i
];
570 /* Build compile-time evalable representations of member-initializer list
571 for a constexpr constructor. */
574 build_constexpr_constructor_member_initializers (tree type
, tree body
)
576 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
579 switch (TREE_CODE (body
))
581 case MUST_NOT_THROW_EXPR
:
583 body
= TREE_OPERAND (body
, 0);
587 for (tree_stmt_iterator i
= tsi_start (body
);
588 !tsi_end_p (i
); tsi_next (&i
))
591 if (TREE_CODE (body
) == BIND_EXPR
)
597 body
= BIND_EXPR_BODY (body
);
604 if (TREE_CODE (body
) == TRY_BLOCK
)
606 body
= TREE_OPERAND (body
, 0);
607 if (TREE_CODE (body
) == BIND_EXPR
)
608 body
= BIND_EXPR_BODY (body
);
610 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
612 body
= TREE_OPERAND (body
, 0);
613 if (TREE_CODE (body
) == EXPR_STMT
)
614 body
= TREE_OPERAND (body
, 0);
615 if (TREE_CODE (body
) == INIT_EXPR
616 && (same_type_ignoring_top_level_qualifiers_p
617 (TREE_TYPE (TREE_OPERAND (body
, 0)),
618 current_class_type
)))
621 return TREE_OPERAND (body
, 1);
623 ok
= build_data_member_initialization (body
, &vec
);
625 else if (TREE_CODE (body
) == STATEMENT_LIST
)
627 tree_stmt_iterator i
;
628 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
630 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
635 else if (EXPR_P (body
))
636 ok
= build_data_member_initialization (body
, &vec
);
638 gcc_assert (errorcount
> 0);
641 if (vec_safe_length (vec
) > 0)
643 /* In a delegating constructor, return the target. */
644 constructor_elt
*ce
= &(*vec
)[0];
645 if (ce
->index
== current_class_ptr
)
652 vec
= sort_constexpr_mem_initializers (type
, vec
);
653 return build_constructor (type
, vec
);
656 return error_mark_node
;
659 /* We have an expression tree T that represents a call, either CALL_EXPR
660 or AGGR_INIT_EXPR. If the call is lexically to a named function,
661 retrun the _DECL for that function. */
664 get_function_named_in_call (tree t
)
666 tree fun
= cp_get_callee (t
);
667 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
668 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
669 fun
= TREE_OPERAND (fun
, 0);
673 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
674 declared to be constexpr, or a sub-statement thereof. Returns the
675 return value if suitable, error_mark_node for a statement not allowed in
676 a constexpr function, or NULL_TREE if no return value was found. */
679 constexpr_fn_retval (tree body
)
681 switch (TREE_CODE (body
))
685 tree_stmt_iterator i
;
686 tree expr
= NULL_TREE
;
687 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
689 tree s
= constexpr_fn_retval (tsi_stmt (i
));
690 if (s
== error_mark_node
)
691 return error_mark_node
;
692 else if (s
== NULL_TREE
)
693 /* Keep iterating. */;
695 /* Multiple return statements. */
696 return error_mark_node
;
704 return break_out_target_exprs (TREE_OPERAND (body
, 0));
708 tree decl
= DECL_EXPR_DECL (body
);
709 if (TREE_CODE (decl
) == USING_DECL
710 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
711 || DECL_ARTIFICIAL (decl
))
713 return error_mark_node
;
716 case CLEANUP_POINT_EXPR
:
717 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
720 if (!check_constexpr_bind_expr_vars (body
))
721 return error_mark_node
;
722 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
725 case DEBUG_BEGIN_STMT
:
730 tree fun
= get_function_named_in_call (body
);
732 && fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
))
738 return error_mark_node
;
742 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
743 FUN; do the necessary transformations to turn it into a single expression
744 that we can store in the hash table. */
747 massage_constexpr_body (tree fun
, tree body
)
749 if (DECL_CONSTRUCTOR_P (fun
))
750 body
= build_constexpr_constructor_member_initializers
751 (DECL_CONTEXT (fun
), body
);
752 else if (cxx_dialect
< cxx14
)
754 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
755 body
= EH_SPEC_STMTS (body
);
756 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
757 body
= TREE_OPERAND (body
, 0);
758 body
= constexpr_fn_retval (body
);
763 /* CTYPE is a type constructed from BODY. Return true if some
764 bases/fields are uninitialized, and complain if COMPLAIN. */
767 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
773 if (TREE_CODE (body
) != CONSTRUCTOR
)
775 nelts
= CONSTRUCTOR_NELTS (body
);
777 tree field
= TYPE_FIELDS (ctype
);
779 if (TREE_CODE (ctype
) == UNION_TYPE
)
781 if (nelts
== 0 && next_initializable_field (field
))
784 error ("%<constexpr%> constructor for union %qT must "
785 "initialize exactly one non-static data member", ctype
);
791 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
792 need an explicit initialization. */
794 for (unsigned i
= 0; i
<= nelts
; ++i
)
796 tree index
= NULL_TREE
;
799 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
800 /* Skip base and vtable inits. */
801 if (TREE_CODE (index
) != FIELD_DECL
802 || DECL_ARTIFICIAL (index
))
806 for (; field
!= index
; field
= DECL_CHAIN (field
))
809 if (TREE_CODE (field
) != FIELD_DECL
)
811 if (DECL_UNNAMED_BIT_FIELD (field
))
813 if (DECL_ARTIFICIAL (field
))
815 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
817 /* Recurse to check the anonummous aggregate member. */
818 bad
|= cx_check_missing_mem_inits
819 (TREE_TYPE (field
), NULL_TREE
, complain
);
820 if (bad
&& !complain
)
824 ftype
= strip_array_types (TREE_TYPE (field
));
825 if (type_has_constexpr_default_constructor (ftype
))
827 /* It's OK to skip a member with a trivial constexpr ctor.
828 A constexpr ctor that isn't trivial should have been
830 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
836 auto_diagnostic_group d
;
837 error ("member %qD must be initialized by mem-initializer "
838 "in %<constexpr%> constructor", field
);
839 inform (DECL_SOURCE_LOCATION (field
), "declared here");
842 if (field
== NULL_TREE
)
845 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
847 /* Check the anonymous aggregate initializer is valid. */
848 bad
|= cx_check_missing_mem_inits
849 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
850 if (bad
&& !complain
)
853 field
= DECL_CHAIN (field
);
859 /* We are processing the definition of the constexpr function FUN.
860 Check that its BODY fulfills the propriate requirements and
861 enter it in the constexpr function definition table.
862 For constructor BODY is actually the TREE_LIST of the
863 member-initializer list. */
866 register_constexpr_fundef (tree fun
, tree body
)
868 constexpr_fundef entry
;
869 constexpr_fundef
**slot
;
871 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
874 tree massaged
= massage_constexpr_body (fun
, body
);
875 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
877 if (!DECL_CONSTRUCTOR_P (fun
))
878 error ("body of %<constexpr%> function %qD not a return-statement",
883 if (!potential_rvalue_constant_expression (massaged
))
885 if (!DECL_GENERATED_P (fun
))
886 require_potential_rvalue_constant_expression (massaged
);
890 if (DECL_CONSTRUCTOR_P (fun
)
891 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
892 massaged
, !DECL_GENERATED_P (fun
)))
895 /* Create the constexpr function table if necessary. */
896 if (constexpr_fundef_table
== NULL
)
897 constexpr_fundef_table
898 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
901 tree saved_fn
= current_function_decl
;
902 bool clear_ctx
= false;
903 current_function_decl
= fun
;
904 if (DECL_RESULT (fun
) && DECL_CONTEXT (DECL_RESULT (fun
)) == NULL_TREE
)
907 DECL_CONTEXT (DECL_RESULT (fun
)) = fun
;
909 entry
.body
= copy_fn (fun
, entry
.parms
, entry
.result
);
910 current_function_decl
= saved_fn
;
911 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
913 DECL_CONTEXT (DECL_RESULT (fun
)) = NULL_TREE
;
915 gcc_assert (*slot
== NULL
);
916 *slot
= ggc_alloc
<constexpr_fundef
> ();
922 /* FUN is a non-constexpr function called in a context that requires a
923 constant expression. If it comes from a constexpr template, explain why
924 the instantiation isn't constexpr. */
927 explain_invalid_constexpr_fn (tree fun
)
929 static hash_set
<tree
> *diagnosed
;
932 /* Only diagnose defaulted functions, lambdas, or instantiations. */
933 if (!DECL_DEFAULTED_FN (fun
)
934 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
935 && !is_instantiation_of_constexpr (fun
))
937 if (diagnosed
== NULL
)
938 diagnosed
= new hash_set
<tree
>;
939 if (diagnosed
->add (fun
))
940 /* Already explained. */
943 save_loc
= input_location
;
944 if (!lambda_static_thunk_p (fun
))
946 /* Diagnostics should completely ignore the static thunk, so leave
947 input_location set to our caller's location. */
948 input_location
= DECL_SOURCE_LOCATION (fun
);
949 inform (input_location
,
950 "%qD is not usable as a %<constexpr%> function because:", fun
);
952 /* First check the declaration. */
953 if (is_valid_constexpr_fn (fun
, true))
955 /* Then if it's OK, the body. */
956 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
957 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
958 explain_implicit_non_constexpr (fun
);
961 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
962 require_potential_rvalue_constant_expression (body
);
963 if (DECL_CONSTRUCTOR_P (fun
))
964 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
967 input_location
= save_loc
;
970 /* Objects of this type represent calls to constexpr functions
971 along with the bindings of parameters to their arguments, for
972 the purpose of compile time evaluation. */
974 struct GTY((for_user
)) constexpr_call
{
975 /* Description of the constexpr function definition. */
976 constexpr_fundef
*fundef
;
977 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
978 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
979 Note: This arrangement is made to accommodate the use of
980 iterative_hash_template_arg (see pt.c). If you change this
981 representation, also change the hash calculation in
982 cxx_eval_call_expression. */
984 /* Result of the call.
985 NULL means the call is being evaluated.
986 error_mark_node means that the evaluation was erroneous;
987 otherwise, the actuall value of the call. */
989 /* The hash of this call; we remember it here to avoid having to
990 recalculate it when expanding the hash table. */
992 /* Whether __builtin_is_constant_evaluated() should evaluate to true. */
993 bool manifestly_const_eval
;
996 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
998 static hashval_t
hash (constexpr_call
*);
999 static bool equal (constexpr_call
*, constexpr_call
*);
1002 enum constexpr_switch_state
{
1003 /* Used when processing a switch for the first time by cxx_eval_switch_expr
1004 and default: label for that switch has not been seen yet. */
1005 css_default_not_seen
,
1006 /* Used when processing a switch for the first time by cxx_eval_switch_expr
1007 and default: label for that switch has been seen already. */
1009 /* Used when processing a switch for the second time by
1010 cxx_eval_switch_expr, where default: label should match. */
1011 css_default_processing
1014 /* The constexpr expansion context. CALL is the current function
1015 expansion, CTOR is the current aggregate initializer, OBJECT is the
1016 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
1017 is a map of values of variables initialized within the expression. */
1019 struct constexpr_ctx
{
1020 /* The innermost call we're evaluating. */
1021 constexpr_call
*call
;
1022 /* Values for any temporaries or local variables within the
1023 constant-expression. */
1024 hash_map
<tree
,tree
> *values
;
1025 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
1026 aren't inside a loop. */
1027 hash_set
<tree
> *save_exprs
;
1028 /* The CONSTRUCTOR we're currently building up for an aggregate
1031 /* The object we're building the CONSTRUCTOR for. */
1033 /* If inside SWITCH_EXPR. */
1034 constexpr_switch_state
*css_state
;
1035 /* Whether we should error on a non-constant expression or fail quietly. */
1037 /* Whether we are strictly conforming to constant expression rules or
1038 trying harder to get a constant value. */
1040 /* Whether __builtin_is_constant_evaluated () should be true. */
1041 bool manifestly_const_eval
;
1044 /* A table of all constexpr calls that have been evaluated by the
1045 compiler in this translation unit. */
1047 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1049 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1050 bool, bool *, bool *, tree
* = NULL
);
1052 /* Compute a hash value for a constexpr call representation. */
1055 constexpr_call_hasher::hash (constexpr_call
*info
)
1060 /* Return true if the objects pointed to by P and Q represent calls
1061 to the same constexpr function with the same arguments.
1062 Otherwise, return false. */
1065 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1071 if (lhs
->hash
!= rhs
->hash
)
1073 if (lhs
->manifestly_const_eval
!= rhs
->manifestly_const_eval
)
1075 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1077 lhs_bindings
= lhs
->bindings
;
1078 rhs_bindings
= rhs
->bindings
;
1079 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1081 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1082 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1083 gcc_assert (same_type_p (TREE_TYPE (lhs_arg
), TREE_TYPE (rhs_arg
)));
1084 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1086 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1087 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1089 return lhs_bindings
== rhs_bindings
;
1092 /* Initialize the constexpr call table, if needed. */
1095 maybe_initialize_constexpr_call_table (void)
1097 if (constexpr_call_table
== NULL
)
1098 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1101 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1102 a function happens to get called recursively, we unshare the callee
1103 function's body and evaluate this unshared copy instead of evaluating the
1106 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1107 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1108 that's keyed off of the original FUNCTION_DECL and whose value is a
1109 TREE_LIST of this function's unused copies awaiting reuse.
1111 This is not GC-deletable to avoid GC affecting UID generation. */
1113 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1115 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1118 maybe_initialize_fundef_copies_table ()
1120 if (fundef_copies_table
== NULL
)
1121 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1124 /* Reuse a copy or create a new unshared copy of the function FUN.
1125 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1126 is parms, TYPE is result. */
1129 get_fundef_copy (constexpr_fundef
*fundef
)
1131 maybe_initialize_fundef_copies_table ();
1135 tree
*slot
= &fundef_copies_table
->get_or_insert (fundef
->decl
, &existed
);
1139 /* There is no cached function available, or in use. We can use
1140 the function directly. That the slot is now created records
1141 that this function is now in use. */
1142 copy
= build_tree_list (fundef
->body
, fundef
->parms
);
1143 TREE_TYPE (copy
) = fundef
->result
;
1145 else if (*slot
== NULL_TREE
)
1147 /* We've already used the function itself, so make a copy. */
1148 copy
= build_tree_list (NULL
, NULL
);
1149 tree saved_body
= DECL_SAVED_TREE (fundef
->decl
);
1150 tree saved_parms
= DECL_ARGUMENTS (fundef
->decl
);
1151 tree saved_result
= DECL_RESULT (fundef
->decl
);
1152 tree saved_fn
= current_function_decl
;
1153 DECL_SAVED_TREE (fundef
->decl
) = fundef
->body
;
1154 DECL_ARGUMENTS (fundef
->decl
) = fundef
->parms
;
1155 DECL_RESULT (fundef
->decl
) = fundef
->result
;
1156 current_function_decl
= fundef
->decl
;
1157 TREE_PURPOSE (copy
) = copy_fn (fundef
->decl
, TREE_VALUE (copy
),
1159 current_function_decl
= saved_fn
;
1160 DECL_RESULT (fundef
->decl
) = saved_result
;
1161 DECL_ARGUMENTS (fundef
->decl
) = saved_parms
;
1162 DECL_SAVED_TREE (fundef
->decl
) = saved_body
;
1166 /* We have a cached function available. */
1168 *slot
= TREE_CHAIN (copy
);
1174 /* Save the copy COPY of function FUN for later reuse by
1175 get_fundef_copy(). By construction, there will always be an entry
1179 save_fundef_copy (tree fun
, tree copy
)
1181 tree
*slot
= fundef_copies_table
->get (fun
);
1182 TREE_CHAIN (copy
) = *slot
;
1186 /* We have an expression tree T that represents a call, either CALL_EXPR
1187 or AGGR_INIT_EXPR. Return the Nth argument. */
1190 get_nth_callarg (tree t
, int n
)
1192 switch (TREE_CODE (t
))
1195 return CALL_EXPR_ARG (t
, n
);
1197 case AGGR_INIT_EXPR
:
1198 return AGGR_INIT_EXPR_ARG (t
, n
);
1206 /* Attempt to evaluate T which represents a call to a builtin function.
1207 We assume here that all builtin functions evaluate to scalar types
1208 represented by _CST nodes. */
1211 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1213 bool *non_constant_p
, bool *overflow_p
)
1215 const int nargs
= call_expr_nargs (t
);
1216 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1220 /* Don't fold __builtin_constant_p within a constexpr function. */
1221 bool bi_const_p
= DECL_IS_BUILTIN_CONSTANT_P (fun
);
1223 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1224 in a constexpr function until we have values for the parameters. */
1226 && !ctx
->manifestly_const_eval
1227 && current_function_decl
1228 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1230 *non_constant_p
= true;
1234 /* For __builtin_is_constant_evaluated, defer it if not
1235 ctx->manifestly_const_eval, otherwise fold it to true. */
1236 if (fndecl_built_in_p (fun
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
1239 if (!ctx
->manifestly_const_eval
)
1241 *non_constant_p
= true;
1244 return boolean_true_node
;
1247 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1248 return constant false for a non-constant argument. */
1249 constexpr_ctx new_ctx
= *ctx
;
1250 new_ctx
.quiet
= true;
1251 for (i
= 0; i
< nargs
; ++i
)
1253 args
[i
] = CALL_EXPR_ARG (t
, i
);
1254 /* If builtin_valid_in_constant_expr_p is true,
1255 potential_constant_expression_1 has not recursed into the arguments
1256 of the builtin, verify it here. */
1257 if (!builtin_valid_in_constant_expr_p (fun
)
1258 || potential_constant_expression (args
[i
]))
1260 bool dummy1
= false, dummy2
= false;
1261 args
[i
] = cxx_eval_constant_expression (&new_ctx
, args
[i
], false,
1266 /* For __builtin_constant_p, fold all expressions with constant values
1267 even if they aren't C++ constant-expressions. */
1268 args
[i
] = cp_fold_rvalue (args
[i
]);
1271 bool save_ffbcp
= force_folding_builtin_constant_p
;
1272 force_folding_builtin_constant_p
= true;
1273 tree save_cur_fn
= current_function_decl
;
1274 /* Return name of ctx->call->fundef->decl for __builtin_FUNCTION (). */
1275 if (fndecl_built_in_p (fun
, BUILT_IN_FUNCTION
)
1277 && ctx
->call
->fundef
)
1278 current_function_decl
= ctx
->call
->fundef
->decl
;
1279 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1280 CALL_EXPR_FN (t
), nargs
, args
);
1281 current_function_decl
= save_cur_fn
;
1282 force_folding_builtin_constant_p
= save_ffbcp
;
1283 if (new_call
== NULL
)
1285 if (!*non_constant_p
&& !ctx
->quiet
)
1287 /* Do not allow__builtin_unreachable in constexpr function.
1288 The __builtin_unreachable call with BUILTINS_LOCATION
1289 comes from cp_maybe_instrument_return. */
1290 if (fndecl_built_in_p (fun
, BUILT_IN_UNREACHABLE
)
1291 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1292 error ("%<constexpr%> call flows off the end of the function");
1295 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1296 CALL_EXPR_FN (t
), nargs
, args
);
1297 error ("%q+E is not a constant expression", new_call
);
1300 *non_constant_p
= true;
1304 if (!potential_constant_expression (new_call
))
1306 if (!*non_constant_p
&& !ctx
->quiet
)
1307 error ("%q+E is not a constant expression", new_call
);
1308 *non_constant_p
= true;
1312 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1313 non_constant_p
, overflow_p
);
1316 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1317 the type of the value to match. */
1320 adjust_temp_type (tree type
, tree temp
)
1322 if (same_type_p (TREE_TYPE (temp
), type
))
1324 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1325 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1327 /* build_constructor wouldn't retain various CONSTRUCTOR flags. */
1328 tree t
= copy_node (temp
);
1329 TREE_TYPE (t
) = type
;
1332 if (TREE_CODE (temp
) == EMPTY_CLASS_EXPR
)
1333 return build0 (EMPTY_CLASS_EXPR
, type
);
1334 gcc_assert (scalarish_type_p (type
));
1335 return cp_fold_convert (type
, temp
);
1338 /* Callback for walk_tree used by unshare_constructor. */
1341 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1345 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1350 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1351 subexpression, return an unshared copy of T. Otherwise return T. */
1354 unshare_constructor (tree t
)
1356 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1357 if (ctor
!= NULL_TREE
)
1358 return unshare_expr (t
);
1362 /* Subroutine of cxx_eval_call_expression.
1363 We are processing a call expression (either CALL_EXPR or
1364 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1365 all arguments and bind their values to correspondings
1366 parameters, making up the NEW_CALL context. */
1369 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1370 constexpr_call
*new_call
,
1371 bool *non_constant_p
, bool *overflow_p
,
1372 bool *non_constant_args
)
1374 const int nargs
= call_expr_nargs (t
);
1375 tree fun
= new_call
->fundef
->decl
;
1376 tree parms
= new_call
->fundef
->parms
;
1378 tree
*p
= &new_call
->bindings
;
1379 for (i
= 0; i
< nargs
; ++i
)
1382 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1383 x
= get_nth_callarg (t
, i
);
1384 /* For member function, the first argument is a pointer to the implied
1385 object. For a constructor, it might still be a dummy object, in
1386 which case we get the real argument from ctx. */
1387 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1388 && is_dummy_object (x
))
1391 x
= build_address (x
);
1393 if (TREE_ADDRESSABLE (type
))
1394 /* Undo convert_for_arg_passing work here. */
1395 x
= convert_from_reference (x
);
1396 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1397 non_constant_p
, overflow_p
);
1398 /* Don't VERIFY_CONSTANT here. */
1399 if (*non_constant_p
&& ctx
->quiet
)
1401 /* Just discard ellipsis args after checking their constantitude. */
1405 if (!*non_constant_p
)
1407 /* Don't share a CONSTRUCTOR that might be changed. */
1408 arg
= unshare_constructor (arg
);
1409 /* Make sure the binding has the same type as the parm. But
1410 only for constant args. */
1411 if (!TYPE_REF_P (type
))
1412 arg
= adjust_temp_type (type
, arg
);
1413 if (!TREE_CONSTANT (arg
))
1414 *non_constant_args
= true;
1415 *p
= build_tree_list (parms
, arg
);
1416 p
= &TREE_CHAIN (*p
);
1418 parms
= TREE_CHAIN (parms
);
1422 /* Variables and functions to manage constexpr call expansion context.
1423 These do not need to be marked for PCH or GC. */
1425 /* FIXME remember and print actual constant arguments. */
1426 static vec
<tree
> call_stack
;
1427 static int call_stack_tick
;
1428 static int last_cx_error_tick
;
1431 push_cx_call_context (tree call
)
1434 if (!EXPR_HAS_LOCATION (call
))
1435 SET_EXPR_LOCATION (call
, input_location
);
1436 call_stack
.safe_push (call
);
1437 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1443 pop_cx_call_context (void)
1450 cx_error_context (void)
1452 vec
<tree
> r
= vNULL
;
1453 if (call_stack_tick
!= last_cx_error_tick
1454 && !call_stack
.is_empty ())
1456 last_cx_error_tick
= call_stack_tick
;
1460 /* Evaluate a call T to a GCC internal function when possible and return
1461 the evaluated result or, under the control of CTX, give an error, set
1462 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1465 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1467 bool *non_constant_p
, bool *overflow_p
)
1469 enum tree_code opcode
= ERROR_MARK
;
1471 switch (CALL_EXPR_IFN (t
))
1473 case IFN_UBSAN_NULL
:
1474 case IFN_UBSAN_BOUNDS
:
1475 case IFN_UBSAN_VPTR
:
1476 case IFN_FALLTHROUGH
:
1479 case IFN_ADD_OVERFLOW
:
1482 case IFN_SUB_OVERFLOW
:
1483 opcode
= MINUS_EXPR
;
1485 case IFN_MUL_OVERFLOW
:
1490 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1491 false, non_constant_p
, overflow_p
);
1493 case IFN_VEC_CONVERT
:
1495 tree arg
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1496 false, non_constant_p
,
1498 if (TREE_CODE (arg
) == VECTOR_CST
)
1499 return fold_const_call (CFN_VEC_CONVERT
, TREE_TYPE (t
), arg
);
1502 *non_constant_p
= true;
1509 error_at (cp_expr_loc_or_loc (t
, input_location
),
1510 "call to internal function %qE", t
);
1511 *non_constant_p
= true;
1515 /* Evaluate constant arguments using OPCODE and return a complex
1516 number containing the result and the overflow bit. */
1517 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1518 non_constant_p
, overflow_p
);
1519 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1520 non_constant_p
, overflow_p
);
1522 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1524 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1525 tree type
= TREE_TYPE (TREE_TYPE (t
));
1526 tree result
= fold_binary_loc (loc
, opcode
, type
,
1527 fold_convert_loc (loc
, type
, arg0
),
1528 fold_convert_loc (loc
, type
, arg1
));
1530 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1531 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1532 if (TREE_OVERFLOW (result
))
1533 TREE_OVERFLOW (result
) = 0;
1535 return build_complex (TREE_TYPE (t
), result
, ovf
);
1538 *non_constant_p
= true;
1542 /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */
1545 clear_no_implicit_zero (tree ctor
)
1547 if (CONSTRUCTOR_NO_CLEARING (ctor
))
1549 CONSTRUCTOR_NO_CLEARING (ctor
) = false;
1550 tree elt
; unsigned HOST_WIDE_INT idx
;
1551 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1552 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1553 clear_no_implicit_zero (elt
);
1557 /* Subroutine of cxx_eval_constant_expression.
1558 Evaluate the call expression tree T in the context of OLD_CALL expression
1562 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1564 bool *non_constant_p
, bool *overflow_p
)
1566 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
1567 tree fun
= get_function_named_in_call (t
);
1568 constexpr_call new_call
1569 = { NULL
, NULL
, NULL
, 0, ctx
->manifestly_const_eval
};
1572 if (fun
== NULL_TREE
)
1573 return cxx_eval_internal_function (ctx
, t
, lval
,
1574 non_constant_p
, overflow_p
);
1576 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1578 /* Might be a constexpr function pointer. */
1579 fun
= cxx_eval_constant_expression (ctx
, fun
,
1580 /*lval*/false, non_constant_p
,
1583 if (TREE_CODE (fun
) == ADDR_EXPR
)
1584 fun
= TREE_OPERAND (fun
, 0);
1585 /* For TARGET_VTABLE_USES_DESCRIPTORS targets, there is no
1586 indirection, the called expression is a pointer into the
1587 virtual table which should contain FDESC_EXPR. Extract the
1588 FUNCTION_DECL from there. */
1589 else if (TARGET_VTABLE_USES_DESCRIPTORS
1590 && TREE_CODE (fun
) == POINTER_PLUS_EXPR
1591 && TREE_CODE (TREE_OPERAND (fun
, 0)) == ADDR_EXPR
1592 && TREE_CODE (TREE_OPERAND (fun
, 1)) == INTEGER_CST
)
1594 tree d
= TREE_OPERAND (TREE_OPERAND (fun
, 0), 0);
1596 && DECL_VTABLE_OR_VTT_P (d
)
1597 && TREE_CODE (TREE_TYPE (d
)) == ARRAY_TYPE
1598 && TREE_TYPE (TREE_TYPE (d
)) == vtable_entry_type
1600 && TREE_CODE (DECL_INITIAL (d
)) == CONSTRUCTOR
)
1602 tree i
= int_const_binop (TRUNC_DIV_EXPR
, TREE_OPERAND (fun
, 1),
1603 TYPE_SIZE_UNIT (vtable_entry_type
));
1604 HOST_WIDE_INT idx
= find_array_ctor_elt (DECL_INITIAL (d
), i
);
1608 = (*CONSTRUCTOR_ELTS (DECL_INITIAL (d
)))[idx
].value
;
1609 if (TREE_CODE (fdesc
) == FDESC_EXPR
1610 && integer_zerop (TREE_OPERAND (fdesc
, 1)))
1611 fun
= TREE_OPERAND (fdesc
, 0);
1616 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1618 if (!ctx
->quiet
&& !*non_constant_p
)
1619 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1621 *non_constant_p
= true;
1624 if (DECL_CLONED_FUNCTION_P (fun
))
1625 fun
= DECL_CLONED_FUNCTION (fun
);
1627 if (is_ubsan_builtin_p (fun
))
1630 if (fndecl_built_in_p (fun
))
1631 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1632 lval
, non_constant_p
, overflow_p
);
1633 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1637 if (!lambda_static_thunk_p (fun
))
1638 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1639 explain_invalid_constexpr_fn (fun
);
1641 *non_constant_p
= true;
1645 constexpr_ctx new_ctx
= *ctx
;
1646 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1647 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1649 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1650 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1651 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1652 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1653 CONSTRUCTOR_NO_CLEARING (ctor
) = true;
1654 ctx
->values
->put (new_ctx
.object
, ctor
);
1658 /* Shortcut trivial constructor/op=. */
1659 if (trivial_fn_p (fun
))
1661 tree init
= NULL_TREE
;
1662 if (call_expr_nargs (t
) == 2)
1663 init
= convert_from_reference (get_nth_callarg (t
, 1));
1664 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1665 && AGGR_INIT_ZERO_FIRST (t
))
1666 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1669 tree op
= get_nth_callarg (t
, 0);
1670 if (is_dummy_object (op
))
1673 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1674 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1675 new_ctx
.call
= &new_call
;
1676 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1677 non_constant_p
, overflow_p
);
1681 /* We can't defer instantiating the function any longer. */
1682 if (!DECL_INITIAL (fun
)
1683 && DECL_TEMPLOID_INSTANTIATION (fun
))
1685 location_t save_loc
= input_location
;
1686 input_location
= loc
;
1688 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1690 input_location
= save_loc
;
1693 /* If in direct recursive call, optimize definition search. */
1694 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1695 new_call
.fundef
= ctx
->call
->fundef
;
1698 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1699 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1700 || fun
== current_function_decl
)
1704 /* We need to check for current_function_decl here in case we're
1705 being called during cp_fold_function, because at that point
1706 DECL_INITIAL is set properly and we have a fundef but we
1707 haven't lowered invisirefs yet (c++/70344). */
1708 if (DECL_INITIAL (fun
) == error_mark_node
1709 || fun
== current_function_decl
)
1710 error_at (loc
, "%qD called in a constant expression before its "
1711 "definition is complete", fun
);
1712 else if (DECL_INITIAL (fun
))
1714 /* The definition of fun was somehow unsuitable. But pretend
1715 that lambda static thunks don't exist. */
1716 if (!lambda_static_thunk_p (fun
))
1717 error_at (loc
, "%qD called in a constant expression", fun
);
1718 explain_invalid_constexpr_fn (fun
);
1721 error_at (loc
, "%qD used before its definition", fun
);
1723 *non_constant_p
= true;
1728 bool non_constant_args
= false;
1729 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1730 non_constant_p
, overflow_p
, &non_constant_args
);
1731 if (*non_constant_p
)
1734 depth_ok
= push_cx_call_context (t
);
1736 tree result
= NULL_TREE
;
1738 constexpr_call
*entry
= NULL
;
1739 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1741 new_call
.hash
= constexpr_fundef_hasher::hash (new_call
.fundef
);
1743 = iterative_hash_template_arg (new_call
.bindings
, new_call
.hash
);
1745 = iterative_hash_object (ctx
->manifestly_const_eval
, new_call
.hash
);
1747 /* If we have seen this call before, we are done. */
1748 maybe_initialize_constexpr_call_table ();
1749 constexpr_call
**slot
1750 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1754 /* We need to keep a pointer to the entry, not just the slot, as the
1755 slot can move in the call to cxx_eval_builtin_function_call. */
1756 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1759 /* Calls that are in progress have their result set to NULL,
1760 so that we can detect circular dependencies. */
1761 else if (entry
->result
== NULL
)
1764 error ("call has circular dependency");
1765 *non_constant_p
= true;
1766 entry
->result
= result
= error_mark_node
;
1769 result
= entry
->result
;
1775 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1776 "%<-fconstexpr-depth=%> to increase the maximum)",
1777 max_constexpr_depth
);
1778 *non_constant_p
= true;
1779 result
= error_mark_node
;
1783 if (result
&& result
!= error_mark_node
)
1785 else if (!DECL_SAVED_TREE (fun
))
1787 /* When at_eof >= 2, cgraph has started throwing away
1788 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1789 late code generation for VEC_INIT_EXPR, which needs to be
1790 completely reconsidered. */
1791 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1792 *non_constant_p
= true;
1796 tree body
, parms
, res
;
1798 /* Reuse or create a new unshared copy of this function's body. */
1799 tree copy
= get_fundef_copy (new_call
.fundef
);
1800 body
= TREE_PURPOSE (copy
);
1801 parms
= TREE_VALUE (copy
);
1802 res
= TREE_TYPE (copy
);
1804 /* Associate the bindings with the remapped parms. */
1805 tree bound
= new_call
.bindings
;
1806 tree remapped
= parms
;
1809 tree oparm
= TREE_PURPOSE (bound
);
1810 tree arg
= TREE_VALUE (bound
);
1811 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1812 /* Don't share a CONSTRUCTOR that might be changed. */
1813 arg
= unshare_constructor (arg
);
1814 ctx
->values
->put (remapped
, arg
);
1815 bound
= TREE_CHAIN (bound
);
1816 remapped
= DECL_CHAIN (remapped
);
1818 /* Add the RESULT_DECL to the values map, too. */
1819 tree slot
= NULL_TREE
;
1820 if (DECL_BY_REFERENCE (res
))
1822 slot
= AGGR_INIT_EXPR_SLOT (t
);
1823 tree addr
= build_address (slot
);
1824 addr
= build_nop (TREE_TYPE (res
), addr
);
1825 ctx
->values
->put (res
, addr
);
1826 ctx
->values
->put (slot
, NULL_TREE
);
1829 ctx
->values
->put (res
, NULL_TREE
);
1831 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1832 their values after the call. */
1833 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1834 hash_set
<tree
> save_exprs
;
1835 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1836 ctx_with_save_exprs
.call
= &new_call
;
1838 tree jump_target
= NULL_TREE
;
1839 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1840 lval
, non_constant_p
, overflow_p
,
1843 if (DECL_CONSTRUCTOR_P (fun
))
1844 /* This can be null for a subobject constructor call, in
1845 which case what we care about is the initialization
1846 side-effects rather than the value. We could get at the
1847 value by evaluating *this, but we don't bother; there's
1848 no need to put such a call in the hash table. */
1849 result
= lval
? ctx
->object
: ctx
->ctor
;
1850 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1854 result
= *ctx
->values
->get (slot
? slot
: res
);
1855 if (result
== NULL_TREE
&& !*non_constant_p
)
1858 error ("%<constexpr%> call flows off the end "
1860 *non_constant_p
= true;
1864 /* Forget the saved values of the callee's SAVE_EXPRs. */
1865 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1866 iter
!= save_exprs
.end(); ++iter
)
1867 ctx_with_save_exprs
.values
->remove (*iter
);
1869 /* Remove the parms/result from the values map. Is it worth
1870 bothering to do this when the map itself is only live for
1871 one constexpr evaluation? If so, maybe also clear out
1872 other vars from call, maybe in BIND_EXPR handling? */
1873 ctx
->values
->remove (res
);
1875 ctx
->values
->remove (slot
);
1876 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1877 ctx
->values
->remove (parm
);
1879 /* Make the unshared function copy we used available for re-use. */
1880 save_fundef_copy (fun
, copy
);
1883 if (result
== error_mark_node
)
1884 *non_constant_p
= true;
1885 if (*non_constant_p
|| *overflow_p
)
1886 result
= error_mark_node
;
1890 entry
->result
= result
;
1893 /* The result of a constexpr function must be completely initialized. */
1894 if (TREE_CODE (result
) == CONSTRUCTOR
)
1895 clear_no_implicit_zero (result
);
1897 pop_cx_call_context ();
1898 return unshare_constructor (result
);
1901 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1904 reduced_constant_expression_p (tree t
)
1909 switch (TREE_CODE (t
))
1912 /* Even if we can't lower this yet, it's constant. */
1916 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1917 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1918 if (CONSTRUCTOR_NO_CLEARING (t
))
1920 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1921 /* An initialized vector would have a VECTOR_CST. */
1924 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1928 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1930 /* If VAL is null, we're in the middle of initializing this
1932 if (!reduced_constant_expression_p (val
))
1938 field
= next_initializable_field (DECL_CHAIN (field
));
1943 else if (CONSTRUCTOR_NO_CLEARING (t
))
1944 /* All the fields are initialized. */
1945 CONSTRUCTOR_NO_CLEARING (t
) = false;
1949 /* FIXME are we calling this too much? */
1950 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1954 /* Some expressions may have constant operands but are not constant
1955 themselves, such as 1/0. Call this function to check for that
1958 We only call this in places that require an arithmetic constant, not in
1959 places where we might have a non-constant expression that can be a
1960 component of a constant expression, such as the address of a constexpr
1961 variable that might be dereferenced later. */
1964 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1967 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1969 if (!allow_non_constant
)
1970 error ("%q+E is not a constant expression", t
);
1971 *non_constant_p
= true;
1973 if (TREE_OVERFLOW_P (t
))
1975 if (!allow_non_constant
)
1977 permerror (input_location
, "overflow in constant expression");
1978 /* If we're being permissive (and are in an enforcing
1979 context), ignore the overflow. */
1980 if (flag_permissive
)
1981 return *non_constant_p
;
1985 return *non_constant_p
;
1988 /* Check whether the shift operation with code CODE and type TYPE on LHS
1989 and RHS is undefined. If it is, give an error with an explanation,
1990 and return true; return false otherwise. */
1993 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1994 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1996 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1997 || TREE_CODE (lhs
) != INTEGER_CST
1998 || TREE_CODE (rhs
) != INTEGER_CST
)
2001 tree lhstype
= TREE_TYPE (lhs
);
2002 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
2004 /* [expr.shift] The behavior is undefined if the right operand
2005 is negative, or greater than or equal to the length in bits
2006 of the promoted left operand. */
2007 if (tree_int_cst_sgn (rhs
) == -1)
2010 permerror (loc
, "right operand of shift expression %q+E is negative",
2011 build2_loc (loc
, code
, type
, lhs
, rhs
));
2012 return (!flag_permissive
|| ctx
->quiet
);
2014 if (compare_tree_int (rhs
, uprec
) >= 0)
2017 permerror (loc
, "right operand of shift expression %q+E is >= than "
2018 "the precision of the left operand",
2019 build2_loc (loc
, code
, type
, lhs
, rhs
));
2020 return (!flag_permissive
|| ctx
->quiet
);
2023 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
2024 if E1 has a signed type and non-negative value, and E1x2^E2 is
2025 representable in the corresponding unsigned type of the result type,
2026 then that value, converted to the result type, is the resulting value;
2027 otherwise, the behavior is undefined.
2029 The value of E1 << E2 is the unique value congruent to E1 x 2^E2 modulo
2030 2^N, where N is the range exponent of the type of the result. */
2031 if (code
== LSHIFT_EXPR
2032 && !TYPE_UNSIGNED (lhstype
)
2033 && cxx_dialect
>= cxx11
2034 && cxx_dialect
< cxx2a
)
2036 if (tree_int_cst_sgn (lhs
) == -1)
2040 "left operand of shift expression %q+E is negative",
2041 build2_loc (loc
, code
, type
, lhs
, rhs
));
2042 return (!flag_permissive
|| ctx
->quiet
);
2044 /* For signed x << y the following:
2045 (unsigned) x >> ((prec (lhs) - 1) - y)
2046 if > 1, is undefined. The right-hand side of this formula
2047 is the highest bit of the LHS that can be set (starting from 0),
2048 so that the shift doesn't overflow. We then right-shift the LHS
2049 to see whether any other bit is set making the original shift
2050 undefined -- the result is not representable in the corresponding
2052 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
2053 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
2054 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
2055 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
2056 if (tree_int_cst_lt (integer_one_node
, t
))
2059 permerror (loc
, "shift expression %q+E overflows",
2060 build2_loc (loc
, code
, type
, lhs
, rhs
));
2061 return (!flag_permissive
|| ctx
->quiet
);
2067 /* Subroutine of cxx_eval_constant_expression.
2068 Attempt to reduce the unary expression tree T to a compile time value.
2069 If successful, return the value. Otherwise issue a diagnostic
2070 and return error_mark_node. */
2073 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
2075 bool *non_constant_p
, bool *overflow_p
)
2078 tree orig_arg
= TREE_OPERAND (t
, 0);
2079 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
2080 non_constant_p
, overflow_p
);
2081 VERIFY_CONSTANT (arg
);
2082 location_t loc
= EXPR_LOCATION (t
);
2083 enum tree_code code
= TREE_CODE (t
);
2084 tree type
= TREE_TYPE (t
);
2085 r
= fold_unary_loc (loc
, code
, type
, arg
);
2088 if (arg
== orig_arg
)
2091 r
= build1_loc (loc
, code
, type
, arg
);
2093 VERIFY_CONSTANT (r
);
2097 /* Helper function for cxx_eval_binary_expression. Try to optimize
2098 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
2099 generic folding should be used. */
2102 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
2103 tree lhs
, tree rhs
, bool *non_constant_p
,
2107 if (TREE_CODE (lhs
) != ADDR_EXPR
)
2110 lhs
= TREE_OPERAND (lhs
, 0);
2112 /* &A[i] p+ j => &A[i + j] */
2113 if (TREE_CODE (lhs
) == ARRAY_REF
2114 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
2115 && TREE_CODE (rhs
) == INTEGER_CST
2116 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
2117 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
2119 tree orig_type
= TREE_TYPE (t
);
2120 location_t loc
= EXPR_LOCATION (t
);
2121 tree type
= TREE_TYPE (lhs
);
2123 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
2124 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
2125 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2127 if (*non_constant_p
)
2129 /* Don't fold an out-of-bound access. */
2130 if (!tree_int_cst_le (t
, nelts
))
2132 rhs
= cp_fold_convert (ssizetype
, rhs
);
2133 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
2134 constexpr int A[1]; ... (char *)&A[0] + 1 */
2135 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
2136 rhs
, TYPE_SIZE_UNIT (type
))))
2138 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2140 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
2141 TYPE_SIZE_UNIT (type
));
2142 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
2143 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
2144 t
, NULL_TREE
, NULL_TREE
);
2145 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2146 t
= cp_fold_convert (orig_type
, t
);
2147 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
2148 non_constant_p
, overflow_p
);
2154 /* Subroutine of cxx_eval_constant_expression.
2155 Like cxx_eval_unary_expression, except for binary expressions. */
2158 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2160 bool *non_constant_p
, bool *overflow_p
)
2163 tree orig_lhs
= TREE_OPERAND (t
, 0);
2164 tree orig_rhs
= TREE_OPERAND (t
, 1);
2166 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2167 non_constant_p
, overflow_p
);
2168 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2170 if (*non_constant_p
)
2172 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2173 non_constant_p
, overflow_p
);
2174 if (*non_constant_p
)
2177 location_t loc
= EXPR_LOCATION (t
);
2178 enum tree_code code
= TREE_CODE (t
);
2179 tree type
= TREE_TYPE (t
);
2181 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2183 bool is_code_eq
= (code
== EQ_EXPR
);
2185 if (TREE_CODE (lhs
) == PTRMEM_CST
2186 && TREE_CODE (rhs
) == PTRMEM_CST
)
2188 tree lmem
= PTRMEM_CST_MEMBER (lhs
);
2189 tree rmem
= PTRMEM_CST_MEMBER (rhs
);
2191 if (TREE_CODE (lmem
) == TREE_CODE (rmem
)
2192 && TREE_CODE (lmem
) == FIELD_DECL
2193 && TREE_CODE (DECL_CONTEXT (lmem
)) == UNION_TYPE
2194 && same_type_p (DECL_CONTEXT (lmem
),
2195 DECL_CONTEXT (rmem
)))
2196 /* If both refer to (possibly different) members of the same union
2197 (12.3), they compare equal. */
2200 eq
= cp_tree_equal (lhs
, rhs
);
2201 r
= constant_boolean_node (eq
== is_code_eq
, type
);
2203 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2204 || TREE_CODE (rhs
) == PTRMEM_CST
)
2205 && (null_member_pointer_value_p (lhs
)
2206 || null_member_pointer_value_p (rhs
)))
2207 r
= constant_boolean_node (!is_code_eq
, type
);
2208 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2209 lhs
= cplus_expand_constant (lhs
);
2210 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2211 rhs
= cplus_expand_constant (rhs
);
2213 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2214 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2217 error ("arithmetic involving a null pointer in %qE", lhs
);
2218 *non_constant_p
= true;
2221 else if (code
== POINTER_PLUS_EXPR
)
2222 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2226 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2230 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2233 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2235 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2236 *non_constant_p
= true;
2237 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2238 a local array in a constexpr function. */
2239 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (lhs
));
2241 VERIFY_CONSTANT (r
);
2245 /* Subroutine of cxx_eval_constant_expression.
2246 Attempt to evaluate condition expressions. Dead branches are not
2250 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2252 bool *non_constant_p
, bool *overflow_p
,
2255 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2257 non_constant_p
, overflow_p
);
2258 VERIFY_CONSTANT (val
);
2259 /* Don't VERIFY_CONSTANT the other operands. */
2260 if (integer_zerop (val
))
2261 val
= TREE_OPERAND (t
, 2);
2263 val
= TREE_OPERAND (t
, 1);
2264 if (TREE_CODE (t
) == IF_STMT
&& !val
)
2266 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2267 overflow_p
, jump_target
);
2270 /* Subroutine of cxx_eval_constant_expression.
2271 Attempt to evaluate vector condition expressions. Unlike
2272 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2273 ternary arithmetics operation, where all 3 arguments have to be
2274 evaluated as constants and then folding computes the result from
2278 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2279 bool *non_constant_p
, bool *overflow_p
)
2281 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2283 non_constant_p
, overflow_p
);
2284 VERIFY_CONSTANT (arg1
);
2285 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2287 non_constant_p
, overflow_p
);
2288 VERIFY_CONSTANT (arg2
);
2289 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2291 non_constant_p
, overflow_p
);
2292 VERIFY_CONSTANT (arg3
);
2293 location_t loc
= EXPR_LOCATION (t
);
2294 tree type
= TREE_TYPE (t
);
2295 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2298 if (arg1
== TREE_OPERAND (t
, 0)
2299 && arg2
== TREE_OPERAND (t
, 1)
2300 && arg3
== TREE_OPERAND (t
, 2))
2303 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2305 VERIFY_CONSTANT (r
);
2309 /* Returns less than, equal to, or greater than zero if KEY is found to be
2310 less than, to match, or to be greater than the constructor_elt's INDEX. */
2313 array_index_cmp (tree key
, tree index
)
2315 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2317 switch (TREE_CODE (index
))
2320 return tree_int_cst_compare (key
, index
);
2323 tree lo
= TREE_OPERAND (index
, 0);
2324 tree hi
= TREE_OPERAND (index
, 1);
2325 if (tree_int_cst_lt (key
, lo
))
2327 else if (tree_int_cst_lt (hi
, key
))
2337 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2338 if none. If INSERT is true, insert a matching element rather than fail. */
2340 static HOST_WIDE_INT
2341 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
)
2343 if (tree_int_cst_sgn (dindex
) < 0)
2346 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2347 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2348 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2350 unsigned HOST_WIDE_INT end
= len
;
2351 unsigned HOST_WIDE_INT begin
= 0;
2353 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2354 that the same is true of the other elements and index directly. */
2357 tree cindex
= (*elts
)[end
- 1].index
;
2358 if (TREE_CODE (cindex
) == INTEGER_CST
2359 && compare_tree_int (cindex
, end
- 1) == 0)
2368 /* Otherwise, find a matching index by means of a binary search. */
2369 while (begin
!= end
)
2371 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2372 constructor_elt
&elt
= (*elts
)[middle
];
2373 tree idx
= elt
.index
;
2375 int cmp
= array_index_cmp (dindex
, idx
);
2382 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2384 /* We need to split the range. */
2386 tree lo
= TREE_OPERAND (idx
, 0);
2387 tree hi
= TREE_OPERAND (idx
, 1);
2388 tree value
= elt
.value
;
2389 dindex
= fold_convert (sizetype
, dindex
);
2390 if (tree_int_cst_lt (lo
, dindex
))
2392 /* There are still some lower elts; shorten the range. */
2393 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2395 if (tree_int_cst_equal (lo
, new_hi
))
2396 /* Only one element left, no longer a range. */
2399 TREE_OPERAND (idx
, 1) = new_hi
;
2400 /* Append the element we want to insert. */
2403 e
.value
= unshare_constructor (value
);
2404 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2407 /* No lower elts, the range elt is now ours. */
2410 if (tree_int_cst_lt (dindex
, hi
))
2412 /* There are still some higher elts; append a range. */
2413 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2415 if (tree_int_cst_equal (new_lo
, hi
))
2418 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2419 e
.value
= unshare_constructor (value
);
2420 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+ 1, e
);
2429 constructor_elt e
= { dindex
, NULL_TREE
};
2430 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2437 /* Under the control of CTX, issue a detailed diagnostic for
2438 an out-of-bounds subscript INDEX into the expression ARRAY. */
2441 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2445 tree arraytype
= TREE_TYPE (array
);
2447 /* Convert the unsigned array subscript to a signed integer to avoid
2448 printing huge numbers for small negative values. */
2449 tree sidx
= fold_convert (ssizetype
, index
);
2452 if (TYPE_DOMAIN (arraytype
))
2453 error ("array subscript value %qE is outside the bounds "
2454 "of array %qD of type %qT", sidx
, array
, arraytype
);
2456 error ("non-zero array subscript %qE is used with array %qD of "
2457 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2458 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2460 else if (TYPE_DOMAIN (arraytype
))
2461 error ("array subscript value %qE is outside the bounds "
2462 "of array type %qT", sidx
, arraytype
);
2464 error ("non-zero array subscript %qE is used with array of type %qT "
2465 "with unknown bounds", sidx
, arraytype
);
2469 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2473 get_array_or_vector_nelts (const constexpr_ctx
*ctx
, tree type
,
2474 bool *non_constant_p
, bool *overflow_p
)
2477 if (TREE_CODE (type
) == ARRAY_TYPE
)
2479 if (TYPE_DOMAIN (type
))
2480 nelts
= array_type_nelts_top (type
);
2482 nelts
= size_zero_node
;
2484 else if (VECTOR_TYPE_P (type
))
2485 nelts
= size_int (TYPE_VECTOR_SUBPARTS (type
));
2489 /* For VLAs, the number of elements won't be an integer constant. */
2490 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
2491 non_constant_p
, overflow_p
);
2495 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2496 STRING_CST STRING. */
2499 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2501 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2504 if (chars_per_elt
== 1)
2505 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2508 const unsigned char *ptr
2509 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2510 + index
* chars_per_elt
);
2511 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2516 /* Subroutine of cxx_eval_constant_expression.
2517 Attempt to reduce a reference to an array slot. */
2520 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2522 bool *non_constant_p
, bool *overflow_p
)
2524 tree oldary
= TREE_OPERAND (t
, 0);
2525 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2527 non_constant_p
, overflow_p
);
2529 HOST_WIDE_INT i
= 0;
2530 tree elem_type
= NULL_TREE
;
2531 unsigned len
= 0, elem_nchars
= 1;
2532 if (*non_constant_p
)
2534 oldidx
= TREE_OPERAND (t
, 1);
2535 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2537 non_constant_p
, overflow_p
);
2538 VERIFY_CONSTANT (index
);
2541 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2542 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2543 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2544 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2545 ary
= TREE_OPERAND (ary
, 0);
2546 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2547 len
= CONSTRUCTOR_NELTS (ary
);
2548 else if (TREE_CODE (ary
) == STRING_CST
)
2550 elem_nchars
= (TYPE_PRECISION (elem_type
)
2551 / TYPE_PRECISION (char_type_node
));
2552 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2554 else if (TREE_CODE (ary
) == VECTOR_CST
)
2555 /* We don't create variable-length VECTOR_CSTs. */
2556 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2559 /* We can't do anything with other tree codes, so use
2560 VERIFY_CONSTANT to complain and fail. */
2561 VERIFY_CONSTANT (ary
);
2565 if (!tree_fits_shwi_p (index
)
2566 || (i
= tree_to_shwi (index
)) < 0)
2568 diag_array_subscript (ctx
, ary
, index
);
2569 *non_constant_p
= true;
2574 tree nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
), non_constant_p
,
2576 VERIFY_CONSTANT (nelts
);
2578 ? !tree_int_cst_le (index
, nelts
)
2579 : !tree_int_cst_lt (index
, nelts
))
2580 || tree_int_cst_sgn (index
) < 0)
2582 diag_array_subscript (ctx
, ary
, index
);
2583 *non_constant_p
= true;
2587 if (lval
&& ary
== oldary
&& index
== oldidx
)
2590 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2593 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2595 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2606 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2607 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2608 else if (TREE_CODE (ary
) == VECTOR_CST
)
2609 r
= VECTOR_CST_ELT (ary
, i
);
2611 r
= extract_string_elt (ary
, elem_nchars
, i
);
2614 /* Don't VERIFY_CONSTANT here. */
2617 /* Otherwise the element doesn't have a value yet. */
2622 if (TREE_CODE (ary
) == CONSTRUCTOR
2623 && CONSTRUCTOR_NO_CLEARING (ary
))
2625 /* 'ary' is part of the aggregate initializer we're currently
2626 building; if there's no initializer for this element yet,
2629 error ("accessing uninitialized array element");
2630 *non_constant_p
= true;
2634 /* If it's within the array bounds but doesn't have an explicit
2635 initializer, it's value-initialized. */
2636 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2637 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2641 /* Subroutine of cxx_eval_constant_expression.
2642 Attempt to reduce a field access of a value of class type. */
2645 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2647 bool *non_constant_p
, bool *overflow_p
)
2649 unsigned HOST_WIDE_INT i
;
2652 tree part
= TREE_OPERAND (t
, 1);
2653 tree orig_whole
= TREE_OPERAND (t
, 0);
2654 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2656 non_constant_p
, overflow_p
);
2657 if (INDIRECT_REF_P (whole
)
2658 && integer_zerop (TREE_OPERAND (whole
, 0)))
2661 error ("dereferencing a null pointer in %qE", orig_whole
);
2662 *non_constant_p
= true;
2666 if (TREE_CODE (whole
) == PTRMEM_CST
)
2667 whole
= cplus_expand_constant (whole
);
2668 if (whole
== orig_whole
)
2671 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2672 whole
, part
, NULL_TREE
);
2673 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2675 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2678 error ("%qE is not a constant expression", orig_whole
);
2679 *non_constant_p
= true;
2681 if (DECL_MUTABLE_P (part
))
2684 error ("mutable %qD is not usable in a constant expression", part
);
2685 *non_constant_p
= true;
2687 if (*non_constant_p
)
2689 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2690 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2692 /* Use name match for PMF fields, as a variant will have a
2693 different FIELD_DECL with a different type. */
2694 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2700 /* We're in the middle of initializing it. */
2704 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2705 && CONSTRUCTOR_NELTS (whole
) > 0)
2707 /* DR 1188 says we don't have to deal with this. */
2709 error ("accessing %qD member instead of initialized %qD member in "
2710 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2711 *non_constant_p
= true;
2715 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2716 classes never get represented; throw together a value now. */
2717 if (is_really_empty_class (TREE_TYPE (t
)))
2718 return build_constructor (TREE_TYPE (t
), NULL
);
2720 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2722 if (CONSTRUCTOR_NO_CLEARING (whole
))
2724 /* 'whole' is part of the aggregate initializer we're currently
2725 building; if there's no initializer for this member yet, that's an
2728 error ("accessing uninitialized member %qD", part
);
2729 *non_constant_p
= true;
2733 /* If there's no explicit init for this field, it's value-initialized. */
2734 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2735 return cxx_eval_constant_expression (ctx
, value
,
2737 non_constant_p
, overflow_p
);
2740 /* Subroutine of cxx_eval_constant_expression.
2741 Attempt to reduce a field access of a value of class type that is
2742 expressed as a BIT_FIELD_REF. */
2745 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2747 bool *non_constant_p
, bool *overflow_p
)
2749 tree orig_whole
= TREE_OPERAND (t
, 0);
2750 tree retval
, fldval
, utype
, mask
;
2751 bool fld_seen
= false;
2752 HOST_WIDE_INT istart
, isize
;
2753 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2755 non_constant_p
, overflow_p
);
2756 tree start
, field
, value
;
2757 unsigned HOST_WIDE_INT i
;
2759 if (whole
== orig_whole
)
2761 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2763 if (!*non_constant_p
2764 && TREE_CODE (whole
) != VECTOR_CST
2765 && TREE_CODE (whole
) != CONSTRUCTOR
)
2768 error ("%qE is not a constant expression", orig_whole
);
2769 *non_constant_p
= true;
2771 if (*non_constant_p
)
2774 if (TREE_CODE (whole
) == VECTOR_CST
)
2775 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2776 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2778 start
= TREE_OPERAND (t
, 2);
2779 istart
= tree_to_shwi (start
);
2780 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2781 utype
= TREE_TYPE (t
);
2782 if (!TYPE_UNSIGNED (utype
))
2783 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2784 retval
= build_int_cst (utype
, 0);
2785 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2787 tree bitpos
= bit_position (field
);
2788 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2790 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2791 && TREE_CODE (value
) == INTEGER_CST
2792 && tree_fits_shwi_p (bitpos
)
2793 && tree_fits_shwi_p (DECL_SIZE (field
)))
2795 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2796 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2797 HOST_WIDE_INT shift
;
2798 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2800 fldval
= fold_convert (utype
, value
);
2801 mask
= build_int_cst_type (utype
, -1);
2802 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2803 size_int (TYPE_PRECISION (utype
) - sz
));
2804 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2805 size_int (TYPE_PRECISION (utype
) - sz
));
2806 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2807 shift
= bit
- istart
;
2808 if (BYTES_BIG_ENDIAN
)
2809 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2810 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2812 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2818 return fold_convert (TREE_TYPE (t
), retval
);
2820 return error_mark_node
;
2823 /* Subroutine of cxx_eval_constant_expression.
2824 Evaluate a short-circuited logical expression T in the context
2825 of a given constexpr CALL. BAILOUT_VALUE is the value for
2826 early return. CONTINUE_VALUE is used here purely for
2827 sanity check purposes. */
2830 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2831 tree bailout_value
, tree continue_value
,
2833 bool *non_constant_p
, bool *overflow_p
)
2836 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2838 non_constant_p
, overflow_p
);
2839 VERIFY_CONSTANT (lhs
);
2840 if (tree_int_cst_equal (lhs
, bailout_value
))
2842 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2843 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2844 lval
, non_constant_p
,
2846 VERIFY_CONSTANT (r
);
2850 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2851 CONSTRUCTOR elements to initialize (part of) an object containing that
2852 field. Return a pointer to the constructor_elt corresponding to the
2853 initialization of the field. */
2855 static constructor_elt
*
2856 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2858 tree aggr
= TREE_OPERAND (ref
, 0);
2859 tree field
= TREE_OPERAND (ref
, 1);
2861 constructor_elt
*ce
;
2863 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2865 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2867 constructor_elt
*base_ce
2868 = base_field_constructor_elt (v
, aggr
);
2869 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2872 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2873 if (ce
->index
== field
)
2880 /* Some of the expressions fed to the constexpr mechanism are calls to
2881 constructors, which have type void. In that case, return the type being
2882 initialized by the constructor. */
2885 initialized_type (tree t
)
2889 tree type
= TREE_TYPE (t
);
2890 if (TREE_CODE (t
) == CALL_EXPR
)
2892 /* A constructor call has void type, so we need to look deeper. */
2893 tree fn
= get_function_named_in_call (t
);
2894 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2895 && DECL_CXX_CONSTRUCTOR_P (fn
))
2896 type
= DECL_CONTEXT (fn
);
2898 else if (TREE_CODE (t
) == COMPOUND_EXPR
)
2899 return initialized_type (TREE_OPERAND (t
, 1));
2900 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
2901 type
= TREE_TYPE (AGGR_INIT_EXPR_SLOT (t
));
2902 return cv_unqualified (type
);
2905 /* We're about to initialize element INDEX of an array or class from VALUE.
2906 Set up NEW_CTX appropriately by adjusting .object to refer to the
2907 subobject and creating a new CONSTRUCTOR if the element is itself
2908 a class or array. */
2911 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2912 tree index
, tree
&value
)
2916 if (index
&& TREE_CODE (index
) != INTEGER_CST
2917 && TREE_CODE (index
) != FIELD_DECL
)
2918 /* This won't have an element in the new CONSTRUCTOR. */
2921 tree type
= initialized_type (value
);
2922 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2923 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2926 /* The sub-aggregate initializer might contain a placeholder;
2927 update object to refer to the subobject and ctor to refer to
2928 the (newly created) sub-initializer. */
2930 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2931 tree elt
= build_constructor (type
, NULL
);
2932 CONSTRUCTOR_NO_CLEARING (elt
) = true;
2935 if (TREE_CODE (value
) == TARGET_EXPR
)
2936 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2937 value
= TARGET_EXPR_INITIAL (value
);
2940 /* We're about to process an initializer for a class or array TYPE. Make
2941 sure that CTX is set up appropriately. */
2944 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2946 /* We don't bother building a ctor for an empty base subobject. */
2947 if (is_empty_class (type
))
2950 /* We're in the middle of an initializer that might involve placeholders;
2951 our caller should have created a CONSTRUCTOR for us to put the
2952 initializer into. We will either return that constructor or T. */
2953 gcc_assert (ctx
->ctor
);
2954 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2955 (type
, TREE_TYPE (ctx
->ctor
)));
2956 /* We used to check that ctx->ctor was empty, but that isn't the case when
2957 the object is zero-initialized before calling the constructor. */
2960 tree otype
= TREE_TYPE (ctx
->object
);
2961 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2962 /* Handle flexible array members. */
2963 || (TREE_CODE (otype
) == ARRAY_TYPE
2964 && TYPE_DOMAIN (otype
) == NULL_TREE
2965 && TREE_CODE (type
) == ARRAY_TYPE
2966 && (same_type_ignoring_top_level_qualifiers_p
2967 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2969 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2970 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2973 /* Subroutine of cxx_eval_constant_expression.
2974 The expression tree T denotes a C-style array or a C-style
2975 aggregate. Reduce it to a constant expression. */
2978 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2980 bool *non_constant_p
, bool *overflow_p
)
2982 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2983 bool changed
= false;
2984 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2985 tree type
= TREE_TYPE (t
);
2987 constexpr_ctx new_ctx
;
2988 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2990 /* We don't really need the ctx->ctor business for a PMF or
2991 vector, but it's simpler to use the same code. */
2993 new_ctx
.ctor
= build_constructor (type
, NULL
);
2994 new_ctx
.object
= NULL_TREE
;
2997 verify_ctor_sanity (ctx
, type
);
2998 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2999 vec_alloc (*p
, vec_safe_length (v
));
3003 bool constant_p
= true;
3004 bool side_effects_p
= false;
3005 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
3007 tree orig_value
= value
;
3008 init_subob_ctx (ctx
, new_ctx
, index
, value
);
3009 if (new_ctx
.ctor
!= ctx
->ctor
)
3010 /* If we built a new CONSTRUCTOR, attach it now so that other
3011 initializers can refer to it. */
3012 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
3013 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
3015 non_constant_p
, overflow_p
);
3016 /* Don't VERIFY_CONSTANT here. */
3017 if (ctx
->quiet
&& *non_constant_p
)
3019 if (elt
!= orig_value
)
3022 if (!TREE_CONSTANT (elt
))
3024 if (TREE_SIDE_EFFECTS (elt
))
3025 side_effects_p
= true;
3026 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
3028 /* This is an initialization of a vfield inside a base
3029 subaggregate that we already initialized; push this
3030 initialization into the previous initialization. */
3031 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
3036 && (TREE_CODE (index
) == NOP_EXPR
3037 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
3039 /* This is an initializer for an empty base; now that we've
3040 checked that it's constant, we can ignore it. */
3041 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
3046 if (new_ctx
.ctor
!= ctx
->ctor
)
3048 /* We appended this element above; update the value. */
3049 gcc_assert ((*p
)->last().index
== index
);
3050 (*p
)->last().value
= elt
;
3053 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
3054 /* Adding or replacing an element might change the ctor's flags. */
3055 TREE_CONSTANT (ctx
->ctor
) = constant_p
;
3056 TREE_SIDE_EFFECTS (ctx
->ctor
) = side_effects_p
;
3059 if (*non_constant_p
|| !changed
)
3062 /* We're done building this CONSTRUCTOR, so now we can interpret an
3063 element without an explicit initializer as value-initialized. */
3064 CONSTRUCTOR_NO_CLEARING (t
) = false;
3065 TREE_CONSTANT (t
) = constant_p
;
3066 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
3067 if (VECTOR_TYPE_P (type
))
3072 /* Subroutine of cxx_eval_constant_expression.
3073 The expression tree T is a VEC_INIT_EXPR which denotes the desired
3074 initialization of a non-static data member of array type. Reduce it to a
3077 Note that apart from value-initialization (when VALUE_INIT is true),
3078 this is only intended to support value-initialization and the
3079 initializations done by defaulted constructors for classes with
3080 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
3081 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
3082 for the copy/move constructor. */
3085 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
3086 bool value_init
, bool lval
,
3087 bool *non_constant_p
, bool *overflow_p
)
3089 tree elttype
= TREE_TYPE (atype
);
3090 verify_ctor_sanity (ctx
, atype
);
3091 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
3092 bool pre_init
= false;
3093 unsigned HOST_WIDE_INT i
;
3094 tsubst_flags_t complain
= ctx
->quiet
? tf_none
: tf_warning_or_error
;
3096 /* For the default constructor, build up a call to the default
3097 constructor of the element type. We only need to handle class types
3098 here, as for a constructor to be constexpr, all members must be
3099 initialized, which for a defaulted default constructor means they must
3100 be of a class type with a constexpr default constructor. */
3101 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3102 /* We only do this at the lowest level. */;
3103 else if (value_init
)
3105 init
= build_value_init (elttype
, complain
);
3110 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
3111 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
3112 &argvec
, elttype
, LOOKUP_NORMAL
,
3114 release_tree_vector (argvec
);
3115 init
= build_aggr_init_expr (elttype
, init
);
3119 tree nelts
= get_array_or_vector_nelts (ctx
, atype
, non_constant_p
,
3121 unsigned HOST_WIDE_INT max
= tree_to_uhwi (nelts
);
3122 for (i
= 0; i
< max
; ++i
)
3124 tree idx
= build_int_cst (size_type_node
, i
);
3127 constexpr_ctx new_ctx
;
3128 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
3129 if (new_ctx
.ctor
!= ctx
->ctor
)
3130 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
3131 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
3133 /* A multidimensional array; recurse. */
3134 if (value_init
|| init
== NULL_TREE
)
3136 eltinit
= NULL_TREE
;
3140 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3141 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
3143 non_constant_p
, overflow_p
);
3147 /* Initializing an element using value or default initialization
3148 we just pre-built above. */
3149 if (init
== void_node
)
3150 /* Trivial default-init, don't do anything to the CONSTRUCTOR. */
3152 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
3153 non_constant_p
, overflow_p
);
3158 /* Copying an element. */
3159 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3160 (atype
, TREE_TYPE (init
)));
3161 eltinit
= cp_build_array_ref (input_location
, init
, idx
, complain
);
3162 if (!lvalue_p (init
))
3163 eltinit
= move (eltinit
);
3164 eltinit
= force_rvalue (eltinit
, complain
);
3165 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
3166 non_constant_p
, overflow_p
);
3168 if (*non_constant_p
&& !ctx
->quiet
)
3170 if (new_ctx
.ctor
!= ctx
->ctor
)
3172 /* We appended this element above; update the value. */
3173 gcc_assert ((*p
)->last().index
== idx
);
3174 (*p
)->last().value
= eltinit
;
3177 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
3178 /* Reuse the result of cxx_eval_constant_expression call
3179 from the first iteration to all others if it is a constant
3180 initializer that doesn't require relocations. */
3183 && (eltinit
== NULL_TREE
3184 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
3185 == null_pointer_node
)))
3187 if (new_ctx
.ctor
!= ctx
->ctor
)
3188 eltinit
= new_ctx
.ctor
;
3189 tree range
= build2 (RANGE_EXPR
, size_type_node
,
3190 build_int_cst (size_type_node
, 1),
3191 build_int_cst (size_type_node
, max
- 1));
3192 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
3196 vec_safe_reserve (*p
, max
);
3199 if (!*non_constant_p
)
3202 CONSTRUCTOR_NO_CLEARING (init
) = false;
3208 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3210 bool *non_constant_p
, bool *overflow_p
)
3212 tree atype
= TREE_TYPE (t
);
3213 tree init
= VEC_INIT_EXPR_INIT (t
);
3214 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3215 VEC_INIT_EXPR_VALUE_INIT (t
),
3216 lval
, non_constant_p
, overflow_p
);
3217 if (*non_constant_p
)
3223 /* Like same_type_ignoring_top_level_qualifiers_p, but also handle the case
3224 where the desired type is an array of unknown bounds because the variable
3225 has had its bounds deduced since the wrapping expression was created. */
3228 same_type_ignoring_tlq_and_bounds_p (tree type1
, tree type2
)
3230 while (TREE_CODE (type1
) == ARRAY_TYPE
3231 && TREE_CODE (type2
) == ARRAY_TYPE
3232 && (!TYPE_DOMAIN (type1
) || !TYPE_DOMAIN (type2
)))
3234 type1
= TREE_TYPE (type1
);
3235 type2
= TREE_TYPE (type2
);
3237 return same_type_ignoring_top_level_qualifiers_p (type1
, type2
);
3240 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3241 match. We want to be less strict for simple *& folding; if we have a
3242 non-const temporary that we access through a const pointer, that should
3243 work. We handle this here rather than change fold_indirect_ref_1
3244 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3245 don't really make sense outside of constant expression evaluation. Also
3246 we want to allow folding to COMPONENT_REF, which could cause trouble
3247 with TBAA in fold_indirect_ref_1.
3249 Try to keep this function synced with fold_indirect_ref_1. */
3252 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3256 poly_uint64 const_op01
;
3259 subtype
= TREE_TYPE (sub
);
3260 if (!INDIRECT_TYPE_P (subtype
))
3263 if (TREE_CODE (sub
) == ADDR_EXPR
)
3265 tree op
= TREE_OPERAND (sub
, 0);
3266 tree optype
= TREE_TYPE (op
);
3268 /* *&CONST_DECL -> to the value of the const decl. */
3269 if (TREE_CODE (op
) == CONST_DECL
)
3270 return DECL_INITIAL (op
);
3271 /* *&p => p; make sure to handle *&"str"[cst] here. */
3272 if (same_type_ignoring_tlq_and_bounds_p (optype
, type
))
3274 tree fop
= fold_read_from_constant_string (op
);
3280 /* *(foo *)&fooarray => fooarray[0] */
3281 else if (TREE_CODE (optype
) == ARRAY_TYPE
3282 && (same_type_ignoring_top_level_qualifiers_p
3283 (type
, TREE_TYPE (optype
))))
3285 tree type_domain
= TYPE_DOMAIN (optype
);
3286 tree min_val
= size_zero_node
;
3287 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3288 min_val
= TYPE_MIN_VALUE (type_domain
);
3289 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3290 NULL_TREE
, NULL_TREE
);
3292 /* *(foo *)&complexfoo => __real__ complexfoo */
3293 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3294 && (same_type_ignoring_top_level_qualifiers_p
3295 (type
, TREE_TYPE (optype
))))
3296 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3297 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3298 else if (VECTOR_TYPE_P (optype
)
3299 && (same_type_ignoring_top_level_qualifiers_p
3300 (type
, TREE_TYPE (optype
))))
3302 tree part_width
= TYPE_SIZE (type
);
3303 tree index
= bitsize_int (0);
3304 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3307 /* Also handle conversion to an empty base class, which
3308 is represented with a NOP_EXPR. */
3309 else if (is_empty_class (type
)
3310 && CLASS_TYPE_P (optype
)
3311 && DERIVED_FROM_P (type
, optype
))
3316 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3317 else if (RECORD_OR_UNION_TYPE_P (optype
))
3319 tree field
= TYPE_FIELDS (optype
);
3320 for (; field
; field
= DECL_CHAIN (field
))
3321 if (TREE_CODE (field
) == FIELD_DECL
3322 && TREE_TYPE (field
) != error_mark_node
3323 && integer_zerop (byte_position (field
))
3324 && (same_type_ignoring_top_level_qualifiers_p
3325 (TREE_TYPE (field
), type
)))
3326 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3329 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3330 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3332 tree op00
= TREE_OPERAND (sub
, 0);
3333 tree op01
= TREE_OPERAND (sub
, 1);
3336 if (TREE_CODE (op00
) == ADDR_EXPR
)
3339 op00
= TREE_OPERAND (op00
, 0);
3340 op00type
= TREE_TYPE (op00
);
3342 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3343 if (VECTOR_TYPE_P (op00type
)
3344 && same_type_ignoring_top_level_qualifiers_p
3345 (type
, TREE_TYPE (op00type
))
3346 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3347 but we want to treat offsets with MSB set as negative.
3348 For the code below negative offsets are invalid and
3349 TYPE_SIZE of the element is something unsigned, so
3350 check whether op01 fits into poly_int64, which implies
3351 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3352 then just use poly_uint64 because we want to treat the
3353 value as unsigned. */
3354 && tree_fits_poly_int64_p (op01
))
3356 tree part_width
= TYPE_SIZE (type
);
3357 poly_uint64 max_offset
3358 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3359 * TYPE_VECTOR_SUBPARTS (op00type
));
3360 if (known_lt (const_op01
, max_offset
))
3362 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3363 return fold_build3_loc (loc
,
3364 BIT_FIELD_REF
, type
, op00
,
3368 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3369 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3370 && (same_type_ignoring_top_level_qualifiers_p
3371 (type
, TREE_TYPE (op00type
))))
3373 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3375 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3377 /* ((foo *)&fooarray)[1] => fooarray[1] */
3378 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3379 && (same_type_ignoring_top_level_qualifiers_p
3380 (type
, TREE_TYPE (op00type
))))
3382 tree type_domain
= TYPE_DOMAIN (op00type
);
3383 tree min_val
= size_zero_node
;
3384 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3385 min_val
= TYPE_MIN_VALUE (type_domain
);
3386 offset_int off
= wi::to_offset (op01
);
3387 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3388 offset_int remainder
;
3389 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3390 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3392 off
= off
+ wi::to_offset (min_val
);
3393 op01
= wide_int_to_tree (sizetype
, off
);
3394 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3395 NULL_TREE
, NULL_TREE
);
3398 /* Also handle conversion to an empty base class, which
3399 is represented with a NOP_EXPR. */
3400 else if (is_empty_class (type
)
3401 && CLASS_TYPE_P (op00type
)
3402 && DERIVED_FROM_P (type
, op00type
))
3407 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3408 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3410 tree field
= TYPE_FIELDS (op00type
);
3411 for (; field
; field
= DECL_CHAIN (field
))
3412 if (TREE_CODE (field
) == FIELD_DECL
3413 && TREE_TYPE (field
) != error_mark_node
3414 && tree_int_cst_equal (byte_position (field
), op01
)
3415 && (same_type_ignoring_top_level_qualifiers_p
3416 (TREE_TYPE (field
), type
)))
3417 return fold_build3 (COMPONENT_REF
, type
, op00
,
3422 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3423 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3424 && (same_type_ignoring_top_level_qualifiers_p
3425 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3428 tree min_val
= size_zero_node
;
3430 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3434 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3435 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3436 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3437 min_val
= TYPE_MIN_VALUE (type_domain
);
3438 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3446 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3448 bool *non_constant_p
, bool *overflow_p
)
3450 tree orig_op0
= TREE_OPERAND (t
, 0);
3451 bool empty_base
= false;
3453 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3454 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3456 if (TREE_CODE (t
) == MEM_REF
3457 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3459 gcc_assert (ctx
->quiet
);
3460 *non_constant_p
= true;
3464 /* First try to simplify it directly. */
3465 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3469 /* If that didn't work, evaluate the operand first. */
3470 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3471 /*lval*/false, non_constant_p
,
3473 /* Don't VERIFY_CONSTANT here. */
3474 if (*non_constant_p
)
3477 if (!lval
&& integer_zerop (op0
))
3480 error ("dereferencing a null pointer");
3481 *non_constant_p
= true;
3485 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3489 /* We couldn't fold to a constant value. Make sure it's not
3490 something we should have been able to fold. */
3493 if (TREE_CODE (sub
) == ADDR_EXPR
)
3495 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3496 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3497 /* DR 1188 says we don't have to deal with this. */
3499 error ("accessing value of %qE through a %qT glvalue in a "
3500 "constant expression", build_fold_indirect_ref (sub
),
3502 *non_constant_p
= true;
3506 if (lval
&& op0
!= orig_op0
)
3507 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3509 VERIFY_CONSTANT (t
);
3514 r
= cxx_eval_constant_expression (ctx
, r
,
3515 lval
, non_constant_p
, overflow_p
);
3516 if (*non_constant_p
)
3519 /* If we're pulling out the value of an empty base, just return an empty
3521 if (empty_base
&& !lval
)
3523 r
= build_constructor (TREE_TYPE (t
), NULL
);
3524 TREE_CONSTANT (r
) = true;
3530 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3531 Shared between potential_constant_expression and
3532 cxx_eval_constant_expression. */
3535 non_const_var_error (tree r
)
3537 tree type
= TREE_TYPE (r
);
3538 error ("the value of %qD is not usable in a constant "
3540 /* Avoid error cascade. */
3541 if (DECL_INITIAL (r
) == error_mark_node
)
3543 if (DECL_DECLARED_CONSTEXPR_P (r
))
3544 inform (DECL_SOURCE_LOCATION (r
),
3545 "%qD used in its own initializer", r
);
3546 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3548 if (!CP_TYPE_CONST_P (type
))
3549 inform (DECL_SOURCE_LOCATION (r
),
3550 "%q#D is not const", r
);
3551 else if (CP_TYPE_VOLATILE_P (type
))
3552 inform (DECL_SOURCE_LOCATION (r
),
3553 "%q#D is volatile", r
);
3554 else if (!DECL_INITIAL (r
)
3555 || !TREE_CONSTANT (DECL_INITIAL (r
))
3556 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3557 inform (DECL_SOURCE_LOCATION (r
),
3558 "%qD was not initialized with a constant "
3563 else if (TYPE_REF_P (type
))
3564 inform (DECL_SOURCE_LOCATION (r
),
3565 "%qD was not initialized with a constant "
3569 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3570 inform (DECL_SOURCE_LOCATION (r
),
3571 "%qD was not declared %<constexpr%>", r
);
3573 inform (DECL_SOURCE_LOCATION (r
),
3574 "%qD does not have integral or enumeration type",
3579 /* Subroutine of cxx_eval_constant_expression.
3580 Like cxx_eval_unary_expression, except for trinary expressions. */
3583 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3585 bool *non_constant_p
, bool *overflow_p
)
3591 for (i
= 0; i
< 3; i
++)
3593 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3595 non_constant_p
, overflow_p
);
3596 VERIFY_CONSTANT (args
[i
]);
3599 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3600 args
[0], args
[1], args
[2]);
3601 if (val
== NULL_TREE
)
3603 VERIFY_CONSTANT (val
);
3607 /* True if T was declared in a function declared to be constexpr, and
3608 therefore potentially constant in C++14. */
3611 var_in_constexpr_fn (tree t
)
3613 tree ctx
= DECL_CONTEXT (t
);
3614 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3615 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3618 /* True if T was declared in a function that might be constexpr: either a
3619 function that was declared constexpr, or a C++17 lambda op(). */
3622 var_in_maybe_constexpr_fn (tree t
)
3624 if (cxx_dialect
>= cxx17
3625 && DECL_FUNCTION_SCOPE_P (t
)
3626 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3628 return var_in_constexpr_fn (t
);
3631 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3632 build_over_call we implement trivial copy of a class with tail padding using
3633 assignment of character arrays, which is valid in normal code, but not in
3634 constexpr evaluation. We don't need to worry about clobbering tail padding
3635 in constexpr evaluation, so strip the type punning. */
3638 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3640 if (TREE_CODE (target
) == MEM_REF
3641 && TREE_CODE (init
) == MEM_REF
3642 && TREE_TYPE (target
) == TREE_TYPE (init
)
3643 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3644 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3646 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3647 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3651 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3654 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3656 bool *non_constant_p
, bool *overflow_p
)
3658 constexpr_ctx new_ctx
= *ctx
;
3660 tree init
= TREE_OPERAND (t
, 1);
3661 if (TREE_CLOBBER_P (init
))
3662 /* Just ignore clobbers. */
3665 /* First we figure out where we're storing to. */
3666 tree target
= TREE_OPERAND (t
, 0);
3668 maybe_simplify_trivial_copy (target
, init
);
3670 tree type
= TREE_TYPE (target
);
3671 bool preeval
= SCALAR_TYPE_P (type
) || TREE_CODE (t
) == MODIFY_EXPR
;
3674 /* Evaluate the value to be stored without knowing what object it will be
3675 stored in, so that any side-effects happen first. */
3676 if (!SCALAR_TYPE_P (type
))
3677 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3678 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3679 non_constant_p
, overflow_p
);
3680 if (*non_constant_p
)
3683 target
= cxx_eval_constant_expression (ctx
, target
,
3685 non_constant_p
, overflow_p
);
3686 if (*non_constant_p
)
3689 /* cxx_eval_array_reference for lval = true allows references one past
3690 end of array, because it does not know if it is just taking address
3691 (which is valid), or actual dereference. Here we know it is
3692 a dereference, so diagnose it here. */
3693 for (tree probe
= target
; probe
; )
3695 switch (TREE_CODE (probe
))
3699 ary
= TREE_OPERAND (probe
, 0);
3700 nelts
= get_array_or_vector_nelts (ctx
, TREE_TYPE (ary
),
3701 non_constant_p
, overflow_p
);
3702 VERIFY_CONSTANT (nelts
);
3703 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3704 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3705 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3707 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3708 *non_constant_p
= true;
3715 probe
= TREE_OPERAND (probe
, 0);
3724 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3726 /* For initialization of an empty base, the original target will be
3727 *(base*)this, which the above evaluation resolves to the object
3728 argument, which has the derived type rather than the base type. In
3729 this situation, just evaluate the initializer and return, since
3730 there's no actual data to store. */
3731 gcc_assert (is_empty_class (type
));
3732 return cxx_eval_constant_expression (ctx
, init
, false,
3733 non_constant_p
, overflow_p
);
3736 /* And then find the underlying variable. */
3737 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3738 tree object
= NULL_TREE
;
3739 for (tree probe
= target
; object
== NULL_TREE
; )
3741 switch (TREE_CODE (probe
))
3746 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3747 vec_safe_push (refs
, TREE_TYPE (probe
));
3748 probe
= TREE_OPERAND (probe
, 0);
3756 /* And then find/build up our initializer for the path to the subobject
3757 we're initializing. */
3759 if (object
== ctx
->object
&& VAR_P (object
)
3760 && DECL_NAME (object
) && ctx
->call
== NULL
)
3761 /* The variable we're building up an aggregate initializer for is outside
3762 the constant-expression, so don't evaluate the store. We check
3763 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3765 else if (DECL_P (object
))
3766 valp
= ctx
->values
->get (object
);
3771 /* A constant-expression cannot modify objects from outside the
3772 constant-expression. */
3774 error ("modification of %qE is not a constant expression", object
);
3775 *non_constant_p
= true;
3778 type
= TREE_TYPE (object
);
3779 bool no_zero_init
= true;
3781 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3782 while (!refs
->is_empty())
3784 if (*valp
== NULL_TREE
)
3786 *valp
= build_constructor (type
, NULL
);
3787 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3789 else if (TREE_CODE (*valp
) == STRING_CST
)
3791 /* An array was initialized with a string constant, and now
3792 we're writing into one of its elements. Explode the
3793 single initialization into a set of element
3795 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3797 tree string
= *valp
;
3798 tree elt_type
= TREE_TYPE (type
);
3799 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3800 / TYPE_PRECISION (char_type_node
));
3801 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3802 tree ary_ctor
= build_constructor (type
, NULL
);
3804 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3805 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3807 constructor_elt elt
=
3809 build_int_cst (size_type_node
, ix
),
3810 extract_string_elt (string
, chars_per_elt
, ix
)
3812 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3818 /* If the value of object is already zero-initialized, any new ctors for
3819 subobjects will also be zero-initialized. */
3820 no_zero_init
= CONSTRUCTOR_NO_CLEARING (*valp
);
3822 vec_safe_push (ctors
, *valp
);
3824 enum tree_code code
= TREE_CODE (type
);
3826 tree index
= refs
->pop();
3828 constructor_elt
*cep
= NULL
;
3829 if (code
== ARRAY_TYPE
)
3832 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3833 gcc_assert (i
>= 0);
3834 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3835 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3839 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3841 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3842 Usually we meet initializers in that order, but it is
3843 possible for base types to be placed not in program
3845 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3846 unsigned HOST_WIDE_INT idx
;
3848 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3849 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3851 if (cxx_dialect
< cxx2a
)
3854 error_at (cp_expr_loc_or_loc (t
, input_location
),
3855 "change of the active member of a union "
3857 CONSTRUCTOR_ELT (*valp
, 0)->index
,
3859 *non_constant_p
= true;
3861 /* Changing active member. */
3862 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3863 no_zero_init
= true;
3867 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3868 idx
++, fields
= DECL_CHAIN (fields
))
3870 if (index
== cep
->index
)
3873 /* The field we're initializing must be on the field
3874 list. Look to see if it is present before the
3875 field the current ELT initializes. */
3876 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3877 if (index
== fields
)
3881 /* We fell off the end of the CONSTRUCTOR, so insert a new
3882 entry at the end. */
3885 constructor_elt ce
= { index
, NULL_TREE
};
3887 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3888 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3894 release_tree_vector (refs
);
3898 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3899 wants to modify it. */
3900 if (*valp
== NULL_TREE
)
3902 *valp
= build_constructor (type
, NULL
);
3903 CONSTRUCTOR_NO_CLEARING (*valp
) = no_zero_init
;
3905 new_ctx
.ctor
= *valp
;
3906 new_ctx
.object
= target
;
3907 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3908 non_constant_p
, overflow_p
);
3909 if (target
== object
)
3910 /* The hash table might have moved since the get earlier. */
3911 valp
= ctx
->values
->get (object
);
3914 /* Don't share a CONSTRUCTOR that might be changed later. */
3915 init
= unshare_constructor (init
);
3917 if (*valp
&& TREE_CODE (*valp
) == CONSTRUCTOR
3918 && TREE_CODE (init
) == CONSTRUCTOR
)
3920 /* An outer ctx->ctor might be pointing to *valp, so replace
3922 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3923 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3924 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3925 CONSTRUCTOR_NO_CLEARING (*valp
)
3926 = CONSTRUCTOR_NO_CLEARING (init
);
3931 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3932 CONSTRUCTORs, if any. */
3935 bool c
= TREE_CONSTANT (init
);
3936 bool s
= TREE_SIDE_EFFECTS (init
);
3938 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3941 TREE_CONSTANT (elt
) = false;
3943 TREE_SIDE_EFFECTS (elt
) = true;
3945 release_tree_vector (ctors
);
3947 if (*non_constant_p
)
3955 /* Evaluate a ++ or -- expression. */
3958 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3960 bool *non_constant_p
, bool *overflow_p
)
3962 enum tree_code code
= TREE_CODE (t
);
3963 tree type
= TREE_TYPE (t
);
3964 tree op
= TREE_OPERAND (t
, 0);
3965 tree offset
= TREE_OPERAND (t
, 1);
3966 gcc_assert (TREE_CONSTANT (offset
));
3968 /* The operand as an lvalue. */
3969 op
= cxx_eval_constant_expression (ctx
, op
, true,
3970 non_constant_p
, overflow_p
);
3972 /* The operand as an rvalue. */
3974 = cxx_eval_constant_expression (ctx
, op
, false,
3975 non_constant_p
, overflow_p
);
3976 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3977 a local array in a constexpr function. */
3978 bool ptr
= INDIRECT_TYPE_P (TREE_TYPE (val
));
3980 VERIFY_CONSTANT (val
);
3982 /* The modified value. */
3983 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3985 if (INDIRECT_TYPE_P (type
))
3987 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3988 offset
= convert_to_ptrofftype (offset
);
3990 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3991 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3994 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3996 VERIFY_CONSTANT (mod
);
3998 /* Storing the modified value. */
3999 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
4000 cxx_eval_constant_expression (ctx
, store
,
4001 true, non_constant_p
, overflow_p
);
4003 /* And the value of the expression. */
4004 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4006 /* Prefix ops are lvalues. */
4010 /* But we optimize when the caller wants an rvalue. */
4014 /* Postfix ops are rvalues. */
4018 /* Predicates for the meaning of *jump_target. */
4021 returns (tree
*jump_target
)
4024 && (TREE_CODE (*jump_target
) == RETURN_EXPR
4025 || (TREE_CODE (*jump_target
) == LABEL_DECL
4026 && LABEL_DECL_CDTOR (*jump_target
)));
4030 breaks (tree
*jump_target
)
4033 && ((TREE_CODE (*jump_target
) == LABEL_DECL
4034 && LABEL_DECL_BREAK (*jump_target
))
4035 || TREE_CODE (*jump_target
) == BREAK_STMT
4036 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
4040 continues (tree
*jump_target
)
4043 && ((TREE_CODE (*jump_target
) == LABEL_DECL
4044 && LABEL_DECL_CONTINUE (*jump_target
))
4045 || TREE_CODE (*jump_target
) == CONTINUE_STMT
);
4050 switches (tree
*jump_target
)
4053 && TREE_CODE (*jump_target
) == INTEGER_CST
;
4056 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
4057 STMT matches *jump_target. If we're looking for a case label and we see
4058 the default label, note it in ctx->css_state. */
4061 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
4063 switch (TREE_CODE (*jump_target
))
4066 if (TREE_CODE (stmt
) == LABEL_EXPR
4067 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
4072 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
4074 gcc_assert (ctx
->css_state
!= NULL
);
4075 if (!CASE_LOW (stmt
))
4077 /* default: should appear just once in a SWITCH_EXPR
4078 body (excluding nested SWITCH_EXPR). */
4079 gcc_assert (*ctx
->css_state
!= css_default_seen
);
4080 /* When evaluating SWITCH_EXPR body for the second time,
4081 return true for the default: label. */
4082 if (*ctx
->css_state
== css_default_processing
)
4084 *ctx
->css_state
= css_default_seen
;
4086 else if (CASE_HIGH (stmt
))
4088 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
4089 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
4092 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
4099 /* These two are handled directly in cxx_eval_loop_expr by testing
4100 breaks (jump_target) or continues (jump_target). */
4109 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
4110 semantics, for switch, break, continue, and return. */
4113 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
4114 bool *non_constant_p
, bool *overflow_p
,
4117 tree_stmt_iterator i
;
4119 /* In a statement-expression we want to return the last value.
4120 For empty statement expression return void_node. */
4124 local_target
= NULL_TREE
;
4125 jump_target
= &local_target
;
4127 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4129 tree stmt
= tsi_stmt (i
);
4130 /* We've found a continue, so skip everything until we reach
4131 the label its jumping to. */
4132 if (continues (jump_target
))
4134 if (label_matches (ctx
, jump_target
, stmt
))
4136 *jump_target
= NULL_TREE
;
4140 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
4142 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
4143 non_constant_p
, overflow_p
,
4145 if (*non_constant_p
)
4147 if (returns (jump_target
) || breaks (jump_target
))
4153 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
4154 semantics; continue semantics are covered by cxx_eval_statement_list. */
4157 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
4158 bool *non_constant_p
, bool *overflow_p
,
4161 constexpr_ctx new_ctx
= *ctx
;
4163 tree body
, cond
= NULL_TREE
, expr
= NULL_TREE
;
4165 switch (TREE_CODE (t
))
4168 body
= LOOP_EXPR_BODY (t
);
4175 body
= WHILE_BODY (t
);
4176 cond
= WHILE_COND (t
);
4180 if (FOR_INIT_STMT (t
))
4181 cxx_eval_constant_expression (ctx
, FOR_INIT_STMT (t
), /*lval*/false,
4182 non_constant_p
, overflow_p
, jump_target
);
4183 if (*non_constant_p
)
4185 body
= FOR_BODY (t
);
4186 cond
= FOR_COND (t
);
4187 expr
= FOR_EXPR (t
);
4193 hash_set
<tree
> save_exprs
;
4194 new_ctx
.save_exprs
= &save_exprs
;
4200 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
4201 non_constant_p
, overflow_p
,
4203 if (breaks (jump_target
))
4205 *jump_target
= NULL_TREE
;
4209 if (TREE_CODE (t
) != LOOP_EXPR
&& continues (jump_target
))
4210 *jump_target
= NULL_TREE
;
4213 cxx_eval_constant_expression (&new_ctx
, expr
, /*lval*/false,
4214 non_constant_p
, overflow_p
,
4221 = cxx_eval_constant_expression (&new_ctx
, cond
, /*lval*/false,
4222 non_constant_p
, overflow_p
,
4226 if (verify_constant (res
, ctx
->quiet
, non_constant_p
,
4229 if (integer_zerop (res
))
4233 gcc_assert (*jump_target
);
4236 /* Forget saved values of SAVE_EXPRs. */
4237 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
4238 iter
!= save_exprs
.end(); ++iter
)
4239 new_ctx
.values
->remove (*iter
);
4241 if (++count
>= constexpr_loop_limit
)
4244 error_at (cp_expr_loc_or_loc (t
, input_location
),
4245 "%<constexpr%> loop iteration count exceeds limit of %d "
4246 "(use -fconstexpr-loop-limit= to increase the limit)",
4247 constexpr_loop_limit
);
4248 *non_constant_p
= true;
4252 while (!returns (jump_target
)
4253 && !breaks (jump_target
)
4254 && !continues (jump_target
)
4255 && (!switches (jump_target
) || count
== 0)
4256 && !*non_constant_p
);
4258 /* Forget saved values of SAVE_EXPRs. */
4259 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
4260 iter
!= save_exprs
.end(); ++iter
)
4261 new_ctx
.values
->remove (*iter
);
4266 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
4270 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
4271 bool *non_constant_p
, bool *overflow_p
,
4275 = TREE_CODE (t
) == SWITCH_STMT
? SWITCH_STMT_COND (t
) : SWITCH_COND (t
);
4276 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
4277 non_constant_p
, overflow_p
);
4278 VERIFY_CONSTANT (cond
);
4279 *jump_target
= cond
;
4282 = TREE_CODE (t
) == SWITCH_STMT
? SWITCH_STMT_BODY (t
) : SWITCH_BODY (t
);
4283 constexpr_ctx new_ctx
= *ctx
;
4284 constexpr_switch_state css
= css_default_not_seen
;
4285 new_ctx
.css_state
= &css
;
4286 cxx_eval_constant_expression (&new_ctx
, body
, false,
4287 non_constant_p
, overflow_p
, jump_target
);
4288 if (switches (jump_target
) && css
== css_default_seen
)
4290 /* If the SWITCH_EXPR body has default: label, process it once again,
4291 this time instructing label_matches to return true for default:
4292 label on switches (jump_target). */
4293 css
= css_default_processing
;
4294 cxx_eval_constant_expression (&new_ctx
, body
, false,
4295 non_constant_p
, overflow_p
, jump_target
);
4297 if (breaks (jump_target
) || switches (jump_target
))
4298 *jump_target
= NULL_TREE
;
4302 /* Find the object of TYPE under initialization in CTX. */
4305 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
4310 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4311 can is a minor optimization. */
4312 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4318 /* Since an object cannot have a field of its own type, we can search outward
4319 from ctx->object to find the unique containing object of TYPE. */
4320 tree ob
= ctx
->object
;
4323 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4325 if (handled_component_p (ob
))
4326 ob
= TREE_OPERAND (ob
, 0);
4334 /* Attempt to reduce the expression T to a constant value.
4335 On failure, issue diagnostic and return error_mark_node. */
4336 /* FIXME unify with c_fully_fold */
4337 /* FIXME overflow_p is too global */
4340 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4342 bool *non_constant_p
, bool *overflow_p
,
4343 tree
*jump_target
/* = NULL */)
4345 constexpr_ctx new_ctx
;
4348 if (jump_target
&& *jump_target
)
4350 /* If we are jumping, ignore all statements/expressions except those
4351 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4352 switch (TREE_CODE (t
))
4355 case STATEMENT_LIST
:
4364 case CASE_LABEL_EXPR
:
4365 if (label_matches (ctx
, jump_target
, t
))
4367 *jump_target
= NULL_TREE
;
4373 if (error_operand_p (t
))
4375 *non_constant_p
= true;
4378 if (CONSTANT_CLASS_P (t
))
4380 if (TREE_OVERFLOW (t
))
4383 permerror (input_location
, "overflow in constant expression");
4384 if (!flag_permissive
|| ctx
->quiet
)
4388 if (TREE_CODE (t
) == INTEGER_CST
4389 && TYPE_PTR_P (TREE_TYPE (t
))
4390 && !integer_zerop (t
))
4393 error ("value %qE of type %qT is not a constant expression",
4395 *non_constant_p
= true;
4401 tree_code tcode
= TREE_CODE (t
);
4407 /* We ask for an rvalue for the RESULT_DECL when indirecting
4408 through an invisible reference, or in named return value
4410 if (tree
*p
= ctx
->values
->get (t
))
4415 error ("%qE is not a constant expression", t
);
4416 *non_constant_p
= true;
4421 if (DECL_HAS_VALUE_EXPR_P (t
))
4422 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4423 lval
, non_constant_p
, overflow_p
);
4426 /* We used to not check lval for CONST_DECL, but darwin.c uses
4427 CONST_DECL for aggregate constants. */
4430 /* is_really_empty_class doesn't take into account _vptr, so initializing
4431 otherwise empty class with { } would overwrite the initializer that
4432 initialize_vtable created for us. */
4433 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4434 && !TYPE_POLYMORPHIC_P (TREE_TYPE (t
))
4435 && is_really_empty_class (TREE_TYPE (t
)))
4437 /* If the class is empty, we aren't actually loading anything. */
4438 r
= build_constructor (TREE_TYPE (t
), NULL
);
4439 TREE_CONSTANT (r
) = true;
4441 else if (ctx
->strict
)
4442 r
= decl_really_constant_value (t
);
4444 r
= decl_constant_value (t
);
4445 if (TREE_CODE (r
) == TARGET_EXPR
4446 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4447 r
= TARGET_EXPR_INITIAL (r
);
4449 if (tree
*p
= ctx
->values
->get (r
))
4450 if (*p
!= NULL_TREE
)
4455 non_const_var_error (r
);
4456 *non_constant_p
= true;
4460 case DEBUG_BEGIN_STMT
:
4461 /* ??? It might be nice to retain this information somehow, so
4462 as to be able to step into a constexpr function call. */
4469 case CASE_LABEL_EXPR
:
4474 if (lval
&& !TYPE_REF_P (TREE_TYPE (t
)))
4476 else if (tree
*p
= ctx
->values
->get (r
))
4479 /* Defer in case this is only used for its type. */;
4480 else if (TYPE_REF_P (TREE_TYPE (t
)))
4481 /* Defer, there's no lvalue->rvalue conversion. */;
4482 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4483 && is_really_empty_class (TREE_TYPE (t
)))
4485 /* If the class is empty, we aren't actually loading anything. */
4486 r
= build_constructor (TREE_TYPE (t
), NULL
);
4487 TREE_CONSTANT (r
) = true;
4492 error ("%qE is not a constant expression", t
);
4493 *non_constant_p
= true;
4498 case AGGR_INIT_EXPR
:
4499 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4500 non_constant_p
, overflow_p
);
4505 r
= DECL_EXPR_DECL (t
);
4506 if (TREE_CODE (r
) == USING_DECL
)
4511 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4512 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4516 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4517 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4518 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4522 if (tree init
= DECL_INITIAL (r
))
4524 init
= cxx_eval_constant_expression (ctx
, init
,
4526 non_constant_p
, overflow_p
);
4527 /* Don't share a CONSTRUCTOR that might be changed. */
4528 init
= unshare_constructor (init
);
4529 ctx
->values
->put (r
, init
);
4531 else if (ctx
== &new_ctx
)
4532 /* We gave it a CONSTRUCTOR above. */;
4534 ctx
->values
->put (r
, NULL_TREE
);
4539 if (!literal_type_p (TREE_TYPE (t
)))
4543 auto_diagnostic_group d
;
4544 error ("temporary of non-literal type %qT in a "
4545 "constant expression", TREE_TYPE (t
));
4546 explain_non_literal_class (TREE_TYPE (t
));
4548 *non_constant_p
= true;
4551 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4553 /* We're being expanded without an explicit target, so start
4554 initializing a new object; expansion with an explicit target
4555 strips the TARGET_EXPR before we get here. */
4557 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4558 CONSTRUCTOR_NO_CLEARING (new_ctx
.ctor
) = true;
4559 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4560 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4563 /* Pass false for 'lval' because this indicates
4564 initialization of a temporary. */
4565 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4567 non_constant_p
, overflow_p
);
4568 if (!*non_constant_p
)
4569 /* Adjust the type of the result to the type of the temporary. */
4570 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4573 tree slot
= TARGET_EXPR_SLOT (t
);
4574 r
= unshare_constructor (r
);
4575 ctx
->values
->put (slot
, r
);
4582 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4583 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4584 non_constant_p
, overflow_p
);
4588 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4590 non_constant_p
, overflow_p
);
4594 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4595 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4597 non_constant_p
, overflow_p
);
4605 /* Can happen with ({ return true; }) && false; passed to
4606 maybe_constant_value. There is nothing to jump over in this
4607 case, and the bug will be diagnosed later. */
4608 gcc_assert (ctx
->quiet
);
4609 *non_constant_p
= true;
4614 /* Avoid evaluating a SAVE_EXPR more than once. */
4615 if (tree
*p
= ctx
->values
->get (t
))
4619 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4620 non_constant_p
, overflow_p
);
4621 ctx
->values
->put (t
, r
);
4622 if (ctx
->save_exprs
)
4623 ctx
->save_exprs
->add (t
);
4627 case NON_LVALUE_EXPR
:
4628 case TRY_CATCH_EXPR
:
4630 case CLEANUP_POINT_EXPR
:
4631 case MUST_NOT_THROW_EXPR
:
4634 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4636 non_constant_p
, overflow_p
,
4640 case TRY_FINALLY_EXPR
:
4641 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4642 non_constant_p
, overflow_p
,
4644 if (!*non_constant_p
)
4645 /* Also evaluate the cleanup. */
4646 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4647 non_constant_p
, overflow_p
,
4652 r
= cxx_eval_constant_expression (ctx
, CLEANUP_BODY (t
), lval
,
4653 non_constant_p
, overflow_p
,
4655 if (!CLEANUP_EH_ONLY (t
) && !*non_constant_p
)
4656 /* Also evaluate the cleanup. */
4657 cxx_eval_constant_expression (ctx
, CLEANUP_EXPR (t
), true,
4658 non_constant_p
, overflow_p
,
4662 /* These differ from cxx_eval_unary_expression in that this doesn't
4663 check for a constant operand or result; an address can be
4664 constant without its operand being, and vice versa. */
4667 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4668 non_constant_p
, overflow_p
);
4673 tree oldop
= TREE_OPERAND (t
, 0);
4674 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4676 non_constant_p
, overflow_p
);
4677 /* Don't VERIFY_CONSTANT here. */
4678 if (*non_constant_p
)
4680 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4681 /* This function does more aggressive folding than fold itself. */
4682 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4683 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4692 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4693 non_constant_p
, overflow_p
);
4694 if (r
== error_mark_node
)
4696 else if (r
== TREE_OPERAND (t
, 0))
4699 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4704 case FIX_TRUNC_EXPR
:
4710 case TRUTH_NOT_EXPR
:
4711 case FIXED_CONVERT_EXPR
:
4712 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4713 non_constant_p
, overflow_p
);
4717 r
= cxx_eval_constant_expression (ctx
, fold_sizeof_expr (t
), lval
,
4718 non_constant_p
, overflow_p
,
4724 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4725 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4726 introduced by build_call_a. */
4727 tree op0
= TREE_OPERAND (t
, 0);
4728 tree op1
= TREE_OPERAND (t
, 1);
4730 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4731 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4732 r
= cxx_eval_constant_expression (ctx
, op0
,
4733 lval
, non_constant_p
, overflow_p
,
4737 /* Check that the LHS is constant and then discard it. */
4738 cxx_eval_constant_expression (ctx
, op0
,
4739 true, non_constant_p
, overflow_p
,
4741 if (*non_constant_p
)
4743 op1
= TREE_OPERAND (t
, 1);
4744 r
= cxx_eval_constant_expression (ctx
, op1
,
4745 lval
, non_constant_p
, overflow_p
,
4751 case POINTER_PLUS_EXPR
:
4752 case POINTER_DIFF_EXPR
:
4756 case TRUNC_DIV_EXPR
:
4758 case FLOOR_DIV_EXPR
:
4759 case ROUND_DIV_EXPR
:
4760 case TRUNC_MOD_EXPR
:
4762 case ROUND_MOD_EXPR
:
4764 case EXACT_DIV_EXPR
:
4774 case TRUTH_XOR_EXPR
:
4781 case UNORDERED_EXPR
:
4791 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4792 non_constant_p
, overflow_p
);
4795 /* fold can introduce non-IF versions of these; still treat them as
4796 short-circuiting. */
4797 case TRUTH_AND_EXPR
:
4798 case TRUTH_ANDIF_EXPR
:
4799 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4802 non_constant_p
, overflow_p
);
4806 case TRUTH_ORIF_EXPR
:
4807 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4810 non_constant_p
, overflow_p
);
4814 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4815 non_constant_p
, overflow_p
);
4819 if (is_overloaded_fn (t
))
4821 /* We can only get here in checking mode via
4822 build_non_dependent_expr, because any expression that
4823 calls or takes the address of the function will have
4824 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4825 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4826 *non_constant_p
= true;
4829 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4830 non_constant_p
, overflow_p
);
4834 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4835 non_constant_p
, overflow_p
);
4840 if (jump_target
&& *jump_target
)
4842 tree orig_jump
= *jump_target
;
4843 tree arg
= ((TREE_CODE (t
) != IF_STMT
|| TREE_OPERAND (t
, 1))
4844 ? TREE_OPERAND (t
, 1) : void_node
);
4845 /* When jumping to a label, the label might be either in the
4846 then or else blocks, so process then block first in skipping
4847 mode first, and if we are still in the skipping mode at its end,
4848 process the else block too. */
4849 r
= cxx_eval_constant_expression (ctx
, arg
, lval
, non_constant_p
,
4850 overflow_p
, jump_target
);
4851 /* It's possible that we found the label in the then block. But
4852 it could have been followed by another jumping statement, e.g.
4853 say we're looking for case 1:
4856 // skipped statements
4857 case 1:; // clears up *jump_target
4858 return 1; // and sets it to a RETURN_EXPR
4861 in which case we need not go looking to the else block.
4862 (goto is not allowed in a constexpr function.) */
4863 if (*jump_target
== orig_jump
)
4865 arg
= ((TREE_CODE (t
) != IF_STMT
|| TREE_OPERAND (t
, 2))
4866 ? TREE_OPERAND (t
, 2) : void_node
);
4867 r
= cxx_eval_constant_expression (ctx
, arg
, lval
, non_constant_p
,
4868 overflow_p
, jump_target
);
4872 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4873 non_constant_p
, overflow_p
,
4877 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4882 if (TREE_CONSTANT (t
) && reduced_constant_expression_p (t
))
4884 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4885 VECTOR_CST if applicable. */
4886 verify_constructor_flags (t
);
4887 if (TREE_CONSTANT (t
))
4890 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4891 non_constant_p
, overflow_p
);
4895 /* We can get this in a defaulted constructor for a class with a
4896 non-static data member of array type. Either the initializer will
4897 be NULL, meaning default-initialization, or it will be an lvalue
4898 or xvalue of the same type, meaning direct-initialization from the
4899 corresponding member. */
4900 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4901 non_constant_p
, overflow_p
);
4905 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4906 non_constant_p
, overflow_p
);
4910 if (REINTERPRET_CAST_P (t
))
4913 error_at (cp_expr_loc_or_loc (t
, input_location
),
4914 "a reinterpret_cast is not a constant expression");
4915 *non_constant_p
= true;
4920 case VIEW_CONVERT_EXPR
:
4921 case UNARY_PLUS_EXPR
:
4923 tree oldop
= TREE_OPERAND (t
, 0);
4925 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4927 non_constant_p
, overflow_p
);
4928 if (*non_constant_p
)
4930 tree type
= TREE_TYPE (t
);
4931 if (TREE_CODE (op
) == PTRMEM_CST
4932 && !TYPE_PTRMEM_P (type
))
4933 op
= cplus_expand_constant (op
);
4935 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4937 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (op
))
4938 && !can_convert_qual (type
, op
))
4939 op
= cplus_expand_constant (op
);
4940 return cp_fold_convert (type
, op
);
4943 if (INDIRECT_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4945 if (integer_zerop (op
))
4947 if (TYPE_REF_P (type
))
4950 error_at (cp_expr_loc_or_loc (t
, input_location
),
4951 "dereferencing a null pointer");
4952 *non_constant_p
= true;
4955 else if (TYPE_PTR_P (TREE_TYPE (op
)))
4957 tree from
= TREE_TYPE (op
);
4959 if (!can_convert (type
, from
, tf_none
))
4962 error_at (cp_expr_loc_or_loc (t
, input_location
),
4963 "conversion of %qT null pointer to %qT "
4964 "is not a constant expression",
4966 *non_constant_p
= true;
4973 /* This detects for example:
4974 reinterpret_cast<void*>(sizeof 0)
4977 error_at (cp_expr_loc_or_loc (t
, input_location
),
4978 "%<reinterpret_cast<%T>(%E)%> is not "
4979 "a constant expression",
4981 *non_constant_p
= true;
4986 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4987 /* We didn't fold at the top so we could check for ptr-int
4991 /* Handle an array's bounds having been deduced after we built
4992 the wrapping expression. */
4993 if (same_type_ignoring_tlq_and_bounds_p (type
, TREE_TYPE (op
)))
4995 else if (tcode
== UNARY_PLUS_EXPR
)
4996 r
= fold_convert (TREE_TYPE (t
), op
);
4998 r
= fold_build1 (tcode
, type
, op
);
5000 /* Conversion of an out-of-range value has implementation-defined
5001 behavior; the language considers it different from arithmetic
5002 overflow, which is undefined. */
5003 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
5004 TREE_OVERFLOW (r
) = false;
5008 case EMPTY_CLASS_EXPR
:
5009 /* This is good enough for a function argument that might not get
5010 used, and they can't do anything with it, so just return it. */
5013 case STATEMENT_LIST
:
5015 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
5016 return cxx_eval_statement_list (&new_ctx
, t
,
5017 non_constant_p
, overflow_p
, jump_target
);
5020 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
5022 non_constant_p
, overflow_p
,
5025 case PREINCREMENT_EXPR
:
5026 case POSTINCREMENT_EXPR
:
5027 case PREDECREMENT_EXPR
:
5028 case POSTDECREMENT_EXPR
:
5029 return cxx_eval_increment_expression (ctx
, t
,
5030 lval
, non_constant_p
, overflow_p
);
5036 case VEC_DELETE_EXPR
:
5039 /* GCC internal stuff. */
5041 case NON_DEPENDENT_EXPR
:
5045 error_at (cp_expr_loc_or_loc (t
, input_location
),
5046 "expression %qE is not a constant expression", t
);
5047 *non_constant_p
= true;
5052 /* Virtual function call. Let the constexpr machinery figure out
5053 the dynamic type. */
5054 int token
= tree_to_shwi (OBJ_TYPE_REF_TOKEN (t
));
5055 tree obj
= OBJ_TYPE_REF_OBJECT (t
);
5056 obj
= cxx_eval_constant_expression (ctx
, obj
, lval
, non_constant_p
,
5058 /* We expect something in the form of &x.D.2103.D.2094; get x. */
5059 if (TREE_CODE (obj
) != ADDR_EXPR
5060 || !DECL_P (get_base_address (TREE_OPERAND (obj
, 0))))
5063 error_at (cp_expr_loc_or_loc (t
, input_location
),
5064 "expression %qE is not a constant expression", t
);
5065 *non_constant_p
= true;
5068 obj
= TREE_OPERAND (obj
, 0);
5069 while (TREE_CODE (obj
) == COMPONENT_REF
5070 && DECL_FIELD_IS_BASE (TREE_OPERAND (obj
, 1)))
5071 obj
= TREE_OPERAND (obj
, 0);
5072 tree objtype
= TREE_TYPE (obj
);
5073 /* Find the function decl in the virtual functions list. TOKEN is
5074 the DECL_VINDEX that says which function we're looking for. */
5075 tree virtuals
= BINFO_VIRTUALS (TYPE_BINFO (objtype
));
5076 if (TARGET_VTABLE_USES_DESCRIPTORS
)
5077 token
/= MAX (TARGET_VTABLE_USES_DESCRIPTORS
, 1);
5078 r
= TREE_VALUE (chain_index (token
, virtuals
));
5082 case PLACEHOLDER_EXPR
:
5083 /* Use of the value or address of the current object. */
5084 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
5085 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
5086 non_constant_p
, overflow_p
);
5087 /* A placeholder without a referent. We can get here when
5088 checking whether NSDMIs are noexcept, or in massage_init_elt;
5089 just say it's non-constant for now. */
5090 gcc_assert (ctx
->quiet
);
5091 *non_constant_p
= true;
5096 tree cond
= TREE_OPERAND (t
, 0);
5097 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
5098 non_constant_p
, overflow_p
);
5099 VERIFY_CONSTANT (cond
);
5100 if (integer_nonzerop (cond
))
5106 *jump_target
= TREE_OPERAND (t
, 0);
5107 gcc_assert (breaks (jump_target
) || continues (jump_target
)
5108 /* Allow for jumping to a cdtor_label. */
5109 || returns (jump_target
));
5116 cxx_eval_loop_expr (ctx
, t
,
5117 non_constant_p
, overflow_p
, jump_target
);
5122 cxx_eval_switch_expr (ctx
, t
,
5123 non_constant_p
, overflow_p
, jump_target
);
5127 /* It's possible to get a requires-expression in a constant
5128 expression. For example:
5130 template<typename T> concept bool C() {
5131 return requires (T t) { t; };
5134 template<typename T> requires !C<T>() void f(T);
5136 Normalization leaves f with the associated constraint
5137 '!requires (T t) { ... }' which is not transformed into
5139 if (!processing_template_decl
)
5140 return evaluate_constraint_expression (t
, NULL_TREE
);
5142 *non_constant_p
= true;
5146 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
5148 non_constant_p
, overflow_p
,
5157 if (STATEMENT_CODE_P (TREE_CODE (t
)))
5159 /* This function doesn't know how to deal with pre-genericize
5160 statements; this can only happen with statement-expressions,
5161 so for now just fail. */
5163 error_at (EXPR_LOCATION (t
),
5164 "statement is not a constant expression");
5167 internal_error ("unexpected expression %qE of kind %s", t
,
5168 get_tree_code_name (TREE_CODE (t
)));
5169 *non_constant_p
= true;
5173 if (r
== error_mark_node
)
5174 *non_constant_p
= true;
5176 if (*non_constant_p
)
5182 /* P0859: A function is needed for constant evaluation if it is a constexpr
5183 function that is named by an expression ([basic.def.odr]) that is
5184 potentially constant evaluated.
5186 So we need to instantiate any constexpr functions mentioned by the
5187 expression even if the definition isn't needed for evaluating the
5191 instantiate_cx_fn_r (tree
*tp
, int *walk_subtrees
, void */
*data*/
)
5193 if (TREE_CODE (*tp
) == FUNCTION_DECL
5194 && DECL_DECLARED_CONSTEXPR_P (*tp
)
5195 && !DECL_INITIAL (*tp
)
5196 && !trivial_fn_p (*tp
)
5197 && DECL_TEMPLOID_INSTANTIATION (*tp
))
5200 instantiate_decl (*tp
, /*defer_ok*/false, /*expl_inst*/false);
5203 else if (TREE_CODE (*tp
) == CALL_EXPR
5204 || TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
5206 if (EXPR_HAS_LOCATION (*tp
))
5207 input_location
= EXPR_LOCATION (*tp
);
5216 instantiate_constexpr_fns (tree t
)
5218 location_t loc
= input_location
;
5219 cp_walk_tree_without_duplicates (&t
, instantiate_cx_fn_r
, NULL
);
5220 input_location
= loc
;
5223 /* ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5224 STRICT has the same sense as for constant_value_1: true if we only allow
5225 conforming C++ constant expressions, or false if we want a constant value
5226 even if it doesn't conform.
5227 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
5228 per P0595 even when ALLOW_NON_CONSTANT is true. */
5231 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
5233 bool manifestly_const_eval
= false,
5234 tree object
= NULL_TREE
)
5236 auto_timevar
time (TV_CONSTEXPR
);
5238 bool non_constant_p
= false;
5239 bool overflow_p
= false;
5240 hash_map
<tree
,tree
> map
;
5242 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
5243 allow_non_constant
, strict
,
5244 manifestly_const_eval
|| !allow_non_constant
};
5246 tree type
= initialized_type (t
);
5248 if (VOID_TYPE_P (type
))
5250 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5252 /* In C++14 an NSDMI can participate in aggregate initialization,
5253 and can refer to the address of the object being initialized, so
5254 we need to pass in the relevant VAR_DECL if we want to do the
5255 evaluation in a single pass. The evaluation will dynamically
5256 update ctx.values for the VAR_DECL. We use the same strategy
5257 for C++11 constexpr constructors that refer to the object being
5259 ctx
.ctor
= build_constructor (type
, NULL
);
5260 CONSTRUCTOR_NO_CLEARING (ctx
.ctor
) = true;
5263 if (TREE_CODE (t
) == TARGET_EXPR
)
5264 object
= TARGET_EXPR_SLOT (t
);
5265 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5266 object
= AGGR_INIT_EXPR_SLOT (t
);
5268 ctx
.object
= object
;
5270 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5271 (type
, TREE_TYPE (object
)));
5272 if (object
&& DECL_P (object
))
5273 map
.put (object
, ctx
.ctor
);
5274 if (TREE_CODE (r
) == TARGET_EXPR
)
5275 /* Avoid creating another CONSTRUCTOR when we expand the
5277 r
= TARGET_EXPR_INITIAL (r
);
5280 instantiate_constexpr_fns (r
);
5281 r
= cxx_eval_constant_expression (&ctx
, r
,
5282 false, &non_constant_p
, &overflow_p
);
5284 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
5286 /* Mutable logic is a bit tricky: we want to allow initialization of
5287 constexpr variables with mutable members, but we can't copy those
5288 members to another constexpr variable. */
5289 if (TREE_CODE (r
) == CONSTRUCTOR
5290 && CONSTRUCTOR_MUTABLE_POISON (r
))
5292 if (!allow_non_constant
)
5293 error ("%qE is not a constant expression because it refers to "
5294 "mutable subobjects of %qT", t
, type
);
5295 non_constant_p
= true;
5298 if (TREE_CODE (r
) == CONSTRUCTOR
5299 && CONSTRUCTOR_NO_CLEARING (r
))
5301 if (!allow_non_constant
)
5302 error ("%qE is not a constant expression because it refers to "
5303 "an incompletely initialized variable", t
);
5304 TREE_CONSTANT (r
) = false;
5305 non_constant_p
= true;
5308 /* Technically we should check this for all subexpressions, but that
5309 runs into problems with our internal representation of pointer
5310 subtraction and the 5.19 rules are still in flux. */
5311 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
5312 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
5313 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
5315 if (!allow_non_constant
)
5316 error ("conversion from pointer type %qT "
5317 "to arithmetic type %qT in a constant expression",
5318 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
5319 non_constant_p
= true;
5322 if (!non_constant_p
&& overflow_p
)
5323 non_constant_p
= true;
5325 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
5327 bool should_unshare
= true;
5328 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
5329 should_unshare
= false;
5331 if (non_constant_p
&& !allow_non_constant
)
5332 return error_mark_node
;
5333 else if (non_constant_p
&& TREE_CONSTANT (r
))
5335 /* If __builtin_is_constant_evaluated () was evaluated to true
5336 and the result is not a valid constant expression, we need to
5338 if (manifestly_const_eval
)
5339 return cxx_eval_outermost_constant_expr (t
, true, strict
,
5341 /* This isn't actually constant, so unset TREE_CONSTANT.
5342 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
5343 it to be set if it is invariant address, even when it is not
5344 a valid C++ constant expression. Wrap it with a NOP_EXPR
5346 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
5348 else if (TREE_CODE (r
) == CONSTRUCTOR
)
5349 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
5351 r
= build_nop (TREE_TYPE (r
), r
);
5352 TREE_CONSTANT (r
) = false;
5354 else if (non_constant_p
)
5358 r
= unshare_expr (r
);
5360 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
5362 r
= adjust_temp_type (type
, r
);
5363 if (TREE_CODE (t
) == TARGET_EXPR
5364 && TARGET_EXPR_INITIAL (t
) == r
)
5366 else if (TREE_CODE (t
) != CONSTRUCTOR
)
5368 r
= get_target_expr (r
);
5369 TREE_CONSTANT (r
) = true;
5376 /* Returns true if T is a valid subexpression of a constant expression,
5377 even if it isn't itself a constant expression. */
5380 is_sub_constant_expr (tree t
)
5382 bool non_constant_p
= false;
5383 bool overflow_p
= false;
5384 hash_map
<tree
, tree
> map
;
5387 = { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true, false };
5389 instantiate_constexpr_fns (t
);
5390 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
5392 return !non_constant_p
&& !overflow_p
;
5395 /* If T represents a constant expression returns its reduced value.
5396 Otherwise return error_mark_node. If T is dependent, then
5400 cxx_constant_value (tree t
, tree decl
)
5402 return cxx_eval_outermost_constant_expr (t
, false, true, true, decl
);
5405 /* Helper routine for fold_simple function. Either return simplified
5406 expression T, otherwise NULL_TREE.
5407 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
5408 even if we are within template-declaration. So be careful on call, as in
5409 such case types can be undefined. */
5412 fold_simple_1 (tree t
)
5415 enum tree_code code
= TREE_CODE (t
);
5427 return fold_sizeof_expr (t
);
5436 case TRUTH_NOT_EXPR
:
5438 case VIEW_CONVERT_EXPR
:
5441 case FIX_TRUNC_EXPR
:
5442 case FIXED_CONVERT_EXPR
:
5443 case ADDR_SPACE_CONVERT_EXPR
:
5445 op1
= TREE_OPERAND (t
, 0);
5447 t
= const_unop (code
, TREE_TYPE (t
), op1
);
5451 if (CONVERT_EXPR_CODE_P (code
)
5452 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
5453 TREE_OVERFLOW (t
) = false;
5461 /* If T is a simple constant expression, returns its simplified value.
5462 Otherwise returns T. In contrast to maybe_constant_value we
5463 simplify only few operations on constant-expressions, and we don't
5464 try to simplify constexpressions. */
5467 fold_simple (tree t
)
5469 if (processing_template_decl
)
5472 tree r
= fold_simple_1 (t
);
5479 /* If T is a constant expression, returns its reduced value.
5480 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5481 Otherwise, returns a version of T without TREE_CONSTANT.
5482 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated
5485 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5488 maybe_constant_value (tree t
, tree decl
, bool manifestly_const_eval
)
5492 if (!is_nondependent_constant_expression (t
))
5494 if (TREE_OVERFLOW_P (t
))
5496 t
= build_nop (TREE_TYPE (t
), t
);
5497 TREE_CONSTANT (t
) = false;
5501 else if (CONSTANT_CLASS_P (t
))
5502 /* No caching or evaluation needed. */
5505 if (manifestly_const_eval
)
5506 return cxx_eval_outermost_constant_expr (t
, true, true, true, decl
);
5508 if (cv_cache
== NULL
)
5509 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5510 if (tree
*cached
= cv_cache
->get (t
))
5513 r
= cxx_eval_outermost_constant_expr (t
, true, true, false, decl
);
5514 gcc_checking_assert (r
== t
5515 || CONVERT_EXPR_P (t
)
5516 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5517 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5518 || !cp_tree_equal (r
, t
));
5519 cv_cache
->put (t
, r
);
5523 /* Dispose of the whole CV_CACHE. */
5526 clear_cv_cache (void)
5528 if (cv_cache
!= NULL
)
5532 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5535 clear_cv_and_fold_caches (void)
5538 clear_fold_cache ();
5541 /* Like maybe_constant_value but first fully instantiate the argument.
5543 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5544 (t, complain) followed by maybe_constant_value but is more efficient,
5545 because it calls instantiation_dependent_expression_p and
5546 potential_constant_expression at most once.
5547 The manifestly_const_eval argument is passed to maybe_constant_value.
5549 Callers should generally pass their active complain, or if they are in a
5550 non-template, diagnosing context, they can use the default of
5551 tf_warning_or_error. Callers that might be within a template context, don't
5552 have a complain parameter, and aren't going to remember the result for long
5553 (e.g. null_ptr_cst_p), can pass tf_none and deal with error_mark_node
5557 fold_non_dependent_expr (tree t
,
5558 tsubst_flags_t complain
/* = tf_warning_or_error */,
5559 bool manifestly_const_eval
/* = false */)
5564 /* If we're in a template, but T isn't value dependent, simplify
5565 it. We're supposed to treat:
5567 template <typename T> void f(T[1 + 1]);
5568 template <typename T> void f(T[2]);
5570 as two declarations of the same function, for example. */
5571 if (processing_template_decl
)
5573 if (is_nondependent_constant_expression (t
))
5575 processing_template_decl_sentinel s
;
5576 t
= instantiate_non_dependent_expr_internal (t
, complain
);
5578 if (type_unknown_p (t
)
5579 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5581 if (TREE_OVERFLOW_P (t
))
5583 t
= build_nop (TREE_TYPE (t
), t
);
5584 TREE_CONSTANT (t
) = false;
5589 tree r
= cxx_eval_outermost_constant_expr (t
, true, true,
5590 manifestly_const_eval
,
5592 /* cp_tree_equal looks through NOPs, so allow them. */
5593 gcc_checking_assert (r
== t
5594 || CONVERT_EXPR_P (t
)
5595 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5596 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5597 || !cp_tree_equal (r
, t
));
5600 else if (TREE_OVERFLOW_P (t
))
5602 t
= build_nop (TREE_TYPE (t
), t
);
5603 TREE_CONSTANT (t
) = false;
5608 return maybe_constant_value (t
, NULL_TREE
, manifestly_const_eval
);
5611 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5612 than wrapped in a TARGET_EXPR.
5613 ALLOW_NON_CONSTANT is false if T is required to be a constant expression.
5614 MANIFESTLY_CONST_EVAL is true if T is manifestly const-evaluated as
5615 per P0595 even when ALLOW_NON_CONSTANT is true. */
5618 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
,
5619 bool manifestly_const_eval
)
5623 if (TREE_CODE (t
) == EXPR_STMT
)
5624 t
= TREE_OPERAND (t
, 0);
5625 if (TREE_CODE (t
) == CONVERT_EXPR
5626 && VOID_TYPE_P (TREE_TYPE (t
)))
5627 t
= TREE_OPERAND (t
, 0);
5628 if (TREE_CODE (t
) == INIT_EXPR
)
5629 t
= TREE_OPERAND (t
, 1);
5630 if (TREE_CODE (t
) == TARGET_EXPR
)
5631 t
= TARGET_EXPR_INITIAL (t
);
5632 if (!is_nondependent_static_init_expression (t
))
5633 /* Don't try to evaluate it. */;
5634 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5635 /* No evaluation needed. */;
5637 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
,
5639 manifestly_const_eval
, decl
);
5640 if (TREE_CODE (t
) == TARGET_EXPR
)
5642 tree init
= TARGET_EXPR_INITIAL (t
);
5643 if (TREE_CODE (init
) == CONSTRUCTOR
)
5649 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5652 maybe_constant_init (tree t
, tree decl
, bool manifestly_const_eval
)
5654 return maybe_constant_init_1 (t
, decl
, true, manifestly_const_eval
);
5657 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5660 cxx_constant_init (tree t
, tree decl
)
5662 return maybe_constant_init_1 (t
, decl
, false, true);
5666 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5667 /* Return true if the object referred to by REF has automatic or thread
5670 enum { ck_ok
, ck_bad
, ck_unknown
};
5672 check_automatic_or_tls (tree ref
)
5675 poly_int64 bitsize
, bitpos
;
5677 int volatilep
= 0, unsignedp
= 0;
5678 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5679 &mode
, &unsignedp
, &volatilep
, false);
5682 /* If there isn't a decl in the middle, we don't know the linkage here,
5683 and this isn't a constant expression anyway. */
5686 dk
= decl_storage_duration (decl
);
5687 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5691 /* Return true if T denotes a potentially constant expression. Issue
5692 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5693 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5694 consider the expression in the current context, independent of constexpr
5697 C++0x [expr.const] used to say
5699 6 An expression is a potential constant expression if it is
5700 a constant expression where all occurrences of function
5701 parameters are replaced by arbitrary constant expressions
5702 of the appropriate type.
5704 2 A conditional expression is a constant expression unless it
5705 involves one of the following as a potentially evaluated
5706 subexpression (3.2), but subexpressions of logical AND (5.14),
5707 logical OR (5.15), and conditional (5.16) operations that are
5708 not evaluated are not considered. */
5711 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5712 tsubst_flags_t flags
, tree
*jump_target
)
5714 #define RECUR(T,RV) \
5715 potential_constant_expression_1 ((T), (RV), strict, now, flags, jump_target)
5717 enum { any
= false, rval
= true };
5721 if (t
== error_mark_node
)
5725 location_t loc
= cp_expr_loc_or_loc (t
, input_location
);
5728 /* If we are jumping, ignore everything. This is simpler than the
5729 cxx_eval_constant_expression handling because we only need to be
5730 conservatively correct, and we don't necessarily have a constant value
5731 available, so we don't bother with switch tracking. */
5734 if (TREE_THIS_VOLATILE (t
) && want_rval
)
5736 if (flags
& tf_error
)
5737 error_at (loc
, "lvalue-to-rvalue conversion of a volatile lvalue "
5738 "%qE with type %qT", t
, TREE_TYPE (t
));
5741 if (CONSTANT_CLASS_P (t
))
5743 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5744 && TREE_TYPE (t
) == error_mark_node
)
5747 switch (TREE_CODE (t
))
5753 case TEMPLATE_ID_EXPR
:
5756 case CASE_LABEL_EXPR
:
5762 case TEMPLATE_PARM_INDEX
:
5764 case IDENTIFIER_NODE
:
5765 case USERDEF_LITERAL
:
5766 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5771 case PLACEHOLDER_EXPR
:
5774 case DEBUG_BEGIN_STMT
:
5778 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5790 if (flags
& tf_error
)
5791 error ("%qE is not a constant expression", t
);
5796 case AGGR_INIT_EXPR
:
5798 /* -- an invocation of a function other than a constexpr function
5799 or a constexpr constructor. */
5801 tree fun
= get_function_named_in_call (t
);
5802 const int nargs
= call_expr_nargs (t
);
5805 if (fun
== NULL_TREE
)
5807 /* Reset to allow the function to continue past the end
5808 of the block below. Otherwise return early. */
5811 if (TREE_CODE (t
) == CALL_EXPR
5812 && CALL_EXPR_FN (t
) == NULL_TREE
)
5813 switch (CALL_EXPR_IFN (t
))
5815 /* These should be ignored, they are optimized away from
5816 constexpr functions. */
5817 case IFN_UBSAN_NULL
:
5818 case IFN_UBSAN_BOUNDS
:
5819 case IFN_UBSAN_VPTR
:
5820 case IFN_FALLTHROUGH
:
5823 case IFN_ADD_OVERFLOW
:
5824 case IFN_SUB_OVERFLOW
:
5825 case IFN_MUL_OVERFLOW
:
5827 case IFN_VEC_CONVERT
:
5837 /* fold_call_expr can't do anything with IFN calls. */
5838 if (flags
& tf_error
)
5839 error_at (loc
, "call to internal function %qE", t
);
5844 if (fun
&& is_overloaded_fn (fun
))
5846 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5848 if (builtin_valid_in_constant_expr_p (fun
))
5850 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5851 /* Allow any built-in function; if the expansion
5852 isn't constant, we'll deal with that then. */
5853 && !fndecl_built_in_p (fun
))
5855 if (flags
& tf_error
)
5857 error_at (loc
, "call to non-%<constexpr%> function %qD",
5859 explain_invalid_constexpr_fn (fun
);
5863 /* A call to a non-static member function takes the address
5864 of the object as the first argument. But in a constant
5865 expression the address will be folded away, so look
5867 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5868 && !DECL_CONSTRUCTOR_P (fun
))
5870 tree x
= get_nth_callarg (t
, 0);
5871 if (is_this_parameter (x
))
5873 /* Don't require an immediately constant value, as
5874 constexpr substitution might not use the value. */
5875 bool sub_now
= false;
5876 if (!potential_constant_expression_1 (x
, rval
, strict
,
5885 if (!RECUR (fun
, true))
5887 fun
= get_first_fn (fun
);
5889 /* Skip initial arguments to base constructors. */
5890 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5891 i
= num_artificial_parms_for (fun
);
5892 fun
= DECL_ORIGIN (fun
);
5896 if (RECUR (fun
, rval
))
5897 /* Might end up being a constant function pointer. */;
5901 for (; i
< nargs
; ++i
)
5903 tree x
= get_nth_callarg (t
, i
);
5904 /* In a template, reference arguments haven't been converted to
5905 REFERENCE_TYPE and we might not even know if the parameter
5906 is a reference, so accept lvalue constants too. */
5907 bool rv
= processing_template_decl
? any
: rval
;
5908 /* Don't require an immediately constant value, as constexpr
5909 substitution might not use the value of the argument. */
5910 bool sub_now
= false;
5911 if (!potential_constant_expression_1 (x
, rv
, strict
,
5912 sub_now
, flags
, jump_target
))
5918 case NON_LVALUE_EXPR
:
5919 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5920 -- an lvalue of integral type that refers to a non-volatile
5921 const variable or static data member initialized with
5922 constant expressions, or
5924 -- an lvalue of literal type that refers to non-volatile
5925 object defined with constexpr, or that refers to a
5926 sub-object of such an object; */
5927 return RECUR (TREE_OPERAND (t
, 0), rval
);
5930 if (DECL_HAS_VALUE_EXPR_P (t
))
5932 if (now
&& is_normal_capture_proxy (t
))
5934 /* -- in a lambda-expression, a reference to this or to a
5935 variable with automatic storage duration defined outside that
5936 lambda-expression, where the reference would be an
5938 if (flags
& tf_error
)
5940 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5941 error ("lambda capture of %qE is not a constant expression",
5943 if (!want_rval
&& decl_constant_var_p (cap
))
5944 inform (input_location
, "because it is used as a glvalue");
5948 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5951 && !var_in_maybe_constexpr_fn (t
)
5952 && !type_dependent_expression_p (t
)
5953 && !decl_maybe_constant_var_p (t
)
5955 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5956 || (DECL_INITIAL (t
)
5957 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5958 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5959 && !is_really_empty_class (TREE_TYPE (t
)))
5961 if (flags
& tf_error
)
5962 non_const_var_error (t
);
5969 case VIEW_CONVERT_EXPR
:
5970 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5971 may change to something more specific to type-punning (DR 1312). */
5973 tree from
= TREE_OPERAND (t
, 0);
5974 if (location_wrapper_p (t
))
5975 return (RECUR (from
, want_rval
));
5976 if (INDIRECT_TYPE_P (TREE_TYPE (t
)))
5978 STRIP_ANY_LOCATION_WRAPPER (from
);
5979 if (TREE_CODE (from
) == INTEGER_CST
5980 && !integer_zerop (from
))
5982 if (flags
& tf_error
)
5983 error_at (loc
, "reinterpret_cast from integer to pointer");
5987 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5990 case ADDRESSOF_EXPR
:
5991 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5992 t
= TREE_OPERAND (t
, 0);
5993 goto handle_addr_expr
;
5996 /* -- a unary operator & that is applied to an lvalue that
5997 designates an object with thread or automatic storage
5999 t
= TREE_OPERAND (t
, 0);
6001 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
6002 /* A pointer-to-member constant. */
6007 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
6008 any checking here, as we might dereference the pointer later. If
6009 we remove this code, also remove check_automatic_or_tls. */
6010 i
= check_automatic_or_tls (t
);
6015 if (flags
& tf_error
)
6016 error ("address-of an object %qE with thread local or "
6017 "automatic storage is not a constant expression", t
);
6021 return RECUR (t
, any
);
6029 /* -- a class member access unless its postfix-expression is
6030 of literal type or of pointer to literal type. */
6031 /* This test would be redundant, as it follows from the
6032 postfix-expression being a potential constant expression. */
6033 if (type_unknown_p (t
))
6035 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6037 case EXPR_PACK_EXPANSION
:
6038 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
6042 tree x
= TREE_OPERAND (t
, 0);
6044 if (is_this_parameter (x
) && !is_capture_proxy (x
))
6046 if (!var_in_maybe_constexpr_fn (x
))
6048 if (flags
& tf_error
)
6049 error_at (loc
, "use of %<this%> in a constant expression");
6054 return RECUR (x
, rval
);
6057 case STATEMENT_LIST
:
6059 tree_stmt_iterator i
;
6060 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
6062 if (!RECUR (tsi_stmt (i
), any
))
6070 if (cxx_dialect
< cxx14
)
6072 if (!RECUR (TREE_OPERAND (t
, 0), any
))
6074 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
6079 if (cxx_dialect
< cxx14
)
6081 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
6083 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
6088 if (!RECUR (DO_COND (t
), rval
))
6090 if (!RECUR (DO_BODY (t
), any
))
6092 if (breaks (jump_target
) || continues (jump_target
))
6093 *jump_target
= NULL_TREE
;
6097 if (!RECUR (FOR_INIT_STMT (t
), any
))
6100 if (!RECUR (tmp
, rval
))
6104 if (!processing_template_decl
)
6105 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6106 /* If we couldn't evaluate the condition, it might not ever be
6108 if (!integer_onep (tmp
))
6111 if (!RECUR (FOR_EXPR (t
), any
))
6113 if (!RECUR (FOR_BODY (t
), any
))
6115 if (breaks (jump_target
) || continues (jump_target
))
6116 *jump_target
= NULL_TREE
;
6119 case RANGE_FOR_STMT
:
6120 if (!RECUR (RANGE_FOR_INIT_STMT (t
), any
))
6122 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
6124 if (!RECUR (RANGE_FOR_BODY (t
), any
))
6126 if (breaks (jump_target
) || continues (jump_target
))
6127 *jump_target
= NULL_TREE
;
6131 tmp
= WHILE_COND (t
);
6132 if (!RECUR (tmp
, rval
))
6134 if (!processing_template_decl
)
6135 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6136 /* If we couldn't evaluate the condition, it might not ever be true. */
6137 if (!integer_onep (tmp
))
6139 if (!RECUR (WHILE_BODY (t
), any
))
6141 if (breaks (jump_target
) || continues (jump_target
))
6142 *jump_target
= NULL_TREE
;
6146 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
6148 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
6149 unreachable labels would be checked. */
6153 return RECUR (STMT_EXPR_STMT (t
), rval
);
6156 if (cxx_dialect
>= cxx17
)
6157 /* In C++17 lambdas can be constexpr, don't give up yet. */
6159 else if (flags
& tf_error
)
6160 error_at (loc
, "lambda-expression is not a constant expression "
6164 case DYNAMIC_CAST_EXPR
:
6165 case PSEUDO_DTOR_EXPR
:
6169 case VEC_DELETE_EXPR
:
6175 case OMP_DISTRIBUTE
:
6178 case OMP_TARGET_DATA
:
6187 case OMP_TARGET_UPDATE
:
6188 case OMP_TARGET_ENTER_DATA
:
6189 case OMP_TARGET_EXIT_DATA
:
6191 case OMP_ATOMIC_READ
:
6192 case OMP_ATOMIC_CAPTURE_OLD
:
6193 case OMP_ATOMIC_CAPTURE_NEW
:
6198 case OACC_HOST_DATA
:
6202 case OACC_ENTER_DATA
:
6203 case OACC_EXIT_DATA
:
6205 /* GCC internal stuff. */
6207 case TRANSACTION_EXPR
:
6209 case AT_ENCODE_EXPR
:
6211 if (flags
& tf_error
)
6212 error_at (loc
, "expression %qE is not a constant expression", t
);
6216 if (cxx_dialect
>= cxx2a
)
6217 /* In C++2a virtual calls can be constexpr, don't give up yet. */
6219 else if (flags
& tf_error
)
6220 error_at (loc
, "virtual functions cannot be constexpr before C++2a");
6224 /* -- a typeid expression whose operand is of polymorphic
6227 tree e
= TREE_OPERAND (t
, 0);
6228 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
6229 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
6231 if (flags
& tf_error
)
6232 error_at (loc
, "typeid-expression is not a constant expression "
6233 "because %qE is of polymorphic type", e
);
6239 case POINTER_DIFF_EXPR
:
6253 case PREINCREMENT_EXPR
:
6254 case POSTINCREMENT_EXPR
:
6255 case PREDECREMENT_EXPR
:
6256 case POSTDECREMENT_EXPR
:
6257 if (cxx_dialect
< cxx14
)
6263 if (TYPE_P (TREE_OPERAND (t
, 0)))
6269 case FIX_TRUNC_EXPR
:
6274 case TRUTH_NOT_EXPR
:
6275 case FIXED_CONVERT_EXPR
:
6276 case UNARY_PLUS_EXPR
:
6277 case UNARY_LEFT_FOLD_EXPR
:
6278 case UNARY_RIGHT_FOLD_EXPR
:
6280 return RECUR (TREE_OPERAND (t
, 0), rval
);
6283 case CONST_CAST_EXPR
:
6284 case STATIC_CAST_EXPR
:
6285 case REINTERPRET_CAST_EXPR
:
6286 case IMPLICIT_CONV_EXPR
:
6287 if (cxx_dialect
< cxx11
6288 && !dependent_type_p (TREE_TYPE (t
))
6289 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
6290 /* In C++98, a conversion to non-integral type can't be part of a
6291 constant expression. */
6293 if (flags
& tf_error
)
6295 "cast to non-integral type %qT in a constant expression",
6299 /* This might be a conversion from a class to a (potentially) literal
6300 type. Let's consider it potentially constant since the conversion
6301 might be a constexpr user-defined conversion. */
6302 else if (cxx_dialect
>= cxx11
6303 && (dependent_type_p (TREE_TYPE (t
))
6304 || !COMPLETE_TYPE_P (TREE_TYPE (t
))
6305 || literal_type_p (TREE_TYPE (t
)))
6306 && TREE_OPERAND (t
, 0))
6308 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6309 /* If this is a dependent type, it could end up being a class
6310 with conversions. */
6311 if (type
== NULL_TREE
|| WILDCARD_TYPE_P (type
))
6313 /* Or a non-dependent class which has conversions. */
6314 else if (CLASS_TYPE_P (type
)
6315 && (TYPE_HAS_CONVERSION (type
) || dependent_scope_p (type
)))
6319 return (RECUR (TREE_OPERAND (t
, 0),
6320 !TYPE_REF_P (TREE_TYPE (t
))));
6323 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
6325 case CLEANUP_POINT_EXPR
:
6326 case MUST_NOT_THROW_EXPR
:
6327 case TRY_CATCH_EXPR
:
6332 case NON_DEPENDENT_EXPR
:
6333 /* For convenience. */
6336 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6339 tmp
= DECL_EXPR_DECL (t
);
6340 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
6342 if (TREE_STATIC (tmp
))
6344 if (flags
& tf_error
)
6345 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6346 "%<static%> in %<constexpr%> context", tmp
);
6349 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
6351 if (flags
& tf_error
)
6352 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
6353 "%<thread_local%> in %<constexpr%> context", tmp
);
6356 else if (!check_for_uninitialized_const_var
6357 (tmp
, /*constexpr_context_p=*/true, flags
))
6360 return RECUR (tmp
, want_rval
);
6362 case TRY_FINALLY_EXPR
:
6363 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
6364 && RECUR (TREE_OPERAND (t
, 1), any
));
6367 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6370 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
6371 && !literal_type_p (TREE_TYPE (t
)))
6373 if (flags
& tf_error
)
6375 auto_diagnostic_group d
;
6376 error_at (loc
, "temporary of non-literal type %qT in a "
6377 "constant expression", TREE_TYPE (t
));
6378 explain_non_literal_class (TREE_TYPE (t
));
6384 return RECUR (TREE_OPERAND (t
, 1), rval
);
6388 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
6389 constructor_elt
*ce
;
6390 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
6391 if (!RECUR (ce
->value
, want_rval
))
6398 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
6399 || DECL_P (TREE_PURPOSE (t
)));
6400 if (!RECUR (TREE_VALUE (t
), want_rval
))
6402 if (TREE_CHAIN (t
) == NULL_TREE
)
6404 return RECUR (TREE_CHAIN (t
), want_rval
);
6407 case TRUNC_DIV_EXPR
:
6409 case FLOOR_DIV_EXPR
:
6410 case ROUND_DIV_EXPR
:
6411 case TRUNC_MOD_EXPR
:
6413 case ROUND_MOD_EXPR
:
6415 tree denom
= TREE_OPERAND (t
, 1);
6416 if (!RECUR (denom
, rval
))
6418 /* We can't call cxx_eval_outermost_constant_expr on an expression
6419 that hasn't been through instantiate_non_dependent_expr yet. */
6420 if (!processing_template_decl
)
6421 denom
= cxx_eval_outermost_constant_expr (denom
, true);
6422 if (integer_zerop (denom
))
6424 if (flags
& tf_error
)
6425 error ("division by zero is not a constant expression");
6431 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
6437 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6438 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6439 introduced by build_call_a. */
6440 tree op0
= TREE_OPERAND (t
, 0);
6441 tree op1
= TREE_OPERAND (t
, 1);
6443 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
6444 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
6445 return RECUR (op0
, want_rval
);
6450 /* If the first operand is the non-short-circuit constant, look at
6451 the second operand; otherwise we only care about the first one for
6453 case TRUTH_AND_EXPR
:
6454 case TRUTH_ANDIF_EXPR
:
6455 tmp
= boolean_true_node
;
6458 case TRUTH_ORIF_EXPR
:
6459 tmp
= boolean_false_node
;
6462 tree op
= TREE_OPERAND (t
, 0);
6463 if (!RECUR (op
, rval
))
6465 if (!processing_template_decl
)
6466 op
= cxx_eval_outermost_constant_expr (op
, true);
6467 if (tree_int_cst_equal (op
, tmp
))
6468 return RECUR (TREE_OPERAND (t
, 1), rval
);
6475 case POINTER_PLUS_EXPR
:
6477 case EXACT_DIV_EXPR
:
6487 case TRUTH_XOR_EXPR
:
6488 case UNORDERED_EXPR
:
6501 case ARRAY_RANGE_REF
:
6505 case BINARY_LEFT_FOLD_EXPR
:
6506 case BINARY_RIGHT_FOLD_EXPR
:
6508 for (i
= 0; i
< 2; ++i
)
6509 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
6514 for (i
= 0; i
< 3; ++i
)
6515 if (!RECUR (TREE_OPERAND (t
, i
), true))
6520 if (COND_EXPR_IS_VEC_DELETE (t
))
6522 if (flags
& tf_error
)
6523 error_at (loc
, "%<delete[]%> is not a constant expression");
6529 /* If the condition is a known constant, we know which of the legs we
6530 care about; otherwise we only require that the condition and
6531 either of the legs be potentially constant. */
6532 tmp
= TREE_OPERAND (t
, 0);
6533 if (!RECUR (tmp
, rval
))
6535 if (!processing_template_decl
)
6536 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
6537 if (integer_zerop (tmp
))
6538 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
6539 else if (TREE_CODE (tmp
) == INTEGER_CST
)
6540 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
6541 for (i
= 1; i
< 3; ++i
)
6542 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
6543 want_rval
, strict
, now
,
6544 tf_none
, jump_target
))
6546 if (flags
& tf_error
)
6547 error_at (loc
, "expression %qE is not a constant expression", t
);
6551 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
6553 if (flags
& tf_error
)
6555 error_at (loc
, "non-constant array initialization");
6556 diagnose_non_constexpr_vec_init (t
);
6562 /* We can see these in statement-expressions. */
6566 case EMPTY_CLASS_EXPR
:
6572 tree
*target
= &TREE_OPERAND (t
, 0);
6573 /* Gotos representing break and continue are OK. */
6574 if (breaks (target
) || continues (target
))
6576 *jump_target
= *target
;
6579 if (flags
& tf_error
)
6580 error_at (loc
, "%<goto%> is not a constant expression");
6585 return RECUR (TREE_OPERAND (t
, 0), rval
);
6588 if (objc_is_property_ref (t
))
6591 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6599 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
6600 tsubst_flags_t flags
)
6602 tree target
= NULL_TREE
;
6603 return potential_constant_expression_1 (t
, want_rval
, strict
, now
,
6607 /* The main entry point to the above. */
6610 potential_constant_expression (tree t
)
6612 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6615 /* As above, but require a constant rvalue. */
6618 potential_rvalue_constant_expression (tree t
)
6620 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6623 /* Like above, but complain about non-constant expressions. */
6626 require_potential_constant_expression (tree t
)
6628 return potential_constant_expression_1 (t
, false, true, false,
6629 tf_warning_or_error
);
6632 /* Cross product of the above. */
6635 require_potential_rvalue_constant_expression (tree t
)
6637 return potential_constant_expression_1 (t
, true, true, false,
6638 tf_warning_or_error
);
6641 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6644 require_rvalue_constant_expression (tree t
)
6646 return potential_constant_expression_1 (t
, true, true, true,
6647 tf_warning_or_error
);
6650 /* Like potential_constant_expression, but don't consider possible constexpr
6651 substitution of the current function. That is, PARM_DECL qualifies under
6652 potential_constant_expression, but not here.
6654 This is basically what you can check when any actual constant values might
6655 be value-dependent. */
6658 is_constant_expression (tree t
)
6660 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6663 /* Like above, but complain about non-constant expressions. */
6666 require_constant_expression (tree t
)
6668 return potential_constant_expression_1 (t
, false, true, true,
6669 tf_warning_or_error
);
6672 /* Like is_constant_expression, but allow const variables that are not allowed
6673 under constexpr rules. */
6676 is_static_init_expression (tree t
)
6678 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6681 /* Returns true if T is a potential constant expression that is not
6682 instantiation-dependent, and therefore a candidate for constant folding even
6686 is_nondependent_constant_expression (tree t
)
6688 return (!type_unknown_p (t
)
6689 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6690 && is_constant_expression (t
)
6691 && !instantiation_dependent_expression_p (t
));
6694 /* Returns true if T is a potential static initializer expression that is not
6695 instantiation-dependent. */
6698 is_nondependent_static_init_expression (tree t
)
6700 return (!type_unknown_p (t
)
6701 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6702 && is_static_init_expression (t
)
6703 && !instantiation_dependent_expression_p (t
));
6706 /* Finalize constexpr processing after parsing. */
6709 fini_constexpr (void)
6711 /* The contexpr call and fundef copies tables are no longer needed. */
6712 constexpr_call_table
= NULL
;
6713 fundef_copies_table
= NULL
;
6716 #include "gt-cp-constexpr.h"