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_C_BIT_FIELD (field
) && !DECL_NAME (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 (TREE_CODE (whole
) == INDIRECT_REF
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 vec_alloc (*p
, max
+ 1);
2889 bool pre_init
= false;
2890 unsigned HOST_WIDE_INT i
;
2892 /* For the default constructor, build up a call to the default
2893 constructor of the element type. We only need to handle class types
2894 here, as for a constructor to be constexpr, all members must be
2895 initialized, which for a defaulted default constructor means they must
2896 be of a class type with a constexpr default constructor. */
2897 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2898 /* We only do this at the lowest level. */;
2899 else if (value_init
)
2901 init
= build_value_init (elttype
, tf_warning_or_error
);
2906 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2907 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2908 &argvec
, elttype
, LOOKUP_NORMAL
,
2909 tf_warning_or_error
);
2910 release_tree_vector (argvec
);
2911 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2915 for (i
= 0; i
< max
; ++i
)
2917 tree idx
= build_int_cst (size_type_node
, i
);
2920 constexpr_ctx new_ctx
;
2921 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2922 if (new_ctx
.ctor
!= ctx
->ctor
)
2923 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2924 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2926 /* A multidimensional array; recurse. */
2927 if (value_init
|| init
== NULL_TREE
)
2929 eltinit
= NULL_TREE
;
2933 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2934 tf_warning_or_error
);
2935 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2937 non_constant_p
, overflow_p
);
2941 /* Initializing an element using value or default initialization
2942 we just pre-built above. */
2943 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2944 non_constant_p
, overflow_p
);
2949 /* Copying an element. */
2950 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2951 (atype
, TREE_TYPE (init
)));
2952 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2953 tf_warning_or_error
);
2954 if (!lvalue_p (init
))
2955 eltinit
= move (eltinit
);
2956 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2957 eltinit
= (cxx_eval_constant_expression
2958 (&new_ctx
, eltinit
, lval
,
2959 non_constant_p
, overflow_p
));
2961 if (*non_constant_p
&& !ctx
->quiet
)
2963 if (new_ctx
.ctor
!= ctx
->ctor
)
2965 /* We appended this element above; update the value. */
2966 gcc_assert ((*p
)->last().index
== idx
);
2967 (*p
)->last().value
= eltinit
;
2970 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2971 /* Reuse the result of cxx_eval_constant_expression call
2972 from the first iteration to all others if it is a constant
2973 initializer that doesn't require relocations. */
2976 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2977 == null_pointer_node
))
2979 if (new_ctx
.ctor
!= ctx
->ctor
)
2980 eltinit
= new_ctx
.ctor
;
2981 for (i
= 1; i
< max
; ++i
)
2983 idx
= build_int_cst (size_type_node
, i
);
2984 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
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
)
3032 subtype
= TREE_TYPE (sub
);
3033 if (!POINTER_TYPE_P (subtype
))
3036 if (TREE_CODE (sub
) == ADDR_EXPR
)
3038 tree op
= TREE_OPERAND (sub
, 0);
3039 tree optype
= TREE_TYPE (op
);
3041 /* *&CONST_DECL -> to the value of the const decl. */
3042 if (TREE_CODE (op
) == CONST_DECL
)
3043 return DECL_INITIAL (op
);
3044 /* *&p => p; make sure to handle *&"str"[cst] here. */
3045 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
3046 /* Also handle the case where the desired type is an array of unknown
3047 bounds because the variable has had its bounds deduced since the
3048 ADDR_EXPR was created. */
3049 || (TREE_CODE (type
) == ARRAY_TYPE
3050 && TREE_CODE (optype
) == ARRAY_TYPE
3051 && TYPE_DOMAIN (type
) == NULL_TREE
3052 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3055 tree fop
= fold_read_from_constant_string (op
);
3061 /* *(foo *)&fooarray => fooarray[0] */
3062 else if (TREE_CODE (optype
) == ARRAY_TYPE
3063 && (same_type_ignoring_top_level_qualifiers_p
3064 (type
, TREE_TYPE (optype
))))
3066 tree type_domain
= TYPE_DOMAIN (optype
);
3067 tree min_val
= size_zero_node
;
3068 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3069 min_val
= TYPE_MIN_VALUE (type_domain
);
3070 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3071 NULL_TREE
, NULL_TREE
);
3073 /* *(foo *)&complexfoo => __real__ complexfoo */
3074 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3075 && (same_type_ignoring_top_level_qualifiers_p
3076 (type
, TREE_TYPE (optype
))))
3077 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3078 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3079 else if (VECTOR_TYPE_P (optype
)
3080 && (same_type_ignoring_top_level_qualifiers_p
3081 (type
, TREE_TYPE (optype
))))
3083 tree part_width
= TYPE_SIZE (type
);
3084 tree index
= bitsize_int (0);
3085 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
3087 /* Also handle conversion to an empty base class, which
3088 is represented with a NOP_EXPR. */
3089 else if (is_empty_class (type
)
3090 && CLASS_TYPE_P (optype
)
3091 && DERIVED_FROM_P (type
, optype
))
3096 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3097 else if (RECORD_OR_UNION_TYPE_P (optype
))
3099 tree field
= TYPE_FIELDS (optype
);
3100 for (; field
; field
= DECL_CHAIN (field
))
3101 if (TREE_CODE (field
) == FIELD_DECL
3102 && TREE_TYPE (field
) != error_mark_node
3103 && integer_zerop (byte_position (field
))
3104 && (same_type_ignoring_top_level_qualifiers_p
3105 (TREE_TYPE (field
), type
)))
3106 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3109 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3110 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
3112 tree op00
= TREE_OPERAND (sub
, 0);
3113 tree op01
= TREE_OPERAND (sub
, 1);
3116 if (TREE_CODE (op00
) == ADDR_EXPR
)
3119 op00
= TREE_OPERAND (op00
, 0);
3120 op00type
= TREE_TYPE (op00
);
3122 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3123 if (VECTOR_TYPE_P (op00type
)
3124 && (same_type_ignoring_top_level_qualifiers_p
3125 (type
, TREE_TYPE (op00type
))))
3127 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
3128 tree part_width
= TYPE_SIZE (type
);
3129 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
3130 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
3131 tree index
= bitsize_int (indexi
);
3133 if (known_lt (offset
/ part_widthi
,
3134 TYPE_VECTOR_SUBPARTS (op00type
)))
3135 return fold_build3_loc (loc
,
3136 BIT_FIELD_REF
, type
, op00
,
3140 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3141 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3142 && (same_type_ignoring_top_level_qualifiers_p
3143 (type
, TREE_TYPE (op00type
))))
3145 tree size
= TYPE_SIZE_UNIT (type
);
3146 if (tree_int_cst_equal (size
, op01
))
3147 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3149 /* ((foo *)&fooarray)[1] => fooarray[1] */
3150 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3151 && (same_type_ignoring_top_level_qualifiers_p
3152 (type
, TREE_TYPE (op00type
))))
3154 tree type_domain
= TYPE_DOMAIN (op00type
);
3155 tree min_val
= size_zero_node
;
3156 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3157 min_val
= TYPE_MIN_VALUE (type_domain
);
3158 offset_int off
= wi::to_offset (op01
);
3159 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3160 offset_int remainder
;
3161 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3162 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3164 off
= off
+ wi::to_offset (min_val
);
3165 op01
= wide_int_to_tree (sizetype
, off
);
3166 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3167 NULL_TREE
, NULL_TREE
);
3170 /* Also handle conversion to an empty base class, which
3171 is represented with a NOP_EXPR. */
3172 else if (is_empty_class (type
)
3173 && CLASS_TYPE_P (op00type
)
3174 && DERIVED_FROM_P (type
, op00type
))
3179 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3180 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3182 tree field
= TYPE_FIELDS (op00type
);
3183 for (; field
; field
= DECL_CHAIN (field
))
3184 if (TREE_CODE (field
) == FIELD_DECL
3185 && TREE_TYPE (field
) != error_mark_node
3186 && tree_int_cst_equal (byte_position (field
), op01
)
3187 && (same_type_ignoring_top_level_qualifiers_p
3188 (TREE_TYPE (field
), type
)))
3189 return fold_build3 (COMPONENT_REF
, type
, op00
,
3194 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3195 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3196 && (same_type_ignoring_top_level_qualifiers_p
3197 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3200 tree min_val
= size_zero_node
;
3201 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3205 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3206 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3207 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3208 min_val
= TYPE_MIN_VALUE (type_domain
);
3209 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3217 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3219 bool *non_constant_p
, bool *overflow_p
)
3221 tree orig_op0
= TREE_OPERAND (t
, 0);
3222 bool empty_base
= false;
3224 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3225 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3227 if (TREE_CODE (t
) == MEM_REF
3228 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3230 gcc_assert (ctx
->quiet
);
3231 *non_constant_p
= true;
3235 /* First try to simplify it directly. */
3236 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3240 /* If that didn't work, evaluate the operand first. */
3241 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3242 /*lval*/false, non_constant_p
,
3244 /* Don't VERIFY_CONSTANT here. */
3245 if (*non_constant_p
)
3248 if (!lval
&& integer_zerop (op0
))
3251 error ("dereferencing a null pointer");
3252 *non_constant_p
= true;
3256 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3260 /* We couldn't fold to a constant value. Make sure it's not
3261 something we should have been able to fold. */
3264 if (TREE_CODE (sub
) == ADDR_EXPR
)
3266 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3267 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3268 /* DR 1188 says we don't have to deal with this. */
3270 error ("accessing value of %qE through a %qT glvalue in a "
3271 "constant expression", build_fold_indirect_ref (sub
),
3273 *non_constant_p
= true;
3277 if (lval
&& op0
!= orig_op0
)
3278 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3280 VERIFY_CONSTANT (t
);
3285 r
= cxx_eval_constant_expression (ctx
, r
,
3286 lval
, non_constant_p
, overflow_p
);
3287 if (*non_constant_p
)
3290 /* If we're pulling out the value of an empty base, just return an empty
3292 if (empty_base
&& !lval
)
3294 r
= build_constructor (TREE_TYPE (t
), NULL
);
3295 TREE_CONSTANT (r
) = true;
3301 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3302 Shared between potential_constant_expression and
3303 cxx_eval_constant_expression. */
3306 non_const_var_error (tree r
)
3308 tree type
= TREE_TYPE (r
);
3309 error ("the value of %qD is not usable in a constant "
3311 /* Avoid error cascade. */
3312 if (DECL_INITIAL (r
) == error_mark_node
)
3314 if (DECL_DECLARED_CONSTEXPR_P (r
))
3315 inform (DECL_SOURCE_LOCATION (r
),
3316 "%qD used in its own initializer", r
);
3317 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3319 if (!CP_TYPE_CONST_P (type
))
3320 inform (DECL_SOURCE_LOCATION (r
),
3321 "%q#D is not const", r
);
3322 else if (CP_TYPE_VOLATILE_P (type
))
3323 inform (DECL_SOURCE_LOCATION (r
),
3324 "%q#D is volatile", r
);
3325 else if (!DECL_INITIAL (r
)
3326 || !TREE_CONSTANT (DECL_INITIAL (r
))
3327 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3328 inform (DECL_SOURCE_LOCATION (r
),
3329 "%qD was not initialized with a constant "
3334 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3335 inform (DECL_SOURCE_LOCATION (r
),
3336 "%qD was not initialized with a constant "
3340 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3341 inform (DECL_SOURCE_LOCATION (r
),
3342 "%qD was not declared %<constexpr%>", r
);
3344 inform (DECL_SOURCE_LOCATION (r
),
3345 "%qD does not have integral or enumeration type",
3350 /* Subroutine of cxx_eval_constant_expression.
3351 Like cxx_eval_unary_expression, except for trinary expressions. */
3354 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3356 bool *non_constant_p
, bool *overflow_p
)
3362 for (i
= 0; i
< 3; i
++)
3364 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3366 non_constant_p
, overflow_p
);
3367 VERIFY_CONSTANT (args
[i
]);
3370 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3371 args
[0], args
[1], args
[2]);
3372 if (val
== NULL_TREE
)
3374 VERIFY_CONSTANT (val
);
3378 /* True if T was declared in a function declared to be constexpr, and
3379 therefore potentially constant in C++14. */
3382 var_in_constexpr_fn (tree t
)
3384 tree ctx
= DECL_CONTEXT (t
);
3385 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3386 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3389 /* True if T was declared in a function that might be constexpr: either a
3390 function that was declared constexpr, or a C++17 lambda op(). */
3393 var_in_maybe_constexpr_fn (tree t
)
3395 if (cxx_dialect
>= cxx17
3396 && DECL_FUNCTION_SCOPE_P (t
)
3397 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3399 return var_in_constexpr_fn (t
);
3402 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3403 build_over_call we implement trivial copy of a class with tail padding using
3404 assignment of character arrays, which is valid in normal code, but not in
3405 constexpr evaluation. We don't need to worry about clobbering tail padding
3406 in constexpr evaluation, so strip the type punning. */
3409 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3411 if (TREE_CODE (target
) == MEM_REF
3412 && TREE_CODE (init
) == MEM_REF
3413 && TREE_TYPE (target
) == TREE_TYPE (init
)
3414 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3415 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3417 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3418 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3422 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3425 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3427 bool *non_constant_p
, bool *overflow_p
)
3429 constexpr_ctx new_ctx
= *ctx
;
3431 tree init
= TREE_OPERAND (t
, 1);
3432 if (TREE_CLOBBER_P (init
))
3433 /* Just ignore clobbers. */
3436 /* First we figure out where we're storing to. */
3437 tree target
= TREE_OPERAND (t
, 0);
3439 maybe_simplify_trivial_copy (target
, init
);
3441 tree type
= TREE_TYPE (target
);
3442 target
= cxx_eval_constant_expression (ctx
, target
,
3444 non_constant_p
, overflow_p
);
3445 if (*non_constant_p
)
3448 /* cxx_eval_array_reference for lval = true allows references one past
3449 end of array, because it does not know if it is just taking address
3450 (which is valid), or actual dereference. Here we know it is
3451 a dereference, so diagnose it here. */
3452 for (tree probe
= target
; probe
; )
3454 switch (TREE_CODE (probe
))
3458 ary
= TREE_OPERAND (probe
, 0);
3459 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3461 if (TYPE_DOMAIN (TREE_TYPE (ary
)))
3462 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3464 nelts
= size_zero_node
;
3466 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3467 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3470 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3471 non_constant_p
, overflow_p
);
3472 VERIFY_CONSTANT (nelts
);
3473 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3474 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3475 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3477 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3478 *non_constant_p
= true;
3485 probe
= TREE_OPERAND (probe
, 0);
3494 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3496 /* For initialization of an empty base, the original target will be
3497 *(base*)this, which the above evaluation resolves to the object
3498 argument, which has the derived type rather than the base type. In
3499 this situation, just evaluate the initializer and return, since
3500 there's no actual data to store. */
3501 gcc_assert (is_empty_class (type
));
3502 return cxx_eval_constant_expression (ctx
, init
, false,
3503 non_constant_p
, overflow_p
);
3506 /* And then find the underlying variable. */
3507 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3508 tree object
= NULL_TREE
;
3509 for (tree probe
= target
; object
== NULL_TREE
; )
3511 switch (TREE_CODE (probe
))
3516 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3517 vec_safe_push (refs
, TREE_TYPE (probe
));
3518 probe
= TREE_OPERAND (probe
, 0);
3526 /* And then find/build up our initializer for the path to the subobject
3527 we're initializing. */
3529 if (object
== ctx
->object
&& VAR_P (object
)
3530 && DECL_NAME (object
) && ctx
->call
== NULL
)
3531 /* The variable we're building up an aggregate initializer for is outside
3532 the constant-expression, so don't evaluate the store. We check
3533 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3535 else if (DECL_P (object
))
3536 valp
= ctx
->values
->get (object
);
3541 /* A constant-expression cannot modify objects from outside the
3542 constant-expression. */
3544 error ("modification of %qE is not a constant expression", object
);
3545 *non_constant_p
= true;
3548 type
= TREE_TYPE (object
);
3549 bool no_zero_init
= true;
3551 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3552 while (!refs
->is_empty())
3554 if (*valp
== NULL_TREE
)
3556 *valp
= build_constructor (type
, NULL
);
3557 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3559 else if (TREE_CODE (*valp
) == STRING_CST
)
3561 /* An array was initialized with a string constant, and now
3562 we're writing into one of its elements. Explode the
3563 single initialization into a set of element
3565 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3567 tree string
= *valp
;
3568 tree elt_type
= TREE_TYPE (type
);
3569 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3570 / TYPE_PRECISION (char_type_node
));
3571 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3572 tree ary_ctor
= build_constructor (type
, NULL
);
3574 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3575 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3577 constructor_elt elt
=
3579 build_int_cst (size_type_node
, ix
),
3580 extract_string_elt (string
, chars_per_elt
, ix
)
3582 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3588 /* If the value of object is already zero-initialized, any new ctors for
3589 subobjects will also be zero-initialized. */
3590 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3592 vec_safe_push (ctors
, *valp
);
3594 enum tree_code code
= TREE_CODE (type
);
3596 tree index
= refs
->pop();
3598 constructor_elt
*cep
= NULL
;
3599 if (code
== ARRAY_TYPE
)
3602 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3603 gcc_assert (i
>= 0);
3604 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3605 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3609 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3611 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3612 Usually we meet initializers in that order, but it is
3613 possible for base types to be placed not in program
3615 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3616 unsigned HOST_WIDE_INT idx
;
3618 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3619 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3620 /* Changing active member. */
3621 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3624 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3625 idx
++, fields
= DECL_CHAIN (fields
))
3627 if (index
== cep
->index
)
3630 /* The field we're initializing must be on the field
3631 list. Look to see if it is present before the
3632 field the current ELT initializes. */
3633 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3634 if (index
== fields
)
3638 /* We fell off the end of the CONSTRUCTOR, so insert a new
3639 entry at the end. */
3642 constructor_elt ce
= { index
, NULL_TREE
};
3644 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3645 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3651 release_tree_vector (refs
);
3653 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3655 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3656 wants to modify it. */
3657 if (*valp
== NULL_TREE
)
3659 *valp
= build_constructor (type
, NULL
);
3660 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3662 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3663 *valp
= cplus_expand_constant (*valp
);
3664 new_ctx
.ctor
= *valp
;
3665 new_ctx
.object
= target
;
3668 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3669 non_constant_p
, overflow_p
);
3670 /* Don't share a CONSTRUCTOR that might be changed later. */
3671 init
= unshare_constructor (init
);
3672 if (target
== object
)
3673 /* The hash table might have moved since the get earlier. */
3674 valp
= ctx
->values
->get (object
);
3676 if (TREE_CODE (init
) == CONSTRUCTOR
)
3678 /* An outer ctx->ctor might be pointing to *valp, so replace
3680 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3681 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3682 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3683 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3684 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3689 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3690 CONSTRUCTORs, if any. */
3693 bool c
= TREE_CONSTANT (init
);
3694 bool s
= TREE_SIDE_EFFECTS (init
);
3696 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3699 TREE_CONSTANT (elt
) = false;
3701 TREE_SIDE_EFFECTS (elt
) = true;
3703 release_tree_vector (ctors
);
3705 if (*non_constant_p
)
3713 /* Evaluate a ++ or -- expression. */
3716 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3718 bool *non_constant_p
, bool *overflow_p
)
3720 enum tree_code code
= TREE_CODE (t
);
3721 tree type
= TREE_TYPE (t
);
3722 tree op
= TREE_OPERAND (t
, 0);
3723 tree offset
= TREE_OPERAND (t
, 1);
3724 gcc_assert (TREE_CONSTANT (offset
));
3726 /* The operand as an lvalue. */
3727 op
= cxx_eval_constant_expression (ctx
, op
, true,
3728 non_constant_p
, overflow_p
);
3730 /* The operand as an rvalue. */
3732 = cxx_eval_constant_expression (ctx
, op
, false,
3733 non_constant_p
, overflow_p
);
3734 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3735 a local array in a constexpr function. */
3736 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3738 VERIFY_CONSTANT (val
);
3740 /* The modified value. */
3741 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3743 if (POINTER_TYPE_P (type
))
3745 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3746 offset
= convert_to_ptrofftype (offset
);
3748 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3749 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3752 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3754 VERIFY_CONSTANT (mod
);
3756 /* Storing the modified value. */
3757 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3758 cxx_eval_constant_expression (ctx
, store
,
3759 true, non_constant_p
, overflow_p
);
3761 /* And the value of the expression. */
3762 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3764 /* Prefix ops are lvalues. */
3768 /* But we optimize when the caller wants an rvalue. */
3772 /* Postfix ops are rvalues. */
3776 /* Predicates for the meaning of *jump_target. */
3779 returns (tree
*jump_target
)
3782 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3783 || (TREE_CODE (*jump_target
) == LABEL_DECL
3784 && LABEL_DECL_CDTOR (*jump_target
)));
3788 breaks (tree
*jump_target
)
3791 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3792 && LABEL_DECL_BREAK (*jump_target
))
3793 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3797 continues (tree
*jump_target
)
3800 && TREE_CODE (*jump_target
) == LABEL_DECL
3801 && LABEL_DECL_CONTINUE (*jump_target
);
3805 switches (tree
*jump_target
)
3808 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3811 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3812 STMT matches *jump_target. If we're looking for a case label and we see
3813 the default label, note it in ctx->css_state. */
3816 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3818 switch (TREE_CODE (*jump_target
))
3821 if (TREE_CODE (stmt
) == LABEL_EXPR
3822 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3827 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3829 gcc_assert (ctx
->css_state
!= NULL
);
3830 if (!CASE_LOW (stmt
))
3832 /* default: should appear just once in a SWITCH_EXPR
3833 body (excluding nested SWITCH_EXPR). */
3834 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3835 /* When evaluating SWITCH_EXPR body for the second time,
3836 return true for the default: label. */
3837 if (*ctx
->css_state
== css_default_processing
)
3839 *ctx
->css_state
= css_default_seen
;
3841 else if (CASE_HIGH (stmt
))
3843 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3844 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3847 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3858 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3859 semantics, for switch, break, continue, and return. */
3862 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3863 bool *non_constant_p
, bool *overflow_p
,
3866 tree_stmt_iterator i
;
3868 /* In a statement-expression we want to return the last value.
3869 For empty statement expression return void_node. */
3873 local_target
= NULL_TREE
;
3874 jump_target
= &local_target
;
3876 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3878 tree stmt
= tsi_stmt (i
);
3879 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
3881 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3882 non_constant_p
, overflow_p
,
3884 if (*non_constant_p
)
3886 if (returns (jump_target
) || breaks (jump_target
))
3892 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3893 semantics; continue semantics are covered by cxx_eval_statement_list. */
3896 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3897 bool *non_constant_p
, bool *overflow_p
,
3900 constexpr_ctx new_ctx
= *ctx
;
3902 tree body
= TREE_OPERAND (t
, 0);
3906 hash_set
<tree
> save_exprs
;
3907 new_ctx
.save_exprs
= &save_exprs
;
3909 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3910 non_constant_p
, overflow_p
, jump_target
);
3912 /* Forget saved values of SAVE_EXPRs. */
3913 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3914 iter
!= save_exprs
.end(); ++iter
)
3915 new_ctx
.values
->remove (*iter
);
3916 if (++count
>= constexpr_loop_limit
)
3919 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3920 "%<constexpr%> loop iteration count exceeds limit of %d "
3921 "(use -fconstexpr-loop-limit= to increase the limit)",
3922 constexpr_loop_limit
);
3923 *non_constant_p
= true;
3927 while (!returns (jump_target
)
3928 && !breaks (jump_target
)
3929 && !switches (jump_target
)
3930 && !*non_constant_p
);
3932 if (breaks (jump_target
))
3933 *jump_target
= NULL_TREE
;
3938 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3942 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3943 bool *non_constant_p
, bool *overflow_p
,
3946 tree cond
= TREE_OPERAND (t
, 0);
3947 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3948 non_constant_p
, overflow_p
);
3949 VERIFY_CONSTANT (cond
);
3950 *jump_target
= cond
;
3952 tree body
= TREE_OPERAND (t
, 1);
3953 constexpr_ctx new_ctx
= *ctx
;
3954 constexpr_switch_state css
= css_default_not_seen
;
3955 new_ctx
.css_state
= &css
;
3956 cxx_eval_constant_expression (&new_ctx
, body
, false,
3957 non_constant_p
, overflow_p
, jump_target
);
3958 if (switches (jump_target
) && css
== css_default_seen
)
3960 /* If the SWITCH_EXPR body has default: label, process it once again,
3961 this time instructing label_matches to return true for default:
3962 label on switches (jump_target). */
3963 css
= css_default_processing
;
3964 cxx_eval_constant_expression (&new_ctx
, body
, false,
3965 non_constant_p
, overflow_p
, jump_target
);
3967 if (breaks (jump_target
) || switches (jump_target
))
3968 *jump_target
= NULL_TREE
;
3972 /* Find the object of TYPE under initialization in CTX. */
3975 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3980 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3981 can is a minor optimization. */
3982 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
3988 /* Since an object cannot have a field of its own type, we can search outward
3989 from ctx->object to find the unique containing object of TYPE. */
3990 tree ob
= ctx
->object
;
3993 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
3995 if (handled_component_p (ob
))
3996 ob
= TREE_OPERAND (ob
, 0);
4004 /* Attempt to reduce the expression T to a constant value.
4005 On failure, issue diagnostic and return error_mark_node. */
4006 /* FIXME unify with c_fully_fold */
4007 /* FIXME overflow_p is too global */
4010 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4012 bool *non_constant_p
, bool *overflow_p
,
4015 constexpr_ctx new_ctx
;
4018 if (jump_target
&& *jump_target
)
4020 /* If we are jumping, ignore all statements/expressions except those
4021 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4022 switch (TREE_CODE (t
))
4025 case STATEMENT_LIST
:
4030 case CASE_LABEL_EXPR
:
4031 if (label_matches (ctx
, jump_target
, t
))
4033 *jump_target
= NULL_TREE
;
4039 if (t
== error_mark_node
)
4041 *non_constant_p
= true;
4044 if (CONSTANT_CLASS_P (t
))
4046 if (TREE_OVERFLOW (t
))
4049 permerror (input_location
, "overflow in constant expression");
4050 if (!flag_permissive
|| ctx
->quiet
)
4054 if (TREE_CODE (t
) == INTEGER_CST
4055 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
4056 && !integer_zerop (t
))
4059 error ("value %qE of type %qT is not a constant expression",
4061 *non_constant_p
= true;
4067 tree_code tcode
= TREE_CODE (t
);
4073 /* We ask for an rvalue for the RESULT_DECL when indirecting
4074 through an invisible reference, or in named return value
4076 return (*ctx
->values
->get (t
));
4079 if (DECL_HAS_VALUE_EXPR_P (t
))
4080 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4081 lval
, non_constant_p
, overflow_p
);
4084 /* We used to not check lval for CONST_DECL, but darwin.c uses
4085 CONST_DECL for aggregate constants. */
4088 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4089 && is_really_empty_class (TREE_TYPE (t
)))
4091 /* If the class is empty, we aren't actually loading anything. */
4092 r
= build_constructor (TREE_TYPE (t
), NULL
);
4093 TREE_CONSTANT (r
) = true;
4095 else if (ctx
->strict
)
4096 r
= decl_really_constant_value (t
);
4098 r
= decl_constant_value (t
);
4099 if (TREE_CODE (r
) == TARGET_EXPR
4100 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4101 r
= TARGET_EXPR_INITIAL (r
);
4103 if (tree
*p
= ctx
->values
->get (r
))
4104 if (*p
!= NULL_TREE
)
4109 non_const_var_error (r
);
4110 *non_constant_p
= true;
4114 case DEBUG_BEGIN_STMT
:
4115 /* ??? It might be nice to retain this information somehow, so
4116 as to be able to step into a constexpr function call. */
4123 case CASE_LABEL_EXPR
:
4128 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4130 else if (tree
*p
= ctx
->values
->get (r
))
4133 /* Defer in case this is only used for its type. */;
4134 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4135 /* Defer, there's no lvalue->rvalue conversion. */;
4136 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4137 && is_really_empty_class (TREE_TYPE (t
)))
4139 /* If the class is empty, we aren't actually loading anything. */
4140 r
= build_constructor (TREE_TYPE (t
), NULL
);
4141 TREE_CONSTANT (r
) = true;
4146 error ("%qE is not a constant expression", t
);
4147 *non_constant_p
= true;
4152 case AGGR_INIT_EXPR
:
4153 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4154 non_constant_p
, overflow_p
);
4159 r
= DECL_EXPR_DECL (t
);
4160 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4161 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4165 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4166 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4167 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4171 if (tree init
= DECL_INITIAL (r
))
4173 init
= cxx_eval_constant_expression (ctx
, init
,
4175 non_constant_p
, overflow_p
);
4176 /* Don't share a CONSTRUCTOR that might be changed. */
4177 init
= unshare_constructor (init
);
4178 ctx
->values
->put (r
, init
);
4180 else if (ctx
== &new_ctx
)
4181 /* We gave it a CONSTRUCTOR above. */;
4183 ctx
->values
->put (r
, NULL_TREE
);
4188 if (!literal_type_p (TREE_TYPE (t
)))
4192 error ("temporary of non-literal type %qT in a "
4193 "constant expression", TREE_TYPE (t
));
4194 explain_non_literal_class (TREE_TYPE (t
));
4196 *non_constant_p
= true;
4199 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4201 /* We're being expanded without an explicit target, so start
4202 initializing a new object; expansion with an explicit target
4203 strips the TARGET_EXPR before we get here. */
4205 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4206 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4207 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4208 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4211 /* Pass false for 'lval' because this indicates
4212 initialization of a temporary. */
4213 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4215 non_constant_p
, overflow_p
);
4216 if (!*non_constant_p
)
4217 /* Adjust the type of the result to the type of the temporary. */
4218 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4221 tree slot
= TARGET_EXPR_SLOT (t
);
4222 r
= unshare_constructor (r
);
4223 ctx
->values
->put (slot
, r
);
4230 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4231 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4232 non_constant_p
, overflow_p
);
4236 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4238 non_constant_p
, overflow_p
);
4242 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4243 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4245 non_constant_p
, overflow_p
);
4250 /* Avoid evaluating a SAVE_EXPR more than once. */
4251 if (tree
*p
= ctx
->values
->get (t
))
4255 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4256 non_constant_p
, overflow_p
);
4257 ctx
->values
->put (t
, r
);
4258 if (ctx
->save_exprs
)
4259 ctx
->save_exprs
->add (t
);
4263 case NON_LVALUE_EXPR
:
4264 case TRY_CATCH_EXPR
:
4266 case CLEANUP_POINT_EXPR
:
4267 case MUST_NOT_THROW_EXPR
:
4270 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4272 non_constant_p
, overflow_p
,
4276 case TRY_FINALLY_EXPR
:
4277 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4278 non_constant_p
, overflow_p
,
4280 if (!*non_constant_p
)
4281 /* Also evaluate the cleanup. */
4282 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4283 non_constant_p
, overflow_p
,
4287 /* These differ from cxx_eval_unary_expression in that this doesn't
4288 check for a constant operand or result; an address can be
4289 constant without its operand being, and vice versa. */
4292 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4293 non_constant_p
, overflow_p
);
4298 tree oldop
= TREE_OPERAND (t
, 0);
4299 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4301 non_constant_p
, overflow_p
);
4302 /* Don't VERIFY_CONSTANT here. */
4303 if (*non_constant_p
)
4305 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4306 /* This function does more aggressive folding than fold itself. */
4307 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4308 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4317 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4318 non_constant_p
, overflow_p
);
4319 if (r
== error_mark_node
)
4321 else if (r
== TREE_OPERAND (t
, 0))
4324 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4329 case FIX_TRUNC_EXPR
:
4334 case TRUTH_NOT_EXPR
:
4335 case FIXED_CONVERT_EXPR
:
4336 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4337 non_constant_p
, overflow_p
);
4341 r
= fold_sizeof_expr (t
);
4342 VERIFY_CONSTANT (r
);
4347 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4348 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4349 introduced by build_call_a. */
4350 tree op0
= TREE_OPERAND (t
, 0);
4351 tree op1
= TREE_OPERAND (t
, 1);
4353 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4354 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4355 r
= cxx_eval_constant_expression (ctx
, op0
,
4356 lval
, non_constant_p
, overflow_p
,
4360 /* Check that the LHS is constant and then discard it. */
4361 cxx_eval_constant_expression (ctx
, op0
,
4362 true, non_constant_p
, overflow_p
,
4364 if (*non_constant_p
)
4366 op1
= TREE_OPERAND (t
, 1);
4367 r
= cxx_eval_constant_expression (ctx
, op1
,
4368 lval
, non_constant_p
, overflow_p
,
4374 case POINTER_PLUS_EXPR
:
4375 case POINTER_DIFF_EXPR
:
4379 case TRUNC_DIV_EXPR
:
4381 case FLOOR_DIV_EXPR
:
4382 case ROUND_DIV_EXPR
:
4383 case TRUNC_MOD_EXPR
:
4385 case ROUND_MOD_EXPR
:
4387 case EXACT_DIV_EXPR
:
4397 case TRUTH_XOR_EXPR
:
4404 case UNORDERED_EXPR
:
4414 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4415 non_constant_p
, overflow_p
);
4418 /* fold can introduce non-IF versions of these; still treat them as
4419 short-circuiting. */
4420 case TRUTH_AND_EXPR
:
4421 case TRUTH_ANDIF_EXPR
:
4422 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4425 non_constant_p
, overflow_p
);
4429 case TRUTH_ORIF_EXPR
:
4430 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4433 non_constant_p
, overflow_p
);
4437 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4438 non_constant_p
, overflow_p
);
4442 if (is_overloaded_fn (t
))
4444 /* We can only get here in checking mode via
4445 build_non_dependent_expr, because any expression that
4446 calls or takes the address of the function will have
4447 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4448 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4449 *non_constant_p
= true;
4452 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4453 non_constant_p
, overflow_p
);
4457 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4458 non_constant_p
, overflow_p
);
4462 if (jump_target
&& *jump_target
)
4464 /* When jumping to a label, the label might be either in the
4465 then or else blocks, so process then block first in skipping
4466 mode first, and if we are still in the skipping mode at its end,
4467 process the else block too. */
4468 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4469 lval
, non_constant_p
, overflow_p
,
4472 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4473 lval
, non_constant_p
, overflow_p
,
4477 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4478 non_constant_p
, overflow_p
,
4482 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4487 if (TREE_CONSTANT (t
))
4489 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4490 VECTOR_CST if applicable. */
4491 /* FIXME after GCC 6 branches, make the verify unconditional. */
4493 verify_constructor_flags (t
);
4495 recompute_constructor_flags (t
);
4496 if (TREE_CONSTANT (t
))
4499 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4500 non_constant_p
, overflow_p
);
4504 /* We can get this in a defaulted constructor for a class with a
4505 non-static data member of array type. Either the initializer will
4506 be NULL, meaning default-initialization, or it will be an lvalue
4507 or xvalue of the same type, meaning direct-initialization from the
4508 corresponding member. */
4509 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4510 non_constant_p
, overflow_p
);
4515 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4516 non_constant_p
, overflow_p
);
4520 case VIEW_CONVERT_EXPR
:
4522 case UNARY_PLUS_EXPR
:
4524 tree oldop
= TREE_OPERAND (t
, 0);
4526 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4528 non_constant_p
, overflow_p
);
4529 if (*non_constant_p
)
4531 tree type
= TREE_TYPE (t
);
4532 if (TREE_CODE (op
) == PTRMEM_CST
4533 && !TYPE_PTRMEM_P (type
))
4534 op
= cplus_expand_constant (op
);
4535 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4537 if (same_type_ignoring_top_level_qualifiers_p (type
,
4539 || can_convert_qual (type
, op
))
4540 return cp_fold_convert (type
, op
);
4544 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4545 "a reinterpret_cast is not a constant expression");
4546 *non_constant_p
= true;
4551 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4553 if (integer_zerop (op
))
4555 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4558 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4559 "dereferencing a null pointer");
4560 *non_constant_p
= true;
4563 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4565 tree from
= TREE_TYPE (op
);
4567 if (!can_convert (type
, from
, tf_none
))
4570 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4571 "conversion of %qT null pointer to %qT "
4572 "is not a constant expression",
4574 *non_constant_p
= true;
4581 /* This detects for example:
4582 reinterpret_cast<void*>(sizeof 0)
4585 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4586 "%<reinterpret_cast<%T>(%E)%> is not "
4587 "a constant expression",
4589 *non_constant_p
= true;
4593 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4594 /* We didn't fold at the top so we could check for ptr-int
4597 if (tcode
== UNARY_PLUS_EXPR
)
4598 r
= fold_convert (TREE_TYPE (t
), op
);
4600 r
= fold_build1 (tcode
, type
, op
);
4601 /* Conversion of an out-of-range value has implementation-defined
4602 behavior; the language considers it different from arithmetic
4603 overflow, which is undefined. */
4604 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4605 TREE_OVERFLOW (r
) = false;
4609 case EMPTY_CLASS_EXPR
:
4610 /* This is good enough for a function argument that might not get
4611 used, and they can't do anything with it, so just return it. */
4614 case STATEMENT_LIST
:
4616 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4617 return cxx_eval_statement_list (&new_ctx
, t
,
4618 non_constant_p
, overflow_p
, jump_target
);
4621 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4623 non_constant_p
, overflow_p
,
4626 case PREINCREMENT_EXPR
:
4627 case POSTINCREMENT_EXPR
:
4628 case PREDECREMENT_EXPR
:
4629 case POSTDECREMENT_EXPR
:
4630 return cxx_eval_increment_expression (ctx
, t
,
4631 lval
, non_constant_p
, overflow_p
);
4637 case VEC_DELETE_EXPR
:
4640 /* GCC internal stuff. */
4643 case NON_DEPENDENT_EXPR
:
4647 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4648 "expression %qE is not a constant expression", t
);
4649 *non_constant_p
= true;
4652 case PLACEHOLDER_EXPR
:
4653 /* Use of the value or address of the current object. */
4654 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4655 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4656 non_constant_p
, overflow_p
);
4657 /* A placeholder without a referent. We can get here when
4658 checking whether NSDMIs are noexcept, or in massage_init_elt;
4659 just say it's non-constant for now. */
4660 gcc_assert (ctx
->quiet
);
4661 *non_constant_p
= true;
4666 tree cond
= TREE_OPERAND (t
, 0);
4667 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4668 non_constant_p
, overflow_p
);
4669 VERIFY_CONSTANT (cond
);
4670 if (integer_nonzerop (cond
))
4676 *jump_target
= TREE_OPERAND (t
, 0);
4677 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4678 /* Allow for jumping to a cdtor_label. */
4679 || returns (jump_target
));
4683 cxx_eval_loop_expr (ctx
, t
,
4684 non_constant_p
, overflow_p
, jump_target
);
4688 cxx_eval_switch_expr (ctx
, t
,
4689 non_constant_p
, overflow_p
, jump_target
);
4693 /* It's possible to get a requires-expression in a constant
4694 expression. For example:
4696 template<typename T> concept bool C() {
4697 return requires (T t) { t; };
4700 template<typename T> requires !C<T>() void f(T);
4702 Normalization leaves f with the associated constraint
4703 '!requires (T t) { ... }' which is not transformed into
4705 if (!processing_template_decl
)
4706 return evaluate_constraint_expression (t
, NULL_TREE
);
4708 *non_constant_p
= true;
4712 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4714 non_constant_p
, overflow_p
,
4719 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4721 /* This function doesn't know how to deal with pre-genericize
4722 statements; this can only happen with statement-expressions,
4723 so for now just fail. */
4725 error_at (EXPR_LOCATION (t
),
4726 "statement is not a constant expression");
4729 internal_error ("unexpected expression %qE of kind %s", t
,
4730 get_tree_code_name (TREE_CODE (t
)));
4731 *non_constant_p
= true;
4735 if (r
== error_mark_node
)
4736 *non_constant_p
= true;
4738 if (*non_constant_p
)
4745 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4746 bool strict
= true, tree object
= NULL_TREE
)
4748 auto_timevar
time (TV_CONSTEXPR
);
4750 bool non_constant_p
= false;
4751 bool overflow_p
= false;
4752 hash_map
<tree
,tree
> map
;
4754 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4755 allow_non_constant
, strict
};
4757 tree type
= initialized_type (t
);
4759 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4761 /* In C++14 an NSDMI can participate in aggregate initialization,
4762 and can refer to the address of the object being initialized, so
4763 we need to pass in the relevant VAR_DECL if we want to do the
4764 evaluation in a single pass. The evaluation will dynamically
4765 update ctx.values for the VAR_DECL. We use the same strategy
4766 for C++11 constexpr constructors that refer to the object being
4768 ctx
.ctor
= build_constructor (type
, NULL
);
4769 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4772 if (TREE_CODE (t
) == TARGET_EXPR
)
4773 object
= TARGET_EXPR_SLOT (t
);
4774 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4775 object
= AGGR_INIT_EXPR_SLOT (t
);
4777 ctx
.object
= object
;
4779 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4780 (type
, TREE_TYPE (object
)));
4781 if (object
&& DECL_P (object
))
4782 map
.put (object
, ctx
.ctor
);
4783 if (TREE_CODE (r
) == TARGET_EXPR
)
4784 /* Avoid creating another CONSTRUCTOR when we expand the
4786 r
= TARGET_EXPR_INITIAL (r
);
4789 r
= cxx_eval_constant_expression (&ctx
, r
,
4790 false, &non_constant_p
, &overflow_p
);
4792 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4794 /* Mutable logic is a bit tricky: we want to allow initialization of
4795 constexpr variables with mutable members, but we can't copy those
4796 members to another constexpr variable. */
4797 if (TREE_CODE (r
) == CONSTRUCTOR
4798 && CONSTRUCTOR_MUTABLE_POISON (r
))
4800 if (!allow_non_constant
)
4801 error ("%qE is not a constant expression because it refers to "
4802 "mutable subobjects of %qT", t
, type
);
4803 non_constant_p
= true;
4806 if (TREE_CODE (r
) == CONSTRUCTOR
4807 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4809 if (!allow_non_constant
)
4810 error ("%qE is not a constant expression because it refers to "
4811 "an incompletely initialized variable", t
);
4812 TREE_CONSTANT (r
) = false;
4813 non_constant_p
= true;
4816 /* Technically we should check this for all subexpressions, but that
4817 runs into problems with our internal representation of pointer
4818 subtraction and the 5.19 rules are still in flux. */
4819 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4820 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4821 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4823 if (!allow_non_constant
)
4824 error ("conversion from pointer type %qT "
4825 "to arithmetic type %qT in a constant expression",
4826 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4827 non_constant_p
= true;
4830 if (!non_constant_p
&& overflow_p
)
4831 non_constant_p
= true;
4833 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4835 bool should_unshare
= true;
4836 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4837 should_unshare
= false;
4839 if (non_constant_p
&& !allow_non_constant
)
4840 return error_mark_node
;
4841 else if (non_constant_p
&& TREE_CONSTANT (r
))
4843 /* This isn't actually constant, so unset TREE_CONSTANT. */
4846 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4847 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4849 r
= build_nop (TREE_TYPE (r
), r
);
4850 TREE_CONSTANT (r
) = false;
4852 else if (non_constant_p
|| r
== t
)
4856 r
= unshare_expr (r
);
4858 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4860 if (TREE_CODE (t
) == TARGET_EXPR
4861 && TARGET_EXPR_INITIAL (t
) == r
)
4865 r
= get_target_expr (r
);
4866 TREE_CONSTANT (r
) = true;
4874 /* Returns true if T is a valid subexpression of a constant expression,
4875 even if it isn't itself a constant expression. */
4878 is_sub_constant_expr (tree t
)
4880 bool non_constant_p
= false;
4881 bool overflow_p
= false;
4882 hash_map
<tree
, tree
> map
;
4884 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4886 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4888 return !non_constant_p
&& !overflow_p
;
4891 /* If T represents a constant expression returns its reduced value.
4892 Otherwise return error_mark_node. If T is dependent, then
4896 cxx_constant_value (tree t
, tree decl
)
4898 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4901 /* Helper routine for fold_simple function. Either return simplified
4902 expression T, otherwise NULL_TREE.
4903 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4904 even if we are within template-declaration. So be careful on call, as in
4905 such case types can be undefined. */
4908 fold_simple_1 (tree t
)
4911 enum tree_code code
= TREE_CODE (t
);
4923 return fold_sizeof_expr (t
);
4931 case TRUTH_NOT_EXPR
:
4933 case VIEW_CONVERT_EXPR
:
4936 case FIX_TRUNC_EXPR
:
4937 case FIXED_CONVERT_EXPR
:
4938 case ADDR_SPACE_CONVERT_EXPR
:
4940 op1
= TREE_OPERAND (t
, 0);
4942 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4946 if (CONVERT_EXPR_CODE_P (code
)
4947 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4948 TREE_OVERFLOW (t
) = false;
4956 /* If T is a simple constant expression, returns its simplified value.
4957 Otherwise returns T. In contrast to maybe_constant_value we
4958 simplify only few operations on constant-expressions, and we don't
4959 try to simplify constexpressions. */
4962 fold_simple (tree t
)
4964 if (processing_template_decl
)
4967 tree r
= fold_simple_1 (t
);
4974 /* If T is a constant expression, returns its reduced value.
4975 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4976 Otherwise, returns a version of T without TREE_CONSTANT. */
4978 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4981 maybe_constant_value (tree t
, tree decl
)
4985 if (!is_nondependent_constant_expression (t
))
4987 if (TREE_OVERFLOW_P (t
))
4989 t
= build_nop (TREE_TYPE (t
), t
);
4990 TREE_CONSTANT (t
) = false;
4994 else if (CONSTANT_CLASS_P (t
))
4995 /* No caching or evaluation needed. */
4998 if (cv_cache
== NULL
)
4999 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5000 if (tree
*cached
= cv_cache
->get (t
))
5003 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
5004 gcc_checking_assert (r
== t
5005 || CONVERT_EXPR_P (t
)
5006 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5007 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5008 || !cp_tree_equal (r
, t
));
5009 cv_cache
->put (t
, r
);
5013 /* Dispose of the whole CV_CACHE. */
5016 clear_cv_cache (void)
5018 if (cv_cache
!= NULL
)
5022 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5025 clear_cv_and_fold_caches (void)
5028 clear_fold_cache ();
5031 /* Like maybe_constant_value but first fully instantiate the argument.
5033 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5034 (t, tf_none) followed by maybe_constant_value but is more efficient,
5035 because calls instantiation_dependent_expression_p and
5036 potential_constant_expression at most once. */
5039 fold_non_dependent_expr (tree t
)
5044 /* If we're in a template, but T isn't value dependent, simplify
5045 it. We're supposed to treat:
5047 template <typename T> void f(T[1 + 1]);
5048 template <typename T> void f(T[2]);
5050 as two declarations of the same function, for example. */
5051 if (processing_template_decl
)
5053 if (is_nondependent_constant_expression (t
))
5055 processing_template_decl_sentinel s
;
5056 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
5058 if (type_unknown_p (t
)
5059 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5061 if (TREE_OVERFLOW_P (t
))
5063 t
= build_nop (TREE_TYPE (t
), t
);
5064 TREE_CONSTANT (t
) = false;
5069 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
5070 /* cp_tree_equal looks through NOPs, so allow them. */
5071 gcc_checking_assert (r
== t
5072 || CONVERT_EXPR_P (t
)
5073 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5074 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5075 || !cp_tree_equal (r
, t
));
5078 else if (TREE_OVERFLOW_P (t
))
5080 t
= build_nop (TREE_TYPE (t
), t
);
5081 TREE_CONSTANT (t
) = false;
5086 return maybe_constant_value (t
);
5089 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5090 than wrapped in a TARGET_EXPR. */
5093 maybe_constant_init (tree t
, tree decl
)
5097 if (TREE_CODE (t
) == EXPR_STMT
)
5098 t
= TREE_OPERAND (t
, 0);
5099 if (TREE_CODE (t
) == CONVERT_EXPR
5100 && VOID_TYPE_P (TREE_TYPE (t
)))
5101 t
= TREE_OPERAND (t
, 0);
5102 if (TREE_CODE (t
) == INIT_EXPR
)
5103 t
= TREE_OPERAND (t
, 1);
5104 if (TREE_CODE (t
) == TARGET_EXPR
)
5105 t
= TARGET_EXPR_INITIAL (t
);
5106 if (!is_nondependent_static_init_expression (t
))
5107 /* Don't try to evaluate it. */;
5108 else if (CONSTANT_CLASS_P (t
))
5109 /* No evaluation needed. */;
5111 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
5112 if (TREE_CODE (t
) == TARGET_EXPR
)
5114 tree init
= TARGET_EXPR_INITIAL (t
);
5115 if (TREE_CODE (init
) == CONSTRUCTOR
)
5122 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5123 /* Return true if the object referred to by REF has automatic or thread
5126 enum { ck_ok
, ck_bad
, ck_unknown
};
5128 check_automatic_or_tls (tree ref
)
5131 poly_int64 bitsize
, bitpos
;
5133 int volatilep
= 0, unsignedp
= 0;
5134 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5135 &mode
, &unsignedp
, &volatilep
, false);
5138 /* If there isn't a decl in the middle, we don't know the linkage here,
5139 and this isn't a constant expression anyway. */
5142 dk
= decl_storage_duration (decl
);
5143 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5147 /* Return true if T denotes a potentially constant expression. Issue
5148 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5149 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5150 consider the expression in the current context, independent of constexpr
5153 C++0x [expr.const] used to say
5155 6 An expression is a potential constant expression if it is
5156 a constant expression where all occurrences of function
5157 parameters are replaced by arbitrary constant expressions
5158 of the appropriate type.
5160 2 A conditional expression is a constant expression unless it
5161 involves one of the following as a potentially evaluated
5162 subexpression (3.2), but subexpressions of logical AND (5.14),
5163 logical OR (5.15), and conditional (5.16) operations that are
5164 not evaluated are not considered. */
5167 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5168 tsubst_flags_t flags
)
5170 #define RECUR(T,RV) \
5171 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5173 enum { any
= false, rval
= true };
5177 if (t
== error_mark_node
)
5181 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5182 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5184 if (flags
& tf_error
)
5185 error_at (loc
, "expression %qE has side-effects", t
);
5188 if (CONSTANT_CLASS_P (t
))
5190 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5191 && TREE_TYPE (t
) == error_mark_node
)
5194 switch (TREE_CODE (t
))
5200 case TEMPLATE_ID_EXPR
:
5203 case CASE_LABEL_EXPR
:
5209 case TEMPLATE_PARM_INDEX
:
5211 case IDENTIFIER_NODE
:
5212 case USERDEF_LITERAL
:
5213 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5218 case PLACEHOLDER_EXPR
:
5223 case DEBUG_BEGIN_STMT
:
5229 if (flags
& tf_error
)
5230 error ("%qE is not a constant expression", t
);
5235 case AGGR_INIT_EXPR
:
5237 /* -- an invocation of a function other than a constexpr function
5238 or a constexpr constructor. */
5240 tree fun
= get_function_named_in_call (t
);
5241 const int nargs
= call_expr_nargs (t
);
5244 if (fun
== NULL_TREE
)
5246 /* Reset to allow the function to continue past the end
5247 of the block below. Otherwise return early. */
5250 if (TREE_CODE (t
) == CALL_EXPR
5251 && CALL_EXPR_FN (t
) == NULL_TREE
)
5252 switch (CALL_EXPR_IFN (t
))
5254 /* These should be ignored, they are optimized away from
5255 constexpr functions. */
5256 case IFN_UBSAN_NULL
:
5257 case IFN_UBSAN_BOUNDS
:
5258 case IFN_UBSAN_VPTR
:
5259 case IFN_FALLTHROUGH
:
5262 case IFN_ADD_OVERFLOW
:
5263 case IFN_SUB_OVERFLOW
:
5264 case IFN_MUL_OVERFLOW
:
5274 /* fold_call_expr can't do anything with IFN calls. */
5275 if (flags
& tf_error
)
5276 error_at (loc
, "call to internal function %qE", t
);
5281 if (fun
&& is_overloaded_fn (fun
))
5283 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5285 if (builtin_valid_in_constant_expr_p (fun
))
5287 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5288 /* Allow any built-in function; if the expansion
5289 isn't constant, we'll deal with that then. */
5290 && !is_builtin_fn (fun
))
5292 if (flags
& tf_error
)
5294 error_at (loc
, "call to non-%<constexpr%> function %qD",
5296 explain_invalid_constexpr_fn (fun
);
5300 /* A call to a non-static member function takes the address
5301 of the object as the first argument. But in a constant
5302 expression the address will be folded away, so look
5304 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5305 && !DECL_CONSTRUCTOR_P (fun
))
5307 tree x
= get_nth_callarg (t
, 0);
5308 if (is_this_parameter (x
))
5310 /* Don't require an immediately constant value, as
5311 constexpr substitution might not use the value. */
5312 bool sub_now
= false;
5313 if (!potential_constant_expression_1 (x
, rval
, strict
,
5321 if (!RECUR (fun
, true))
5323 fun
= get_first_fn (fun
);
5325 /* Skip initial arguments to base constructors. */
5326 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5327 i
= num_artificial_parms_for (fun
);
5328 fun
= DECL_ORIGIN (fun
);
5332 if (RECUR (fun
, rval
))
5333 /* Might end up being a constant function pointer. */;
5337 for (; i
< nargs
; ++i
)
5339 tree x
= get_nth_callarg (t
, i
);
5340 /* In a template, reference arguments haven't been converted to
5341 REFERENCE_TYPE and we might not even know if the parameter
5342 is a reference, so accept lvalue constants too. */
5343 bool rv
= processing_template_decl
? any
: rval
;
5344 /* Don't require an immediately constant value, as constexpr
5345 substitution might not use the value of the argument. */
5346 bool sub_now
= false;
5347 if (!potential_constant_expression_1 (x
, rv
, strict
,
5354 case NON_LVALUE_EXPR
:
5355 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5356 -- an lvalue of integral type that refers to a non-volatile
5357 const variable or static data member initialized with
5358 constant expressions, or
5360 -- an lvalue of literal type that refers to non-volatile
5361 object defined with constexpr, or that refers to a
5362 sub-object of such an object; */
5363 return RECUR (TREE_OPERAND (t
, 0), rval
);
5366 if (DECL_HAS_VALUE_EXPR_P (t
))
5368 if (now
&& is_normal_capture_proxy (t
))
5370 /* -- in a lambda-expression, a reference to this or to a
5371 variable with automatic storage duration defined outside that
5372 lambda-expression, where the reference would be an
5374 if (flags
& tf_error
)
5376 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5377 error ("lambda capture of %qE is not a constant expression",
5379 if (!want_rval
&& decl_constant_var_p (cap
))
5380 inform (input_location
, "because it is used as a glvalue");
5384 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5387 && !var_in_maybe_constexpr_fn (t
)
5388 && !type_dependent_expression_p (t
)
5389 && !decl_maybe_constant_var_p (t
)
5391 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5392 || (DECL_INITIAL (t
)
5393 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5394 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5395 && !is_really_empty_class (TREE_TYPE (t
)))
5397 if (flags
& tf_error
)
5398 non_const_var_error (t
);
5405 case VIEW_CONVERT_EXPR
:
5406 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5407 may change to something more specific to type-punning (DR 1312). */
5409 tree from
= TREE_OPERAND (t
, 0);
5410 if (POINTER_TYPE_P (TREE_TYPE (t
))
5411 && TREE_CODE (from
) == INTEGER_CST
5412 && !integer_zerop (from
))
5414 if (flags
& tf_error
)
5415 error_at (loc
, "reinterpret_cast from integer to pointer");
5418 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5421 case ADDRESSOF_EXPR
:
5422 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5423 t
= TREE_OPERAND (t
, 0);
5424 goto handle_addr_expr
;
5427 /* -- a unary operator & that is applied to an lvalue that
5428 designates an object with thread or automatic storage
5430 t
= TREE_OPERAND (t
, 0);
5432 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5433 /* A pointer-to-member constant. */
5438 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5439 any checking here, as we might dereference the pointer later. If
5440 we remove this code, also remove check_automatic_or_tls. */
5441 i
= check_automatic_or_tls (t
);
5446 if (flags
& tf_error
)
5447 error ("address-of an object %qE with thread local or "
5448 "automatic storage is not a constant expression", t
);
5452 return RECUR (t
, any
);
5460 /* -- a class member access unless its postfix-expression is
5461 of literal type or of pointer to literal type. */
5462 /* This test would be redundant, as it follows from the
5463 postfix-expression being a potential constant expression. */
5464 if (type_unknown_p (t
))
5466 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5468 case EXPR_PACK_EXPANSION
:
5469 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5473 tree x
= TREE_OPERAND (t
, 0);
5475 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5477 if (!var_in_maybe_constexpr_fn (x
))
5479 if (flags
& tf_error
)
5480 error_at (loc
, "use of %<this%> in a constant expression");
5485 return RECUR (x
, rval
);
5488 case STATEMENT_LIST
:
5490 tree_stmt_iterator i
;
5491 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5493 if (!RECUR (tsi_stmt (i
), any
))
5501 if (cxx_dialect
< cxx14
)
5503 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5505 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5510 if (cxx_dialect
< cxx14
)
5512 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5514 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5519 if (!RECUR (DO_COND (t
), rval
))
5521 if (!RECUR (DO_BODY (t
), any
))
5526 if (!RECUR (FOR_INIT_STMT (t
), any
))
5528 if (!RECUR (FOR_COND (t
), rval
))
5530 if (!RECUR (FOR_EXPR (t
), any
))
5532 if (!RECUR (FOR_BODY (t
), any
))
5536 case RANGE_FOR_STMT
:
5537 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5539 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5544 if (!RECUR (WHILE_COND (t
), rval
))
5546 if (!RECUR (WHILE_BODY (t
), any
))
5551 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5553 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5554 unreachable labels would be checked. */
5558 return RECUR (STMT_EXPR_STMT (t
), rval
);
5561 if (cxx_dialect
>= cxx17
)
5562 /* In C++17 lambdas can be constexpr, don't give up yet. */
5564 else if (flags
& tf_error
)
5565 error_at (loc
, "lambda-expression is not a constant expression "
5569 case DYNAMIC_CAST_EXPR
:
5570 case PSEUDO_DTOR_EXPR
:
5574 case VEC_DELETE_EXPR
:
5579 case OMP_DISTRIBUTE
:
5582 case OMP_TARGET_DATA
:
5591 case OMP_TARGET_UPDATE
:
5592 case OMP_TARGET_ENTER_DATA
:
5593 case OMP_TARGET_EXIT_DATA
:
5595 case OMP_ATOMIC_READ
:
5596 case OMP_ATOMIC_CAPTURE_OLD
:
5597 case OMP_ATOMIC_CAPTURE_NEW
:
5601 case OACC_HOST_DATA
:
5605 case OACC_ENTER_DATA
:
5606 case OACC_EXIT_DATA
:
5608 /* GCC internal stuff. */
5611 case TRANSACTION_EXPR
:
5613 case AT_ENCODE_EXPR
:
5615 if (flags
& tf_error
)
5616 error_at (loc
, "expression %qE is not a constant expression", t
);
5620 /* -- a typeid expression whose operand is of polymorphic
5623 tree e
= TREE_OPERAND (t
, 0);
5624 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5625 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5627 if (flags
& tf_error
)
5628 error_at (loc
, "typeid-expression is not a constant expression "
5629 "because %qE is of polymorphic type", e
);
5635 case POINTER_DIFF_EXPR
:
5649 case PREINCREMENT_EXPR
:
5650 case POSTINCREMENT_EXPR
:
5651 case PREDECREMENT_EXPR
:
5652 case POSTDECREMENT_EXPR
:
5653 if (cxx_dialect
< cxx14
)
5659 if (TYPE_P (TREE_OPERAND (t
, 0)))
5665 case FIX_TRUNC_EXPR
:
5669 case TRUTH_NOT_EXPR
:
5670 case FIXED_CONVERT_EXPR
:
5671 case UNARY_PLUS_EXPR
:
5672 case UNARY_LEFT_FOLD_EXPR
:
5673 case UNARY_RIGHT_FOLD_EXPR
:
5675 return RECUR (TREE_OPERAND (t
, 0), rval
);
5678 case CONST_CAST_EXPR
:
5679 case STATIC_CAST_EXPR
:
5680 case REINTERPRET_CAST_EXPR
:
5681 case IMPLICIT_CONV_EXPR
:
5682 if (cxx_dialect
< cxx11
5683 && !dependent_type_p (TREE_TYPE (t
))
5684 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5685 /* In C++98, a conversion to non-integral type can't be part of a
5686 constant expression. */
5688 if (flags
& tf_error
)
5690 "cast to non-integral type %qT in a constant expression",
5695 return (RECUR (TREE_OPERAND (t
, 0),
5696 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5699 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5701 case CLEANUP_POINT_EXPR
:
5702 case MUST_NOT_THROW_EXPR
:
5703 case TRY_CATCH_EXPR
:
5708 case NON_DEPENDENT_EXPR
:
5709 /* For convenience. */
5713 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5716 tmp
= DECL_EXPR_DECL (t
);
5717 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5719 if (TREE_STATIC (tmp
))
5721 if (flags
& tf_error
)
5722 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5723 "%<static%> in %<constexpr%> context", tmp
);
5726 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5728 if (flags
& tf_error
)
5729 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5730 "%<thread_local%> in %<constexpr%> context", tmp
);
5733 else if (!check_for_uninitialized_const_var
5734 (tmp
, /*constexpr_context_p=*/true, flags
))
5737 return RECUR (tmp
, want_rval
);
5739 case TRY_FINALLY_EXPR
:
5740 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5741 && RECUR (TREE_OPERAND (t
, 1), any
));
5744 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5747 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
5748 && !literal_type_p (TREE_TYPE (t
)))
5750 if (flags
& tf_error
)
5752 error_at (loc
, "temporary of non-literal type %qT in a "
5753 "constant expression", TREE_TYPE (t
));
5754 explain_non_literal_class (TREE_TYPE (t
));
5760 return RECUR (TREE_OPERAND (t
, 1), rval
);
5764 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5765 constructor_elt
*ce
;
5766 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5767 if (!RECUR (ce
->value
, want_rval
))
5774 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5775 || DECL_P (TREE_PURPOSE (t
)));
5776 if (!RECUR (TREE_VALUE (t
), want_rval
))
5778 if (TREE_CHAIN (t
) == NULL_TREE
)
5780 return RECUR (TREE_CHAIN (t
), want_rval
);
5783 case TRUNC_DIV_EXPR
:
5785 case FLOOR_DIV_EXPR
:
5786 case ROUND_DIV_EXPR
:
5787 case TRUNC_MOD_EXPR
:
5789 case ROUND_MOD_EXPR
:
5791 tree denom
= TREE_OPERAND (t
, 1);
5792 if (!RECUR (denom
, rval
))
5794 /* We can't call cxx_eval_outermost_constant_expr on an expression
5795 that hasn't been through instantiate_non_dependent_expr yet. */
5796 if (!processing_template_decl
)
5797 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5798 if (integer_zerop (denom
))
5800 if (flags
& tf_error
)
5801 error ("division by zero is not a constant expression");
5807 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5813 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5814 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5815 introduced by build_call_a. */
5816 tree op0
= TREE_OPERAND (t
, 0);
5817 tree op1
= TREE_OPERAND (t
, 1);
5819 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5820 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5821 return RECUR (op0
, want_rval
);
5826 /* If the first operand is the non-short-circuit constant, look at
5827 the second operand; otherwise we only care about the first one for
5829 case TRUTH_AND_EXPR
:
5830 case TRUTH_ANDIF_EXPR
:
5831 tmp
= boolean_true_node
;
5834 case TRUTH_ORIF_EXPR
:
5835 tmp
= boolean_false_node
;
5838 tree op
= TREE_OPERAND (t
, 0);
5839 if (!RECUR (op
, rval
))
5841 if (!processing_template_decl
)
5842 op
= cxx_eval_outermost_constant_expr (op
, true);
5843 if (tree_int_cst_equal (op
, tmp
))
5844 return RECUR (TREE_OPERAND (t
, 1), rval
);
5851 case POINTER_PLUS_EXPR
:
5853 case EXACT_DIV_EXPR
:
5863 case TRUTH_XOR_EXPR
:
5864 case UNORDERED_EXPR
:
5877 case ARRAY_RANGE_REF
:
5881 case BINARY_LEFT_FOLD_EXPR
:
5882 case BINARY_RIGHT_FOLD_EXPR
:
5884 for (i
= 0; i
< 2; ++i
)
5885 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5891 for (i
= 0; i
< 3; ++i
)
5892 if (!RECUR (TREE_OPERAND (t
, i
), true))
5897 if (COND_EXPR_IS_VEC_DELETE (t
))
5899 if (flags
& tf_error
)
5900 error_at (loc
, "%<delete[]%> is not a constant expression");
5906 /* If the condition is a known constant, we know which of the legs we
5907 care about; otherwise we only require that the condition and
5908 either of the legs be potentially constant. */
5909 tmp
= TREE_OPERAND (t
, 0);
5910 if (!RECUR (tmp
, rval
))
5912 if (!processing_template_decl
)
5913 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5914 if (integer_zerop (tmp
))
5915 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5916 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5917 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5918 for (i
= 1; i
< 3; ++i
)
5919 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5920 want_rval
, strict
, now
, tf_none
))
5922 if (flags
& tf_error
)
5923 error_at (loc
, "expression %qE is not a constant expression", t
);
5927 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5929 if (flags
& tf_error
)
5931 error_at (loc
, "non-constant array initialization");
5932 diagnose_non_constexpr_vec_init (t
);
5938 /* We can see these in statement-expressions. */
5942 case EMPTY_CLASS_EXPR
:
5948 tree
*target
= &TREE_OPERAND (t
, 0);
5949 /* Gotos representing break and continue are OK. */
5950 if (breaks (target
) || continues (target
))
5952 if (flags
& tf_error
)
5953 error_at (loc
, "%<goto%> is not a constant expression");
5958 return RECUR (TREE_OPERAND (t
, 0), rval
);
5961 if (objc_is_property_ref (t
))
5964 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5971 /* The main entry point to the above. */
5974 potential_constant_expression (tree t
)
5976 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
5979 /* As above, but require a constant rvalue. */
5982 potential_rvalue_constant_expression (tree t
)
5984 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
5987 /* Like above, but complain about non-constant expressions. */
5990 require_potential_constant_expression (tree t
)
5992 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
5995 /* Cross product of the above. */
5998 require_potential_rvalue_constant_expression (tree t
)
6000 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
6003 /* Like potential_constant_expression, but don't consider possible constexpr
6004 substitution of the current function. That is, PARM_DECL qualifies under
6005 potential_constant_expression, but not here.
6007 This is basically what you can check when any actual constant values might
6008 be value-dependent. */
6011 is_constant_expression (tree t
)
6013 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6016 /* Like above, but complain about non-constant expressions. */
6019 require_constant_expression (tree t
)
6021 return potential_constant_expression_1 (t
, false, true, true,
6022 tf_warning_or_error
);
6025 /* Like is_constant_expression, but allow const variables that are not allowed
6026 under constexpr rules. */
6029 is_static_init_expression (tree t
)
6031 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6034 /* Returns true if T is a potential constant expression that is not
6035 instantiation-dependent, and therefore a candidate for constant folding even
6039 is_nondependent_constant_expression (tree t
)
6041 return (!type_unknown_p (t
)
6042 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6043 && is_constant_expression (t
)
6044 && !instantiation_dependent_expression_p (t
));
6047 /* Returns true if T is a potential static initializer expression that is not
6048 instantiation-dependent. */
6051 is_nondependent_static_init_expression (tree t
)
6053 return (!type_unknown_p (t
)
6054 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6055 && is_static_init_expression (t
)
6056 && !instantiation_dependent_expression_p (t
));
6059 /* Finalize constexpr processing after parsing. */
6062 fini_constexpr (void)
6064 /* The contexpr call and fundef copies tables are no longer needed. */
6065 constexpr_call_table
= NULL
;
6066 fundef_copies_table
= NULL
;
6069 #include "gt-cp-constexpr.h"