1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2018 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
34 #include "gimple-fold.h"
37 static bool verify_constant (tree
, bool, bool *, bool *);
38 #define VERIFY_CONSTANT(X) \
40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
44 /* Returns true iff FUN is an instantiation of a constexpr function
45 template or a defaulted constexpr function. */
48 is_instantiation_of_constexpr (tree fun
)
50 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
52 || (DECL_DEFAULTED_FN (fun
)
53 && DECL_DECLARED_CONSTEXPR_P (fun
)));
56 /* Return true if T is a literal type. */
59 literal_type_p (tree t
)
63 || TREE_CODE (t
) == REFERENCE_TYPE
64 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
68 t
= complete_type (t
);
69 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
70 return CLASSTYPE_LITERAL_P (t
);
72 if (TREE_CODE (t
) == ARRAY_TYPE
)
73 return literal_type_p (strip_array_types (t
));
77 /* If DECL is a variable declared `constexpr', require its type
78 be literal. Return error_mark_node if we give an error, the
82 ensure_literal_type_for_constexpr_object (tree decl
)
84 tree type
= TREE_TYPE (decl
);
86 && (DECL_DECLARED_CONSTEXPR_P (decl
)
87 || var_in_constexpr_fn (decl
))
88 && !processing_template_decl
)
90 tree stype
= strip_array_types (type
);
91 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
92 /* Don't complain here, we'll complain about incompleteness
93 when we try to initialize the variable. */;
94 else if (!literal_type_p (type
))
96 if (DECL_DECLARED_CONSTEXPR_P (decl
))
98 error ("the type %qT of %<constexpr%> variable %qD "
99 "is not literal", type
, decl
);
100 explain_non_literal_class (type
);
101 decl
= error_mark_node
;
105 if (!is_instantiation_of_constexpr (current_function_decl
))
107 error ("variable %qD of non-literal type %qT in %<constexpr%> "
108 "function", decl
, type
);
109 explain_non_literal_class (type
);
110 decl
= error_mark_node
;
112 cp_function_chain
->invalid_constexpr
= true;
119 /* Representation of entries in the constexpr function definition table. */
121 struct GTY((for_user
)) constexpr_fundef
{
126 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
128 static hashval_t
hash (constexpr_fundef
*);
129 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
132 /* This table holds all constexpr function definitions seen in
133 the current translation unit. */
135 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
137 /* Utility function used for managing the constexpr function table.
138 Return true if the entries pointed to by P and Q are for the
139 same constexpr function. */
142 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
144 return lhs
->decl
== rhs
->decl
;
147 /* Utility function used for managing the constexpr function table.
148 Return a hash value for the entry pointed to by Q. */
151 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
153 return DECL_UID (fundef
->decl
);
156 /* Return a previously saved definition of function FUN. */
158 static constexpr_fundef
*
159 retrieve_constexpr_fundef (tree fun
)
161 constexpr_fundef fundef
= { NULL
, NULL
};
162 if (constexpr_fundef_table
== NULL
)
166 return constexpr_fundef_table
->find (&fundef
);
169 /* Check whether the parameter and return types of FUN are valid for a
170 constexpr function, and complain if COMPLAIN. */
173 is_valid_constexpr_fn (tree fun
, bool complain
)
177 if (DECL_INHERITED_CTOR (fun
)
178 && TREE_CODE (fun
) == TEMPLATE_DECL
)
182 error ("inherited constructor %qD is not %<constexpr%>",
183 DECL_INHERITED_CTOR (fun
));
187 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
188 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
189 if (!literal_type_p (TREE_TYPE (parm
)))
194 error ("invalid type for parameter %d of %<constexpr%> "
195 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
196 explain_non_literal_class (TREE_TYPE (parm
));
201 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
205 inform (DECL_SOURCE_LOCATION (fun
),
206 "lambdas are implicitly %<constexpr%> only in C++17 and later");
208 else if (!DECL_CONSTRUCTOR_P (fun
))
210 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
211 if (!literal_type_p (rettype
))
216 error ("invalid return type %qT of %<constexpr%> function %q+D",
218 explain_non_literal_class (rettype
);
222 /* C++14 DR 1684 removed this restriction. */
223 if (cxx_dialect
< cxx14
224 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
225 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
229 && pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
230 "enclosing class of %<constexpr%> non-static member "
231 "function %q+#D is not a literal type", fun
))
232 explain_non_literal_class (DECL_CONTEXT (fun
));
235 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
239 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
245 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
246 for a member of an anonymous aggregate, INIT is the initializer for that
247 member, and VEC_OUTER is the vector of constructor elements for the class
248 whose constructor we are processing. Add the initializer to the vector
249 and return true to indicate success. */
252 build_anon_member_initialization (tree member
, tree init
,
253 vec
<constructor_elt
, va_gc
> **vec_outer
)
255 /* MEMBER presents the relevant fields from the inside out, but we need
256 to build up the initializer from the outside in so that we can reuse
257 previously built CONSTRUCTORs if this is, say, the second field in an
258 anonymous struct. So we use a vec as a stack. */
259 auto_vec
<tree
, 2> fields
;
262 fields
.safe_push (TREE_OPERAND (member
, 1));
263 member
= TREE_OPERAND (member
, 0);
265 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
266 && TREE_CODE (member
) == COMPONENT_REF
);
268 /* VEC has the constructor elements vector for the context of FIELD.
269 If FIELD is an anonymous aggregate, we will push inside it. */
270 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
272 while (field
= fields
.pop(),
273 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
276 /* If there is already an outer constructor entry for the anonymous
277 aggregate FIELD, use it; otherwise, insert one. */
278 if (vec_safe_is_empty (*vec
)
279 || (*vec
)->last().index
!= field
)
281 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
282 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
285 ctor
= (*vec
)->last().value
;
286 vec
= &CONSTRUCTOR_ELTS (ctor
);
289 /* Now we're at the innermost field, the one that isn't an anonymous
290 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
291 gcc_assert (fields
.is_empty());
292 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
297 /* Subroutine of build_constexpr_constructor_member_initializers.
298 The expression tree T represents a data member initialization
299 in a (constexpr) constructor definition. Build a pairing of
300 the data member with its initializer, and prepend that pair
301 to the existing initialization pair INITS. */
304 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
307 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
308 t
= TREE_OPERAND (t
, 0);
309 if (TREE_CODE (t
) == EXPR_STMT
)
310 t
= TREE_OPERAND (t
, 0);
311 if (t
== error_mark_node
)
313 if (TREE_CODE (t
) == STATEMENT_LIST
)
315 tree_stmt_iterator i
;
316 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
318 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
323 if (TREE_CODE (t
) == CLEANUP_STMT
)
325 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
326 but we can in a constexpr constructor for a non-literal class. Just
327 ignore it; either all the initialization will be constant, in which
328 case the cleanup can't run, or it can't be constexpr.
329 Still recurse into CLEANUP_BODY. */
330 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
332 if (TREE_CODE (t
) == CONVERT_EXPR
)
333 t
= TREE_OPERAND (t
, 0);
334 if (TREE_CODE (t
) == INIT_EXPR
335 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
336 use what this function builds for cx_check_missing_mem_inits, and
337 assignment in the ctor body doesn't count. */
338 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
340 member
= TREE_OPERAND (t
, 0);
341 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
343 else if (TREE_CODE (t
) == CALL_EXPR
)
345 tree fn
= get_callee_fndecl (t
);
346 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
347 /* We're only interested in calls to subobject constructors. */
349 member
= CALL_EXPR_ARG (t
, 0);
350 /* We don't use build_cplus_new here because it complains about
351 abstract bases. Leaving the call unwrapped means that it has the
352 wrong type, but cxx_eval_constant_expression doesn't care. */
353 init
= break_out_target_exprs (t
);
355 else if (TREE_CODE (t
) == BIND_EXPR
)
356 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
358 /* Don't add anything else to the CONSTRUCTOR. */
360 if (INDIRECT_REF_P (member
))
361 member
= TREE_OPERAND (member
, 0);
362 if (TREE_CODE (member
) == NOP_EXPR
)
366 if (TREE_CODE (op
) == ADDR_EXPR
)
368 gcc_assert (same_type_ignoring_top_level_qualifiers_p
369 (TREE_TYPE (TREE_TYPE (op
)),
370 TREE_TYPE (TREE_TYPE (member
))));
371 /* Initializing a cv-qualified member; we need to look through
375 else if (op
== current_class_ptr
376 && (same_type_ignoring_top_level_qualifiers_p
377 (TREE_TYPE (TREE_TYPE (member
)),
378 current_class_type
)))
379 /* Delegating constructor. */
383 /* This is an initializer for an empty base; keep it for now so
384 we can check it in cxx_eval_bare_aggregate. */
385 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
388 if (TREE_CODE (member
) == ADDR_EXPR
)
389 member
= TREE_OPERAND (member
, 0);
390 if (TREE_CODE (member
) == COMPONENT_REF
)
392 tree aggr
= TREE_OPERAND (member
, 0);
393 if (TREE_CODE (aggr
) == VAR_DECL
)
394 /* Initializing a local variable, don't add anything. */
396 if (TREE_CODE (aggr
) != COMPONENT_REF
)
397 /* Normal member initialization. */
398 member
= TREE_OPERAND (member
, 1);
399 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
400 /* Initializing a member of an anonymous union. */
401 return build_anon_member_initialization (member
, init
, vec
);
403 /* We're initializing a vtable pointer in a base. Leave it as
404 COMPONENT_REF so we remember the path to get to the vfield. */
405 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
408 /* Value-initialization can produce multiple initializers for the
409 same field; use the last one. */
410 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
411 (*vec
)->last().value
= init
;
413 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
417 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
418 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
419 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
422 check_constexpr_bind_expr_vars (tree t
)
424 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
426 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
427 if (TREE_CODE (var
) == TYPE_DECL
428 && DECL_IMPLICIT_TYPEDEF_P (var
)
429 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
434 /* Subroutine of check_constexpr_ctor_body. */
437 check_constexpr_ctor_body_1 (tree last
, tree list
)
439 switch (TREE_CODE (list
))
442 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
443 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
447 case CLEANUP_POINT_EXPR
:
448 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
452 if (!check_constexpr_bind_expr_vars (list
)
453 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
460 case DEBUG_BEGIN_STMT
:
468 /* Make sure that there are no statements after LAST in the constructor
469 body represented by LIST. */
472 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
474 /* C++14 doesn't require a constexpr ctor to have an empty body. */
475 if (cxx_dialect
>= cxx14
)
479 if (TREE_CODE (list
) == STATEMENT_LIST
)
481 tree_stmt_iterator i
= tsi_last (list
);
482 for (; !tsi_end_p (i
); tsi_prev (&i
))
484 tree t
= tsi_stmt (i
);
487 if (!check_constexpr_ctor_body_1 (last
, t
))
494 else if (list
!= last
495 && !check_constexpr_ctor_body_1 (last
, list
))
500 error ("%<constexpr%> constructor does not have empty body");
501 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
506 /* V is a vector of constructor elements built up for the base and member
507 initializers of a constructor for TYPE. They need to be in increasing
508 offset order, which they might not be yet if TYPE has a primary base
509 which is not first in the base-clause or a vptr and at least one base
510 all of which are non-primary. */
512 static vec
<constructor_elt
, va_gc
> *
513 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
515 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
521 field_type
= BINFO_TYPE (pri
);
522 else if (TYPE_CONTAINS_VPTR_P (type
))
523 field_type
= vtbl_ptr_type_node
;
527 /* Find the element for the primary base or vptr and move it to the
528 beginning of the vec. */
529 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
530 if (TREE_TYPE (ce
->index
) == field_type
)
533 if (i
> 0 && i
< vec_safe_length (v
))
535 vec
<constructor_elt
, va_gc
> &vref
= *v
;
536 constructor_elt elt
= vref
[i
];
545 /* Build compile-time evalable representations of member-initializer list
546 for a constexpr constructor. */
549 build_constexpr_constructor_member_initializers (tree type
, tree body
)
551 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
554 switch (TREE_CODE (body
))
556 case MUST_NOT_THROW_EXPR
:
558 body
= TREE_OPERAND (body
, 0);
562 for (tree_stmt_iterator i
= tsi_start (body
);
563 !tsi_end_p (i
); tsi_next (&i
))
566 if (TREE_CODE (body
) == BIND_EXPR
)
572 body
= BIND_EXPR_BODY (body
);
579 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
581 body
= TREE_OPERAND (body
, 0);
582 if (TREE_CODE (body
) == EXPR_STMT
)
583 body
= TREE_OPERAND (body
, 0);
584 if (TREE_CODE (body
) == INIT_EXPR
585 && (same_type_ignoring_top_level_qualifiers_p
586 (TREE_TYPE (TREE_OPERAND (body
, 0)),
587 current_class_type
)))
590 return TREE_OPERAND (body
, 1);
592 ok
= build_data_member_initialization (body
, &vec
);
594 else if (TREE_CODE (body
) == STATEMENT_LIST
)
596 tree_stmt_iterator i
;
597 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
599 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
604 else if (TREE_CODE (body
) == TRY_BLOCK
)
606 error ("body of %<constexpr%> constructor cannot be "
607 "a function-try-block");
608 return error_mark_node
;
610 else if (EXPR_P (body
))
611 ok
= build_data_member_initialization (body
, &vec
);
613 gcc_assert (errorcount
> 0);
616 if (vec_safe_length (vec
) > 0)
618 /* In a delegating constructor, return the target. */
619 constructor_elt
*ce
= &(*vec
)[0];
620 if (ce
->index
== current_class_ptr
)
627 vec
= sort_constexpr_mem_initializers (type
, vec
);
628 return build_constructor (type
, vec
);
631 return error_mark_node
;
634 /* We have an expression tree T that represents a call, either CALL_EXPR
635 or AGGR_INIT_EXPR. If the call is lexically to a named function,
636 retrun the _DECL for that function. */
639 get_function_named_in_call (tree t
)
641 tree fun
= cp_get_callee (t
);
642 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
643 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
644 fun
= TREE_OPERAND (fun
, 0);
648 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
649 declared to be constexpr, or a sub-statement thereof. Returns the
650 return value if suitable, error_mark_node for a statement not allowed in
651 a constexpr function, or NULL_TREE if no return value was found. */
654 constexpr_fn_retval (tree body
)
656 switch (TREE_CODE (body
))
660 tree_stmt_iterator i
;
661 tree expr
= NULL_TREE
;
662 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
664 tree s
= constexpr_fn_retval (tsi_stmt (i
));
665 if (s
== error_mark_node
)
666 return error_mark_node
;
667 else if (s
== NULL_TREE
)
668 /* Keep iterating. */;
670 /* Multiple return statements. */
671 return error_mark_node
;
679 return break_out_target_exprs (TREE_OPERAND (body
, 0));
683 tree decl
= DECL_EXPR_DECL (body
);
684 if (TREE_CODE (decl
) == USING_DECL
685 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
686 || DECL_ARTIFICIAL (decl
))
688 return error_mark_node
;
691 case CLEANUP_POINT_EXPR
:
692 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
695 if (!check_constexpr_bind_expr_vars (body
))
696 return error_mark_node
;
697 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
700 case DEBUG_BEGIN_STMT
:
705 tree fun
= get_function_named_in_call (body
);
707 && DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
)
713 return error_mark_node
;
717 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
718 FUN; do the necessary transformations to turn it into a single expression
719 that we can store in the hash table. */
722 massage_constexpr_body (tree fun
, tree body
)
724 if (DECL_CONSTRUCTOR_P (fun
))
725 body
= build_constexpr_constructor_member_initializers
726 (DECL_CONTEXT (fun
), body
);
727 else if (cxx_dialect
< cxx14
)
729 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
730 body
= EH_SPEC_STMTS (body
);
731 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
732 body
= TREE_OPERAND (body
, 0);
733 body
= constexpr_fn_retval (body
);
738 /* CTYPE is a type constructed from BODY. Return true if some
739 bases/fields are uninitialized, and complain if COMPLAIN. */
742 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
748 if (TREE_CODE (body
) != CONSTRUCTOR
)
750 nelts
= CONSTRUCTOR_NELTS (body
);
752 tree field
= TYPE_FIELDS (ctype
);
754 if (TREE_CODE (ctype
) == UNION_TYPE
)
756 if (nelts
== 0 && next_initializable_field (field
))
759 error ("%<constexpr%> constructor for union %qT must "
760 "initialize exactly one non-static data member", ctype
);
766 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
767 need an explicit initialization. */
769 for (unsigned i
= 0; i
<= nelts
; ++i
)
771 tree index
= NULL_TREE
;
774 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
775 /* Skip base and vtable inits. */
776 if (TREE_CODE (index
) != FIELD_DECL
777 || DECL_ARTIFICIAL (index
))
781 for (; field
!= index
; field
= DECL_CHAIN (field
))
784 if (TREE_CODE (field
) != FIELD_DECL
)
786 if (DECL_UNNAMED_BIT_FIELD (field
))
788 if (DECL_ARTIFICIAL (field
))
790 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
792 /* Recurse to check the anonummous aggregate member. */
793 bad
|= cx_check_missing_mem_inits
794 (TREE_TYPE (field
), NULL_TREE
, complain
);
795 if (bad
&& !complain
)
799 ftype
= strip_array_types (TREE_TYPE (field
));
800 if (type_has_constexpr_default_constructor (ftype
))
802 /* It's OK to skip a member with a trivial constexpr ctor.
803 A constexpr ctor that isn't trivial should have been
805 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
811 error ("member %qD must be initialized by mem-initializer "
812 "in %<constexpr%> constructor", field
);
813 inform (DECL_SOURCE_LOCATION (field
), "declared here");
816 if (field
== NULL_TREE
)
819 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
821 /* Check the anonymous aggregate initializer is valid. */
822 bad
|= cx_check_missing_mem_inits
823 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
824 if (bad
&& !complain
)
827 field
= DECL_CHAIN (field
);
833 /* We are processing the definition of the constexpr function FUN.
834 Check that its BODY fulfills the propriate requirements and
835 enter it in the constexpr function definition table.
836 For constructor BODY is actually the TREE_LIST of the
837 member-initializer list. */
840 register_constexpr_fundef (tree fun
, tree body
)
842 constexpr_fundef entry
;
843 constexpr_fundef
**slot
;
845 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
848 tree massaged
= massage_constexpr_body (fun
, body
);
849 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
851 if (!DECL_CONSTRUCTOR_P (fun
))
852 error ("body of %<constexpr%> function %qD not a return-statement",
857 if (!potential_rvalue_constant_expression (massaged
))
859 if (!DECL_GENERATED_P (fun
))
860 require_potential_rvalue_constant_expression (massaged
);
864 if (DECL_CONSTRUCTOR_P (fun
)
865 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
866 massaged
, !DECL_GENERATED_P (fun
)))
869 /* Create the constexpr function table if necessary. */
870 if (constexpr_fundef_table
== NULL
)
871 constexpr_fundef_table
872 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
876 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
878 gcc_assert (*slot
== NULL
);
879 *slot
= ggc_alloc
<constexpr_fundef
> ();
885 /* FUN is a non-constexpr function called in a context that requires a
886 constant expression. If it comes from a constexpr template, explain why
887 the instantiation isn't constexpr. */
890 explain_invalid_constexpr_fn (tree fun
)
892 static hash_set
<tree
> *diagnosed
;
895 /* Only diagnose defaulted functions, lambdas, or instantiations. */
896 if (!DECL_DEFAULTED_FN (fun
)
897 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
898 && !is_instantiation_of_constexpr (fun
))
900 if (diagnosed
== NULL
)
901 diagnosed
= new hash_set
<tree
>;
902 if (diagnosed
->add (fun
))
903 /* Already explained. */
906 save_loc
= input_location
;
907 if (!lambda_static_thunk_p (fun
))
909 /* Diagnostics should completely ignore the static thunk, so leave
910 input_location set to our caller's location. */
911 input_location
= DECL_SOURCE_LOCATION (fun
);
912 inform (input_location
,
913 "%qD is not usable as a %<constexpr%> function because:", fun
);
915 /* First check the declaration. */
916 if (is_valid_constexpr_fn (fun
, true))
918 /* Then if it's OK, the body. */
919 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
920 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
921 explain_implicit_non_constexpr (fun
);
924 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
925 require_potential_rvalue_constant_expression (body
);
926 if (DECL_CONSTRUCTOR_P (fun
))
927 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
930 input_location
= save_loc
;
933 /* Objects of this type represent calls to constexpr functions
934 along with the bindings of parameters to their arguments, for
935 the purpose of compile time evaluation. */
937 struct GTY((for_user
)) constexpr_call
{
938 /* Description of the constexpr function definition. */
939 constexpr_fundef
*fundef
;
940 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
941 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
942 Note: This arrangement is made to accommodate the use of
943 iterative_hash_template_arg (see pt.c). If you change this
944 representation, also change the hash calculation in
945 cxx_eval_call_expression. */
947 /* Result of the call.
948 NULL means the call is being evaluated.
949 error_mark_node means that the evaluation was erroneous;
950 otherwise, the actuall value of the call. */
952 /* The hash of this call; we remember it here to avoid having to
953 recalculate it when expanding the hash table. */
957 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
959 static hashval_t
hash (constexpr_call
*);
960 static bool equal (constexpr_call
*, constexpr_call
*);
963 enum constexpr_switch_state
{
964 /* Used when processing a switch for the first time by cxx_eval_switch_expr
965 and default: label for that switch has not been seen yet. */
966 css_default_not_seen
,
967 /* Used when processing a switch for the first time by cxx_eval_switch_expr
968 and default: label for that switch has been seen already. */
970 /* Used when processing a switch for the second time by
971 cxx_eval_switch_expr, where default: label should match. */
972 css_default_processing
975 /* The constexpr expansion context. CALL is the current function
976 expansion, CTOR is the current aggregate initializer, OBJECT is the
977 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
978 is a map of values of variables initialized within the expression. */
980 struct constexpr_ctx
{
981 /* The innermost call we're evaluating. */
982 constexpr_call
*call
;
983 /* Values for any temporaries or local variables within the
984 constant-expression. */
985 hash_map
<tree
,tree
> *values
;
986 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
987 aren't inside a loop. */
988 hash_set
<tree
> *save_exprs
;
989 /* The CONSTRUCTOR we're currently building up for an aggregate
992 /* The object we're building the CONSTRUCTOR for. */
994 /* If inside SWITCH_EXPR. */
995 constexpr_switch_state
*css_state
;
996 /* Whether we should error on a non-constant expression or fail quietly. */
998 /* Whether we are strictly conforming to constant expression rules or
999 trying harder to get a constant value. */
1003 /* A table of all constexpr calls that have been evaluated by the
1004 compiler in this translation unit. */
1006 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1008 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1009 bool, bool *, bool *, tree
* = NULL
);
1011 /* Compute a hash value for a constexpr call representation. */
1014 constexpr_call_hasher::hash (constexpr_call
*info
)
1019 /* Return true if the objects pointed to by P and Q represent calls
1020 to the same constexpr function with the same arguments.
1021 Otherwise, return false. */
1024 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1030 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1032 lhs_bindings
= lhs
->bindings
;
1033 rhs_bindings
= rhs
->bindings
;
1034 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1036 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1037 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1038 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1039 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1041 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1042 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1044 return lhs_bindings
== rhs_bindings
;
1047 /* Initialize the constexpr call table, if needed. */
1050 maybe_initialize_constexpr_call_table (void)
1052 if (constexpr_call_table
== NULL
)
1053 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1056 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1057 a function happens to get called recursively, we unshare the callee
1058 function's body and evaluate this unshared copy instead of evaluating the
1061 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1062 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1063 that's keyed off of the original FUNCTION_DECL and whose value is a
1064 TREE_LIST of this function's unused copies awaiting reuse.
1066 This is not GC-deletable to avoid GC affecting UID generation. */
1068 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1070 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1073 maybe_initialize_fundef_copies_table ()
1075 if (fundef_copies_table
== NULL
)
1076 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1079 /* Reuse a copy or create a new unshared copy of the function FUN.
1080 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1081 is parms, TYPE is result. */
1084 get_fundef_copy (tree fun
)
1086 maybe_initialize_fundef_copies_table ();
1090 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1094 /* There is no cached function available, or in use. We can use
1095 the function directly. That the slot is now created records
1096 that this function is now in use. */
1097 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1098 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1100 else if (*slot
== NULL_TREE
)
1102 /* We've already used the function itself, so make a copy. */
1103 copy
= build_tree_list (NULL
, NULL
);
1104 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1108 /* We have a cached function available. */
1110 *slot
= TREE_CHAIN (copy
);
1116 /* Save the copy COPY of function FUN for later reuse by
1117 get_fundef_copy(). By construction, there will always be an entry
1121 save_fundef_copy (tree fun
, tree copy
)
1123 tree
*slot
= fundef_copies_table
->get (fun
);
1124 TREE_CHAIN (copy
) = *slot
;
1128 /* We have an expression tree T that represents a call, either CALL_EXPR
1129 or AGGR_INIT_EXPR. Return the Nth argument. */
1132 get_nth_callarg (tree t
, int n
)
1134 switch (TREE_CODE (t
))
1137 return CALL_EXPR_ARG (t
, n
);
1139 case AGGR_INIT_EXPR
:
1140 return AGGR_INIT_EXPR_ARG (t
, n
);
1148 /* Attempt to evaluate T which represents a call to a builtin function.
1149 We assume here that all builtin functions evaluate to scalar types
1150 represented by _CST nodes. */
1153 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1155 bool *non_constant_p
, bool *overflow_p
)
1157 const int nargs
= call_expr_nargs (t
);
1158 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1162 /* Don't fold __builtin_constant_p within a constexpr function. */
1163 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1166 && current_function_decl
1167 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1169 *non_constant_p
= true;
1173 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1174 return constant false for a non-constant argument. */
1175 constexpr_ctx new_ctx
= *ctx
;
1176 new_ctx
.quiet
= true;
1177 bool dummy1
= false, dummy2
= false;
1178 for (i
= 0; i
< nargs
; ++i
)
1180 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1181 false, &dummy1
, &dummy2
);
1183 /* For __built_in_constant_p, fold all expressions with constant values
1184 even if they aren't C++ constant-expressions. */
1185 args
[i
] = cp_fully_fold (args
[i
]);
1188 bool save_ffbcp
= force_folding_builtin_constant_p
;
1189 force_folding_builtin_constant_p
= true;
1190 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1191 CALL_EXPR_FN (t
), nargs
, args
);
1192 force_folding_builtin_constant_p
= save_ffbcp
;
1193 if (new_call
== NULL
)
1195 if (!*non_constant_p
&& !ctx
->quiet
)
1197 /* Do not allow__builtin_unreachable in constexpr function.
1198 The __builtin_unreachable call with BUILTINS_LOCATION
1199 comes from cp_maybe_instrument_return. */
1200 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
1201 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1202 error ("%<constexpr%> call flows off the end of the function");
1205 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1206 CALL_EXPR_FN (t
), nargs
, args
);
1207 error ("%q+E is not a constant expression", new_call
);
1210 *non_constant_p
= true;
1214 if (!is_constant_expression (new_call
))
1216 if (!*non_constant_p
&& !ctx
->quiet
)
1217 error ("%q+E is not a constant expression", new_call
);
1218 *non_constant_p
= true;
1222 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1223 non_constant_p
, overflow_p
);
1226 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1227 the type of the value to match. */
1230 adjust_temp_type (tree type
, tree temp
)
1232 if (TREE_TYPE (temp
) == type
)
1234 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1235 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1236 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1237 gcc_assert (scalarish_type_p (type
));
1238 return cp_fold_convert (type
, temp
);
1241 /* Callback for walk_tree used by unshare_constructor. */
1244 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1248 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1253 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1254 subexpression, return an unshared copy of T. Otherwise return T. */
1257 unshare_constructor (tree t
)
1259 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1260 if (ctor
!= NULL_TREE
)
1261 return unshare_expr (t
);
1265 /* Subroutine of cxx_eval_call_expression.
1266 We are processing a call expression (either CALL_EXPR or
1267 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1268 all arguments and bind their values to correspondings
1269 parameters, making up the NEW_CALL context. */
1272 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1273 constexpr_call
*new_call
,
1274 bool *non_constant_p
, bool *overflow_p
,
1275 bool *non_constant_args
)
1277 const int nargs
= call_expr_nargs (t
);
1278 tree fun
= new_call
->fundef
->decl
;
1279 tree parms
= DECL_ARGUMENTS (fun
);
1281 tree
*p
= &new_call
->bindings
;
1282 for (i
= 0; i
< nargs
; ++i
)
1285 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1286 x
= get_nth_callarg (t
, i
);
1287 /* For member function, the first argument is a pointer to the implied
1288 object. For a constructor, it might still be a dummy object, in
1289 which case we get the real argument from ctx. */
1290 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1291 && is_dummy_object (x
))
1294 x
= build_address (x
);
1296 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1297 non_constant_p
, overflow_p
);
1298 /* Don't VERIFY_CONSTANT here. */
1299 if (*non_constant_p
&& ctx
->quiet
)
1301 /* Just discard ellipsis args after checking their constantitude. */
1305 if (!*non_constant_p
)
1307 /* Make sure the binding has the same type as the parm. But
1308 only for constant args. */
1309 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1310 arg
= adjust_temp_type (type
, arg
);
1311 if (!TREE_CONSTANT (arg
))
1312 *non_constant_args
= true;
1313 *p
= build_tree_list (parms
, arg
);
1314 p
= &TREE_CHAIN (*p
);
1316 parms
= TREE_CHAIN (parms
);
1320 /* Variables and functions to manage constexpr call expansion context.
1321 These do not need to be marked for PCH or GC. */
1323 /* FIXME remember and print actual constant arguments. */
1324 static vec
<tree
> call_stack
;
1325 static int call_stack_tick
;
1326 static int last_cx_error_tick
;
1329 push_cx_call_context (tree call
)
1332 if (!EXPR_HAS_LOCATION (call
))
1333 SET_EXPR_LOCATION (call
, input_location
);
1334 call_stack
.safe_push (call
);
1335 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1341 pop_cx_call_context (void)
1348 cx_error_context (void)
1350 vec
<tree
> r
= vNULL
;
1351 if (call_stack_tick
!= last_cx_error_tick
1352 && !call_stack
.is_empty ())
1354 last_cx_error_tick
= call_stack_tick
;
1358 /* Evaluate a call T to a GCC internal function when possible and return
1359 the evaluated result or, under the control of CTX, give an error, set
1360 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1363 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1365 bool *non_constant_p
, bool *overflow_p
)
1367 enum tree_code opcode
= ERROR_MARK
;
1369 switch (CALL_EXPR_IFN (t
))
1371 case IFN_UBSAN_NULL
:
1372 case IFN_UBSAN_BOUNDS
:
1373 case IFN_UBSAN_VPTR
:
1374 case IFN_FALLTHROUGH
:
1377 case IFN_ADD_OVERFLOW
:
1380 case IFN_SUB_OVERFLOW
:
1381 opcode
= MINUS_EXPR
;
1383 case IFN_MUL_OVERFLOW
:
1388 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1389 false, non_constant_p
, overflow_p
);
1393 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1394 "call to internal function %qE", t
);
1395 *non_constant_p
= true;
1399 /* Evaluate constant arguments using OPCODE and return a complex
1400 number containing the result and the overflow bit. */
1401 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1402 non_constant_p
, overflow_p
);
1403 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1404 non_constant_p
, overflow_p
);
1406 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1408 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1409 tree type
= TREE_TYPE (TREE_TYPE (t
));
1410 tree result
= fold_binary_loc (loc
, opcode
, type
,
1411 fold_convert_loc (loc
, type
, arg0
),
1412 fold_convert_loc (loc
, type
, arg1
));
1414 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1415 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1416 if (TREE_OVERFLOW (result
))
1417 TREE_OVERFLOW (result
) = 0;
1419 return build_complex (TREE_TYPE (t
), result
, ovf
);
1422 *non_constant_p
= true;
1426 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1429 clear_no_implicit_zero (tree ctor
)
1431 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1433 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1434 tree elt
; unsigned HOST_WIDE_INT idx
;
1435 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1436 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1437 clear_no_implicit_zero (elt
);
1441 /* Subroutine of cxx_eval_constant_expression.
1442 Evaluate the call expression tree T in the context of OLD_CALL expression
1446 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1448 bool *non_constant_p
, bool *overflow_p
)
1450 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1451 tree fun
= get_function_named_in_call (t
);
1452 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1455 if (fun
== NULL_TREE
)
1456 return cxx_eval_internal_function (ctx
, t
, lval
,
1457 non_constant_p
, overflow_p
);
1459 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1461 /* Might be a constexpr function pointer. */
1462 fun
= cxx_eval_constant_expression (ctx
, fun
,
1463 /*lval*/false, non_constant_p
,
1466 if (TREE_CODE (fun
) == ADDR_EXPR
)
1467 fun
= TREE_OPERAND (fun
, 0);
1469 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1471 if (!ctx
->quiet
&& !*non_constant_p
)
1472 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1474 *non_constant_p
= true;
1477 if (DECL_CLONED_FUNCTION_P (fun
))
1478 fun
= DECL_CLONED_FUNCTION (fun
);
1480 if (is_ubsan_builtin_p (fun
))
1483 if (is_builtin_fn (fun
))
1484 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1485 lval
, non_constant_p
, overflow_p
);
1486 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1490 if (!lambda_static_thunk_p (fun
))
1491 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1492 explain_invalid_constexpr_fn (fun
);
1494 *non_constant_p
= true;
1498 constexpr_ctx new_ctx
= *ctx
;
1499 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1500 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1502 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1503 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1504 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1505 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1506 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1507 ctx
->values
->put (new_ctx
.object
, ctor
);
1511 /* Shortcut trivial constructor/op=. */
1512 if (trivial_fn_p (fun
))
1514 tree init
= NULL_TREE
;
1515 if (call_expr_nargs (t
) == 2)
1516 init
= convert_from_reference (get_nth_callarg (t
, 1));
1517 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1518 && AGGR_INIT_ZERO_FIRST (t
))
1519 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1522 tree op
= get_nth_callarg (t
, 0);
1523 if (is_dummy_object (op
))
1526 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1527 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1528 new_ctx
.call
= &new_call
;
1529 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1530 non_constant_p
, overflow_p
);
1534 /* We can't defer instantiating the function any longer. */
1535 if (!DECL_INITIAL (fun
)
1536 && DECL_TEMPLOID_INSTANTIATION (fun
))
1538 location_t save_loc
= input_location
;
1539 input_location
= loc
;
1541 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1543 input_location
= save_loc
;
1546 /* If in direct recursive call, optimize definition search. */
1547 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1548 new_call
.fundef
= ctx
->call
->fundef
;
1551 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1552 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1553 || fun
== current_function_decl
)
1557 /* We need to check for current_function_decl here in case we're
1558 being called during cp_fold_function, because at that point
1559 DECL_INITIAL is set properly and we have a fundef but we
1560 haven't lowered invisirefs yet (c++/70344). */
1561 if (DECL_INITIAL (fun
) == error_mark_node
1562 || fun
== current_function_decl
)
1563 error_at (loc
, "%qD called in a constant expression before its "
1564 "definition is complete", fun
);
1565 else if (DECL_INITIAL (fun
))
1567 /* The definition of fun was somehow unsuitable. But pretend
1568 that lambda static thunks don't exist. */
1569 if (!lambda_static_thunk_p (fun
))
1570 error_at (loc
, "%qD called in a constant expression", fun
);
1571 explain_invalid_constexpr_fn (fun
);
1574 error_at (loc
, "%qD used before its definition", fun
);
1576 *non_constant_p
= true;
1581 bool non_constant_args
= false;
1582 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1583 non_constant_p
, overflow_p
, &non_constant_args
);
1584 if (*non_constant_p
)
1587 depth_ok
= push_cx_call_context (t
);
1589 tree result
= NULL_TREE
;
1591 constexpr_call
*entry
= NULL
;
1592 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1594 new_call
.hash
= iterative_hash_template_arg
1595 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1597 /* If we have seen this call before, we are done. */
1598 maybe_initialize_constexpr_call_table ();
1599 constexpr_call
**slot
1600 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1604 /* We need to keep a pointer to the entry, not just the slot, as the
1605 slot can move in the call to cxx_eval_builtin_function_call. */
1606 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1609 /* Calls that are in progress have their result set to NULL,
1610 so that we can detect circular dependencies. */
1611 else if (entry
->result
== NULL
)
1614 error ("call has circular dependency");
1615 *non_constant_p
= true;
1616 entry
->result
= result
= error_mark_node
;
1619 result
= entry
->result
;
1625 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1626 "-fconstexpr-depth= to increase the maximum)",
1627 max_constexpr_depth
);
1628 *non_constant_p
= true;
1629 result
= error_mark_node
;
1633 if (result
&& result
!= error_mark_node
)
1635 else if (!DECL_SAVED_TREE (fun
))
1637 /* When at_eof >= 2, cgraph has started throwing away
1638 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1639 late code generation for VEC_INIT_EXPR, which needs to be
1640 completely reconsidered. */
1641 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1642 *non_constant_p
= true;
1646 tree body
, parms
, res
;
1648 /* Reuse or create a new unshared copy of this function's body. */
1649 tree copy
= get_fundef_copy (fun
);
1650 body
= TREE_PURPOSE (copy
);
1651 parms
= TREE_VALUE (copy
);
1652 res
= TREE_TYPE (copy
);
1654 /* Associate the bindings with the remapped parms. */
1655 tree bound
= new_call
.bindings
;
1656 tree remapped
= parms
;
1659 tree oparm
= TREE_PURPOSE (bound
);
1660 tree arg
= TREE_VALUE (bound
);
1661 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1662 /* Don't share a CONSTRUCTOR that might be changed. */
1663 arg
= unshare_constructor (arg
);
1664 ctx
->values
->put (remapped
, arg
);
1665 bound
= TREE_CHAIN (bound
);
1666 remapped
= DECL_CHAIN (remapped
);
1668 /* Add the RESULT_DECL to the values map, too. */
1669 tree slot
= NULL_TREE
;
1670 if (DECL_BY_REFERENCE (res
))
1672 slot
= AGGR_INIT_EXPR_SLOT (t
);
1673 tree addr
= build_address (slot
);
1674 addr
= build_nop (TREE_TYPE (res
), addr
);
1675 ctx
->values
->put (res
, addr
);
1676 ctx
->values
->put (slot
, NULL_TREE
);
1679 ctx
->values
->put (res
, NULL_TREE
);
1681 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1682 their values after the call. */
1683 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1684 hash_set
<tree
> save_exprs
;
1685 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1686 ctx_with_save_exprs
.call
= &new_call
;
1688 tree jump_target
= NULL_TREE
;
1689 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1690 lval
, non_constant_p
, overflow_p
,
1693 if (DECL_CONSTRUCTOR_P (fun
))
1694 /* This can be null for a subobject constructor call, in
1695 which case what we care about is the initialization
1696 side-effects rather than the value. We could get at the
1697 value by evaluating *this, but we don't bother; there's
1698 no need to put such a call in the hash table. */
1699 result
= lval
? ctx
->object
: ctx
->ctor
;
1700 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1704 result
= *ctx
->values
->get (slot
? slot
: res
);
1705 if (result
== NULL_TREE
&& !*non_constant_p
)
1708 error ("%<constexpr%> call flows off the end "
1710 *non_constant_p
= true;
1714 /* Forget the saved values of the callee's SAVE_EXPRs. */
1715 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1716 iter
!= save_exprs
.end(); ++iter
)
1717 ctx_with_save_exprs
.values
->remove (*iter
);
1719 /* Remove the parms/result from the values map. Is it worth
1720 bothering to do this when the map itself is only live for
1721 one constexpr evaluation? If so, maybe also clear out
1722 other vars from call, maybe in BIND_EXPR handling? */
1723 ctx
->values
->remove (res
);
1725 ctx
->values
->remove (slot
);
1726 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1727 ctx
->values
->remove (parm
);
1729 /* Make the unshared function copy we used available for re-use. */
1730 save_fundef_copy (fun
, copy
);
1733 if (result
== error_mark_node
)
1734 *non_constant_p
= true;
1735 if (*non_constant_p
|| *overflow_p
)
1736 result
= error_mark_node
;
1740 entry
->result
= result
;
1743 /* The result of a constexpr function must be completely initialized. */
1744 if (TREE_CODE (result
) == CONSTRUCTOR
)
1745 clear_no_implicit_zero (result
);
1747 pop_cx_call_context ();
1748 return unshare_constructor (result
);
1751 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1754 reduced_constant_expression_p (tree t
)
1756 switch (TREE_CODE (t
))
1759 /* Even if we can't lower this yet, it's constant. */
1763 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1764 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1765 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1766 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1769 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1772 /* We're in the middle of initializing this element. */
1774 if (!reduced_constant_expression_p (val
))
1780 field
= next_initializable_field (DECL_CHAIN (field
));
1785 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1786 /* All the fields are initialized. */
1787 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1791 /* FIXME are we calling this too much? */
1792 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1796 /* Some expressions may have constant operands but are not constant
1797 themselves, such as 1/0. Call this function (or rather, the macro
1798 following it) to check for that condition.
1800 We only call this in places that require an arithmetic constant, not in
1801 places where we might have a non-constant expression that can be a
1802 component of a constant expression, such as the address of a constexpr
1803 variable that might be dereferenced later. */
1806 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1809 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1811 if (!allow_non_constant
)
1812 error ("%q+E is not a constant expression", t
);
1813 *non_constant_p
= true;
1815 if (TREE_OVERFLOW_P (t
))
1817 if (!allow_non_constant
)
1819 permerror (input_location
, "overflow in constant expression");
1820 /* If we're being permissive (and are in an enforcing
1821 context), ignore the overflow. */
1822 if (flag_permissive
)
1823 return *non_constant_p
;
1827 return *non_constant_p
;
1830 /* Check whether the shift operation with code CODE and type TYPE on LHS
1831 and RHS is undefined. If it is, give an error with an explanation,
1832 and return true; return false otherwise. */
1835 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1836 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1838 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1839 || TREE_CODE (lhs
) != INTEGER_CST
1840 || TREE_CODE (rhs
) != INTEGER_CST
)
1843 tree lhstype
= TREE_TYPE (lhs
);
1844 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1846 /* [expr.shift] The behavior is undefined if the right operand
1847 is negative, or greater than or equal to the length in bits
1848 of the promoted left operand. */
1849 if (tree_int_cst_sgn (rhs
) == -1)
1852 permerror (loc
, "right operand of shift expression %q+E is negative",
1853 build2_loc (loc
, code
, type
, lhs
, rhs
));
1854 return (!flag_permissive
|| ctx
->quiet
);
1856 if (compare_tree_int (rhs
, uprec
) >= 0)
1859 permerror (loc
, "right operand of shift expression %q+E is >= than "
1860 "the precision of the left operand",
1861 build2_loc (loc
, code
, type
, lhs
, rhs
));
1862 return (!flag_permissive
|| ctx
->quiet
);
1865 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1866 if E1 has a signed type and non-negative value, and E1x2^E2 is
1867 representable in the corresponding unsigned type of the result type,
1868 then that value, converted to the result type, is the resulting value;
1869 otherwise, the behavior is undefined. */
1870 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1871 && (cxx_dialect
>= cxx11
))
1873 if (tree_int_cst_sgn (lhs
) == -1)
1877 "left operand of shift expression %q+E is negative",
1878 build2_loc (loc
, code
, type
, lhs
, rhs
));
1879 return (!flag_permissive
|| ctx
->quiet
);
1881 /* For signed x << y the following:
1882 (unsigned) x >> ((prec (lhs) - 1) - y)
1883 if > 1, is undefined. The right-hand side of this formula
1884 is the highest bit of the LHS that can be set (starting from 0),
1885 so that the shift doesn't overflow. We then right-shift the LHS
1886 to see whether any other bit is set making the original shift
1887 undefined -- the result is not representable in the corresponding
1889 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1890 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1891 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1892 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1893 if (tree_int_cst_lt (integer_one_node
, t
))
1896 permerror (loc
, "shift expression %q+E overflows",
1897 build2_loc (loc
, code
, type
, lhs
, rhs
));
1898 return (!flag_permissive
|| ctx
->quiet
);
1904 /* Subroutine of cxx_eval_constant_expression.
1905 Attempt to reduce the unary expression tree T to a compile time value.
1906 If successful, return the value. Otherwise issue a diagnostic
1907 and return error_mark_node. */
1910 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1912 bool *non_constant_p
, bool *overflow_p
)
1915 tree orig_arg
= TREE_OPERAND (t
, 0);
1916 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1917 non_constant_p
, overflow_p
);
1918 VERIFY_CONSTANT (arg
);
1919 location_t loc
= EXPR_LOCATION (t
);
1920 enum tree_code code
= TREE_CODE (t
);
1921 tree type
= TREE_TYPE (t
);
1922 r
= fold_unary_loc (loc
, code
, type
, arg
);
1925 if (arg
== orig_arg
)
1928 r
= build1_loc (loc
, code
, type
, arg
);
1930 VERIFY_CONSTANT (r
);
1934 /* Helper function for cxx_eval_binary_expression. Try to optimize
1935 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1936 generic folding should be used. */
1939 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1940 tree lhs
, tree rhs
, bool *non_constant_p
,
1944 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1947 lhs
= TREE_OPERAND (lhs
, 0);
1949 /* &A[i] p+ j => &A[i + j] */
1950 if (TREE_CODE (lhs
) == ARRAY_REF
1951 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1952 && TREE_CODE (rhs
) == INTEGER_CST
1953 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1954 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1956 tree orig_type
= TREE_TYPE (t
);
1957 location_t loc
= EXPR_LOCATION (t
);
1958 tree type
= TREE_TYPE (lhs
);
1960 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1961 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1962 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1964 if (*non_constant_p
)
1966 /* Don't fold an out-of-bound access. */
1967 if (!tree_int_cst_le (t
, nelts
))
1969 rhs
= cp_fold_convert (ssizetype
, rhs
);
1970 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1971 constexpr int A[1]; ... (char *)&A[0] + 1 */
1972 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1973 rhs
, TYPE_SIZE_UNIT (type
))))
1975 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1977 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1978 TYPE_SIZE_UNIT (type
));
1979 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1980 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1981 t
, NULL_TREE
, NULL_TREE
);
1982 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1983 t
= cp_fold_convert (orig_type
, t
);
1984 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1985 non_constant_p
, overflow_p
);
1991 /* Subroutine of cxx_eval_constant_expression.
1992 Like cxx_eval_unary_expression, except for binary expressions. */
1995 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1997 bool *non_constant_p
, bool *overflow_p
)
2000 tree orig_lhs
= TREE_OPERAND (t
, 0);
2001 tree orig_rhs
= TREE_OPERAND (t
, 1);
2003 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2004 non_constant_p
, overflow_p
);
2005 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2007 if (*non_constant_p
)
2009 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2010 non_constant_p
, overflow_p
);
2011 if (*non_constant_p
)
2014 location_t loc
= EXPR_LOCATION (t
);
2015 enum tree_code code
= TREE_CODE (t
);
2016 tree type
= TREE_TYPE (t
);
2018 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2020 bool is_code_eq
= (code
== EQ_EXPR
);
2022 if (TREE_CODE (lhs
) == PTRMEM_CST
2023 && TREE_CODE (rhs
) == PTRMEM_CST
)
2024 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2026 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2027 || TREE_CODE (rhs
) == PTRMEM_CST
)
2028 && (null_member_pointer_value_p (lhs
)
2029 || null_member_pointer_value_p (rhs
)))
2030 r
= constant_boolean_node (!is_code_eq
, type
);
2031 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2032 lhs
= cplus_expand_constant (lhs
);
2033 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2034 rhs
= cplus_expand_constant (rhs
);
2036 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2037 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2040 error ("arithmetic involving a null pointer in %qE", lhs
);
2043 else if (code
== POINTER_PLUS_EXPR
)
2044 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2048 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2052 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2055 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2057 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2058 *non_constant_p
= true;
2059 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2060 a local array in a constexpr function. */
2061 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2063 VERIFY_CONSTANT (r
);
2067 /* Subroutine of cxx_eval_constant_expression.
2068 Attempt to evaluate condition expressions. Dead branches are not
2072 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2074 bool *non_constant_p
, bool *overflow_p
,
2077 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2079 non_constant_p
, overflow_p
);
2080 VERIFY_CONSTANT (val
);
2081 /* Don't VERIFY_CONSTANT the other operands. */
2082 if (integer_zerop (val
))
2083 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2085 non_constant_p
, overflow_p
,
2087 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2089 non_constant_p
, overflow_p
,
2093 /* Subroutine of cxx_eval_constant_expression.
2094 Attempt to evaluate vector condition expressions. Unlike
2095 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2096 ternary arithmetics operation, where all 3 arguments have to be
2097 evaluated as constants and then folding computes the result from
2101 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2102 bool *non_constant_p
, bool *overflow_p
)
2104 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2106 non_constant_p
, overflow_p
);
2107 VERIFY_CONSTANT (arg1
);
2108 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2110 non_constant_p
, overflow_p
);
2111 VERIFY_CONSTANT (arg2
);
2112 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2114 non_constant_p
, overflow_p
);
2115 VERIFY_CONSTANT (arg3
);
2116 location_t loc
= EXPR_LOCATION (t
);
2117 tree type
= TREE_TYPE (t
);
2118 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2121 if (arg1
== TREE_OPERAND (t
, 0)
2122 && arg2
== TREE_OPERAND (t
, 1)
2123 && arg3
== TREE_OPERAND (t
, 2))
2126 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2128 VERIFY_CONSTANT (r
);
2132 /* Returns less than, equal to, or greater than zero if KEY is found to be
2133 less than, to match, or to be greater than the constructor_elt's INDEX. */
2136 array_index_cmp (tree key
, tree index
)
2138 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2140 switch (TREE_CODE (index
))
2143 return tree_int_cst_compare (key
, index
);
2146 tree lo
= TREE_OPERAND (index
, 0);
2147 tree hi
= TREE_OPERAND (index
, 1);
2148 if (tree_int_cst_lt (key
, lo
))
2150 else if (tree_int_cst_lt (hi
, key
))
2160 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2161 if none. If INSERT is true, insert a matching element rather than fail. */
2163 static HOST_WIDE_INT
2164 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2166 if (tree_int_cst_sgn (dindex
) < 0)
2169 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2170 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2171 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2173 unsigned HOST_WIDE_INT end
= len
;
2174 unsigned HOST_WIDE_INT begin
= 0;
2176 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2177 that the same is true of the other elements and index directly. */
2180 tree cindex
= (*elts
)[end
-1].index
;
2181 if (TREE_CODE (cindex
) == INTEGER_CST
2182 && compare_tree_int (cindex
, end
-1) == 0)
2191 /* Otherwise, find a matching index by means of a binary search. */
2192 while (begin
!= end
)
2194 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2195 constructor_elt
&elt
= (*elts
)[middle
];
2196 tree idx
= elt
.index
;
2198 int cmp
= array_index_cmp (dindex
, idx
);
2205 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2207 /* We need to split the range. */
2209 tree lo
= TREE_OPERAND (idx
, 0);
2210 tree hi
= TREE_OPERAND (idx
, 1);
2211 if (tree_int_cst_lt (lo
, dindex
))
2213 /* There are still some lower elts; shorten the range. */
2214 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2216 if (tree_int_cst_equal (lo
, new_hi
))
2217 /* Only one element left, no longer a range. */
2220 TREE_OPERAND (idx
, 1) = new_hi
;
2221 /* Append the element we want to insert. */
2224 e
.value
= unshare_constructor (elt
.value
);
2225 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2228 /* No lower elts, the range elt is now ours. */
2231 if (tree_int_cst_lt (dindex
, hi
))
2233 /* There are still some higher elts; append a range. */
2234 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2236 if (tree_int_cst_equal (new_lo
, hi
))
2239 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2240 e
.value
= unshare_constructor (elt
.value
);
2241 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2250 constructor_elt e
= { dindex
, NULL_TREE
};
2251 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2258 /* Under the control of CTX, issue a detailed diagnostic for
2259 an out-of-bounds subscript INDEX into the expression ARRAY. */
2262 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2266 tree arraytype
= TREE_TYPE (array
);
2268 /* Convert the unsigned array subscript to a signed integer to avoid
2269 printing huge numbers for small negative values. */
2270 tree sidx
= fold_convert (ssizetype
, index
);
2273 if (TYPE_DOMAIN (arraytype
))
2274 error ("array subscript value %qE is outside the bounds "
2275 "of array %qD of type %qT", sidx
, array
, arraytype
);
2277 error ("non-zero array subscript %qE is used with array %qD of "
2278 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2279 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2281 else if (TYPE_DOMAIN (arraytype
))
2282 error ("array subscript value %qE is outside the bounds "
2283 "of array type %qT", sidx
, arraytype
);
2285 error ("non-zero array subscript %qE is used with array of type %qT "
2286 "with unknown bounds", sidx
, arraytype
);
2290 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2291 STRING_CST STRING. */
2294 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2296 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2299 if (chars_per_elt
== 1)
2300 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2303 const unsigned char *ptr
2304 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2305 + index
* chars_per_elt
);
2306 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2311 /* Subroutine of cxx_eval_constant_expression.
2312 Attempt to reduce a reference to an array slot. */
2315 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2317 bool *non_constant_p
, bool *overflow_p
)
2319 tree oldary
= TREE_OPERAND (t
, 0);
2320 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2322 non_constant_p
, overflow_p
);
2324 HOST_WIDE_INT i
= 0;
2325 tree elem_type
= NULL_TREE
;
2326 unsigned len
= 0, elem_nchars
= 1;
2327 if (*non_constant_p
)
2329 oldidx
= TREE_OPERAND (t
, 1);
2330 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2332 non_constant_p
, overflow_p
);
2333 VERIFY_CONSTANT (index
);
2336 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2337 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2338 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2339 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2340 ary
= TREE_OPERAND (ary
, 0);
2341 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2342 len
= CONSTRUCTOR_NELTS (ary
);
2343 else if (TREE_CODE (ary
) == STRING_CST
)
2345 elem_nchars
= (TYPE_PRECISION (elem_type
)
2346 / TYPE_PRECISION (char_type_node
));
2347 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2349 else if (TREE_CODE (ary
) == VECTOR_CST
)
2350 /* We don't create variable-length VECTOR_CSTs. */
2351 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2354 /* We can't do anything with other tree codes, so use
2355 VERIFY_CONSTANT to complain and fail. */
2356 VERIFY_CONSTANT (ary
);
2360 if (!tree_fits_shwi_p (index
)
2361 || (i
= tree_to_shwi (index
)) < 0)
2363 diag_array_subscript (ctx
, ary
, index
);
2364 *non_constant_p
= true;
2370 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2372 if (TYPE_DOMAIN (TREE_TYPE (ary
)))
2373 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2375 nelts
= size_zero_node
;
2377 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2378 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2382 /* For VLAs, the number of elements won't be an integer constant. */
2383 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2385 VERIFY_CONSTANT (nelts
);
2387 ? !tree_int_cst_le (index
, nelts
)
2388 : !tree_int_cst_lt (index
, nelts
))
2389 || tree_int_cst_sgn (index
) < 0)
2391 diag_array_subscript (ctx
, ary
, index
);
2392 *non_constant_p
= true;
2396 if (lval
&& ary
== oldary
&& index
== oldidx
)
2399 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2402 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2404 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2415 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2416 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2417 else if (TREE_CODE (ary
) == VECTOR_CST
)
2418 r
= VECTOR_CST_ELT (ary
, i
);
2420 r
= extract_string_elt (ary
, elem_nchars
, i
);
2423 /* Don't VERIFY_CONSTANT here. */
2426 /* Otherwise the element doesn't have a value yet. */
2431 if (TREE_CODE (ary
) == CONSTRUCTOR
2432 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2434 /* 'ary' is part of the aggregate initializer we're currently
2435 building; if there's no initializer for this element yet,
2438 error ("accessing uninitialized array element");
2439 *non_constant_p
= true;
2443 /* If it's within the array bounds but doesn't have an explicit
2444 initializer, it's value-initialized. */
2445 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2446 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2450 /* Subroutine of cxx_eval_constant_expression.
2451 Attempt to reduce a field access of a value of class type. */
2454 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2456 bool *non_constant_p
, bool *overflow_p
)
2458 unsigned HOST_WIDE_INT i
;
2461 tree part
= TREE_OPERAND (t
, 1);
2462 tree orig_whole
= TREE_OPERAND (t
, 0);
2463 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2465 non_constant_p
, overflow_p
);
2466 if (INDIRECT_REF_P (whole
)
2467 && integer_zerop (TREE_OPERAND (whole
, 0))
2469 error ("dereferencing a null pointer in %qE", orig_whole
);
2471 if (TREE_CODE (whole
) == PTRMEM_CST
)
2472 whole
= cplus_expand_constant (whole
);
2473 if (whole
== orig_whole
)
2476 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2477 whole
, part
, NULL_TREE
);
2478 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2480 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2483 error ("%qE is not a constant expression", orig_whole
);
2484 *non_constant_p
= true;
2486 if (DECL_MUTABLE_P (part
))
2489 error ("mutable %qD is not usable in a constant expression", part
);
2490 *non_constant_p
= true;
2492 if (*non_constant_p
)
2494 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2495 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2497 /* Use name match for PMF fields, as a variant will have a
2498 different FIELD_DECL with a different type. */
2499 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2505 /* We're in the middle of initializing it. */
2509 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2510 && CONSTRUCTOR_NELTS (whole
) > 0)
2512 /* DR 1188 says we don't have to deal with this. */
2514 error ("accessing %qD member instead of initialized %qD member in "
2515 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2516 *non_constant_p
= true;
2520 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2521 classes never get represented; throw together a value now. */
2522 if (is_really_empty_class (TREE_TYPE (t
)))
2523 return build_constructor (TREE_TYPE (t
), NULL
);
2525 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2527 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2529 /* 'whole' is part of the aggregate initializer we're currently
2530 building; if there's no initializer for this member yet, that's an
2533 error ("accessing uninitialized member %qD", part
);
2534 *non_constant_p
= true;
2538 /* If there's no explicit init for this field, it's value-initialized. */
2539 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2540 return cxx_eval_constant_expression (ctx
, value
,
2542 non_constant_p
, overflow_p
);
2545 /* Subroutine of cxx_eval_constant_expression.
2546 Attempt to reduce a field access of a value of class type that is
2547 expressed as a BIT_FIELD_REF. */
2550 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2552 bool *non_constant_p
, bool *overflow_p
)
2554 tree orig_whole
= TREE_OPERAND (t
, 0);
2555 tree retval
, fldval
, utype
, mask
;
2556 bool fld_seen
= false;
2557 HOST_WIDE_INT istart
, isize
;
2558 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2560 non_constant_p
, overflow_p
);
2561 tree start
, field
, value
;
2562 unsigned HOST_WIDE_INT i
;
2564 if (whole
== orig_whole
)
2566 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2568 if (!*non_constant_p
2569 && TREE_CODE (whole
) != VECTOR_CST
2570 && TREE_CODE (whole
) != CONSTRUCTOR
)
2573 error ("%qE is not a constant expression", orig_whole
);
2574 *non_constant_p
= true;
2576 if (*non_constant_p
)
2579 if (TREE_CODE (whole
) == VECTOR_CST
)
2580 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2581 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2583 start
= TREE_OPERAND (t
, 2);
2584 istart
= tree_to_shwi (start
);
2585 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2586 utype
= TREE_TYPE (t
);
2587 if (!TYPE_UNSIGNED (utype
))
2588 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2589 retval
= build_int_cst (utype
, 0);
2590 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2592 tree bitpos
= bit_position (field
);
2593 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2595 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2596 && TREE_CODE (value
) == INTEGER_CST
2597 && tree_fits_shwi_p (bitpos
)
2598 && tree_fits_shwi_p (DECL_SIZE (field
)))
2600 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2601 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2602 HOST_WIDE_INT shift
;
2603 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2605 fldval
= fold_convert (utype
, value
);
2606 mask
= build_int_cst_type (utype
, -1);
2607 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2608 size_int (TYPE_PRECISION (utype
) - sz
));
2609 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2610 size_int (TYPE_PRECISION (utype
) - sz
));
2611 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2612 shift
= bit
- istart
;
2613 if (BYTES_BIG_ENDIAN
)
2614 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2615 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2617 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2623 return fold_convert (TREE_TYPE (t
), retval
);
2625 return error_mark_node
;
2628 /* Subroutine of cxx_eval_constant_expression.
2629 Evaluate a short-circuited logical expression T in the context
2630 of a given constexpr CALL. BAILOUT_VALUE is the value for
2631 early return. CONTINUE_VALUE is used here purely for
2632 sanity check purposes. */
2635 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2636 tree bailout_value
, tree continue_value
,
2638 bool *non_constant_p
, bool *overflow_p
)
2641 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2643 non_constant_p
, overflow_p
);
2644 VERIFY_CONSTANT (lhs
);
2645 if (tree_int_cst_equal (lhs
, bailout_value
))
2647 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2648 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2649 lval
, non_constant_p
,
2651 VERIFY_CONSTANT (r
);
2655 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2656 CONSTRUCTOR elements to initialize (part of) an object containing that
2657 field. Return a pointer to the constructor_elt corresponding to the
2658 initialization of the field. */
2660 static constructor_elt
*
2661 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2663 tree aggr
= TREE_OPERAND (ref
, 0);
2664 tree field
= TREE_OPERAND (ref
, 1);
2666 constructor_elt
*ce
;
2668 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2670 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2672 constructor_elt
*base_ce
2673 = base_field_constructor_elt (v
, aggr
);
2674 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2677 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2678 if (ce
->index
== field
)
2685 /* Some of the expressions fed to the constexpr mechanism are calls to
2686 constructors, which have type void. In that case, return the type being
2687 initialized by the constructor. */
2690 initialized_type (tree t
)
2694 tree type
= cv_unqualified (TREE_TYPE (t
));
2695 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2697 /* A constructor call has void type, so we need to look deeper. */
2698 tree fn
= get_function_named_in_call (t
);
2699 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2700 && DECL_CXX_CONSTRUCTOR_P (fn
))
2701 type
= DECL_CONTEXT (fn
);
2706 /* We're about to initialize element INDEX of an array or class from VALUE.
2707 Set up NEW_CTX appropriately by adjusting .object to refer to the
2708 subobject and creating a new CONSTRUCTOR if the element is itself
2709 a class or array. */
2712 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2713 tree index
, tree
&value
)
2717 if (index
&& TREE_CODE (index
) != INTEGER_CST
2718 && TREE_CODE (index
) != FIELD_DECL
)
2719 /* This won't have an element in the new CONSTRUCTOR. */
2722 tree type
= initialized_type (value
);
2723 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2724 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2727 /* The sub-aggregate initializer might contain a placeholder;
2728 update object to refer to the subobject and ctor to refer to
2729 the (newly created) sub-initializer. */
2731 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2732 tree elt
= build_constructor (type
, NULL
);
2733 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2736 if (TREE_CODE (value
) == TARGET_EXPR
)
2737 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2738 value
= TARGET_EXPR_INITIAL (value
);
2741 /* We're about to process an initializer for a class or array TYPE. Make
2742 sure that CTX is set up appropriately. */
2745 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2747 /* We don't bother building a ctor for an empty base subobject. */
2748 if (is_empty_class (type
))
2751 /* We're in the middle of an initializer that might involve placeholders;
2752 our caller should have created a CONSTRUCTOR for us to put the
2753 initializer into. We will either return that constructor or T. */
2754 gcc_assert (ctx
->ctor
);
2755 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2756 (type
, TREE_TYPE (ctx
->ctor
)));
2757 /* We used to check that ctx->ctor was empty, but that isn't the case when
2758 the object is zero-initialized before calling the constructor. */
2761 tree otype
= TREE_TYPE (ctx
->object
);
2762 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2763 /* Handle flexible array members. */
2764 || (TREE_CODE (otype
) == ARRAY_TYPE
2765 && TYPE_DOMAIN (otype
) == NULL_TREE
2766 && TREE_CODE (type
) == ARRAY_TYPE
2767 && (same_type_ignoring_top_level_qualifiers_p
2768 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2770 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2771 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2774 /* Subroutine of cxx_eval_constant_expression.
2775 The expression tree T denotes a C-style array or a C-style
2776 aggregate. Reduce it to a constant expression. */
2779 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2781 bool *non_constant_p
, bool *overflow_p
)
2783 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2784 bool changed
= false;
2785 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2786 tree type
= TREE_TYPE (t
);
2788 constexpr_ctx new_ctx
;
2789 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2791 /* We don't really need the ctx->ctor business for a PMF or
2792 vector, but it's simpler to use the same code. */
2794 new_ctx
.ctor
= build_constructor (type
, NULL
);
2795 new_ctx
.object
= NULL_TREE
;
2798 verify_ctor_sanity (ctx
, type
);
2799 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2800 vec_alloc (*p
, vec_safe_length (v
));
2804 bool constant_p
= true;
2805 bool side_effects_p
= false;
2806 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2808 tree orig_value
= value
;
2809 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2810 if (new_ctx
.ctor
!= ctx
->ctor
)
2811 /* If we built a new CONSTRUCTOR, attach it now so that other
2812 initializers can refer to it. */
2813 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2814 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2816 non_constant_p
, overflow_p
);
2817 /* Don't VERIFY_CONSTANT here. */
2818 if (ctx
->quiet
&& *non_constant_p
)
2820 if (elt
!= orig_value
)
2823 if (!TREE_CONSTANT (elt
))
2825 if (TREE_SIDE_EFFECTS (elt
))
2826 side_effects_p
= true;
2827 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2829 /* This is an initialization of a vfield inside a base
2830 subaggregate that we already initialized; push this
2831 initialization into the previous initialization. */
2832 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2837 && (TREE_CODE (index
) == NOP_EXPR
2838 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2840 /* This is an initializer for an empty base; now that we've
2841 checked that it's constant, we can ignore it. */
2842 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2845 else if (new_ctx
.ctor
!= ctx
->ctor
)
2847 /* We appended this element above; update the value. */
2848 gcc_assert ((*p
)->last().index
== index
);
2849 (*p
)->last().value
= elt
;
2852 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2854 if (*non_constant_p
|| !changed
)
2857 /* We're done building this CONSTRUCTOR, so now we can interpret an
2858 element without an explicit initializer as value-initialized. */
2859 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2860 TREE_CONSTANT (t
) = constant_p
;
2861 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2862 if (VECTOR_TYPE_P (type
))
2867 /* Subroutine of cxx_eval_constant_expression.
2868 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2869 initialization of a non-static data member of array type. Reduce it to a
2872 Note that apart from value-initialization (when VALUE_INIT is true),
2873 this is only intended to support value-initialization and the
2874 initializations done by defaulted constructors for classes with
2875 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2876 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2877 for the copy/move constructor. */
2880 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2881 bool value_init
, bool lval
,
2882 bool *non_constant_p
, bool *overflow_p
)
2884 tree elttype
= TREE_TYPE (atype
);
2885 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2886 verify_ctor_sanity (ctx
, atype
);
2887 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2888 bool pre_init
= false;
2889 unsigned HOST_WIDE_INT i
;
2891 /* For the default constructor, build up a call to the default
2892 constructor of the element type. We only need to handle class types
2893 here, as for a constructor to be constexpr, all members must be
2894 initialized, which for a defaulted default constructor means they must
2895 be of a class type with a constexpr default constructor. */
2896 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2897 /* We only do this at the lowest level. */;
2898 else if (value_init
)
2900 init
= build_value_init (elttype
, tf_warning_or_error
);
2905 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2906 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2907 &argvec
, elttype
, LOOKUP_NORMAL
,
2908 tf_warning_or_error
);
2909 release_tree_vector (argvec
);
2910 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2914 for (i
= 0; i
< max
; ++i
)
2916 tree idx
= build_int_cst (size_type_node
, i
);
2919 constexpr_ctx new_ctx
;
2920 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2921 if (new_ctx
.ctor
!= ctx
->ctor
)
2922 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2923 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2925 /* A multidimensional array; recurse. */
2926 if (value_init
|| init
== NULL_TREE
)
2928 eltinit
= NULL_TREE
;
2932 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2933 tf_warning_or_error
);
2934 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2936 non_constant_p
, overflow_p
);
2940 /* Initializing an element using value or default initialization
2941 we just pre-built above. */
2942 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2943 non_constant_p
, overflow_p
);
2948 /* Copying an element. */
2949 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2950 (atype
, TREE_TYPE (init
)));
2951 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2952 tf_warning_or_error
);
2953 if (!lvalue_p (init
))
2954 eltinit
= move (eltinit
);
2955 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2956 eltinit
= (cxx_eval_constant_expression
2957 (&new_ctx
, eltinit
, lval
,
2958 non_constant_p
, overflow_p
));
2960 if (*non_constant_p
&& !ctx
->quiet
)
2962 if (new_ctx
.ctor
!= ctx
->ctor
)
2964 /* We appended this element above; update the value. */
2965 gcc_assert ((*p
)->last().index
== idx
);
2966 (*p
)->last().value
= eltinit
;
2969 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2970 /* Reuse the result of cxx_eval_constant_expression call
2971 from the first iteration to all others if it is a constant
2972 initializer that doesn't require relocations. */
2975 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2976 == null_pointer_node
))
2978 if (new_ctx
.ctor
!= ctx
->ctor
)
2979 eltinit
= new_ctx
.ctor
;
2980 tree range
= build2 (RANGE_EXPR
, size_type_node
,
2981 build_int_cst (size_type_node
, 1),
2982 build_int_cst (size_type_node
, max
- 1));
2983 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
2987 vec_safe_reserve (*p
, max
);
2990 if (!*non_constant_p
)
2993 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2999 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3001 bool *non_constant_p
, bool *overflow_p
)
3003 tree atype
= TREE_TYPE (t
);
3004 tree init
= VEC_INIT_EXPR_INIT (t
);
3005 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3006 VEC_INIT_EXPR_VALUE_INIT (t
),
3007 lval
, non_constant_p
, overflow_p
);
3008 if (*non_constant_p
)
3014 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3015 match. We want to be less strict for simple *& folding; if we have a
3016 non-const temporary that we access through a const pointer, that should
3017 work. We handle this here rather than change fold_indirect_ref_1
3018 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3019 don't really make sense outside of constant expression evaluation. Also
3020 we want to allow folding to COMPONENT_REF, which could cause trouble
3021 with TBAA in fold_indirect_ref_1.
3023 Try to keep this function synced with fold_indirect_ref_1. */
3026 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3030 poly_uint64 const_op01
;
3033 subtype
= TREE_TYPE (sub
);
3034 if (!POINTER_TYPE_P (subtype
))
3037 if (TREE_CODE (sub
) == ADDR_EXPR
)
3039 tree op
= TREE_OPERAND (sub
, 0);
3040 tree optype
= TREE_TYPE (op
);
3042 /* *&CONST_DECL -> to the value of the const decl. */
3043 if (TREE_CODE (op
) == CONST_DECL
)
3044 return DECL_INITIAL (op
);
3045 /* *&p => p; make sure to handle *&"str"[cst] here. */
3046 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
3047 /* Also handle the case where the desired type is an array of unknown
3048 bounds because the variable has had its bounds deduced since the
3049 ADDR_EXPR was created. */
3050 || (TREE_CODE (type
) == ARRAY_TYPE
3051 && TREE_CODE (optype
) == ARRAY_TYPE
3052 && TYPE_DOMAIN (type
) == NULL_TREE
3053 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3056 tree fop
= fold_read_from_constant_string (op
);
3062 /* *(foo *)&fooarray => fooarray[0] */
3063 else if (TREE_CODE (optype
) == ARRAY_TYPE
3064 && (same_type_ignoring_top_level_qualifiers_p
3065 (type
, TREE_TYPE (optype
))))
3067 tree type_domain
= TYPE_DOMAIN (optype
);
3068 tree min_val
= size_zero_node
;
3069 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3070 min_val
= TYPE_MIN_VALUE (type_domain
);
3071 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3072 NULL_TREE
, NULL_TREE
);
3074 /* *(foo *)&complexfoo => __real__ complexfoo */
3075 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3076 && (same_type_ignoring_top_level_qualifiers_p
3077 (type
, TREE_TYPE (optype
))))
3078 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3079 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3080 else if (VECTOR_TYPE_P (optype
)
3081 && (same_type_ignoring_top_level_qualifiers_p
3082 (type
, TREE_TYPE (optype
))))
3084 tree part_width
= TYPE_SIZE (type
);
3085 tree index
= bitsize_int (0);
3086 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3089 /* Also handle conversion to an empty base class, which
3090 is represented with a NOP_EXPR. */
3091 else if (is_empty_class (type
)
3092 && CLASS_TYPE_P (optype
)
3093 && DERIVED_FROM_P (type
, optype
))
3098 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3099 else if (RECORD_OR_UNION_TYPE_P (optype
))
3101 tree field
= TYPE_FIELDS (optype
);
3102 for (; field
; field
= DECL_CHAIN (field
))
3103 if (TREE_CODE (field
) == FIELD_DECL
3104 && TREE_TYPE (field
) != error_mark_node
3105 && integer_zerop (byte_position (field
))
3106 && (same_type_ignoring_top_level_qualifiers_p
3107 (TREE_TYPE (field
), type
)))
3108 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3111 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3112 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3114 tree op00
= TREE_OPERAND (sub
, 0);
3115 tree op01
= TREE_OPERAND (sub
, 1);
3118 if (TREE_CODE (op00
) == ADDR_EXPR
)
3121 op00
= TREE_OPERAND (op00
, 0);
3122 op00type
= TREE_TYPE (op00
);
3124 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3125 if (VECTOR_TYPE_P (op00type
)
3126 && same_type_ignoring_top_level_qualifiers_p
3127 (type
, TREE_TYPE (op00type
))
3128 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3129 but we want to treat offsets with MSB set as negative.
3130 For the code below negative offsets are invalid and
3131 TYPE_SIZE of the element is something unsigned, so
3132 check whether op01 fits into poly_int64, which implies
3133 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3134 then just use poly_uint64 because we want to treat the
3135 value as unsigned. */
3136 && tree_fits_poly_int64_p (op01
))
3138 tree part_width
= TYPE_SIZE (type
);
3139 poly_uint64 max_offset
3140 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3141 * TYPE_VECTOR_SUBPARTS (op00type
));
3142 if (known_lt (const_op01
, max_offset
))
3144 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3145 return fold_build3_loc (loc
,
3146 BIT_FIELD_REF
, type
, op00
,
3150 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3151 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3152 && (same_type_ignoring_top_level_qualifiers_p
3153 (type
, TREE_TYPE (op00type
))))
3155 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3157 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3159 /* ((foo *)&fooarray)[1] => fooarray[1] */
3160 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3161 && (same_type_ignoring_top_level_qualifiers_p
3162 (type
, TREE_TYPE (op00type
))))
3164 tree type_domain
= TYPE_DOMAIN (op00type
);
3165 tree min_val
= size_zero_node
;
3166 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3167 min_val
= TYPE_MIN_VALUE (type_domain
);
3168 offset_int off
= wi::to_offset (op01
);
3169 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3170 offset_int remainder
;
3171 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3172 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3174 off
= off
+ wi::to_offset (min_val
);
3175 op01
= wide_int_to_tree (sizetype
, off
);
3176 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3177 NULL_TREE
, NULL_TREE
);
3180 /* Also handle conversion to an empty base class, which
3181 is represented with a NOP_EXPR. */
3182 else if (is_empty_class (type
)
3183 && CLASS_TYPE_P (op00type
)
3184 && DERIVED_FROM_P (type
, op00type
))
3189 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3190 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3192 tree field
= TYPE_FIELDS (op00type
);
3193 for (; field
; field
= DECL_CHAIN (field
))
3194 if (TREE_CODE (field
) == FIELD_DECL
3195 && TREE_TYPE (field
) != error_mark_node
3196 && tree_int_cst_equal (byte_position (field
), op01
)
3197 && (same_type_ignoring_top_level_qualifiers_p
3198 (TREE_TYPE (field
), type
)))
3199 return fold_build3 (COMPONENT_REF
, type
, op00
,
3204 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3205 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3206 && (same_type_ignoring_top_level_qualifiers_p
3207 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3210 tree min_val
= size_zero_node
;
3212 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3216 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3217 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3218 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3219 min_val
= TYPE_MIN_VALUE (type_domain
);
3220 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3228 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3230 bool *non_constant_p
, bool *overflow_p
)
3232 tree orig_op0
= TREE_OPERAND (t
, 0);
3233 bool empty_base
= false;
3235 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3236 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3238 if (TREE_CODE (t
) == MEM_REF
3239 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3241 gcc_assert (ctx
->quiet
);
3242 *non_constant_p
= true;
3246 /* First try to simplify it directly. */
3247 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3251 /* If that didn't work, evaluate the operand first. */
3252 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3253 /*lval*/false, non_constant_p
,
3255 /* Don't VERIFY_CONSTANT here. */
3256 if (*non_constant_p
)
3259 if (!lval
&& integer_zerop (op0
))
3262 error ("dereferencing a null pointer");
3263 *non_constant_p
= true;
3267 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3271 /* We couldn't fold to a constant value. Make sure it's not
3272 something we should have been able to fold. */
3275 if (TREE_CODE (sub
) == ADDR_EXPR
)
3277 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3278 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3279 /* DR 1188 says we don't have to deal with this. */
3281 error ("accessing value of %qE through a %qT glvalue in a "
3282 "constant expression", build_fold_indirect_ref (sub
),
3284 *non_constant_p
= true;
3288 if (lval
&& op0
!= orig_op0
)
3289 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3291 VERIFY_CONSTANT (t
);
3296 r
= cxx_eval_constant_expression (ctx
, r
,
3297 lval
, non_constant_p
, overflow_p
);
3298 if (*non_constant_p
)
3301 /* If we're pulling out the value of an empty base, just return an empty
3303 if (empty_base
&& !lval
)
3305 r
= build_constructor (TREE_TYPE (t
), NULL
);
3306 TREE_CONSTANT (r
) = true;
3312 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3313 Shared between potential_constant_expression and
3314 cxx_eval_constant_expression. */
3317 non_const_var_error (tree r
)
3319 tree type
= TREE_TYPE (r
);
3320 error ("the value of %qD is not usable in a constant "
3322 /* Avoid error cascade. */
3323 if (DECL_INITIAL (r
) == error_mark_node
)
3325 if (DECL_DECLARED_CONSTEXPR_P (r
))
3326 inform (DECL_SOURCE_LOCATION (r
),
3327 "%qD used in its own initializer", r
);
3328 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3330 if (!CP_TYPE_CONST_P (type
))
3331 inform (DECL_SOURCE_LOCATION (r
),
3332 "%q#D is not const", r
);
3333 else if (CP_TYPE_VOLATILE_P (type
))
3334 inform (DECL_SOURCE_LOCATION (r
),
3335 "%q#D is volatile", r
);
3336 else if (!DECL_INITIAL (r
)
3337 || !TREE_CONSTANT (DECL_INITIAL (r
))
3338 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3339 inform (DECL_SOURCE_LOCATION (r
),
3340 "%qD was not initialized with a constant "
3345 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3346 inform (DECL_SOURCE_LOCATION (r
),
3347 "%qD was not initialized with a constant "
3351 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3352 inform (DECL_SOURCE_LOCATION (r
),
3353 "%qD was not declared %<constexpr%>", r
);
3355 inform (DECL_SOURCE_LOCATION (r
),
3356 "%qD does not have integral or enumeration type",
3361 /* Subroutine of cxx_eval_constant_expression.
3362 Like cxx_eval_unary_expression, except for trinary expressions. */
3365 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3367 bool *non_constant_p
, bool *overflow_p
)
3373 for (i
= 0; i
< 3; i
++)
3375 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3377 non_constant_p
, overflow_p
);
3378 VERIFY_CONSTANT (args
[i
]);
3381 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3382 args
[0], args
[1], args
[2]);
3383 if (val
== NULL_TREE
)
3385 VERIFY_CONSTANT (val
);
3389 /* True if T was declared in a function declared to be constexpr, and
3390 therefore potentially constant in C++14. */
3393 var_in_constexpr_fn (tree t
)
3395 tree ctx
= DECL_CONTEXT (t
);
3396 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3397 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3400 /* True if T was declared in a function that might be constexpr: either a
3401 function that was declared constexpr, or a C++17 lambda op(). */
3404 var_in_maybe_constexpr_fn (tree t
)
3406 if (cxx_dialect
>= cxx17
3407 && DECL_FUNCTION_SCOPE_P (t
)
3408 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3410 return var_in_constexpr_fn (t
);
3413 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3414 build_over_call we implement trivial copy of a class with tail padding using
3415 assignment of character arrays, which is valid in normal code, but not in
3416 constexpr evaluation. We don't need to worry about clobbering tail padding
3417 in constexpr evaluation, so strip the type punning. */
3420 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3422 if (TREE_CODE (target
) == MEM_REF
3423 && TREE_CODE (init
) == MEM_REF
3424 && TREE_TYPE (target
) == TREE_TYPE (init
)
3425 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3426 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3428 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3429 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3433 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3436 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3438 bool *non_constant_p
, bool *overflow_p
)
3440 constexpr_ctx new_ctx
= *ctx
;
3442 tree init
= TREE_OPERAND (t
, 1);
3443 if (TREE_CLOBBER_P (init
))
3444 /* Just ignore clobbers. */
3447 /* First we figure out where we're storing to. */
3448 tree target
= TREE_OPERAND (t
, 0);
3450 maybe_simplify_trivial_copy (target
, init
);
3452 tree type
= TREE_TYPE (target
);
3453 target
= cxx_eval_constant_expression (ctx
, target
,
3455 non_constant_p
, overflow_p
);
3456 if (*non_constant_p
)
3459 /* cxx_eval_array_reference for lval = true allows references one past
3460 end of array, because it does not know if it is just taking address
3461 (which is valid), or actual dereference. Here we know it is
3462 a dereference, so diagnose it here. */
3463 for (tree probe
= target
; probe
; )
3465 switch (TREE_CODE (probe
))
3469 ary
= TREE_OPERAND (probe
, 0);
3470 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3472 if (TYPE_DOMAIN (TREE_TYPE (ary
)))
3473 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3475 nelts
= size_zero_node
;
3477 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3478 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3481 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3482 non_constant_p
, overflow_p
);
3483 VERIFY_CONSTANT (nelts
);
3484 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3485 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3486 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3488 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3489 *non_constant_p
= true;
3496 probe
= TREE_OPERAND (probe
, 0);
3505 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3507 /* For initialization of an empty base, the original target will be
3508 *(base*)this, which the above evaluation resolves to the object
3509 argument, which has the derived type rather than the base type. In
3510 this situation, just evaluate the initializer and return, since
3511 there's no actual data to store. */
3512 gcc_assert (is_empty_class (type
));
3513 return cxx_eval_constant_expression (ctx
, init
, false,
3514 non_constant_p
, overflow_p
);
3517 /* And then find the underlying variable. */
3518 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3519 tree object
= NULL_TREE
;
3520 for (tree probe
= target
; object
== NULL_TREE
; )
3522 switch (TREE_CODE (probe
))
3527 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3528 vec_safe_push (refs
, TREE_TYPE (probe
));
3529 probe
= TREE_OPERAND (probe
, 0);
3537 /* And then find/build up our initializer for the path to the subobject
3538 we're initializing. */
3540 if (object
== ctx
->object
&& VAR_P (object
)
3541 && DECL_NAME (object
) && ctx
->call
== NULL
)
3542 /* The variable we're building up an aggregate initializer for is outside
3543 the constant-expression, so don't evaluate the store. We check
3544 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3546 else if (DECL_P (object
))
3547 valp
= ctx
->values
->get (object
);
3552 /* A constant-expression cannot modify objects from outside the
3553 constant-expression. */
3555 error ("modification of %qE is not a constant expression", object
);
3556 *non_constant_p
= true;
3559 type
= TREE_TYPE (object
);
3560 bool no_zero_init
= true;
3562 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3563 while (!refs
->is_empty())
3565 if (*valp
== NULL_TREE
)
3567 *valp
= build_constructor (type
, NULL
);
3568 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3570 else if (TREE_CODE (*valp
) == STRING_CST
)
3572 /* An array was initialized with a string constant, and now
3573 we're writing into one of its elements. Explode the
3574 single initialization into a set of element
3576 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3578 tree string
= *valp
;
3579 tree elt_type
= TREE_TYPE (type
);
3580 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3581 / TYPE_PRECISION (char_type_node
));
3582 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3583 tree ary_ctor
= build_constructor (type
, NULL
);
3585 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3586 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3588 constructor_elt elt
=
3590 build_int_cst (size_type_node
, ix
),
3591 extract_string_elt (string
, chars_per_elt
, ix
)
3593 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3599 /* If the value of object is already zero-initialized, any new ctors for
3600 subobjects will also be zero-initialized. */
3601 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3603 vec_safe_push (ctors
, *valp
);
3605 enum tree_code code
= TREE_CODE (type
);
3607 tree index
= refs
->pop();
3609 constructor_elt
*cep
= NULL
;
3610 if (code
== ARRAY_TYPE
)
3613 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3614 gcc_assert (i
>= 0);
3615 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3616 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3620 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3622 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3623 Usually we meet initializers in that order, but it is
3624 possible for base types to be placed not in program
3626 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3627 unsigned HOST_WIDE_INT idx
;
3629 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3630 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3631 /* Changing active member. */
3632 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3635 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3636 idx
++, fields
= DECL_CHAIN (fields
))
3638 if (index
== cep
->index
)
3641 /* The field we're initializing must be on the field
3642 list. Look to see if it is present before the
3643 field the current ELT initializes. */
3644 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3645 if (index
== fields
)
3649 /* We fell off the end of the CONSTRUCTOR, so insert a new
3650 entry at the end. */
3653 constructor_elt ce
= { index
, NULL_TREE
};
3655 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3656 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3662 release_tree_vector (refs
);
3664 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3666 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3667 wants to modify it. */
3668 if (*valp
== NULL_TREE
)
3670 *valp
= build_constructor (type
, NULL
);
3671 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3673 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3674 *valp
= cplus_expand_constant (*valp
);
3675 new_ctx
.ctor
= *valp
;
3676 new_ctx
.object
= target
;
3679 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3680 non_constant_p
, overflow_p
);
3681 /* Don't share a CONSTRUCTOR that might be changed later. */
3682 init
= unshare_constructor (init
);
3683 if (target
== object
)
3684 /* The hash table might have moved since the get earlier. */
3685 valp
= ctx
->values
->get (object
);
3687 if (TREE_CODE (init
) == CONSTRUCTOR
)
3689 /* An outer ctx->ctor might be pointing to *valp, so replace
3691 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3692 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3693 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3694 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3695 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3700 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3701 CONSTRUCTORs, if any. */
3704 bool c
= TREE_CONSTANT (init
);
3705 bool s
= TREE_SIDE_EFFECTS (init
);
3707 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3710 TREE_CONSTANT (elt
) = false;
3712 TREE_SIDE_EFFECTS (elt
) = true;
3714 release_tree_vector (ctors
);
3716 if (*non_constant_p
)
3724 /* Evaluate a ++ or -- expression. */
3727 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3729 bool *non_constant_p
, bool *overflow_p
)
3731 enum tree_code code
= TREE_CODE (t
);
3732 tree type
= TREE_TYPE (t
);
3733 tree op
= TREE_OPERAND (t
, 0);
3734 tree offset
= TREE_OPERAND (t
, 1);
3735 gcc_assert (TREE_CONSTANT (offset
));
3737 /* The operand as an lvalue. */
3738 op
= cxx_eval_constant_expression (ctx
, op
, true,
3739 non_constant_p
, overflow_p
);
3741 /* The operand as an rvalue. */
3743 = cxx_eval_constant_expression (ctx
, op
, false,
3744 non_constant_p
, overflow_p
);
3745 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3746 a local array in a constexpr function. */
3747 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3749 VERIFY_CONSTANT (val
);
3751 /* The modified value. */
3752 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3754 if (POINTER_TYPE_P (type
))
3756 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3757 offset
= convert_to_ptrofftype (offset
);
3759 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3760 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3763 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3765 VERIFY_CONSTANT (mod
);
3767 /* Storing the modified value. */
3768 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3769 cxx_eval_constant_expression (ctx
, store
,
3770 true, non_constant_p
, overflow_p
);
3772 /* And the value of the expression. */
3773 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3775 /* Prefix ops are lvalues. */
3779 /* But we optimize when the caller wants an rvalue. */
3783 /* Postfix ops are rvalues. */
3787 /* Predicates for the meaning of *jump_target. */
3790 returns (tree
*jump_target
)
3793 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3794 || (TREE_CODE (*jump_target
) == LABEL_DECL
3795 && LABEL_DECL_CDTOR (*jump_target
)));
3799 breaks (tree
*jump_target
)
3802 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3803 && LABEL_DECL_BREAK (*jump_target
))
3804 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3808 continues (tree
*jump_target
)
3811 && TREE_CODE (*jump_target
) == LABEL_DECL
3812 && LABEL_DECL_CONTINUE (*jump_target
);
3816 switches (tree
*jump_target
)
3819 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3822 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3823 STMT matches *jump_target. If we're looking for a case label and we see
3824 the default label, note it in ctx->css_state. */
3827 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3829 switch (TREE_CODE (*jump_target
))
3832 if (TREE_CODE (stmt
) == LABEL_EXPR
3833 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3838 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3840 gcc_assert (ctx
->css_state
!= NULL
);
3841 if (!CASE_LOW (stmt
))
3843 /* default: should appear just once in a SWITCH_EXPR
3844 body (excluding nested SWITCH_EXPR). */
3845 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3846 /* When evaluating SWITCH_EXPR body for the second time,
3847 return true for the default: label. */
3848 if (*ctx
->css_state
== css_default_processing
)
3850 *ctx
->css_state
= css_default_seen
;
3852 else if (CASE_HIGH (stmt
))
3854 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3855 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3858 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3869 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3870 semantics, for switch, break, continue, and return. */
3873 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3874 bool *non_constant_p
, bool *overflow_p
,
3877 tree_stmt_iterator i
;
3879 /* In a statement-expression we want to return the last value.
3880 For empty statement expression return void_node. */
3884 local_target
= NULL_TREE
;
3885 jump_target
= &local_target
;
3887 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3889 tree stmt
= tsi_stmt (i
);
3890 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
3892 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3893 non_constant_p
, overflow_p
,
3895 if (*non_constant_p
)
3897 if (returns (jump_target
) || breaks (jump_target
))
3903 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3904 semantics; continue semantics are covered by cxx_eval_statement_list. */
3907 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3908 bool *non_constant_p
, bool *overflow_p
,
3911 constexpr_ctx new_ctx
= *ctx
;
3913 tree body
= TREE_OPERAND (t
, 0);
3917 hash_set
<tree
> save_exprs
;
3918 new_ctx
.save_exprs
= &save_exprs
;
3920 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3921 non_constant_p
, overflow_p
, jump_target
);
3923 /* Forget saved values of SAVE_EXPRs. */
3924 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3925 iter
!= save_exprs
.end(); ++iter
)
3926 new_ctx
.values
->remove (*iter
);
3927 if (++count
>= constexpr_loop_limit
)
3930 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3931 "%<constexpr%> loop iteration count exceeds limit of %d "
3932 "(use -fconstexpr-loop-limit= to increase the limit)",
3933 constexpr_loop_limit
);
3934 *non_constant_p
= true;
3938 while (!returns (jump_target
)
3939 && !breaks (jump_target
)
3940 && !switches (jump_target
)
3941 && !*non_constant_p
);
3943 if (breaks (jump_target
))
3944 *jump_target
= NULL_TREE
;
3949 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3953 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3954 bool *non_constant_p
, bool *overflow_p
,
3957 tree cond
= TREE_OPERAND (t
, 0);
3958 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3959 non_constant_p
, overflow_p
);
3960 VERIFY_CONSTANT (cond
);
3961 *jump_target
= cond
;
3963 tree body
= TREE_OPERAND (t
, 1);
3964 constexpr_ctx new_ctx
= *ctx
;
3965 constexpr_switch_state css
= css_default_not_seen
;
3966 new_ctx
.css_state
= &css
;
3967 cxx_eval_constant_expression (&new_ctx
, body
, false,
3968 non_constant_p
, overflow_p
, jump_target
);
3969 if (switches (jump_target
) && css
== css_default_seen
)
3971 /* If the SWITCH_EXPR body has default: label, process it once again,
3972 this time instructing label_matches to return true for default:
3973 label on switches (jump_target). */
3974 css
= css_default_processing
;
3975 cxx_eval_constant_expression (&new_ctx
, body
, false,
3976 non_constant_p
, overflow_p
, jump_target
);
3978 if (breaks (jump_target
) || switches (jump_target
))
3979 *jump_target
= NULL_TREE
;
3983 /* Find the object of TYPE under initialization in CTX. */
3986 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3991 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3992 can is a minor optimization. */
3993 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
3999 /* Since an object cannot have a field of its own type, we can search outward
4000 from ctx->object to find the unique containing object of TYPE. */
4001 tree ob
= ctx
->object
;
4004 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4006 if (handled_component_p (ob
))
4007 ob
= TREE_OPERAND (ob
, 0);
4015 /* Attempt to reduce the expression T to a constant value.
4016 On failure, issue diagnostic and return error_mark_node. */
4017 /* FIXME unify with c_fully_fold */
4018 /* FIXME overflow_p is too global */
4021 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4023 bool *non_constant_p
, bool *overflow_p
,
4026 constexpr_ctx new_ctx
;
4029 if (jump_target
&& *jump_target
)
4031 /* If we are jumping, ignore all statements/expressions except those
4032 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4033 switch (TREE_CODE (t
))
4036 case STATEMENT_LIST
:
4041 case CASE_LABEL_EXPR
:
4042 if (label_matches (ctx
, jump_target
, t
))
4044 *jump_target
= NULL_TREE
;
4050 if (t
== error_mark_node
)
4052 *non_constant_p
= true;
4055 if (CONSTANT_CLASS_P (t
))
4057 if (TREE_OVERFLOW (t
))
4060 permerror (input_location
, "overflow in constant expression");
4061 if (!flag_permissive
|| ctx
->quiet
)
4065 if (TREE_CODE (t
) == INTEGER_CST
4066 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
4067 && !integer_zerop (t
))
4070 error ("value %qE of type %qT is not a constant expression",
4072 *non_constant_p
= true;
4078 tree_code tcode
= TREE_CODE (t
);
4084 /* We ask for an rvalue for the RESULT_DECL when indirecting
4085 through an invisible reference, or in named return value
4087 return (*ctx
->values
->get (t
));
4090 if (DECL_HAS_VALUE_EXPR_P (t
))
4091 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4092 lval
, non_constant_p
, overflow_p
);
4095 /* We used to not check lval for CONST_DECL, but darwin.c uses
4096 CONST_DECL for aggregate constants. */
4099 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4100 && is_really_empty_class (TREE_TYPE (t
)))
4102 /* If the class is empty, we aren't actually loading anything. */
4103 r
= build_constructor (TREE_TYPE (t
), NULL
);
4104 TREE_CONSTANT (r
) = true;
4106 else if (ctx
->strict
)
4107 r
= decl_really_constant_value (t
);
4109 r
= decl_constant_value (t
);
4110 if (TREE_CODE (r
) == TARGET_EXPR
4111 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4112 r
= TARGET_EXPR_INITIAL (r
);
4114 if (tree
*p
= ctx
->values
->get (r
))
4115 if (*p
!= NULL_TREE
)
4120 non_const_var_error (r
);
4121 *non_constant_p
= true;
4125 case DEBUG_BEGIN_STMT
:
4126 /* ??? It might be nice to retain this information somehow, so
4127 as to be able to step into a constexpr function call. */
4134 case CASE_LABEL_EXPR
:
4139 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4141 else if (tree
*p
= ctx
->values
->get (r
))
4144 /* Defer in case this is only used for its type. */;
4145 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4146 /* Defer, there's no lvalue->rvalue conversion. */;
4147 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4148 && is_really_empty_class (TREE_TYPE (t
)))
4150 /* If the class is empty, we aren't actually loading anything. */
4151 r
= build_constructor (TREE_TYPE (t
), NULL
);
4152 TREE_CONSTANT (r
) = true;
4157 error ("%qE is not a constant expression", t
);
4158 *non_constant_p
= true;
4163 case AGGR_INIT_EXPR
:
4164 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4165 non_constant_p
, overflow_p
);
4170 r
= DECL_EXPR_DECL (t
);
4171 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4172 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4176 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4177 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4178 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4182 if (tree init
= DECL_INITIAL (r
))
4184 init
= cxx_eval_constant_expression (ctx
, init
,
4186 non_constant_p
, overflow_p
);
4187 /* Don't share a CONSTRUCTOR that might be changed. */
4188 init
= unshare_constructor (init
);
4189 ctx
->values
->put (r
, init
);
4191 else if (ctx
== &new_ctx
)
4192 /* We gave it a CONSTRUCTOR above. */;
4194 ctx
->values
->put (r
, NULL_TREE
);
4199 if (!literal_type_p (TREE_TYPE (t
)))
4203 error ("temporary of non-literal type %qT in a "
4204 "constant expression", TREE_TYPE (t
));
4205 explain_non_literal_class (TREE_TYPE (t
));
4207 *non_constant_p
= true;
4210 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4212 /* We're being expanded without an explicit target, so start
4213 initializing a new object; expansion with an explicit target
4214 strips the TARGET_EXPR before we get here. */
4216 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4217 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4218 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4219 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4222 /* Pass false for 'lval' because this indicates
4223 initialization of a temporary. */
4224 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4226 non_constant_p
, overflow_p
);
4227 if (!*non_constant_p
)
4228 /* Adjust the type of the result to the type of the temporary. */
4229 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4232 tree slot
= TARGET_EXPR_SLOT (t
);
4233 r
= unshare_constructor (r
);
4234 ctx
->values
->put (slot
, r
);
4241 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4242 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4243 non_constant_p
, overflow_p
);
4247 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4249 non_constant_p
, overflow_p
);
4253 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4254 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4256 non_constant_p
, overflow_p
);
4261 /* Can happen with ({ return true; }) && false; passed to
4262 maybe_constant_value. There is nothing to jump over in this
4263 case, and the bug will be diagnosed later. */
4264 gcc_assert (ctx
->quiet
);
4265 *non_constant_p
= true;
4270 /* Avoid evaluating a SAVE_EXPR more than once. */
4271 if (tree
*p
= ctx
->values
->get (t
))
4275 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4276 non_constant_p
, overflow_p
);
4277 ctx
->values
->put (t
, r
);
4278 if (ctx
->save_exprs
)
4279 ctx
->save_exprs
->add (t
);
4283 case NON_LVALUE_EXPR
:
4284 case TRY_CATCH_EXPR
:
4286 case CLEANUP_POINT_EXPR
:
4287 case MUST_NOT_THROW_EXPR
:
4290 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4292 non_constant_p
, overflow_p
,
4296 case TRY_FINALLY_EXPR
:
4297 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4298 non_constant_p
, overflow_p
,
4300 if (!*non_constant_p
)
4301 /* Also evaluate the cleanup. */
4302 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4303 non_constant_p
, overflow_p
,
4307 /* These differ from cxx_eval_unary_expression in that this doesn't
4308 check for a constant operand or result; an address can be
4309 constant without its operand being, and vice versa. */
4312 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4313 non_constant_p
, overflow_p
);
4318 tree oldop
= TREE_OPERAND (t
, 0);
4319 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4321 non_constant_p
, overflow_p
);
4322 /* Don't VERIFY_CONSTANT here. */
4323 if (*non_constant_p
)
4325 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4326 /* This function does more aggressive folding than fold itself. */
4327 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4328 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4337 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4338 non_constant_p
, overflow_p
);
4339 if (r
== error_mark_node
)
4341 else if (r
== TREE_OPERAND (t
, 0))
4344 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4349 case FIX_TRUNC_EXPR
:
4354 case TRUTH_NOT_EXPR
:
4355 case FIXED_CONVERT_EXPR
:
4356 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4357 non_constant_p
, overflow_p
);
4361 r
= fold_sizeof_expr (t
);
4362 VERIFY_CONSTANT (r
);
4367 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4368 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4369 introduced by build_call_a. */
4370 tree op0
= TREE_OPERAND (t
, 0);
4371 tree op1
= TREE_OPERAND (t
, 1);
4373 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4374 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4375 r
= cxx_eval_constant_expression (ctx
, op0
,
4376 lval
, non_constant_p
, overflow_p
,
4380 /* Check that the LHS is constant and then discard it. */
4381 cxx_eval_constant_expression (ctx
, op0
,
4382 true, non_constant_p
, overflow_p
,
4384 if (*non_constant_p
)
4386 op1
= TREE_OPERAND (t
, 1);
4387 r
= cxx_eval_constant_expression (ctx
, op1
,
4388 lval
, non_constant_p
, overflow_p
,
4394 case POINTER_PLUS_EXPR
:
4395 case POINTER_DIFF_EXPR
:
4399 case TRUNC_DIV_EXPR
:
4401 case FLOOR_DIV_EXPR
:
4402 case ROUND_DIV_EXPR
:
4403 case TRUNC_MOD_EXPR
:
4405 case ROUND_MOD_EXPR
:
4407 case EXACT_DIV_EXPR
:
4417 case TRUTH_XOR_EXPR
:
4424 case UNORDERED_EXPR
:
4434 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4435 non_constant_p
, overflow_p
);
4438 /* fold can introduce non-IF versions of these; still treat them as
4439 short-circuiting. */
4440 case TRUTH_AND_EXPR
:
4441 case TRUTH_ANDIF_EXPR
:
4442 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4445 non_constant_p
, overflow_p
);
4449 case TRUTH_ORIF_EXPR
:
4450 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4453 non_constant_p
, overflow_p
);
4457 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4458 non_constant_p
, overflow_p
);
4462 if (is_overloaded_fn (t
))
4464 /* We can only get here in checking mode via
4465 build_non_dependent_expr, because any expression that
4466 calls or takes the address of the function will have
4467 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4468 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4469 *non_constant_p
= true;
4472 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4473 non_constant_p
, overflow_p
);
4477 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4478 non_constant_p
, overflow_p
);
4482 if (jump_target
&& *jump_target
)
4484 /* When jumping to a label, the label might be either in the
4485 then or else blocks, so process then block first in skipping
4486 mode first, and if we are still in the skipping mode at its end,
4487 process the else block too. */
4488 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4489 lval
, non_constant_p
, overflow_p
,
4492 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4493 lval
, non_constant_p
, overflow_p
,
4497 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4498 non_constant_p
, overflow_p
,
4502 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4507 if (TREE_CONSTANT (t
))
4509 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4510 VECTOR_CST if applicable. */
4511 /* FIXME after GCC 6 branches, make the verify unconditional. */
4513 verify_constructor_flags (t
);
4515 recompute_constructor_flags (t
);
4516 if (TREE_CONSTANT (t
))
4519 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4520 non_constant_p
, overflow_p
);
4524 /* We can get this in a defaulted constructor for a class with a
4525 non-static data member of array type. Either the initializer will
4526 be NULL, meaning default-initialization, or it will be an lvalue
4527 or xvalue of the same type, meaning direct-initialization from the
4528 corresponding member. */
4529 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4530 non_constant_p
, overflow_p
);
4535 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4536 non_constant_p
, overflow_p
);
4540 case VIEW_CONVERT_EXPR
:
4542 case UNARY_PLUS_EXPR
:
4544 tree oldop
= TREE_OPERAND (t
, 0);
4546 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4548 non_constant_p
, overflow_p
);
4549 if (*non_constant_p
)
4551 tree type
= TREE_TYPE (t
);
4552 if (TREE_CODE (op
) == PTRMEM_CST
4553 && !TYPE_PTRMEM_P (type
))
4554 op
= cplus_expand_constant (op
);
4555 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4557 if (same_type_ignoring_top_level_qualifiers_p (type
,
4559 || can_convert_qual (type
, op
))
4560 return cp_fold_convert (type
, op
);
4564 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4565 "a reinterpret_cast is not a constant expression");
4566 *non_constant_p
= true;
4571 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4573 if (integer_zerop (op
))
4575 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4578 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4579 "dereferencing a null pointer");
4580 *non_constant_p
= true;
4583 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4585 tree from
= TREE_TYPE (op
);
4587 if (!can_convert (type
, from
, tf_none
))
4590 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4591 "conversion of %qT null pointer to %qT "
4592 "is not a constant expression",
4594 *non_constant_p
= true;
4601 /* This detects for example:
4602 reinterpret_cast<void*>(sizeof 0)
4605 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4606 "%<reinterpret_cast<%T>(%E)%> is not "
4607 "a constant expression",
4609 *non_constant_p
= true;
4613 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4614 /* We didn't fold at the top so we could check for ptr-int
4617 if (tcode
== UNARY_PLUS_EXPR
)
4618 r
= fold_convert (TREE_TYPE (t
), op
);
4620 r
= fold_build1 (tcode
, type
, op
);
4621 /* Conversion of an out-of-range value has implementation-defined
4622 behavior; the language considers it different from arithmetic
4623 overflow, which is undefined. */
4624 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4625 TREE_OVERFLOW (r
) = false;
4629 case EMPTY_CLASS_EXPR
:
4630 /* This is good enough for a function argument that might not get
4631 used, and they can't do anything with it, so just return it. */
4634 case STATEMENT_LIST
:
4636 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4637 return cxx_eval_statement_list (&new_ctx
, t
,
4638 non_constant_p
, overflow_p
, jump_target
);
4641 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4643 non_constant_p
, overflow_p
,
4646 case PREINCREMENT_EXPR
:
4647 case POSTINCREMENT_EXPR
:
4648 case PREDECREMENT_EXPR
:
4649 case POSTDECREMENT_EXPR
:
4650 return cxx_eval_increment_expression (ctx
, t
,
4651 lval
, non_constant_p
, overflow_p
);
4657 case VEC_DELETE_EXPR
:
4660 /* GCC internal stuff. */
4663 case NON_DEPENDENT_EXPR
:
4667 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4668 "expression %qE is not a constant expression", t
);
4669 *non_constant_p
= true;
4672 case PLACEHOLDER_EXPR
:
4673 /* Use of the value or address of the current object. */
4674 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4675 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4676 non_constant_p
, overflow_p
);
4677 /* A placeholder without a referent. We can get here when
4678 checking whether NSDMIs are noexcept, or in massage_init_elt;
4679 just say it's non-constant for now. */
4680 gcc_assert (ctx
->quiet
);
4681 *non_constant_p
= true;
4686 tree cond
= TREE_OPERAND (t
, 0);
4687 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4688 non_constant_p
, overflow_p
);
4689 VERIFY_CONSTANT (cond
);
4690 if (integer_nonzerop (cond
))
4696 *jump_target
= TREE_OPERAND (t
, 0);
4697 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4698 /* Allow for jumping to a cdtor_label. */
4699 || returns (jump_target
));
4703 cxx_eval_loop_expr (ctx
, t
,
4704 non_constant_p
, overflow_p
, jump_target
);
4708 cxx_eval_switch_expr (ctx
, t
,
4709 non_constant_p
, overflow_p
, jump_target
);
4713 /* It's possible to get a requires-expression in a constant
4714 expression. For example:
4716 template<typename T> concept bool C() {
4717 return requires (T t) { t; };
4720 template<typename T> requires !C<T>() void f(T);
4722 Normalization leaves f with the associated constraint
4723 '!requires (T t) { ... }' which is not transformed into
4725 if (!processing_template_decl
)
4726 return evaluate_constraint_expression (t
, NULL_TREE
);
4728 *non_constant_p
= true;
4732 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4734 non_constant_p
, overflow_p
,
4743 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4745 /* This function doesn't know how to deal with pre-genericize
4746 statements; this can only happen with statement-expressions,
4747 so for now just fail. */
4749 error_at (EXPR_LOCATION (t
),
4750 "statement is not a constant expression");
4753 internal_error ("unexpected expression %qE of kind %s", t
,
4754 get_tree_code_name (TREE_CODE (t
)));
4755 *non_constant_p
= true;
4759 if (r
== error_mark_node
)
4760 *non_constant_p
= true;
4762 if (*non_constant_p
)
4769 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4770 bool strict
= true, tree object
= NULL_TREE
)
4772 auto_timevar
time (TV_CONSTEXPR
);
4774 bool non_constant_p
= false;
4775 bool overflow_p
= false;
4776 hash_map
<tree
,tree
> map
;
4778 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4779 allow_non_constant
, strict
};
4781 tree type
= initialized_type (t
);
4783 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4785 /* In C++14 an NSDMI can participate in aggregate initialization,
4786 and can refer to the address of the object being initialized, so
4787 we need to pass in the relevant VAR_DECL if we want to do the
4788 evaluation in a single pass. The evaluation will dynamically
4789 update ctx.values for the VAR_DECL. We use the same strategy
4790 for C++11 constexpr constructors that refer to the object being
4792 ctx
.ctor
= build_constructor (type
, NULL
);
4793 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4796 if (TREE_CODE (t
) == TARGET_EXPR
)
4797 object
= TARGET_EXPR_SLOT (t
);
4798 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4799 object
= AGGR_INIT_EXPR_SLOT (t
);
4801 ctx
.object
= object
;
4803 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4804 (type
, TREE_TYPE (object
)));
4805 if (object
&& DECL_P (object
))
4806 map
.put (object
, ctx
.ctor
);
4807 if (TREE_CODE (r
) == TARGET_EXPR
)
4808 /* Avoid creating another CONSTRUCTOR when we expand the
4810 r
= TARGET_EXPR_INITIAL (r
);
4813 r
= cxx_eval_constant_expression (&ctx
, r
,
4814 false, &non_constant_p
, &overflow_p
);
4816 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4818 /* Mutable logic is a bit tricky: we want to allow initialization of
4819 constexpr variables with mutable members, but we can't copy those
4820 members to another constexpr variable. */
4821 if (TREE_CODE (r
) == CONSTRUCTOR
4822 && CONSTRUCTOR_MUTABLE_POISON (r
))
4824 if (!allow_non_constant
)
4825 error ("%qE is not a constant expression because it refers to "
4826 "mutable subobjects of %qT", t
, type
);
4827 non_constant_p
= true;
4830 if (TREE_CODE (r
) == CONSTRUCTOR
4831 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4833 if (!allow_non_constant
)
4834 error ("%qE is not a constant expression because it refers to "
4835 "an incompletely initialized variable", t
);
4836 TREE_CONSTANT (r
) = false;
4837 non_constant_p
= true;
4840 /* Technically we should check this for all subexpressions, but that
4841 runs into problems with our internal representation of pointer
4842 subtraction and the 5.19 rules are still in flux. */
4843 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4844 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4845 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4847 if (!allow_non_constant
)
4848 error ("conversion from pointer type %qT "
4849 "to arithmetic type %qT in a constant expression",
4850 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4851 non_constant_p
= true;
4854 if (!non_constant_p
&& overflow_p
)
4855 non_constant_p
= true;
4857 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4859 bool should_unshare
= true;
4860 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4861 should_unshare
= false;
4863 if (non_constant_p
&& !allow_non_constant
)
4864 return error_mark_node
;
4865 else if (non_constant_p
&& TREE_CONSTANT (r
))
4867 /* This isn't actually constant, so unset TREE_CONSTANT.
4868 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
4869 it to be set if it is invariant address, even when it is not
4870 a valid C++ constant expression. Wrap it with a NOP_EXPR
4872 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
4874 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4875 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4877 r
= build_nop (TREE_TYPE (r
), r
);
4878 TREE_CONSTANT (r
) = false;
4880 else if (non_constant_p
|| r
== t
)
4884 r
= unshare_expr (r
);
4886 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4888 if (TREE_CODE (t
) == TARGET_EXPR
4889 && TARGET_EXPR_INITIAL (t
) == r
)
4893 r
= get_target_expr (r
);
4894 TREE_CONSTANT (r
) = true;
4902 /* Returns true if T is a valid subexpression of a constant expression,
4903 even if it isn't itself a constant expression. */
4906 is_sub_constant_expr (tree t
)
4908 bool non_constant_p
= false;
4909 bool overflow_p
= false;
4910 hash_map
<tree
, tree
> map
;
4912 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4914 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4916 return !non_constant_p
&& !overflow_p
;
4919 /* If T represents a constant expression returns its reduced value.
4920 Otherwise return error_mark_node. If T is dependent, then
4924 cxx_constant_value (tree t
, tree decl
)
4926 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4929 /* Helper routine for fold_simple function. Either return simplified
4930 expression T, otherwise NULL_TREE.
4931 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4932 even if we are within template-declaration. So be careful on call, as in
4933 such case types can be undefined. */
4936 fold_simple_1 (tree t
)
4939 enum tree_code code
= TREE_CODE (t
);
4951 return fold_sizeof_expr (t
);
4959 case TRUTH_NOT_EXPR
:
4961 case VIEW_CONVERT_EXPR
:
4964 case FIX_TRUNC_EXPR
:
4965 case FIXED_CONVERT_EXPR
:
4966 case ADDR_SPACE_CONVERT_EXPR
:
4968 op1
= TREE_OPERAND (t
, 0);
4970 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4974 if (CONVERT_EXPR_CODE_P (code
)
4975 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4976 TREE_OVERFLOW (t
) = false;
4984 /* If T is a simple constant expression, returns its simplified value.
4985 Otherwise returns T. In contrast to maybe_constant_value we
4986 simplify only few operations on constant-expressions, and we don't
4987 try to simplify constexpressions. */
4990 fold_simple (tree t
)
4992 if (processing_template_decl
)
4995 tree r
= fold_simple_1 (t
);
5002 /* If T is a constant expression, returns its reduced value.
5003 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5004 Otherwise, returns a version of T without TREE_CONSTANT. */
5006 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5009 maybe_constant_value (tree t
, tree decl
)
5013 if (!is_nondependent_constant_expression (t
))
5015 if (TREE_OVERFLOW_P (t
))
5017 t
= build_nop (TREE_TYPE (t
), t
);
5018 TREE_CONSTANT (t
) = false;
5022 else if (CONSTANT_CLASS_P (t
))
5023 /* No caching or evaluation needed. */
5026 if (cv_cache
== NULL
)
5027 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5028 if (tree
*cached
= cv_cache
->get (t
))
5031 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
5032 gcc_checking_assert (r
== t
5033 || CONVERT_EXPR_P (t
)
5034 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5035 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5036 || !cp_tree_equal (r
, t
));
5037 cv_cache
->put (t
, r
);
5041 /* Dispose of the whole CV_CACHE. */
5044 clear_cv_cache (void)
5046 if (cv_cache
!= NULL
)
5050 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5053 clear_cv_and_fold_caches (void)
5056 clear_fold_cache ();
5059 /* Like maybe_constant_value but first fully instantiate the argument.
5061 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5062 (t, tf_none) followed by maybe_constant_value but is more efficient,
5063 because calls instantiation_dependent_expression_p and
5064 potential_constant_expression at most once. */
5067 fold_non_dependent_expr (tree t
)
5072 /* If we're in a template, but T isn't value dependent, simplify
5073 it. We're supposed to treat:
5075 template <typename T> void f(T[1 + 1]);
5076 template <typename T> void f(T[2]);
5078 as two declarations of the same function, for example. */
5079 if (processing_template_decl
)
5081 if (is_nondependent_constant_expression (t
))
5083 processing_template_decl_sentinel s
;
5084 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
5086 if (type_unknown_p (t
)
5087 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5089 if (TREE_OVERFLOW_P (t
))
5091 t
= build_nop (TREE_TYPE (t
), t
);
5092 TREE_CONSTANT (t
) = false;
5097 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
5098 /* cp_tree_equal looks through NOPs, so allow them. */
5099 gcc_checking_assert (r
== t
5100 || CONVERT_EXPR_P (t
)
5101 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5102 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5103 || !cp_tree_equal (r
, t
));
5106 else if (TREE_OVERFLOW_P (t
))
5108 t
= build_nop (TREE_TYPE (t
), t
);
5109 TREE_CONSTANT (t
) = false;
5114 return maybe_constant_value (t
);
5117 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5118 than wrapped in a TARGET_EXPR. */
5121 maybe_constant_init (tree t
, tree decl
)
5125 if (TREE_CODE (t
) == EXPR_STMT
)
5126 t
= TREE_OPERAND (t
, 0);
5127 if (TREE_CODE (t
) == CONVERT_EXPR
5128 && VOID_TYPE_P (TREE_TYPE (t
)))
5129 t
= TREE_OPERAND (t
, 0);
5130 if (TREE_CODE (t
) == INIT_EXPR
)
5131 t
= TREE_OPERAND (t
, 1);
5132 if (TREE_CODE (t
) == TARGET_EXPR
)
5133 t
= TARGET_EXPR_INITIAL (t
);
5134 if (!is_nondependent_static_init_expression (t
))
5135 /* Don't try to evaluate it. */;
5136 else if (CONSTANT_CLASS_P (t
))
5137 /* No evaluation needed. */;
5139 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
5140 if (TREE_CODE (t
) == TARGET_EXPR
)
5142 tree init
= TARGET_EXPR_INITIAL (t
);
5143 if (TREE_CODE (init
) == CONSTRUCTOR
)
5150 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5151 /* Return true if the object referred to by REF has automatic or thread
5154 enum { ck_ok
, ck_bad
, ck_unknown
};
5156 check_automatic_or_tls (tree ref
)
5159 poly_int64 bitsize
, bitpos
;
5161 int volatilep
= 0, unsignedp
= 0;
5162 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5163 &mode
, &unsignedp
, &volatilep
, false);
5166 /* If there isn't a decl in the middle, we don't know the linkage here,
5167 and this isn't a constant expression anyway. */
5170 dk
= decl_storage_duration (decl
);
5171 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5175 /* Return true if T denotes a potentially constant expression. Issue
5176 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5177 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5178 consider the expression in the current context, independent of constexpr
5181 C++0x [expr.const] used to say
5183 6 An expression is a potential constant expression if it is
5184 a constant expression where all occurrences of function
5185 parameters are replaced by arbitrary constant expressions
5186 of the appropriate type.
5188 2 A conditional expression is a constant expression unless it
5189 involves one of the following as a potentially evaluated
5190 subexpression (3.2), but subexpressions of logical AND (5.14),
5191 logical OR (5.15), and conditional (5.16) operations that are
5192 not evaluated are not considered. */
5195 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5196 tsubst_flags_t flags
)
5198 #define RECUR(T,RV) \
5199 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5201 enum { any
= false, rval
= true };
5205 if (t
== error_mark_node
)
5209 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5210 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5212 if (flags
& tf_error
)
5213 error_at (loc
, "expression %qE has side-effects", t
);
5216 if (CONSTANT_CLASS_P (t
))
5218 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5219 && TREE_TYPE (t
) == error_mark_node
)
5222 switch (TREE_CODE (t
))
5228 case TEMPLATE_ID_EXPR
:
5231 case CASE_LABEL_EXPR
:
5237 case TEMPLATE_PARM_INDEX
:
5239 case IDENTIFIER_NODE
:
5240 case USERDEF_LITERAL
:
5241 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5246 case PLACEHOLDER_EXPR
:
5251 case DEBUG_BEGIN_STMT
:
5257 if (flags
& tf_error
)
5258 error ("%qE is not a constant expression", t
);
5263 case AGGR_INIT_EXPR
:
5265 /* -- an invocation of a function other than a constexpr function
5266 or a constexpr constructor. */
5268 tree fun
= get_function_named_in_call (t
);
5269 const int nargs
= call_expr_nargs (t
);
5272 if (fun
== NULL_TREE
)
5274 /* Reset to allow the function to continue past the end
5275 of the block below. Otherwise return early. */
5278 if (TREE_CODE (t
) == CALL_EXPR
5279 && CALL_EXPR_FN (t
) == NULL_TREE
)
5280 switch (CALL_EXPR_IFN (t
))
5282 /* These should be ignored, they are optimized away from
5283 constexpr functions. */
5284 case IFN_UBSAN_NULL
:
5285 case IFN_UBSAN_BOUNDS
:
5286 case IFN_UBSAN_VPTR
:
5287 case IFN_FALLTHROUGH
:
5290 case IFN_ADD_OVERFLOW
:
5291 case IFN_SUB_OVERFLOW
:
5292 case IFN_MUL_OVERFLOW
:
5302 /* fold_call_expr can't do anything with IFN calls. */
5303 if (flags
& tf_error
)
5304 error_at (loc
, "call to internal function %qE", t
);
5309 if (fun
&& is_overloaded_fn (fun
))
5311 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5313 if (builtin_valid_in_constant_expr_p (fun
))
5315 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5316 /* Allow any built-in function; if the expansion
5317 isn't constant, we'll deal with that then. */
5318 && !is_builtin_fn (fun
))
5320 if (flags
& tf_error
)
5322 error_at (loc
, "call to non-%<constexpr%> function %qD",
5324 explain_invalid_constexpr_fn (fun
);
5328 /* A call to a non-static member function takes the address
5329 of the object as the first argument. But in a constant
5330 expression the address will be folded away, so look
5332 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5333 && !DECL_CONSTRUCTOR_P (fun
))
5335 tree x
= get_nth_callarg (t
, 0);
5336 if (is_this_parameter (x
))
5338 /* Don't require an immediately constant value, as
5339 constexpr substitution might not use the value. */
5340 bool sub_now
= false;
5341 if (!potential_constant_expression_1 (x
, rval
, strict
,
5349 if (!RECUR (fun
, true))
5351 fun
= get_first_fn (fun
);
5353 /* Skip initial arguments to base constructors. */
5354 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5355 i
= num_artificial_parms_for (fun
);
5356 fun
= DECL_ORIGIN (fun
);
5360 if (RECUR (fun
, rval
))
5361 /* Might end up being a constant function pointer. */;
5365 for (; i
< nargs
; ++i
)
5367 tree x
= get_nth_callarg (t
, i
);
5368 /* In a template, reference arguments haven't been converted to
5369 REFERENCE_TYPE and we might not even know if the parameter
5370 is a reference, so accept lvalue constants too. */
5371 bool rv
= processing_template_decl
? any
: rval
;
5372 /* Don't require an immediately constant value, as constexpr
5373 substitution might not use the value of the argument. */
5374 bool sub_now
= false;
5375 if (!potential_constant_expression_1 (x
, rv
, strict
,
5382 case NON_LVALUE_EXPR
:
5383 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5384 -- an lvalue of integral type that refers to a non-volatile
5385 const variable or static data member initialized with
5386 constant expressions, or
5388 -- an lvalue of literal type that refers to non-volatile
5389 object defined with constexpr, or that refers to a
5390 sub-object of such an object; */
5391 return RECUR (TREE_OPERAND (t
, 0), rval
);
5394 if (DECL_HAS_VALUE_EXPR_P (t
))
5396 if (now
&& is_capture_proxy_with_ref (t
))
5398 /* -- in a lambda-expression, a reference to this or to a
5399 variable with automatic storage duration defined outside that
5400 lambda-expression, where the reference would be an
5402 if (flags
& tf_error
)
5404 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5405 error ("lambda capture of %qE is not a constant expression",
5407 if (!want_rval
&& decl_constant_var_p (cap
))
5408 inform (input_location
, "because it is used as a glvalue");
5412 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5415 && !var_in_maybe_constexpr_fn (t
)
5416 && !type_dependent_expression_p (t
)
5417 && !decl_maybe_constant_var_p (t
)
5419 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5420 || (DECL_INITIAL (t
)
5421 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5422 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5423 && !is_really_empty_class (TREE_TYPE (t
)))
5425 if (flags
& tf_error
)
5426 non_const_var_error (t
);
5433 case VIEW_CONVERT_EXPR
:
5434 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5435 may change to something more specific to type-punning (DR 1312). */
5437 tree from
= TREE_OPERAND (t
, 0);
5438 if (POINTER_TYPE_P (TREE_TYPE (t
))
5439 && TREE_CODE (from
) == INTEGER_CST
5440 && !integer_zerop (from
))
5442 if (flags
& tf_error
)
5443 error_at (loc
, "reinterpret_cast from integer to pointer");
5446 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5449 case ADDRESSOF_EXPR
:
5450 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5451 t
= TREE_OPERAND (t
, 0);
5452 goto handle_addr_expr
;
5455 /* -- a unary operator & that is applied to an lvalue that
5456 designates an object with thread or automatic storage
5458 t
= TREE_OPERAND (t
, 0);
5460 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5461 /* A pointer-to-member constant. */
5466 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5467 any checking here, as we might dereference the pointer later. If
5468 we remove this code, also remove check_automatic_or_tls. */
5469 i
= check_automatic_or_tls (t
);
5474 if (flags
& tf_error
)
5475 error ("address-of an object %qE with thread local or "
5476 "automatic storage is not a constant expression", t
);
5480 return RECUR (t
, any
);
5488 /* -- a class member access unless its postfix-expression is
5489 of literal type or of pointer to literal type. */
5490 /* This test would be redundant, as it follows from the
5491 postfix-expression being a potential constant expression. */
5492 if (type_unknown_p (t
))
5494 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5496 case EXPR_PACK_EXPANSION
:
5497 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5501 tree x
= TREE_OPERAND (t
, 0);
5503 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5505 if (!var_in_maybe_constexpr_fn (x
))
5507 if (flags
& tf_error
)
5508 error_at (loc
, "use of %<this%> in a constant expression");
5513 return RECUR (x
, rval
);
5516 case STATEMENT_LIST
:
5518 tree_stmt_iterator i
;
5519 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5521 if (!RECUR (tsi_stmt (i
), any
))
5529 if (cxx_dialect
< cxx14
)
5531 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5533 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5538 if (cxx_dialect
< cxx14
)
5540 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5542 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5547 if (!RECUR (DO_COND (t
), rval
))
5549 if (!RECUR (DO_BODY (t
), any
))
5554 if (!RECUR (FOR_INIT_STMT (t
), any
))
5556 if (!RECUR (FOR_COND (t
), rval
))
5558 if (!RECUR (FOR_EXPR (t
), any
))
5560 if (!RECUR (FOR_BODY (t
), any
))
5564 case RANGE_FOR_STMT
:
5565 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5567 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5572 if (!RECUR (WHILE_COND (t
), rval
))
5574 if (!RECUR (WHILE_BODY (t
), any
))
5579 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5581 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5582 unreachable labels would be checked. */
5586 return RECUR (STMT_EXPR_STMT (t
), rval
);
5589 if (cxx_dialect
>= cxx17
)
5590 /* In C++17 lambdas can be constexpr, don't give up yet. */
5592 else if (flags
& tf_error
)
5593 error_at (loc
, "lambda-expression is not a constant expression "
5597 case DYNAMIC_CAST_EXPR
:
5598 case PSEUDO_DTOR_EXPR
:
5602 case VEC_DELETE_EXPR
:
5607 case OMP_DISTRIBUTE
:
5610 case OMP_TARGET_DATA
:
5619 case OMP_TARGET_UPDATE
:
5620 case OMP_TARGET_ENTER_DATA
:
5621 case OMP_TARGET_EXIT_DATA
:
5623 case OMP_ATOMIC_READ
:
5624 case OMP_ATOMIC_CAPTURE_OLD
:
5625 case OMP_ATOMIC_CAPTURE_NEW
:
5629 case OACC_HOST_DATA
:
5633 case OACC_ENTER_DATA
:
5634 case OACC_EXIT_DATA
:
5636 /* GCC internal stuff. */
5639 case TRANSACTION_EXPR
:
5641 case AT_ENCODE_EXPR
:
5643 if (flags
& tf_error
)
5644 error_at (loc
, "expression %qE is not a constant expression", t
);
5648 /* -- a typeid expression whose operand is of polymorphic
5651 tree e
= TREE_OPERAND (t
, 0);
5652 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5653 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5655 if (flags
& tf_error
)
5656 error_at (loc
, "typeid-expression is not a constant expression "
5657 "because %qE is of polymorphic type", e
);
5663 case POINTER_DIFF_EXPR
:
5677 case PREINCREMENT_EXPR
:
5678 case POSTINCREMENT_EXPR
:
5679 case PREDECREMENT_EXPR
:
5680 case POSTDECREMENT_EXPR
:
5681 if (cxx_dialect
< cxx14
)
5687 if (TYPE_P (TREE_OPERAND (t
, 0)))
5693 case FIX_TRUNC_EXPR
:
5697 case TRUTH_NOT_EXPR
:
5698 case FIXED_CONVERT_EXPR
:
5699 case UNARY_PLUS_EXPR
:
5700 case UNARY_LEFT_FOLD_EXPR
:
5701 case UNARY_RIGHT_FOLD_EXPR
:
5703 return RECUR (TREE_OPERAND (t
, 0), rval
);
5706 case CONST_CAST_EXPR
:
5707 case STATIC_CAST_EXPR
:
5708 case REINTERPRET_CAST_EXPR
:
5709 case IMPLICIT_CONV_EXPR
:
5710 if (cxx_dialect
< cxx11
5711 && !dependent_type_p (TREE_TYPE (t
))
5712 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5713 /* In C++98, a conversion to non-integral type can't be part of a
5714 constant expression. */
5716 if (flags
& tf_error
)
5718 "cast to non-integral type %qT in a constant expression",
5723 return (RECUR (TREE_OPERAND (t
, 0),
5724 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5727 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5729 case CLEANUP_POINT_EXPR
:
5730 case MUST_NOT_THROW_EXPR
:
5731 case TRY_CATCH_EXPR
:
5736 case NON_DEPENDENT_EXPR
:
5737 /* For convenience. */
5741 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5744 tmp
= DECL_EXPR_DECL (t
);
5745 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5747 if (TREE_STATIC (tmp
))
5749 if (flags
& tf_error
)
5750 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5751 "%<static%> in %<constexpr%> context", tmp
);
5754 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5756 if (flags
& tf_error
)
5757 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5758 "%<thread_local%> in %<constexpr%> context", tmp
);
5761 else if (!check_for_uninitialized_const_var
5762 (tmp
, /*constexpr_context_p=*/true, flags
))
5765 return RECUR (tmp
, want_rval
);
5767 case TRY_FINALLY_EXPR
:
5768 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5769 && RECUR (TREE_OPERAND (t
, 1), any
));
5772 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5775 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
5776 && !literal_type_p (TREE_TYPE (t
)))
5778 if (flags
& tf_error
)
5780 error_at (loc
, "temporary of non-literal type %qT in a "
5781 "constant expression", TREE_TYPE (t
));
5782 explain_non_literal_class (TREE_TYPE (t
));
5788 return RECUR (TREE_OPERAND (t
, 1), rval
);
5792 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5793 constructor_elt
*ce
;
5794 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5795 if (!RECUR (ce
->value
, want_rval
))
5802 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5803 || DECL_P (TREE_PURPOSE (t
)));
5804 if (!RECUR (TREE_VALUE (t
), want_rval
))
5806 if (TREE_CHAIN (t
) == NULL_TREE
)
5808 return RECUR (TREE_CHAIN (t
), want_rval
);
5811 case TRUNC_DIV_EXPR
:
5813 case FLOOR_DIV_EXPR
:
5814 case ROUND_DIV_EXPR
:
5815 case TRUNC_MOD_EXPR
:
5817 case ROUND_MOD_EXPR
:
5819 tree denom
= TREE_OPERAND (t
, 1);
5820 if (!RECUR (denom
, rval
))
5822 /* We can't call cxx_eval_outermost_constant_expr on an expression
5823 that hasn't been through instantiate_non_dependent_expr yet. */
5824 if (!processing_template_decl
)
5825 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5826 if (integer_zerop (denom
))
5828 if (flags
& tf_error
)
5829 error ("division by zero is not a constant expression");
5835 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5841 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5842 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5843 introduced by build_call_a. */
5844 tree op0
= TREE_OPERAND (t
, 0);
5845 tree op1
= TREE_OPERAND (t
, 1);
5847 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5848 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5849 return RECUR (op0
, want_rval
);
5854 /* If the first operand is the non-short-circuit constant, look at
5855 the second operand; otherwise we only care about the first one for
5857 case TRUTH_AND_EXPR
:
5858 case TRUTH_ANDIF_EXPR
:
5859 tmp
= boolean_true_node
;
5862 case TRUTH_ORIF_EXPR
:
5863 tmp
= boolean_false_node
;
5866 tree op
= TREE_OPERAND (t
, 0);
5867 if (!RECUR (op
, rval
))
5869 if (!processing_template_decl
)
5870 op
= cxx_eval_outermost_constant_expr (op
, true);
5871 if (tree_int_cst_equal (op
, tmp
))
5872 return RECUR (TREE_OPERAND (t
, 1), rval
);
5879 case POINTER_PLUS_EXPR
:
5881 case EXACT_DIV_EXPR
:
5891 case TRUTH_XOR_EXPR
:
5892 case UNORDERED_EXPR
:
5905 case ARRAY_RANGE_REF
:
5909 case BINARY_LEFT_FOLD_EXPR
:
5910 case BINARY_RIGHT_FOLD_EXPR
:
5912 for (i
= 0; i
< 2; ++i
)
5913 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5919 for (i
= 0; i
< 3; ++i
)
5920 if (!RECUR (TREE_OPERAND (t
, i
), true))
5925 if (COND_EXPR_IS_VEC_DELETE (t
))
5927 if (flags
& tf_error
)
5928 error_at (loc
, "%<delete[]%> is not a constant expression");
5934 /* If the condition is a known constant, we know which of the legs we
5935 care about; otherwise we only require that the condition and
5936 either of the legs be potentially constant. */
5937 tmp
= TREE_OPERAND (t
, 0);
5938 if (!RECUR (tmp
, rval
))
5940 if (!processing_template_decl
)
5941 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5942 if (integer_zerop (tmp
))
5943 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5944 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5945 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5946 for (i
= 1; i
< 3; ++i
)
5947 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5948 want_rval
, strict
, now
, tf_none
))
5950 if (flags
& tf_error
)
5951 error_at (loc
, "expression %qE is not a constant expression", t
);
5955 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5957 if (flags
& tf_error
)
5959 error_at (loc
, "non-constant array initialization");
5960 diagnose_non_constexpr_vec_init (t
);
5966 /* We can see these in statement-expressions. */
5970 case EMPTY_CLASS_EXPR
:
5976 tree
*target
= &TREE_OPERAND (t
, 0);
5977 /* Gotos representing break and continue are OK. */
5978 if (breaks (target
) || continues (target
))
5980 if (flags
& tf_error
)
5981 error_at (loc
, "%<goto%> is not a constant expression");
5986 return RECUR (TREE_OPERAND (t
, 0), rval
);
5989 if (objc_is_property_ref (t
))
5992 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5999 /* The main entry point to the above. */
6002 potential_constant_expression (tree t
)
6004 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6007 /* As above, but require a constant rvalue. */
6010 potential_rvalue_constant_expression (tree t
)
6012 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6015 /* Like above, but complain about non-constant expressions. */
6018 require_potential_constant_expression (tree t
)
6020 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
6023 /* Cross product of the above. */
6026 require_potential_rvalue_constant_expression (tree t
)
6028 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
6031 /* Like potential_constant_expression, but don't consider possible constexpr
6032 substitution of the current function. That is, PARM_DECL qualifies under
6033 potential_constant_expression, but not here.
6035 This is basically what you can check when any actual constant values might
6036 be value-dependent. */
6039 is_constant_expression (tree t
)
6041 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6044 /* Like above, but complain about non-constant expressions. */
6047 require_constant_expression (tree t
)
6049 return potential_constant_expression_1 (t
, false, true, true,
6050 tf_warning_or_error
);
6053 /* Like is_constant_expression, but allow const variables that are not allowed
6054 under constexpr rules. */
6057 is_static_init_expression (tree t
)
6059 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6062 /* Returns true if T is a potential constant expression that is not
6063 instantiation-dependent, and therefore a candidate for constant folding even
6067 is_nondependent_constant_expression (tree t
)
6069 return (!type_unknown_p (t
)
6070 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6071 && is_constant_expression (t
)
6072 && !instantiation_dependent_expression_p (t
));
6075 /* Returns true if T is a potential static initializer expression that is not
6076 instantiation-dependent. */
6079 is_nondependent_static_init_expression (tree t
)
6081 return (!type_unknown_p (t
)
6082 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6083 && is_static_init_expression (t
)
6084 && !instantiation_dependent_expression_p (t
));
6087 /* Finalize constexpr processing after parsing. */
6090 fini_constexpr (void)
6092 /* The contexpr call and fundef copies tables are no longer needed. */
6093 constexpr_call_table
= NULL
;
6094 fundef_copies_table
= NULL
;
6097 #include "gt-cp-constexpr.h"