1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2018 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
34 #include "gimple-fold.h"
37 static bool verify_constant (tree
, bool, bool *, bool *);
38 #define VERIFY_CONSTANT(X) \
40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
44 /* Returns true iff FUN is an instantiation of a constexpr function
45 template or a defaulted constexpr function. */
48 is_instantiation_of_constexpr (tree fun
)
50 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
52 || (DECL_DEFAULTED_FN (fun
)
53 && DECL_DECLARED_CONSTEXPR_P (fun
)));
56 /* Return true if T is a literal type. */
59 literal_type_p (tree t
)
63 || TREE_CODE (t
) == REFERENCE_TYPE
64 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
68 t
= complete_type (t
);
69 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
70 return CLASSTYPE_LITERAL_P (t
);
72 if (TREE_CODE (t
) == ARRAY_TYPE
)
73 return literal_type_p (strip_array_types (t
));
77 /* If DECL is a variable declared `constexpr', require its type
78 be literal. Return error_mark_node if we give an error, the
82 ensure_literal_type_for_constexpr_object (tree decl
)
84 tree type
= TREE_TYPE (decl
);
86 && (DECL_DECLARED_CONSTEXPR_P (decl
)
87 || var_in_constexpr_fn (decl
))
88 && !processing_template_decl
)
90 tree stype
= strip_array_types (type
);
91 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
92 /* Don't complain here, we'll complain about incompleteness
93 when we try to initialize the variable. */;
94 else if (!literal_type_p (type
))
96 if (DECL_DECLARED_CONSTEXPR_P (decl
))
98 error ("the type %qT of %<constexpr%> variable %qD "
99 "is not literal", type
, decl
);
100 explain_non_literal_class (type
);
101 decl
= error_mark_node
;
105 if (!is_instantiation_of_constexpr (current_function_decl
))
107 error ("variable %qD of non-literal type %qT in %<constexpr%> "
108 "function", decl
, type
);
109 explain_non_literal_class (type
);
110 decl
= error_mark_node
;
112 cp_function_chain
->invalid_constexpr
= true;
119 /* Representation of entries in the constexpr function definition table. */
121 struct GTY((for_user
)) constexpr_fundef
{
126 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
128 static hashval_t
hash (constexpr_fundef
*);
129 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
132 /* This table holds all constexpr function definitions seen in
133 the current translation unit. */
135 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
137 /* Utility function used for managing the constexpr function table.
138 Return true if the entries pointed to by P and Q are for the
139 same constexpr function. */
142 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
144 return lhs
->decl
== rhs
->decl
;
147 /* Utility function used for managing the constexpr function table.
148 Return a hash value for the entry pointed to by Q. */
151 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
153 return DECL_UID (fundef
->decl
);
156 /* Return a previously saved definition of function FUN. */
158 static constexpr_fundef
*
159 retrieve_constexpr_fundef (tree fun
)
161 constexpr_fundef fundef
= { NULL
, NULL
};
162 if (constexpr_fundef_table
== NULL
)
166 return constexpr_fundef_table
->find (&fundef
);
169 /* Check whether the parameter and return types of FUN are valid for a
170 constexpr function, and complain if COMPLAIN. */
173 is_valid_constexpr_fn (tree fun
, bool complain
)
177 if (DECL_INHERITED_CTOR (fun
)
178 && TREE_CODE (fun
) == TEMPLATE_DECL
)
182 error ("inherited constructor %qD is not %<constexpr%>",
183 DECL_INHERITED_CTOR (fun
));
187 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
188 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
189 if (!literal_type_p (TREE_TYPE (parm
)))
194 error ("invalid type for parameter %d of %<constexpr%> "
195 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
196 explain_non_literal_class (TREE_TYPE (parm
));
201 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
205 inform (DECL_SOURCE_LOCATION (fun
),
206 "lambdas are implicitly %<constexpr%> only in C++17 and later");
208 else if (!DECL_CONSTRUCTOR_P (fun
))
210 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
211 if (!literal_type_p (rettype
))
216 error ("invalid return type %qT of %<constexpr%> function %q+D",
218 explain_non_literal_class (rettype
);
222 /* C++14 DR 1684 removed this restriction. */
223 if (cxx_dialect
< cxx14
224 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
225 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
229 && pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
230 "enclosing class of %<constexpr%> non-static member "
231 "function %q+#D is not a literal type", fun
))
232 explain_non_literal_class (DECL_CONTEXT (fun
));
235 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
239 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
245 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
246 for a member of an anonymous aggregate, INIT is the initializer for that
247 member, and VEC_OUTER is the vector of constructor elements for the class
248 whose constructor we are processing. Add the initializer to the vector
249 and return true to indicate success. */
252 build_anon_member_initialization (tree member
, tree init
,
253 vec
<constructor_elt
, va_gc
> **vec_outer
)
255 /* MEMBER presents the relevant fields from the inside out, but we need
256 to build up the initializer from the outside in so that we can reuse
257 previously built CONSTRUCTORs if this is, say, the second field in an
258 anonymous struct. So we use a vec as a stack. */
259 auto_vec
<tree
, 2> fields
;
262 fields
.safe_push (TREE_OPERAND (member
, 1));
263 member
= TREE_OPERAND (member
, 0);
265 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
266 && TREE_CODE (member
) == COMPONENT_REF
);
268 /* VEC has the constructor elements vector for the context of FIELD.
269 If FIELD is an anonymous aggregate, we will push inside it. */
270 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
272 while (field
= fields
.pop(),
273 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
276 /* If there is already an outer constructor entry for the anonymous
277 aggregate FIELD, use it; otherwise, insert one. */
278 if (vec_safe_is_empty (*vec
)
279 || (*vec
)->last().index
!= field
)
281 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
282 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
285 ctor
= (*vec
)->last().value
;
286 vec
= &CONSTRUCTOR_ELTS (ctor
);
289 /* Now we're at the innermost field, the one that isn't an anonymous
290 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
291 gcc_assert (fields
.is_empty());
292 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
297 /* Subroutine of build_constexpr_constructor_member_initializers.
298 The expression tree T represents a data member initialization
299 in a (constexpr) constructor definition. Build a pairing of
300 the data member with its initializer, and prepend that pair
301 to the existing initialization pair INITS. */
304 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
307 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
308 t
= TREE_OPERAND (t
, 0);
309 if (TREE_CODE (t
) == EXPR_STMT
)
310 t
= TREE_OPERAND (t
, 0);
311 if (t
== error_mark_node
)
313 if (TREE_CODE (t
) == STATEMENT_LIST
)
315 tree_stmt_iterator i
;
316 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
318 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
323 if (TREE_CODE (t
) == CLEANUP_STMT
)
325 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
326 but we can in a constexpr constructor for a non-literal class. Just
327 ignore it; either all the initialization will be constant, in which
328 case the cleanup can't run, or it can't be constexpr.
329 Still recurse into CLEANUP_BODY. */
330 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
332 if (TREE_CODE (t
) == CONVERT_EXPR
)
333 t
= TREE_OPERAND (t
, 0);
334 if (TREE_CODE (t
) == INIT_EXPR
335 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
336 use what this function builds for cx_check_missing_mem_inits, and
337 assignment in the ctor body doesn't count. */
338 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
340 member
= TREE_OPERAND (t
, 0);
341 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
343 else if (TREE_CODE (t
) == CALL_EXPR
)
345 tree fn
= get_callee_fndecl (t
);
346 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
347 /* We're only interested in calls to subobject constructors. */
349 member
= CALL_EXPR_ARG (t
, 0);
350 /* We don't use build_cplus_new here because it complains about
351 abstract bases. Leaving the call unwrapped means that it has the
352 wrong type, but cxx_eval_constant_expression doesn't care. */
353 init
= break_out_target_exprs (t
);
355 else if (TREE_CODE (t
) == BIND_EXPR
)
356 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
358 /* Don't add anything else to the CONSTRUCTOR. */
360 if (INDIRECT_REF_P (member
))
361 member
= TREE_OPERAND (member
, 0);
362 if (TREE_CODE (member
) == NOP_EXPR
)
366 if (TREE_CODE (op
) == ADDR_EXPR
)
368 gcc_assert (same_type_ignoring_top_level_qualifiers_p
369 (TREE_TYPE (TREE_TYPE (op
)),
370 TREE_TYPE (TREE_TYPE (member
))));
371 /* Initializing a cv-qualified member; we need to look through
375 else if (op
== current_class_ptr
376 && (same_type_ignoring_top_level_qualifiers_p
377 (TREE_TYPE (TREE_TYPE (member
)),
378 current_class_type
)))
379 /* Delegating constructor. */
383 /* This is an initializer for an empty base; keep it for now so
384 we can check it in cxx_eval_bare_aggregate. */
385 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
388 if (TREE_CODE (member
) == ADDR_EXPR
)
389 member
= TREE_OPERAND (member
, 0);
390 if (TREE_CODE (member
) == COMPONENT_REF
)
392 tree aggr
= TREE_OPERAND (member
, 0);
393 if (TREE_CODE (aggr
) == VAR_DECL
)
394 /* Initializing a local variable, don't add anything. */
396 if (TREE_CODE (aggr
) != COMPONENT_REF
)
397 /* Normal member initialization. */
398 member
= TREE_OPERAND (member
, 1);
399 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
400 /* Initializing a member of an anonymous union. */
401 return build_anon_member_initialization (member
, init
, vec
);
403 /* We're initializing a vtable pointer in a base. Leave it as
404 COMPONENT_REF so we remember the path to get to the vfield. */
405 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
408 /* Value-initialization can produce multiple initializers for the
409 same field; use the last one. */
410 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
411 (*vec
)->last().value
= init
;
413 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
417 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
418 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
419 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
422 check_constexpr_bind_expr_vars (tree t
)
424 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
426 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
427 if (TREE_CODE (var
) == TYPE_DECL
428 && DECL_IMPLICIT_TYPEDEF_P (var
)
429 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
434 /* Subroutine of check_constexpr_ctor_body. */
437 check_constexpr_ctor_body_1 (tree last
, tree list
)
439 switch (TREE_CODE (list
))
442 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
443 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
447 case CLEANUP_POINT_EXPR
:
448 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
452 if (!check_constexpr_bind_expr_vars (list
)
453 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
460 case DEBUG_BEGIN_STMT
:
468 /* Make sure that there are no statements after LAST in the constructor
469 body represented by LIST. */
472 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
474 /* C++14 doesn't require a constexpr ctor to have an empty body. */
475 if (cxx_dialect
>= cxx14
)
479 if (TREE_CODE (list
) == STATEMENT_LIST
)
481 tree_stmt_iterator i
= tsi_last (list
);
482 for (; !tsi_end_p (i
); tsi_prev (&i
))
484 tree t
= tsi_stmt (i
);
487 if (!check_constexpr_ctor_body_1 (last
, t
))
494 else if (list
!= last
495 && !check_constexpr_ctor_body_1 (last
, list
))
500 error ("%<constexpr%> constructor does not have empty body");
501 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
506 /* V is a vector of constructor elements built up for the base and member
507 initializers of a constructor for TYPE. They need to be in increasing
508 offset order, which they might not be yet if TYPE has a primary base
509 which is not first in the base-clause or a vptr and at least one base
510 all of which are non-primary. */
512 static vec
<constructor_elt
, va_gc
> *
513 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
515 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
521 field_type
= BINFO_TYPE (pri
);
522 else if (TYPE_CONTAINS_VPTR_P (type
))
523 field_type
= vtbl_ptr_type_node
;
527 /* Find the element for the primary base or vptr and move it to the
528 beginning of the vec. */
529 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
530 if (TREE_TYPE (ce
->index
) == field_type
)
533 if (i
> 0 && i
< vec_safe_length (v
))
535 vec
<constructor_elt
, va_gc
> &vref
= *v
;
536 constructor_elt elt
= vref
[i
];
545 /* Build compile-time evalable representations of member-initializer list
546 for a constexpr constructor. */
549 build_constexpr_constructor_member_initializers (tree type
, tree body
)
551 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
554 switch (TREE_CODE (body
))
556 case MUST_NOT_THROW_EXPR
:
558 body
= TREE_OPERAND (body
, 0);
562 for (tree_stmt_iterator i
= tsi_start (body
);
563 !tsi_end_p (i
); tsi_next (&i
))
566 if (TREE_CODE (body
) == BIND_EXPR
)
572 body
= BIND_EXPR_BODY (body
);
579 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
581 body
= TREE_OPERAND (body
, 0);
582 if (TREE_CODE (body
) == EXPR_STMT
)
583 body
= TREE_OPERAND (body
, 0);
584 if (TREE_CODE (body
) == INIT_EXPR
585 && (same_type_ignoring_top_level_qualifiers_p
586 (TREE_TYPE (TREE_OPERAND (body
, 0)),
587 current_class_type
)))
590 return TREE_OPERAND (body
, 1);
592 ok
= build_data_member_initialization (body
, &vec
);
594 else if (TREE_CODE (body
) == STATEMENT_LIST
)
596 tree_stmt_iterator i
;
597 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
599 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
604 else if (TREE_CODE (body
) == TRY_BLOCK
)
606 error ("body of %<constexpr%> constructor cannot be "
607 "a function-try-block");
608 return error_mark_node
;
610 else if (EXPR_P (body
))
611 ok
= build_data_member_initialization (body
, &vec
);
613 gcc_assert (errorcount
> 0);
616 if (vec_safe_length (vec
) > 0)
618 /* In a delegating constructor, return the target. */
619 constructor_elt
*ce
= &(*vec
)[0];
620 if (ce
->index
== current_class_ptr
)
627 vec
= sort_constexpr_mem_initializers (type
, vec
);
628 return build_constructor (type
, vec
);
631 return error_mark_node
;
634 /* We have an expression tree T that represents a call, either CALL_EXPR
635 or AGGR_INIT_EXPR. If the call is lexically to a named function,
636 retrun the _DECL for that function. */
639 get_function_named_in_call (tree t
)
641 tree fun
= cp_get_callee (t
);
642 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
643 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
644 fun
= TREE_OPERAND (fun
, 0);
648 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
649 declared to be constexpr, or a sub-statement thereof. Returns the
650 return value if suitable, error_mark_node for a statement not allowed in
651 a constexpr function, or NULL_TREE if no return value was found. */
654 constexpr_fn_retval (tree body
)
656 switch (TREE_CODE (body
))
660 tree_stmt_iterator i
;
661 tree expr
= NULL_TREE
;
662 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
664 tree s
= constexpr_fn_retval (tsi_stmt (i
));
665 if (s
== error_mark_node
)
666 return error_mark_node
;
667 else if (s
== NULL_TREE
)
668 /* Keep iterating. */;
670 /* Multiple return statements. */
671 return error_mark_node
;
679 return break_out_target_exprs (TREE_OPERAND (body
, 0));
683 tree decl
= DECL_EXPR_DECL (body
);
684 if (TREE_CODE (decl
) == USING_DECL
685 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
686 || DECL_ARTIFICIAL (decl
))
688 return error_mark_node
;
691 case CLEANUP_POINT_EXPR
:
692 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
695 if (!check_constexpr_bind_expr_vars (body
))
696 return error_mark_node
;
697 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
700 case DEBUG_BEGIN_STMT
:
705 tree fun
= get_function_named_in_call (body
);
707 && DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
)
713 return error_mark_node
;
717 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
718 FUN; do the necessary transformations to turn it into a single expression
719 that we can store in the hash table. */
722 massage_constexpr_body (tree fun
, tree body
)
724 if (DECL_CONSTRUCTOR_P (fun
))
725 body
= build_constexpr_constructor_member_initializers
726 (DECL_CONTEXT (fun
), body
);
727 else if (cxx_dialect
< cxx14
)
729 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
730 body
= EH_SPEC_STMTS (body
);
731 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
732 body
= TREE_OPERAND (body
, 0);
733 body
= constexpr_fn_retval (body
);
738 /* CTYPE is a type constructed from BODY. Return true if some
739 bases/fields are uninitialized, and complain if COMPLAIN. */
742 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
748 if (TREE_CODE (body
) != CONSTRUCTOR
)
750 nelts
= CONSTRUCTOR_NELTS (body
);
752 tree field
= TYPE_FIELDS (ctype
);
754 if (TREE_CODE (ctype
) == UNION_TYPE
)
756 if (nelts
== 0 && next_initializable_field (field
))
759 error ("%<constexpr%> constructor for union %qT must "
760 "initialize exactly one non-static data member", ctype
);
766 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
767 need an explicit initialization. */
769 for (unsigned i
= 0; i
<= nelts
; ++i
)
771 tree index
= NULL_TREE
;
774 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
775 /* Skip base and vtable inits. */
776 if (TREE_CODE (index
) != FIELD_DECL
777 || DECL_ARTIFICIAL (index
))
781 for (; field
!= index
; field
= DECL_CHAIN (field
))
784 if (TREE_CODE (field
) != FIELD_DECL
)
786 if (DECL_UNNAMED_BIT_FIELD (field
))
788 if (DECL_ARTIFICIAL (field
))
790 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
792 /* Recurse to check the anonummous aggregate member. */
793 bad
|= cx_check_missing_mem_inits
794 (TREE_TYPE (field
), NULL_TREE
, complain
);
795 if (bad
&& !complain
)
799 ftype
= strip_array_types (TREE_TYPE (field
));
800 if (type_has_constexpr_default_constructor (ftype
))
802 /* It's OK to skip a member with a trivial constexpr ctor.
803 A constexpr ctor that isn't trivial should have been
805 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
811 error ("member %qD must be initialized by mem-initializer "
812 "in %<constexpr%> constructor", field
);
813 inform (DECL_SOURCE_LOCATION (field
), "declared here");
816 if (field
== NULL_TREE
)
819 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
821 /* Check the anonymous aggregate initializer is valid. */
822 bad
|= cx_check_missing_mem_inits
823 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
824 if (bad
&& !complain
)
827 field
= DECL_CHAIN (field
);
833 /* We are processing the definition of the constexpr function FUN.
834 Check that its BODY fulfills the propriate requirements and
835 enter it in the constexpr function definition table.
836 For constructor BODY is actually the TREE_LIST of the
837 member-initializer list. */
840 register_constexpr_fundef (tree fun
, tree body
)
842 constexpr_fundef entry
;
843 constexpr_fundef
**slot
;
845 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
848 tree massaged
= massage_constexpr_body (fun
, body
);
849 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
851 if (!DECL_CONSTRUCTOR_P (fun
))
852 error ("body of %<constexpr%> function %qD not a return-statement",
857 if (!potential_rvalue_constant_expression (massaged
))
859 if (!DECL_GENERATED_P (fun
))
860 require_potential_rvalue_constant_expression (massaged
);
864 if (DECL_CONSTRUCTOR_P (fun
)
865 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
866 massaged
, !DECL_GENERATED_P (fun
)))
869 /* Create the constexpr function table if necessary. */
870 if (constexpr_fundef_table
== NULL
)
871 constexpr_fundef_table
872 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
876 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
878 gcc_assert (*slot
== NULL
);
879 *slot
= ggc_alloc
<constexpr_fundef
> ();
885 /* FUN is a non-constexpr function called in a context that requires a
886 constant expression. If it comes from a constexpr template, explain why
887 the instantiation isn't constexpr. */
890 explain_invalid_constexpr_fn (tree fun
)
892 static hash_set
<tree
> *diagnosed
;
895 /* Only diagnose defaulted functions, lambdas, or instantiations. */
896 if (!DECL_DEFAULTED_FN (fun
)
897 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
898 && !is_instantiation_of_constexpr (fun
))
900 if (diagnosed
== NULL
)
901 diagnosed
= new hash_set
<tree
>;
902 if (diagnosed
->add (fun
))
903 /* Already explained. */
906 save_loc
= input_location
;
907 if (!lambda_static_thunk_p (fun
))
909 /* Diagnostics should completely ignore the static thunk, so leave
910 input_location set to our caller's location. */
911 input_location
= DECL_SOURCE_LOCATION (fun
);
912 inform (input_location
,
913 "%qD is not usable as a %<constexpr%> function because:", fun
);
915 /* First check the declaration. */
916 if (is_valid_constexpr_fn (fun
, true))
918 /* Then if it's OK, the body. */
919 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
920 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
921 explain_implicit_non_constexpr (fun
);
924 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
925 require_potential_rvalue_constant_expression (body
);
926 if (DECL_CONSTRUCTOR_P (fun
))
927 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
930 input_location
= save_loc
;
933 /* Objects of this type represent calls to constexpr functions
934 along with the bindings of parameters to their arguments, for
935 the purpose of compile time evaluation. */
937 struct GTY((for_user
)) constexpr_call
{
938 /* Description of the constexpr function definition. */
939 constexpr_fundef
*fundef
;
940 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
941 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
942 Note: This arrangement is made to accommodate the use of
943 iterative_hash_template_arg (see pt.c). If you change this
944 representation, also change the hash calculation in
945 cxx_eval_call_expression. */
947 /* Result of the call.
948 NULL means the call is being evaluated.
949 error_mark_node means that the evaluation was erroneous;
950 otherwise, the actuall value of the call. */
952 /* The hash of this call; we remember it here to avoid having to
953 recalculate it when expanding the hash table. */
957 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
959 static hashval_t
hash (constexpr_call
*);
960 static bool equal (constexpr_call
*, constexpr_call
*);
963 enum constexpr_switch_state
{
964 /* Used when processing a switch for the first time by cxx_eval_switch_expr
965 and default: label for that switch has not been seen yet. */
966 css_default_not_seen
,
967 /* Used when processing a switch for the first time by cxx_eval_switch_expr
968 and default: label for that switch has been seen already. */
970 /* Used when processing a switch for the second time by
971 cxx_eval_switch_expr, where default: label should match. */
972 css_default_processing
975 /* The constexpr expansion context. CALL is the current function
976 expansion, CTOR is the current aggregate initializer, OBJECT is the
977 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
978 is a map of values of variables initialized within the expression. */
980 struct constexpr_ctx
{
981 /* The innermost call we're evaluating. */
982 constexpr_call
*call
;
983 /* Values for any temporaries or local variables within the
984 constant-expression. */
985 hash_map
<tree
,tree
> *values
;
986 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
987 aren't inside a loop. */
988 hash_set
<tree
> *save_exprs
;
989 /* The CONSTRUCTOR we're currently building up for an aggregate
992 /* The object we're building the CONSTRUCTOR for. */
994 /* If inside SWITCH_EXPR. */
995 constexpr_switch_state
*css_state
;
996 /* Whether we should error on a non-constant expression or fail quietly. */
998 /* Whether we are strictly conforming to constant expression rules or
999 trying harder to get a constant value. */
1003 /* A table of all constexpr calls that have been evaluated by the
1004 compiler in this translation unit. */
1006 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
1008 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
1009 bool, bool *, bool *, tree
* = NULL
);
1011 /* Compute a hash value for a constexpr call representation. */
1014 constexpr_call_hasher::hash (constexpr_call
*info
)
1019 /* Return true if the objects pointed to by P and Q represent calls
1020 to the same constexpr function with the same arguments.
1021 Otherwise, return false. */
1024 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1030 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1032 lhs_bindings
= lhs
->bindings
;
1033 rhs_bindings
= rhs
->bindings
;
1034 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1036 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1037 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1038 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1039 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1041 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1042 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1044 return lhs_bindings
== rhs_bindings
;
1047 /* Initialize the constexpr call table, if needed. */
1050 maybe_initialize_constexpr_call_table (void)
1052 if (constexpr_call_table
== NULL
)
1053 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1056 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1057 a function happens to get called recursively, we unshare the callee
1058 function's body and evaluate this unshared copy instead of evaluating the
1061 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1062 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1063 that's keyed off of the original FUNCTION_DECL and whose value is a
1064 TREE_LIST of this function's unused copies awaiting reuse.
1066 This is not GC-deletable to avoid GC affecting UID generation. */
1068 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1070 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1073 maybe_initialize_fundef_copies_table ()
1075 if (fundef_copies_table
== NULL
)
1076 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1079 /* Reuse a copy or create a new unshared copy of the function FUN.
1080 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1081 is parms, TYPE is result. */
1084 get_fundef_copy (tree fun
)
1086 maybe_initialize_fundef_copies_table ();
1090 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1094 /* There is no cached function available, or in use. We can use
1095 the function directly. That the slot is now created records
1096 that this function is now in use. */
1097 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1098 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1100 else if (*slot
== NULL_TREE
)
1102 /* We've already used the function itself, so make a copy. */
1103 copy
= build_tree_list (NULL
, NULL
);
1104 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1108 /* We have a cached function available. */
1110 *slot
= TREE_CHAIN (copy
);
1116 /* Save the copy COPY of function FUN for later reuse by
1117 get_fundef_copy(). By construction, there will always be an entry
1121 save_fundef_copy (tree fun
, tree copy
)
1123 tree
*slot
= fundef_copies_table
->get (fun
);
1124 TREE_CHAIN (copy
) = *slot
;
1128 /* We have an expression tree T that represents a call, either CALL_EXPR
1129 or AGGR_INIT_EXPR. Return the Nth argument. */
1132 get_nth_callarg (tree t
, int n
)
1134 switch (TREE_CODE (t
))
1137 return CALL_EXPR_ARG (t
, n
);
1139 case AGGR_INIT_EXPR
:
1140 return AGGR_INIT_EXPR_ARG (t
, n
);
1148 /* Attempt to evaluate T which represents a call to a builtin function.
1149 We assume here that all builtin functions evaluate to scalar types
1150 represented by _CST nodes. */
1153 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1155 bool *non_constant_p
, bool *overflow_p
)
1157 const int nargs
= call_expr_nargs (t
);
1158 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1162 /* Don't fold __builtin_constant_p within a constexpr function. */
1163 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1166 && current_function_decl
1167 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1169 *non_constant_p
= true;
1173 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1174 return constant false for a non-constant argument. */
1175 constexpr_ctx new_ctx
= *ctx
;
1176 new_ctx
.quiet
= true;
1177 bool dummy1
= false, dummy2
= false;
1178 for (i
= 0; i
< nargs
; ++i
)
1180 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1181 false, &dummy1
, &dummy2
);
1183 /* For __built_in_constant_p, fold all expressions with constant values
1184 even if they aren't C++ constant-expressions. */
1185 args
[i
] = cp_fully_fold (args
[i
]);
1188 bool save_ffbcp
= force_folding_builtin_constant_p
;
1189 force_folding_builtin_constant_p
= true;
1190 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1191 CALL_EXPR_FN (t
), nargs
, args
);
1192 force_folding_builtin_constant_p
= save_ffbcp
;
1193 if (new_call
== NULL
)
1195 if (!*non_constant_p
&& !ctx
->quiet
)
1197 /* Do not allow__builtin_unreachable in constexpr function.
1198 The __builtin_unreachable call with BUILTINS_LOCATION
1199 comes from cp_maybe_instrument_return. */
1200 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_UNREACHABLE
1201 && EXPR_LOCATION (t
) == BUILTINS_LOCATION
)
1202 error ("%<constexpr%> call flows off the end of the function");
1205 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1206 CALL_EXPR_FN (t
), nargs
, args
);
1207 error ("%q+E is not a constant expression", new_call
);
1210 *non_constant_p
= true;
1214 if (!is_constant_expression (new_call
))
1216 if (!*non_constant_p
&& !ctx
->quiet
)
1217 error ("%q+E is not a constant expression", new_call
);
1218 *non_constant_p
= true;
1222 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1223 non_constant_p
, overflow_p
);
1226 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1227 the type of the value to match. */
1230 adjust_temp_type (tree type
, tree temp
)
1232 if (TREE_TYPE (temp
) == type
)
1234 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1235 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1236 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1237 gcc_assert (scalarish_type_p (type
));
1238 return cp_fold_convert (type
, temp
);
1241 /* Callback for walk_tree used by unshare_constructor. */
1244 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1248 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1253 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1254 subexpression, return an unshared copy of T. Otherwise return T. */
1257 unshare_constructor (tree t
)
1259 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1260 if (ctor
!= NULL_TREE
)
1261 return unshare_expr (t
);
1265 /* Subroutine of cxx_eval_call_expression.
1266 We are processing a call expression (either CALL_EXPR or
1267 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1268 all arguments and bind their values to correspondings
1269 parameters, making up the NEW_CALL context. */
1272 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1273 constexpr_call
*new_call
,
1274 bool *non_constant_p
, bool *overflow_p
,
1275 bool *non_constant_args
)
1277 const int nargs
= call_expr_nargs (t
);
1278 tree fun
= new_call
->fundef
->decl
;
1279 tree parms
= DECL_ARGUMENTS (fun
);
1281 tree
*p
= &new_call
->bindings
;
1282 for (i
= 0; i
< nargs
; ++i
)
1285 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1286 x
= get_nth_callarg (t
, i
);
1287 /* For member function, the first argument is a pointer to the implied
1288 object. For a constructor, it might still be a dummy object, in
1289 which case we get the real argument from ctx. */
1290 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1291 && is_dummy_object (x
))
1294 x
= build_address (x
);
1296 arg
= cxx_eval_constant_expression (ctx
, x
, /*lval=*/false,
1297 non_constant_p
, overflow_p
);
1298 /* Don't VERIFY_CONSTANT here. */
1299 if (*non_constant_p
&& ctx
->quiet
)
1301 /* Just discard ellipsis args after checking their constantitude. */
1305 if (!*non_constant_p
)
1307 /* Make sure the binding has the same type as the parm. But
1308 only for constant args. */
1309 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1310 arg
= adjust_temp_type (type
, arg
);
1311 if (!TREE_CONSTANT (arg
))
1312 *non_constant_args
= true;
1313 *p
= build_tree_list (parms
, arg
);
1314 p
= &TREE_CHAIN (*p
);
1316 parms
= TREE_CHAIN (parms
);
1320 /* Variables and functions to manage constexpr call expansion context.
1321 These do not need to be marked for PCH or GC. */
1323 /* FIXME remember and print actual constant arguments. */
1324 static vec
<tree
> call_stack
;
1325 static int call_stack_tick
;
1326 static int last_cx_error_tick
;
1329 push_cx_call_context (tree call
)
1332 if (!EXPR_HAS_LOCATION (call
))
1333 SET_EXPR_LOCATION (call
, input_location
);
1334 call_stack
.safe_push (call
);
1335 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1341 pop_cx_call_context (void)
1348 cx_error_context (void)
1350 vec
<tree
> r
= vNULL
;
1351 if (call_stack_tick
!= last_cx_error_tick
1352 && !call_stack
.is_empty ())
1354 last_cx_error_tick
= call_stack_tick
;
1358 /* Evaluate a call T to a GCC internal function when possible and return
1359 the evaluated result or, under the control of CTX, give an error, set
1360 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1363 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1365 bool *non_constant_p
, bool *overflow_p
)
1367 enum tree_code opcode
= ERROR_MARK
;
1369 switch (CALL_EXPR_IFN (t
))
1371 case IFN_UBSAN_NULL
:
1372 case IFN_UBSAN_BOUNDS
:
1373 case IFN_UBSAN_VPTR
:
1374 case IFN_FALLTHROUGH
:
1377 case IFN_ADD_OVERFLOW
:
1380 case IFN_SUB_OVERFLOW
:
1381 opcode
= MINUS_EXPR
;
1383 case IFN_MUL_OVERFLOW
:
1388 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1389 false, non_constant_p
, overflow_p
);
1393 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1394 "call to internal function %qE", t
);
1395 *non_constant_p
= true;
1399 /* Evaluate constant arguments using OPCODE and return a complex
1400 number containing the result and the overflow bit. */
1401 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1402 non_constant_p
, overflow_p
);
1403 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1404 non_constant_p
, overflow_p
);
1406 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1408 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1409 tree type
= TREE_TYPE (TREE_TYPE (t
));
1410 tree result
= fold_binary_loc (loc
, opcode
, type
,
1411 fold_convert_loc (loc
, type
, arg0
),
1412 fold_convert_loc (loc
, type
, arg1
));
1414 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1415 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1416 if (TREE_OVERFLOW (result
))
1417 TREE_OVERFLOW (result
) = 0;
1419 return build_complex (TREE_TYPE (t
), result
, ovf
);
1422 *non_constant_p
= true;
1426 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1429 clear_no_implicit_zero (tree ctor
)
1431 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1433 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1434 tree elt
; unsigned HOST_WIDE_INT idx
;
1435 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1436 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1437 clear_no_implicit_zero (elt
);
1441 /* Subroutine of cxx_eval_constant_expression.
1442 Evaluate the call expression tree T in the context of OLD_CALL expression
1446 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1448 bool *non_constant_p
, bool *overflow_p
)
1450 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1451 tree fun
= get_function_named_in_call (t
);
1452 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1455 if (fun
== NULL_TREE
)
1456 return cxx_eval_internal_function (ctx
, t
, lval
,
1457 non_constant_p
, overflow_p
);
1459 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1461 /* Might be a constexpr function pointer. */
1462 fun
= cxx_eval_constant_expression (ctx
, fun
,
1463 /*lval*/false, non_constant_p
,
1466 if (TREE_CODE (fun
) == ADDR_EXPR
)
1467 fun
= TREE_OPERAND (fun
, 0);
1469 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1471 if (!ctx
->quiet
&& !*non_constant_p
)
1472 error_at (loc
, "expression %qE does not designate a %<constexpr%> "
1474 *non_constant_p
= true;
1477 if (DECL_CLONED_FUNCTION_P (fun
))
1478 fun
= DECL_CLONED_FUNCTION (fun
);
1480 if (is_ubsan_builtin_p (fun
))
1483 if (is_builtin_fn (fun
))
1484 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1485 lval
, non_constant_p
, overflow_p
);
1486 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1490 if (!lambda_static_thunk_p (fun
))
1491 error_at (loc
, "call to non-%<constexpr%> function %qD", fun
);
1492 explain_invalid_constexpr_fn (fun
);
1494 *non_constant_p
= true;
1498 constexpr_ctx new_ctx
= *ctx
;
1499 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1500 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1502 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1503 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1504 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1505 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1506 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1507 ctx
->values
->put (new_ctx
.object
, ctor
);
1511 /* Shortcut trivial constructor/op=. */
1512 if (trivial_fn_p (fun
))
1514 tree init
= NULL_TREE
;
1515 if (call_expr_nargs (t
) == 2)
1516 init
= convert_from_reference (get_nth_callarg (t
, 1));
1517 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1518 && AGGR_INIT_ZERO_FIRST (t
))
1519 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1522 tree op
= get_nth_callarg (t
, 0);
1523 if (is_dummy_object (op
))
1526 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1527 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1528 new_ctx
.call
= &new_call
;
1529 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1530 non_constant_p
, overflow_p
);
1534 /* We can't defer instantiating the function any longer. */
1535 if (!DECL_INITIAL (fun
)
1536 && DECL_TEMPLOID_INSTANTIATION (fun
))
1538 location_t save_loc
= input_location
;
1539 input_location
= loc
;
1541 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1543 input_location
= save_loc
;
1546 /* If in direct recursive call, optimize definition search. */
1547 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1548 new_call
.fundef
= ctx
->call
->fundef
;
1551 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1552 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1553 || fun
== current_function_decl
)
1557 /* We need to check for current_function_decl here in case we're
1558 being called during cp_fold_function, because at that point
1559 DECL_INITIAL is set properly and we have a fundef but we
1560 haven't lowered invisirefs yet (c++/70344). */
1561 if (DECL_INITIAL (fun
) == error_mark_node
1562 || fun
== current_function_decl
)
1563 error_at (loc
, "%qD called in a constant expression before its "
1564 "definition is complete", fun
);
1565 else if (DECL_INITIAL (fun
))
1567 /* The definition of fun was somehow unsuitable. But pretend
1568 that lambda static thunks don't exist. */
1569 if (!lambda_static_thunk_p (fun
))
1570 error_at (loc
, "%qD called in a constant expression", fun
);
1571 explain_invalid_constexpr_fn (fun
);
1574 error_at (loc
, "%qD used before its definition", fun
);
1576 *non_constant_p
= true;
1581 bool non_constant_args
= false;
1582 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1583 non_constant_p
, overflow_p
, &non_constant_args
);
1584 if (*non_constant_p
)
1587 depth_ok
= push_cx_call_context (t
);
1589 tree result
= NULL_TREE
;
1591 constexpr_call
*entry
= NULL
;
1592 if (depth_ok
&& !non_constant_args
&& ctx
->strict
)
1594 new_call
.hash
= iterative_hash_template_arg
1595 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1597 /* If we have seen this call before, we are done. */
1598 maybe_initialize_constexpr_call_table ();
1599 constexpr_call
**slot
1600 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1604 /* We need to keep a pointer to the entry, not just the slot, as the
1605 slot can move in the call to cxx_eval_builtin_function_call. */
1606 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1609 /* Calls that are in progress have their result set to NULL,
1610 so that we can detect circular dependencies. */
1611 else if (entry
->result
== NULL
)
1614 error ("call has circular dependency");
1615 *non_constant_p
= true;
1616 entry
->result
= result
= error_mark_node
;
1619 result
= entry
->result
;
1625 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1626 "-fconstexpr-depth= to increase the maximum)",
1627 max_constexpr_depth
);
1628 *non_constant_p
= true;
1629 result
= error_mark_node
;
1633 if (result
&& result
!= error_mark_node
)
1635 else if (!DECL_SAVED_TREE (fun
))
1637 /* When at_eof >= 2, cgraph has started throwing away
1638 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1639 late code generation for VEC_INIT_EXPR, which needs to be
1640 completely reconsidered. */
1641 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1642 *non_constant_p
= true;
1646 tree body
, parms
, res
;
1648 /* Reuse or create a new unshared copy of this function's body. */
1649 tree copy
= get_fundef_copy (fun
);
1650 body
= TREE_PURPOSE (copy
);
1651 parms
= TREE_VALUE (copy
);
1652 res
= TREE_TYPE (copy
);
1654 /* Associate the bindings with the remapped parms. */
1655 tree bound
= new_call
.bindings
;
1656 tree remapped
= parms
;
1659 tree oparm
= TREE_PURPOSE (bound
);
1660 tree arg
= TREE_VALUE (bound
);
1661 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1662 /* Don't share a CONSTRUCTOR that might be changed. */
1663 arg
= unshare_constructor (arg
);
1664 ctx
->values
->put (remapped
, arg
);
1665 bound
= TREE_CHAIN (bound
);
1666 remapped
= DECL_CHAIN (remapped
);
1668 /* Add the RESULT_DECL to the values map, too. */
1669 tree slot
= NULL_TREE
;
1670 if (DECL_BY_REFERENCE (res
))
1672 slot
= AGGR_INIT_EXPR_SLOT (t
);
1673 tree addr
= build_address (slot
);
1674 addr
= build_nop (TREE_TYPE (res
), addr
);
1675 ctx
->values
->put (res
, addr
);
1676 ctx
->values
->put (slot
, NULL_TREE
);
1679 ctx
->values
->put (res
, NULL_TREE
);
1681 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1682 their values after the call. */
1683 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1684 hash_set
<tree
> save_exprs
;
1685 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1686 ctx_with_save_exprs
.call
= &new_call
;
1688 tree jump_target
= NULL_TREE
;
1689 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1690 lval
, non_constant_p
, overflow_p
,
1693 if (DECL_CONSTRUCTOR_P (fun
))
1694 /* This can be null for a subobject constructor call, in
1695 which case what we care about is the initialization
1696 side-effects rather than the value. We could get at the
1697 value by evaluating *this, but we don't bother; there's
1698 no need to put such a call in the hash table. */
1699 result
= lval
? ctx
->object
: ctx
->ctor
;
1700 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1704 result
= *ctx
->values
->get (slot
? slot
: res
);
1705 if (result
== NULL_TREE
&& !*non_constant_p
)
1708 error ("%<constexpr%> call flows off the end "
1710 *non_constant_p
= true;
1714 /* Forget the saved values of the callee's SAVE_EXPRs. */
1715 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1716 iter
!= save_exprs
.end(); ++iter
)
1717 ctx_with_save_exprs
.values
->remove (*iter
);
1719 /* Remove the parms/result from the values map. Is it worth
1720 bothering to do this when the map itself is only live for
1721 one constexpr evaluation? If so, maybe also clear out
1722 other vars from call, maybe in BIND_EXPR handling? */
1723 ctx
->values
->remove (res
);
1725 ctx
->values
->remove (slot
);
1726 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1727 ctx
->values
->remove (parm
);
1729 /* Make the unshared function copy we used available for re-use. */
1730 save_fundef_copy (fun
, copy
);
1733 if (result
== error_mark_node
)
1734 *non_constant_p
= true;
1735 if (*non_constant_p
|| *overflow_p
)
1736 result
= error_mark_node
;
1740 entry
->result
= result
;
1743 /* The result of a constexpr function must be completely initialized. */
1744 if (TREE_CODE (result
) == CONSTRUCTOR
)
1745 clear_no_implicit_zero (result
);
1747 pop_cx_call_context ();
1748 return unshare_constructor (result
);
1751 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1754 reduced_constant_expression_p (tree t
)
1756 switch (TREE_CODE (t
))
1759 /* Even if we can't lower this yet, it's constant. */
1763 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1764 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1765 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1767 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1768 /* An initialized vector would have a VECTOR_CST. */
1771 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1775 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1778 /* We're in the middle of initializing this element. */
1780 if (!reduced_constant_expression_p (val
))
1786 field
= next_initializable_field (DECL_CHAIN (field
));
1791 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1792 /* All the fields are initialized. */
1793 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1797 /* FIXME are we calling this too much? */
1798 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1802 /* Some expressions may have constant operands but are not constant
1803 themselves, such as 1/0. Call this function (or rather, the macro
1804 following it) to check for that condition.
1806 We only call this in places that require an arithmetic constant, not in
1807 places where we might have a non-constant expression that can be a
1808 component of a constant expression, such as the address of a constexpr
1809 variable that might be dereferenced later. */
1812 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1815 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1817 if (!allow_non_constant
)
1818 error ("%q+E is not a constant expression", t
);
1819 *non_constant_p
= true;
1821 if (TREE_OVERFLOW_P (t
))
1823 if (!allow_non_constant
)
1825 permerror (input_location
, "overflow in constant expression");
1826 /* If we're being permissive (and are in an enforcing
1827 context), ignore the overflow. */
1828 if (flag_permissive
)
1829 return *non_constant_p
;
1833 return *non_constant_p
;
1836 /* Check whether the shift operation with code CODE and type TYPE on LHS
1837 and RHS is undefined. If it is, give an error with an explanation,
1838 and return true; return false otherwise. */
1841 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1842 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1844 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1845 || TREE_CODE (lhs
) != INTEGER_CST
1846 || TREE_CODE (rhs
) != INTEGER_CST
)
1849 tree lhstype
= TREE_TYPE (lhs
);
1850 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1852 /* [expr.shift] The behavior is undefined if the right operand
1853 is negative, or greater than or equal to the length in bits
1854 of the promoted left operand. */
1855 if (tree_int_cst_sgn (rhs
) == -1)
1858 permerror (loc
, "right operand of shift expression %q+E is negative",
1859 build2_loc (loc
, code
, type
, lhs
, rhs
));
1860 return (!flag_permissive
|| ctx
->quiet
);
1862 if (compare_tree_int (rhs
, uprec
) >= 0)
1865 permerror (loc
, "right operand of shift expression %q+E is >= than "
1866 "the precision of the left operand",
1867 build2_loc (loc
, code
, type
, lhs
, rhs
));
1868 return (!flag_permissive
|| ctx
->quiet
);
1871 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1872 if E1 has a signed type and non-negative value, and E1x2^E2 is
1873 representable in the corresponding unsigned type of the result type,
1874 then that value, converted to the result type, is the resulting value;
1875 otherwise, the behavior is undefined. */
1876 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1877 && (cxx_dialect
>= cxx11
))
1879 if (tree_int_cst_sgn (lhs
) == -1)
1883 "left operand of shift expression %q+E is negative",
1884 build2_loc (loc
, code
, type
, lhs
, rhs
));
1885 return (!flag_permissive
|| ctx
->quiet
);
1887 /* For signed x << y the following:
1888 (unsigned) x >> ((prec (lhs) - 1) - y)
1889 if > 1, is undefined. The right-hand side of this formula
1890 is the highest bit of the LHS that can be set (starting from 0),
1891 so that the shift doesn't overflow. We then right-shift the LHS
1892 to see whether any other bit is set making the original shift
1893 undefined -- the result is not representable in the corresponding
1895 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1896 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1897 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1898 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1899 if (tree_int_cst_lt (integer_one_node
, t
))
1902 permerror (loc
, "shift expression %q+E overflows",
1903 build2_loc (loc
, code
, type
, lhs
, rhs
));
1904 return (!flag_permissive
|| ctx
->quiet
);
1910 /* Subroutine of cxx_eval_constant_expression.
1911 Attempt to reduce the unary expression tree T to a compile time value.
1912 If successful, return the value. Otherwise issue a diagnostic
1913 and return error_mark_node. */
1916 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1918 bool *non_constant_p
, bool *overflow_p
)
1921 tree orig_arg
= TREE_OPERAND (t
, 0);
1922 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1923 non_constant_p
, overflow_p
);
1924 VERIFY_CONSTANT (arg
);
1925 location_t loc
= EXPR_LOCATION (t
);
1926 enum tree_code code
= TREE_CODE (t
);
1927 tree type
= TREE_TYPE (t
);
1928 r
= fold_unary_loc (loc
, code
, type
, arg
);
1931 if (arg
== orig_arg
)
1934 r
= build1_loc (loc
, code
, type
, arg
);
1936 VERIFY_CONSTANT (r
);
1940 /* Helper function for cxx_eval_binary_expression. Try to optimize
1941 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1942 generic folding should be used. */
1945 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1946 tree lhs
, tree rhs
, bool *non_constant_p
,
1950 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1953 lhs
= TREE_OPERAND (lhs
, 0);
1955 /* &A[i] p+ j => &A[i + j] */
1956 if (TREE_CODE (lhs
) == ARRAY_REF
1957 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1958 && TREE_CODE (rhs
) == INTEGER_CST
1959 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1960 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1962 tree orig_type
= TREE_TYPE (t
);
1963 location_t loc
= EXPR_LOCATION (t
);
1964 tree type
= TREE_TYPE (lhs
);
1966 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1967 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1968 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1970 if (*non_constant_p
)
1972 /* Don't fold an out-of-bound access. */
1973 if (!tree_int_cst_le (t
, nelts
))
1975 rhs
= cp_fold_convert (ssizetype
, rhs
);
1976 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1977 constexpr int A[1]; ... (char *)&A[0] + 1 */
1978 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1979 rhs
, TYPE_SIZE_UNIT (type
))))
1981 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1983 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1984 TYPE_SIZE_UNIT (type
));
1985 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1986 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1987 t
, NULL_TREE
, NULL_TREE
);
1988 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1989 t
= cp_fold_convert (orig_type
, t
);
1990 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1991 non_constant_p
, overflow_p
);
1997 /* Subroutine of cxx_eval_constant_expression.
1998 Like cxx_eval_unary_expression, except for binary expressions. */
2001 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
2003 bool *non_constant_p
, bool *overflow_p
)
2006 tree orig_lhs
= TREE_OPERAND (t
, 0);
2007 tree orig_rhs
= TREE_OPERAND (t
, 1);
2009 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
2010 non_constant_p
, overflow_p
);
2011 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2013 if (*non_constant_p
)
2015 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
2016 non_constant_p
, overflow_p
);
2017 if (*non_constant_p
)
2020 location_t loc
= EXPR_LOCATION (t
);
2021 enum tree_code code
= TREE_CODE (t
);
2022 tree type
= TREE_TYPE (t
);
2024 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2026 bool is_code_eq
= (code
== EQ_EXPR
);
2028 if (TREE_CODE (lhs
) == PTRMEM_CST
2029 && TREE_CODE (rhs
) == PTRMEM_CST
)
2030 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2032 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2033 || TREE_CODE (rhs
) == PTRMEM_CST
)
2034 && (null_member_pointer_value_p (lhs
)
2035 || null_member_pointer_value_p (rhs
)))
2036 r
= constant_boolean_node (!is_code_eq
, type
);
2037 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2038 lhs
= cplus_expand_constant (lhs
);
2039 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2040 rhs
= cplus_expand_constant (rhs
);
2042 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2043 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2046 error ("arithmetic involving a null pointer in %qE", lhs
);
2049 else if (code
== POINTER_PLUS_EXPR
)
2050 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2054 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2058 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2061 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2063 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2064 *non_constant_p
= true;
2065 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2066 a local array in a constexpr function. */
2067 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2069 VERIFY_CONSTANT (r
);
2073 /* Subroutine of cxx_eval_constant_expression.
2074 Attempt to evaluate condition expressions. Dead branches are not
2078 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2080 bool *non_constant_p
, bool *overflow_p
,
2083 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2085 non_constant_p
, overflow_p
);
2086 VERIFY_CONSTANT (val
);
2087 /* Don't VERIFY_CONSTANT the other operands. */
2088 if (integer_zerop (val
))
2089 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2091 non_constant_p
, overflow_p
,
2093 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2095 non_constant_p
, overflow_p
,
2099 /* Subroutine of cxx_eval_constant_expression.
2100 Attempt to evaluate vector condition expressions. Unlike
2101 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2102 ternary arithmetics operation, where all 3 arguments have to be
2103 evaluated as constants and then folding computes the result from
2107 cxx_eval_vector_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2108 bool *non_constant_p
, bool *overflow_p
)
2110 tree arg1
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2112 non_constant_p
, overflow_p
);
2113 VERIFY_CONSTANT (arg1
);
2114 tree arg2
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2116 non_constant_p
, overflow_p
);
2117 VERIFY_CONSTANT (arg2
);
2118 tree arg3
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2120 non_constant_p
, overflow_p
);
2121 VERIFY_CONSTANT (arg3
);
2122 location_t loc
= EXPR_LOCATION (t
);
2123 tree type
= TREE_TYPE (t
);
2124 tree r
= fold_ternary_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2127 if (arg1
== TREE_OPERAND (t
, 0)
2128 && arg2
== TREE_OPERAND (t
, 1)
2129 && arg3
== TREE_OPERAND (t
, 2))
2132 r
= build3_loc (loc
, VEC_COND_EXPR
, type
, arg1
, arg2
, arg3
);
2134 VERIFY_CONSTANT (r
);
2138 /* Returns less than, equal to, or greater than zero if KEY is found to be
2139 less than, to match, or to be greater than the constructor_elt's INDEX. */
2142 array_index_cmp (tree key
, tree index
)
2144 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2146 switch (TREE_CODE (index
))
2149 return tree_int_cst_compare (key
, index
);
2152 tree lo
= TREE_OPERAND (index
, 0);
2153 tree hi
= TREE_OPERAND (index
, 1);
2154 if (tree_int_cst_lt (key
, lo
))
2156 else if (tree_int_cst_lt (hi
, key
))
2166 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2167 if none. If INSERT is true, insert a matching element rather than fail. */
2169 static HOST_WIDE_INT
2170 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2172 if (tree_int_cst_sgn (dindex
) < 0)
2175 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2176 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2177 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2179 unsigned HOST_WIDE_INT end
= len
;
2180 unsigned HOST_WIDE_INT begin
= 0;
2182 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2183 that the same is true of the other elements and index directly. */
2186 tree cindex
= (*elts
)[end
-1].index
;
2187 if (TREE_CODE (cindex
) == INTEGER_CST
2188 && compare_tree_int (cindex
, end
-1) == 0)
2197 /* Otherwise, find a matching index by means of a binary search. */
2198 while (begin
!= end
)
2200 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2201 constructor_elt
&elt
= (*elts
)[middle
];
2202 tree idx
= elt
.index
;
2204 int cmp
= array_index_cmp (dindex
, idx
);
2211 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2213 /* We need to split the range. */
2215 tree lo
= TREE_OPERAND (idx
, 0);
2216 tree hi
= TREE_OPERAND (idx
, 1);
2217 if (tree_int_cst_lt (lo
, dindex
))
2219 /* There are still some lower elts; shorten the range. */
2220 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2222 if (tree_int_cst_equal (lo
, new_hi
))
2223 /* Only one element left, no longer a range. */
2226 TREE_OPERAND (idx
, 1) = new_hi
;
2227 /* Append the element we want to insert. */
2230 e
.value
= unshare_constructor (elt
.value
);
2231 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2234 /* No lower elts, the range elt is now ours. */
2237 if (tree_int_cst_lt (dindex
, hi
))
2239 /* There are still some higher elts; append a range. */
2240 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2242 if (tree_int_cst_equal (new_lo
, hi
))
2245 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2246 e
.value
= unshare_constructor (elt
.value
);
2247 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2256 constructor_elt e
= { dindex
, NULL_TREE
};
2257 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2264 /* Under the control of CTX, issue a detailed diagnostic for
2265 an out-of-bounds subscript INDEX into the expression ARRAY. */
2268 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2272 tree arraytype
= TREE_TYPE (array
);
2274 /* Convert the unsigned array subscript to a signed integer to avoid
2275 printing huge numbers for small negative values. */
2276 tree sidx
= fold_convert (ssizetype
, index
);
2279 if (TYPE_DOMAIN (arraytype
))
2280 error ("array subscript value %qE is outside the bounds "
2281 "of array %qD of type %qT", sidx
, array
, arraytype
);
2283 error ("non-zero array subscript %qE is used with array %qD of "
2284 "type %qT with unknown bounds", sidx
, array
, arraytype
);
2285 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2287 else if (TYPE_DOMAIN (arraytype
))
2288 error ("array subscript value %qE is outside the bounds "
2289 "of array type %qT", sidx
, arraytype
);
2291 error ("non-zero array subscript %qE is used with array of type %qT "
2292 "with unknown bounds", sidx
, arraytype
);
2296 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2297 STRING_CST STRING. */
2300 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2302 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2305 if (chars_per_elt
== 1)
2306 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2309 const unsigned char *ptr
2310 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2311 + index
* chars_per_elt
);
2312 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2317 /* Subroutine of cxx_eval_constant_expression.
2318 Attempt to reduce a reference to an array slot. */
2321 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2323 bool *non_constant_p
, bool *overflow_p
)
2325 tree oldary
= TREE_OPERAND (t
, 0);
2326 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2328 non_constant_p
, overflow_p
);
2330 HOST_WIDE_INT i
= 0;
2331 tree elem_type
= NULL_TREE
;
2332 unsigned len
= 0, elem_nchars
= 1;
2333 if (*non_constant_p
)
2335 oldidx
= TREE_OPERAND (t
, 1);
2336 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2338 non_constant_p
, overflow_p
);
2339 VERIFY_CONSTANT (index
);
2342 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2343 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2344 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2345 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2346 ary
= TREE_OPERAND (ary
, 0);
2347 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2348 len
= CONSTRUCTOR_NELTS (ary
);
2349 else if (TREE_CODE (ary
) == STRING_CST
)
2351 elem_nchars
= (TYPE_PRECISION (elem_type
)
2352 / TYPE_PRECISION (char_type_node
));
2353 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2355 else if (TREE_CODE (ary
) == VECTOR_CST
)
2356 /* We don't create variable-length VECTOR_CSTs. */
2357 len
= VECTOR_CST_NELTS (ary
).to_constant ();
2360 /* We can't do anything with other tree codes, so use
2361 VERIFY_CONSTANT to complain and fail. */
2362 VERIFY_CONSTANT (ary
);
2366 if (!tree_fits_shwi_p (index
)
2367 || (i
= tree_to_shwi (index
)) < 0)
2369 diag_array_subscript (ctx
, ary
, index
);
2370 *non_constant_p
= true;
2376 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2378 if (TYPE_DOMAIN (TREE_TYPE (ary
)))
2379 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2381 nelts
= size_zero_node
;
2383 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2384 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2388 /* For VLAs, the number of elements won't be an integer constant. */
2389 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2391 VERIFY_CONSTANT (nelts
);
2393 ? !tree_int_cst_le (index
, nelts
)
2394 : !tree_int_cst_lt (index
, nelts
))
2395 || tree_int_cst_sgn (index
) < 0)
2397 diag_array_subscript (ctx
, ary
, index
);
2398 *non_constant_p
= true;
2402 if (lval
&& ary
== oldary
&& index
== oldidx
)
2405 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2408 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2410 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2421 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2422 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2423 else if (TREE_CODE (ary
) == VECTOR_CST
)
2424 r
= VECTOR_CST_ELT (ary
, i
);
2426 r
= extract_string_elt (ary
, elem_nchars
, i
);
2429 /* Don't VERIFY_CONSTANT here. */
2432 /* Otherwise the element doesn't have a value yet. */
2437 if (TREE_CODE (ary
) == CONSTRUCTOR
2438 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2440 /* 'ary' is part of the aggregate initializer we're currently
2441 building; if there's no initializer for this element yet,
2444 error ("accessing uninitialized array element");
2445 *non_constant_p
= true;
2449 /* If it's within the array bounds but doesn't have an explicit
2450 initializer, it's value-initialized. */
2451 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2452 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2456 /* Subroutine of cxx_eval_constant_expression.
2457 Attempt to reduce a field access of a value of class type. */
2460 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2462 bool *non_constant_p
, bool *overflow_p
)
2464 unsigned HOST_WIDE_INT i
;
2467 tree part
= TREE_OPERAND (t
, 1);
2468 tree orig_whole
= TREE_OPERAND (t
, 0);
2469 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2471 non_constant_p
, overflow_p
);
2472 if (INDIRECT_REF_P (whole
)
2473 && integer_zerop (TREE_OPERAND (whole
, 0))
2475 error ("dereferencing a null pointer in %qE", orig_whole
);
2477 if (TREE_CODE (whole
) == PTRMEM_CST
)
2478 whole
= cplus_expand_constant (whole
);
2479 if (whole
== orig_whole
)
2482 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2483 whole
, part
, NULL_TREE
);
2484 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2486 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2489 error ("%qE is not a constant expression", orig_whole
);
2490 *non_constant_p
= true;
2492 if (DECL_MUTABLE_P (part
))
2495 error ("mutable %qD is not usable in a constant expression", part
);
2496 *non_constant_p
= true;
2498 if (*non_constant_p
)
2500 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2501 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2503 /* Use name match for PMF fields, as a variant will have a
2504 different FIELD_DECL with a different type. */
2505 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2511 /* We're in the middle of initializing it. */
2515 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2516 && CONSTRUCTOR_NELTS (whole
) > 0)
2518 /* DR 1188 says we don't have to deal with this. */
2520 error ("accessing %qD member instead of initialized %qD member in "
2521 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2522 *non_constant_p
= true;
2526 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2527 classes never get represented; throw together a value now. */
2528 if (is_really_empty_class (TREE_TYPE (t
)))
2529 return build_constructor (TREE_TYPE (t
), NULL
);
2531 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2533 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2535 /* 'whole' is part of the aggregate initializer we're currently
2536 building; if there's no initializer for this member yet, that's an
2539 error ("accessing uninitialized member %qD", part
);
2540 *non_constant_p
= true;
2544 /* If there's no explicit init for this field, it's value-initialized. */
2545 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2546 return cxx_eval_constant_expression (ctx
, value
,
2548 non_constant_p
, overflow_p
);
2551 /* Subroutine of cxx_eval_constant_expression.
2552 Attempt to reduce a field access of a value of class type that is
2553 expressed as a BIT_FIELD_REF. */
2556 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2558 bool *non_constant_p
, bool *overflow_p
)
2560 tree orig_whole
= TREE_OPERAND (t
, 0);
2561 tree retval
, fldval
, utype
, mask
;
2562 bool fld_seen
= false;
2563 HOST_WIDE_INT istart
, isize
;
2564 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2566 non_constant_p
, overflow_p
);
2567 tree start
, field
, value
;
2568 unsigned HOST_WIDE_INT i
;
2570 if (whole
== orig_whole
)
2572 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2574 if (!*non_constant_p
2575 && TREE_CODE (whole
) != VECTOR_CST
2576 && TREE_CODE (whole
) != CONSTRUCTOR
)
2579 error ("%qE is not a constant expression", orig_whole
);
2580 *non_constant_p
= true;
2582 if (*non_constant_p
)
2585 if (TREE_CODE (whole
) == VECTOR_CST
)
2586 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2587 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2589 start
= TREE_OPERAND (t
, 2);
2590 istart
= tree_to_shwi (start
);
2591 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2592 utype
= TREE_TYPE (t
);
2593 if (!TYPE_UNSIGNED (utype
))
2594 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2595 retval
= build_int_cst (utype
, 0);
2596 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2598 tree bitpos
= bit_position (field
);
2599 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2601 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2602 && TREE_CODE (value
) == INTEGER_CST
2603 && tree_fits_shwi_p (bitpos
)
2604 && tree_fits_shwi_p (DECL_SIZE (field
)))
2606 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2607 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2608 HOST_WIDE_INT shift
;
2609 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2611 fldval
= fold_convert (utype
, value
);
2612 mask
= build_int_cst_type (utype
, -1);
2613 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2614 size_int (TYPE_PRECISION (utype
) - sz
));
2615 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2616 size_int (TYPE_PRECISION (utype
) - sz
));
2617 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2618 shift
= bit
- istart
;
2619 if (BYTES_BIG_ENDIAN
)
2620 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2621 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2623 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2629 return fold_convert (TREE_TYPE (t
), retval
);
2631 return error_mark_node
;
2634 /* Subroutine of cxx_eval_constant_expression.
2635 Evaluate a short-circuited logical expression T in the context
2636 of a given constexpr CALL. BAILOUT_VALUE is the value for
2637 early return. CONTINUE_VALUE is used here purely for
2638 sanity check purposes. */
2641 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2642 tree bailout_value
, tree continue_value
,
2644 bool *non_constant_p
, bool *overflow_p
)
2647 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2649 non_constant_p
, overflow_p
);
2650 VERIFY_CONSTANT (lhs
);
2651 if (tree_int_cst_equal (lhs
, bailout_value
))
2653 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2654 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2655 lval
, non_constant_p
,
2657 VERIFY_CONSTANT (r
);
2661 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2662 CONSTRUCTOR elements to initialize (part of) an object containing that
2663 field. Return a pointer to the constructor_elt corresponding to the
2664 initialization of the field. */
2666 static constructor_elt
*
2667 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2669 tree aggr
= TREE_OPERAND (ref
, 0);
2670 tree field
= TREE_OPERAND (ref
, 1);
2672 constructor_elt
*ce
;
2674 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2676 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2678 constructor_elt
*base_ce
2679 = base_field_constructor_elt (v
, aggr
);
2680 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2683 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2684 if (ce
->index
== field
)
2691 /* Some of the expressions fed to the constexpr mechanism are calls to
2692 constructors, which have type void. In that case, return the type being
2693 initialized by the constructor. */
2696 initialized_type (tree t
)
2700 tree type
= cv_unqualified (TREE_TYPE (t
));
2701 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2703 /* A constructor call has void type, so we need to look deeper. */
2704 tree fn
= get_function_named_in_call (t
);
2705 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2706 && DECL_CXX_CONSTRUCTOR_P (fn
))
2707 type
= DECL_CONTEXT (fn
);
2712 /* We're about to initialize element INDEX of an array or class from VALUE.
2713 Set up NEW_CTX appropriately by adjusting .object to refer to the
2714 subobject and creating a new CONSTRUCTOR if the element is itself
2715 a class or array. */
2718 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2719 tree index
, tree
&value
)
2723 if (index
&& TREE_CODE (index
) != INTEGER_CST
2724 && TREE_CODE (index
) != FIELD_DECL
)
2725 /* This won't have an element in the new CONSTRUCTOR. */
2728 tree type
= initialized_type (value
);
2729 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2730 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2733 /* The sub-aggregate initializer might contain a placeholder;
2734 update object to refer to the subobject and ctor to refer to
2735 the (newly created) sub-initializer. */
2737 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2738 tree elt
= build_constructor (type
, NULL
);
2739 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2742 if (TREE_CODE (value
) == TARGET_EXPR
)
2743 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2744 value
= TARGET_EXPR_INITIAL (value
);
2747 /* We're about to process an initializer for a class or array TYPE. Make
2748 sure that CTX is set up appropriately. */
2751 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2753 /* We don't bother building a ctor for an empty base subobject. */
2754 if (is_empty_class (type
))
2757 /* We're in the middle of an initializer that might involve placeholders;
2758 our caller should have created a CONSTRUCTOR for us to put the
2759 initializer into. We will either return that constructor or T. */
2760 gcc_assert (ctx
->ctor
);
2761 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2762 (type
, TREE_TYPE (ctx
->ctor
)));
2763 /* We used to check that ctx->ctor was empty, but that isn't the case when
2764 the object is zero-initialized before calling the constructor. */
2767 tree otype
= TREE_TYPE (ctx
->object
);
2768 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2769 /* Handle flexible array members. */
2770 || (TREE_CODE (otype
) == ARRAY_TYPE
2771 && TYPE_DOMAIN (otype
) == NULL_TREE
2772 && TREE_CODE (type
) == ARRAY_TYPE
2773 && (same_type_ignoring_top_level_qualifiers_p
2774 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2776 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2777 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2780 /* Subroutine of cxx_eval_constant_expression.
2781 The expression tree T denotes a C-style array or a C-style
2782 aggregate. Reduce it to a constant expression. */
2785 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2787 bool *non_constant_p
, bool *overflow_p
)
2789 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2790 bool changed
= false;
2791 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2792 tree type
= TREE_TYPE (t
);
2794 constexpr_ctx new_ctx
;
2795 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2797 /* We don't really need the ctx->ctor business for a PMF or
2798 vector, but it's simpler to use the same code. */
2800 new_ctx
.ctor
= build_constructor (type
, NULL
);
2801 new_ctx
.object
= NULL_TREE
;
2804 verify_ctor_sanity (ctx
, type
);
2805 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2806 vec_alloc (*p
, vec_safe_length (v
));
2810 bool constant_p
= true;
2811 bool side_effects_p
= false;
2812 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2814 tree orig_value
= value
;
2815 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2816 if (new_ctx
.ctor
!= ctx
->ctor
)
2817 /* If we built a new CONSTRUCTOR, attach it now so that other
2818 initializers can refer to it. */
2819 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2820 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2822 non_constant_p
, overflow_p
);
2823 /* Don't VERIFY_CONSTANT here. */
2824 if (ctx
->quiet
&& *non_constant_p
)
2826 if (elt
!= orig_value
)
2829 if (!TREE_CONSTANT (elt
))
2831 if (TREE_SIDE_EFFECTS (elt
))
2832 side_effects_p
= true;
2833 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2835 /* This is an initialization of a vfield inside a base
2836 subaggregate that we already initialized; push this
2837 initialization into the previous initialization. */
2838 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2843 && (TREE_CODE (index
) == NOP_EXPR
2844 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2846 /* This is an initializer for an empty base; now that we've
2847 checked that it's constant, we can ignore it. */
2848 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2851 else if (new_ctx
.ctor
!= ctx
->ctor
)
2853 /* We appended this element above; update the value. */
2854 gcc_assert ((*p
)->last().index
== index
);
2855 (*p
)->last().value
= elt
;
2858 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2860 if (*non_constant_p
|| !changed
)
2863 /* We're done building this CONSTRUCTOR, so now we can interpret an
2864 element without an explicit initializer as value-initialized. */
2865 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2866 TREE_CONSTANT (t
) = constant_p
;
2867 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2868 if (VECTOR_TYPE_P (type
))
2873 /* Subroutine of cxx_eval_constant_expression.
2874 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2875 initialization of a non-static data member of array type. Reduce it to a
2878 Note that apart from value-initialization (when VALUE_INIT is true),
2879 this is only intended to support value-initialization and the
2880 initializations done by defaulted constructors for classes with
2881 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2882 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2883 for the copy/move constructor. */
2886 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2887 bool value_init
, bool lval
,
2888 bool *non_constant_p
, bool *overflow_p
)
2890 tree elttype
= TREE_TYPE (atype
);
2891 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2892 verify_ctor_sanity (ctx
, atype
);
2893 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2894 bool pre_init
= false;
2895 unsigned HOST_WIDE_INT i
;
2897 /* For the default constructor, build up a call to the default
2898 constructor of the element type. We only need to handle class types
2899 here, as for a constructor to be constexpr, all members must be
2900 initialized, which for a defaulted default constructor means they must
2901 be of a class type with a constexpr default constructor. */
2902 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2903 /* We only do this at the lowest level. */;
2904 else if (value_init
)
2906 init
= build_value_init (elttype
, tf_warning_or_error
);
2911 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2912 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2913 &argvec
, elttype
, LOOKUP_NORMAL
,
2914 tf_warning_or_error
);
2915 release_tree_vector (argvec
);
2916 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2920 for (i
= 0; i
< max
; ++i
)
2922 tree idx
= build_int_cst (size_type_node
, i
);
2925 constexpr_ctx new_ctx
;
2926 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2927 if (new_ctx
.ctor
!= ctx
->ctor
)
2928 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2929 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2931 /* A multidimensional array; recurse. */
2932 if (value_init
|| init
== NULL_TREE
)
2934 eltinit
= NULL_TREE
;
2938 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2939 tf_warning_or_error
);
2940 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2942 non_constant_p
, overflow_p
);
2946 /* Initializing an element using value or default initialization
2947 we just pre-built above. */
2948 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2949 non_constant_p
, overflow_p
);
2954 /* Copying an element. */
2955 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2956 (atype
, TREE_TYPE (init
)));
2957 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2958 tf_warning_or_error
);
2959 if (!lvalue_p (init
))
2960 eltinit
= move (eltinit
);
2961 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2962 eltinit
= cxx_eval_constant_expression (&new_ctx
, eltinit
, lval
,
2963 non_constant_p
, overflow_p
);
2965 if (*non_constant_p
&& !ctx
->quiet
)
2967 if (new_ctx
.ctor
!= ctx
->ctor
)
2969 /* We appended this element above; update the value. */
2970 gcc_assert ((*p
)->last().index
== idx
);
2971 (*p
)->last().value
= eltinit
;
2974 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2975 /* Reuse the result of cxx_eval_constant_expression call
2976 from the first iteration to all others if it is a constant
2977 initializer that doesn't require relocations. */
2980 && (eltinit
== NULL_TREE
2981 || (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2982 == null_pointer_node
)))
2984 if (new_ctx
.ctor
!= ctx
->ctor
)
2985 eltinit
= new_ctx
.ctor
;
2986 tree range
= build2 (RANGE_EXPR
, size_type_node
,
2987 build_int_cst (size_type_node
, 1),
2988 build_int_cst (size_type_node
, max
- 1));
2989 CONSTRUCTOR_APPEND_ELT (*p
, range
, unshare_constructor (eltinit
));
2993 vec_safe_reserve (*p
, max
);
2996 if (!*non_constant_p
)
2999 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
3005 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
3007 bool *non_constant_p
, bool *overflow_p
)
3009 tree atype
= TREE_TYPE (t
);
3010 tree init
= VEC_INIT_EXPR_INIT (t
);
3011 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
3012 VEC_INIT_EXPR_VALUE_INIT (t
),
3013 lval
, non_constant_p
, overflow_p
);
3014 if (*non_constant_p
)
3020 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3021 match. We want to be less strict for simple *& folding; if we have a
3022 non-const temporary that we access through a const pointer, that should
3023 work. We handle this here rather than change fold_indirect_ref_1
3024 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3025 don't really make sense outside of constant expression evaluation. Also
3026 we want to allow folding to COMPONENT_REF, which could cause trouble
3027 with TBAA in fold_indirect_ref_1.
3029 Try to keep this function synced with fold_indirect_ref_1. */
3032 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
3036 poly_uint64 const_op01
;
3039 subtype
= TREE_TYPE (sub
);
3040 if (!POINTER_TYPE_P (subtype
))
3043 if (TREE_CODE (sub
) == ADDR_EXPR
)
3045 tree op
= TREE_OPERAND (sub
, 0);
3046 tree optype
= TREE_TYPE (op
);
3048 /* *&CONST_DECL -> to the value of the const decl. */
3049 if (TREE_CODE (op
) == CONST_DECL
)
3050 return DECL_INITIAL (op
);
3051 /* *&p => p; make sure to handle *&"str"[cst] here. */
3052 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
3053 /* Also handle the case where the desired type is an array of unknown
3054 bounds because the variable has had its bounds deduced since the
3055 ADDR_EXPR was created. */
3056 || (TREE_CODE (type
) == ARRAY_TYPE
3057 && TREE_CODE (optype
) == ARRAY_TYPE
3058 && TYPE_DOMAIN (type
) == NULL_TREE
3059 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
3062 tree fop
= fold_read_from_constant_string (op
);
3068 /* *(foo *)&fooarray => fooarray[0] */
3069 else if (TREE_CODE (optype
) == ARRAY_TYPE
3070 && (same_type_ignoring_top_level_qualifiers_p
3071 (type
, TREE_TYPE (optype
))))
3073 tree type_domain
= TYPE_DOMAIN (optype
);
3074 tree min_val
= size_zero_node
;
3075 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3076 min_val
= TYPE_MIN_VALUE (type_domain
);
3077 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3078 NULL_TREE
, NULL_TREE
);
3080 /* *(foo *)&complexfoo => __real__ complexfoo */
3081 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3082 && (same_type_ignoring_top_level_qualifiers_p
3083 (type
, TREE_TYPE (optype
))))
3084 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3085 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3086 else if (VECTOR_TYPE_P (optype
)
3087 && (same_type_ignoring_top_level_qualifiers_p
3088 (type
, TREE_TYPE (optype
))))
3090 tree part_width
= TYPE_SIZE (type
);
3091 tree index
= bitsize_int (0);
3092 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
3095 /* Also handle conversion to an empty base class, which
3096 is represented with a NOP_EXPR. */
3097 else if (is_empty_class (type
)
3098 && CLASS_TYPE_P (optype
)
3099 && DERIVED_FROM_P (type
, optype
))
3104 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3105 else if (RECORD_OR_UNION_TYPE_P (optype
))
3107 tree field
= TYPE_FIELDS (optype
);
3108 for (; field
; field
= DECL_CHAIN (field
))
3109 if (TREE_CODE (field
) == FIELD_DECL
3110 && TREE_TYPE (field
) != error_mark_node
3111 && integer_zerop (byte_position (field
))
3112 && (same_type_ignoring_top_level_qualifiers_p
3113 (TREE_TYPE (field
), type
)))
3114 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3117 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3118 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
3120 tree op00
= TREE_OPERAND (sub
, 0);
3121 tree op01
= TREE_OPERAND (sub
, 1);
3124 if (TREE_CODE (op00
) == ADDR_EXPR
)
3127 op00
= TREE_OPERAND (op00
, 0);
3128 op00type
= TREE_TYPE (op00
);
3130 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3131 if (VECTOR_TYPE_P (op00type
)
3132 && same_type_ignoring_top_level_qualifiers_p
3133 (type
, TREE_TYPE (op00type
))
3134 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3135 but we want to treat offsets with MSB set as negative.
3136 For the code below negative offsets are invalid and
3137 TYPE_SIZE of the element is something unsigned, so
3138 check whether op01 fits into poly_int64, which implies
3139 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3140 then just use poly_uint64 because we want to treat the
3141 value as unsigned. */
3142 && tree_fits_poly_int64_p (op01
))
3144 tree part_width
= TYPE_SIZE (type
);
3145 poly_uint64 max_offset
3146 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
3147 * TYPE_VECTOR_SUBPARTS (op00type
));
3148 if (known_lt (const_op01
, max_offset
))
3150 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
3151 return fold_build3_loc (loc
,
3152 BIT_FIELD_REF
, type
, op00
,
3156 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3157 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3158 && (same_type_ignoring_top_level_qualifiers_p
3159 (type
, TREE_TYPE (op00type
))))
3161 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
3163 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3165 /* ((foo *)&fooarray)[1] => fooarray[1] */
3166 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3167 && (same_type_ignoring_top_level_qualifiers_p
3168 (type
, TREE_TYPE (op00type
))))
3170 tree type_domain
= TYPE_DOMAIN (op00type
);
3171 tree min_val
= size_zero_node
;
3172 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3173 min_val
= TYPE_MIN_VALUE (type_domain
);
3174 offset_int off
= wi::to_offset (op01
);
3175 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
3176 offset_int remainder
;
3177 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
3178 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
3180 off
= off
+ wi::to_offset (min_val
);
3181 op01
= wide_int_to_tree (sizetype
, off
);
3182 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3183 NULL_TREE
, NULL_TREE
);
3186 /* Also handle conversion to an empty base class, which
3187 is represented with a NOP_EXPR. */
3188 else if (is_empty_class (type
)
3189 && CLASS_TYPE_P (op00type
)
3190 && DERIVED_FROM_P (type
, op00type
))
3195 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3196 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3198 tree field
= TYPE_FIELDS (op00type
);
3199 for (; field
; field
= DECL_CHAIN (field
))
3200 if (TREE_CODE (field
) == FIELD_DECL
3201 && TREE_TYPE (field
) != error_mark_node
3202 && tree_int_cst_equal (byte_position (field
), op01
)
3203 && (same_type_ignoring_top_level_qualifiers_p
3204 (TREE_TYPE (field
), type
)))
3205 return fold_build3 (COMPONENT_REF
, type
, op00
,
3210 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3211 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3212 && (same_type_ignoring_top_level_qualifiers_p
3213 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3216 tree min_val
= size_zero_node
;
3218 = cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3222 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3223 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3224 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3225 min_val
= TYPE_MIN_VALUE (type_domain
);
3226 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3234 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3236 bool *non_constant_p
, bool *overflow_p
)
3238 tree orig_op0
= TREE_OPERAND (t
, 0);
3239 bool empty_base
= false;
3241 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3242 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3244 if (TREE_CODE (t
) == MEM_REF
3245 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3247 gcc_assert (ctx
->quiet
);
3248 *non_constant_p
= true;
3252 /* First try to simplify it directly. */
3253 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3257 /* If that didn't work, evaluate the operand first. */
3258 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3259 /*lval*/false, non_constant_p
,
3261 /* Don't VERIFY_CONSTANT here. */
3262 if (*non_constant_p
)
3265 if (!lval
&& integer_zerop (op0
))
3268 error ("dereferencing a null pointer");
3269 *non_constant_p
= true;
3273 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3277 /* We couldn't fold to a constant value. Make sure it's not
3278 something we should have been able to fold. */
3281 if (TREE_CODE (sub
) == ADDR_EXPR
)
3283 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3284 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3285 /* DR 1188 says we don't have to deal with this. */
3287 error ("accessing value of %qE through a %qT glvalue in a "
3288 "constant expression", build_fold_indirect_ref (sub
),
3290 *non_constant_p
= true;
3294 if (lval
&& op0
!= orig_op0
)
3295 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3297 VERIFY_CONSTANT (t
);
3302 r
= cxx_eval_constant_expression (ctx
, r
,
3303 lval
, non_constant_p
, overflow_p
);
3304 if (*non_constant_p
)
3307 /* If we're pulling out the value of an empty base, just return an empty
3309 if (empty_base
&& !lval
)
3311 r
= build_constructor (TREE_TYPE (t
), NULL
);
3312 TREE_CONSTANT (r
) = true;
3318 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3319 Shared between potential_constant_expression and
3320 cxx_eval_constant_expression. */
3323 non_const_var_error (tree r
)
3325 tree type
= TREE_TYPE (r
);
3326 error ("the value of %qD is not usable in a constant "
3328 /* Avoid error cascade. */
3329 if (DECL_INITIAL (r
) == error_mark_node
)
3331 if (DECL_DECLARED_CONSTEXPR_P (r
))
3332 inform (DECL_SOURCE_LOCATION (r
),
3333 "%qD used in its own initializer", r
);
3334 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3336 if (!CP_TYPE_CONST_P (type
))
3337 inform (DECL_SOURCE_LOCATION (r
),
3338 "%q#D is not const", r
);
3339 else if (CP_TYPE_VOLATILE_P (type
))
3340 inform (DECL_SOURCE_LOCATION (r
),
3341 "%q#D is volatile", r
);
3342 else if (!DECL_INITIAL (r
)
3343 || !TREE_CONSTANT (DECL_INITIAL (r
))
3344 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3345 inform (DECL_SOURCE_LOCATION (r
),
3346 "%qD was not initialized with a constant "
3351 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3352 inform (DECL_SOURCE_LOCATION (r
),
3353 "%qD was not initialized with a constant "
3357 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3358 inform (DECL_SOURCE_LOCATION (r
),
3359 "%qD was not declared %<constexpr%>", r
);
3361 inform (DECL_SOURCE_LOCATION (r
),
3362 "%qD does not have integral or enumeration type",
3367 /* Subroutine of cxx_eval_constant_expression.
3368 Like cxx_eval_unary_expression, except for trinary expressions. */
3371 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3373 bool *non_constant_p
, bool *overflow_p
)
3379 for (i
= 0; i
< 3; i
++)
3381 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3383 non_constant_p
, overflow_p
);
3384 VERIFY_CONSTANT (args
[i
]);
3387 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3388 args
[0], args
[1], args
[2]);
3389 if (val
== NULL_TREE
)
3391 VERIFY_CONSTANT (val
);
3395 /* True if T was declared in a function declared to be constexpr, and
3396 therefore potentially constant in C++14. */
3399 var_in_constexpr_fn (tree t
)
3401 tree ctx
= DECL_CONTEXT (t
);
3402 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3403 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3406 /* True if T was declared in a function that might be constexpr: either a
3407 function that was declared constexpr, or a C++17 lambda op(). */
3410 var_in_maybe_constexpr_fn (tree t
)
3412 if (cxx_dialect
>= cxx17
3413 && DECL_FUNCTION_SCOPE_P (t
)
3414 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3416 return var_in_constexpr_fn (t
);
3419 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3420 build_over_call we implement trivial copy of a class with tail padding using
3421 assignment of character arrays, which is valid in normal code, but not in
3422 constexpr evaluation. We don't need to worry about clobbering tail padding
3423 in constexpr evaluation, so strip the type punning. */
3426 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3428 if (TREE_CODE (target
) == MEM_REF
3429 && TREE_CODE (init
) == MEM_REF
3430 && TREE_TYPE (target
) == TREE_TYPE (init
)
3431 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3432 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3434 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3435 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3439 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3442 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3444 bool *non_constant_p
, bool *overflow_p
)
3446 constexpr_ctx new_ctx
= *ctx
;
3448 tree init
= TREE_OPERAND (t
, 1);
3449 if (TREE_CLOBBER_P (init
))
3450 /* Just ignore clobbers. */
3453 /* First we figure out where we're storing to. */
3454 tree target
= TREE_OPERAND (t
, 0);
3456 maybe_simplify_trivial_copy (target
, init
);
3458 tree type
= TREE_TYPE (target
);
3459 target
= cxx_eval_constant_expression (ctx
, target
,
3461 non_constant_p
, overflow_p
);
3462 if (*non_constant_p
)
3465 /* cxx_eval_array_reference for lval = true allows references one past
3466 end of array, because it does not know if it is just taking address
3467 (which is valid), or actual dereference. Here we know it is
3468 a dereference, so diagnose it here. */
3469 for (tree probe
= target
; probe
; )
3471 switch (TREE_CODE (probe
))
3475 ary
= TREE_OPERAND (probe
, 0);
3476 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3478 if (TYPE_DOMAIN (TREE_TYPE (ary
)))
3479 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3481 nelts
= size_zero_node
;
3483 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3484 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3487 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3488 non_constant_p
, overflow_p
);
3489 VERIFY_CONSTANT (nelts
);
3490 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3491 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3492 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3494 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3495 *non_constant_p
= true;
3502 probe
= TREE_OPERAND (probe
, 0);
3511 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3513 /* For initialization of an empty base, the original target will be
3514 *(base*)this, which the above evaluation resolves to the object
3515 argument, which has the derived type rather than the base type. In
3516 this situation, just evaluate the initializer and return, since
3517 there's no actual data to store. */
3518 gcc_assert (is_empty_class (type
));
3519 return cxx_eval_constant_expression (ctx
, init
, false,
3520 non_constant_p
, overflow_p
);
3523 /* And then find the underlying variable. */
3524 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3525 tree object
= NULL_TREE
;
3526 for (tree probe
= target
; object
== NULL_TREE
; )
3528 switch (TREE_CODE (probe
))
3533 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3534 vec_safe_push (refs
, TREE_TYPE (probe
));
3535 probe
= TREE_OPERAND (probe
, 0);
3543 /* And then find/build up our initializer for the path to the subobject
3544 we're initializing. */
3546 if (object
== ctx
->object
&& VAR_P (object
)
3547 && DECL_NAME (object
) && ctx
->call
== NULL
)
3548 /* The variable we're building up an aggregate initializer for is outside
3549 the constant-expression, so don't evaluate the store. We check
3550 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3552 else if (DECL_P (object
))
3553 valp
= ctx
->values
->get (object
);
3558 /* A constant-expression cannot modify objects from outside the
3559 constant-expression. */
3561 error ("modification of %qE is not a constant expression", object
);
3562 *non_constant_p
= true;
3565 type
= TREE_TYPE (object
);
3566 bool no_zero_init
= true;
3568 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3569 while (!refs
->is_empty())
3571 if (*valp
== NULL_TREE
)
3573 *valp
= build_constructor (type
, NULL
);
3574 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3576 else if (TREE_CODE (*valp
) == STRING_CST
)
3578 /* An array was initialized with a string constant, and now
3579 we're writing into one of its elements. Explode the
3580 single initialization into a set of element
3582 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3584 tree string
= *valp
;
3585 tree elt_type
= TREE_TYPE (type
);
3586 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3587 / TYPE_PRECISION (char_type_node
));
3588 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3589 tree ary_ctor
= build_constructor (type
, NULL
);
3591 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3592 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3594 constructor_elt elt
=
3596 build_int_cst (size_type_node
, ix
),
3597 extract_string_elt (string
, chars_per_elt
, ix
)
3599 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3605 /* If the value of object is already zero-initialized, any new ctors for
3606 subobjects will also be zero-initialized. */
3607 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3609 vec_safe_push (ctors
, *valp
);
3611 enum tree_code code
= TREE_CODE (type
);
3613 tree index
= refs
->pop();
3615 constructor_elt
*cep
= NULL
;
3616 if (code
== ARRAY_TYPE
)
3619 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3620 gcc_assert (i
>= 0);
3621 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3622 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3626 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3628 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3629 Usually we meet initializers in that order, but it is
3630 possible for base types to be placed not in program
3632 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3633 unsigned HOST_WIDE_INT idx
;
3635 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3636 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3637 /* Changing active member. */
3638 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3641 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3642 idx
++, fields
= DECL_CHAIN (fields
))
3644 if (index
== cep
->index
)
3647 /* The field we're initializing must be on the field
3648 list. Look to see if it is present before the
3649 field the current ELT initializes. */
3650 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3651 if (index
== fields
)
3655 /* We fell off the end of the CONSTRUCTOR, so insert a new
3656 entry at the end. */
3659 constructor_elt ce
= { index
, NULL_TREE
};
3661 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3662 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3668 release_tree_vector (refs
);
3670 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3672 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3673 wants to modify it. */
3674 if (*valp
== NULL_TREE
)
3676 *valp
= build_constructor (type
, NULL
);
3677 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3679 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3680 *valp
= cplus_expand_constant (*valp
);
3681 new_ctx
.ctor
= *valp
;
3682 new_ctx
.object
= target
;
3685 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3686 non_constant_p
, overflow_p
);
3687 /* Don't share a CONSTRUCTOR that might be changed later. */
3688 init
= unshare_constructor (init
);
3689 if (target
== object
)
3690 /* The hash table might have moved since the get earlier. */
3691 valp
= ctx
->values
->get (object
);
3693 if (TREE_CODE (init
) == CONSTRUCTOR
)
3695 /* An outer ctx->ctor might be pointing to *valp, so replace
3697 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3698 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3699 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3700 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3701 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3706 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3707 CONSTRUCTORs, if any. */
3710 bool c
= TREE_CONSTANT (init
);
3711 bool s
= TREE_SIDE_EFFECTS (init
);
3713 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3716 TREE_CONSTANT (elt
) = false;
3718 TREE_SIDE_EFFECTS (elt
) = true;
3720 release_tree_vector (ctors
);
3722 if (*non_constant_p
)
3730 /* Evaluate a ++ or -- expression. */
3733 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3735 bool *non_constant_p
, bool *overflow_p
)
3737 enum tree_code code
= TREE_CODE (t
);
3738 tree type
= TREE_TYPE (t
);
3739 tree op
= TREE_OPERAND (t
, 0);
3740 tree offset
= TREE_OPERAND (t
, 1);
3741 gcc_assert (TREE_CONSTANT (offset
));
3743 /* The operand as an lvalue. */
3744 op
= cxx_eval_constant_expression (ctx
, op
, true,
3745 non_constant_p
, overflow_p
);
3747 /* The operand as an rvalue. */
3749 = cxx_eval_constant_expression (ctx
, op
, false,
3750 non_constant_p
, overflow_p
);
3751 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3752 a local array in a constexpr function. */
3753 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3755 VERIFY_CONSTANT (val
);
3757 /* The modified value. */
3758 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3760 if (POINTER_TYPE_P (type
))
3762 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3763 offset
= convert_to_ptrofftype (offset
);
3765 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3766 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3769 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3771 VERIFY_CONSTANT (mod
);
3773 /* Storing the modified value. */
3774 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3775 cxx_eval_constant_expression (ctx
, store
,
3776 true, non_constant_p
, overflow_p
);
3778 /* And the value of the expression. */
3779 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3781 /* Prefix ops are lvalues. */
3785 /* But we optimize when the caller wants an rvalue. */
3789 /* Postfix ops are rvalues. */
3793 /* Predicates for the meaning of *jump_target. */
3796 returns (tree
*jump_target
)
3799 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3800 || (TREE_CODE (*jump_target
) == LABEL_DECL
3801 && LABEL_DECL_CDTOR (*jump_target
)));
3805 breaks (tree
*jump_target
)
3808 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3809 && LABEL_DECL_BREAK (*jump_target
))
3810 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3814 continues (tree
*jump_target
)
3817 && TREE_CODE (*jump_target
) == LABEL_DECL
3818 && LABEL_DECL_CONTINUE (*jump_target
);
3822 switches (tree
*jump_target
)
3825 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3828 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3829 STMT matches *jump_target. If we're looking for a case label and we see
3830 the default label, note it in ctx->css_state. */
3833 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3835 switch (TREE_CODE (*jump_target
))
3838 if (TREE_CODE (stmt
) == LABEL_EXPR
3839 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3844 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3846 gcc_assert (ctx
->css_state
!= NULL
);
3847 if (!CASE_LOW (stmt
))
3849 /* default: should appear just once in a SWITCH_EXPR
3850 body (excluding nested SWITCH_EXPR). */
3851 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3852 /* When evaluating SWITCH_EXPR body for the second time,
3853 return true for the default: label. */
3854 if (*ctx
->css_state
== css_default_processing
)
3856 *ctx
->css_state
= css_default_seen
;
3858 else if (CASE_HIGH (stmt
))
3860 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3861 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3864 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3875 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3876 semantics, for switch, break, continue, and return. */
3879 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3880 bool *non_constant_p
, bool *overflow_p
,
3883 tree_stmt_iterator i
;
3885 /* In a statement-expression we want to return the last value.
3886 For empty statement expression return void_node. */
3890 local_target
= NULL_TREE
;
3891 jump_target
= &local_target
;
3893 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3895 tree stmt
= tsi_stmt (i
);
3896 if (TREE_CODE (stmt
) == DEBUG_BEGIN_STMT
)
3898 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3899 non_constant_p
, overflow_p
,
3901 if (*non_constant_p
)
3903 if (returns (jump_target
) || breaks (jump_target
))
3909 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3910 semantics; continue semantics are covered by cxx_eval_statement_list. */
3913 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3914 bool *non_constant_p
, bool *overflow_p
,
3917 constexpr_ctx new_ctx
= *ctx
;
3919 tree body
= TREE_OPERAND (t
, 0);
3923 hash_set
<tree
> save_exprs
;
3924 new_ctx
.save_exprs
= &save_exprs
;
3926 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3927 non_constant_p
, overflow_p
, jump_target
);
3929 /* Forget saved values of SAVE_EXPRs. */
3930 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3931 iter
!= save_exprs
.end(); ++iter
)
3932 new_ctx
.values
->remove (*iter
);
3933 if (++count
>= constexpr_loop_limit
)
3936 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3937 "%<constexpr%> loop iteration count exceeds limit of %d "
3938 "(use -fconstexpr-loop-limit= to increase the limit)",
3939 constexpr_loop_limit
);
3940 *non_constant_p
= true;
3944 while (!returns (jump_target
)
3945 && !breaks (jump_target
)
3946 && !switches (jump_target
)
3947 && !*non_constant_p
);
3949 if (breaks (jump_target
))
3950 *jump_target
= NULL_TREE
;
3955 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3959 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3960 bool *non_constant_p
, bool *overflow_p
,
3963 tree cond
= TREE_OPERAND (t
, 0);
3964 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3965 non_constant_p
, overflow_p
);
3966 VERIFY_CONSTANT (cond
);
3967 *jump_target
= cond
;
3969 tree body
= TREE_OPERAND (t
, 1);
3970 constexpr_ctx new_ctx
= *ctx
;
3971 constexpr_switch_state css
= css_default_not_seen
;
3972 new_ctx
.css_state
= &css
;
3973 cxx_eval_constant_expression (&new_ctx
, body
, false,
3974 non_constant_p
, overflow_p
, jump_target
);
3975 if (switches (jump_target
) && css
== css_default_seen
)
3977 /* If the SWITCH_EXPR body has default: label, process it once again,
3978 this time instructing label_matches to return true for default:
3979 label on switches (jump_target). */
3980 css
= css_default_processing
;
3981 cxx_eval_constant_expression (&new_ctx
, body
, false,
3982 non_constant_p
, overflow_p
, jump_target
);
3984 if (breaks (jump_target
) || switches (jump_target
))
3985 *jump_target
= NULL_TREE
;
3989 /* Find the object of TYPE under initialization in CTX. */
3992 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3997 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3998 can is a minor optimization. */
3999 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
4005 /* Since an object cannot have a field of its own type, we can search outward
4006 from ctx->object to find the unique containing object of TYPE. */
4007 tree ob
= ctx
->object
;
4010 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
4012 if (handled_component_p (ob
))
4013 ob
= TREE_OPERAND (ob
, 0);
4021 /* Attempt to reduce the expression T to a constant value.
4022 On failure, issue diagnostic and return error_mark_node. */
4023 /* FIXME unify with c_fully_fold */
4024 /* FIXME overflow_p is too global */
4027 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
4029 bool *non_constant_p
, bool *overflow_p
,
4032 constexpr_ctx new_ctx
;
4035 if (jump_target
&& *jump_target
)
4037 /* If we are jumping, ignore all statements/expressions except those
4038 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4039 switch (TREE_CODE (t
))
4042 case STATEMENT_LIST
:
4047 case CASE_LABEL_EXPR
:
4048 if (label_matches (ctx
, jump_target
, t
))
4050 *jump_target
= NULL_TREE
;
4056 if (t
== error_mark_node
)
4058 *non_constant_p
= true;
4061 if (CONSTANT_CLASS_P (t
))
4063 if (TREE_OVERFLOW (t
))
4066 permerror (input_location
, "overflow in constant expression");
4067 if (!flag_permissive
|| ctx
->quiet
)
4071 if (TREE_CODE (t
) == INTEGER_CST
4072 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
4073 && !integer_zerop (t
))
4076 error ("value %qE of type %qT is not a constant expression",
4078 *non_constant_p
= true;
4084 tree_code tcode
= TREE_CODE (t
);
4090 /* We ask for an rvalue for the RESULT_DECL when indirecting
4091 through an invisible reference, or in named return value
4093 return (*ctx
->values
->get (t
));
4096 if (DECL_HAS_VALUE_EXPR_P (t
))
4097 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
4098 lval
, non_constant_p
, overflow_p
);
4101 /* We used to not check lval for CONST_DECL, but darwin.c uses
4102 CONST_DECL for aggregate constants. */
4105 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4106 && is_really_empty_class (TREE_TYPE (t
)))
4108 /* If the class is empty, we aren't actually loading anything. */
4109 r
= build_constructor (TREE_TYPE (t
), NULL
);
4110 TREE_CONSTANT (r
) = true;
4112 else if (ctx
->strict
)
4113 r
= decl_really_constant_value (t
);
4115 r
= decl_constant_value (t
);
4116 if (TREE_CODE (r
) == TARGET_EXPR
4117 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4118 r
= TARGET_EXPR_INITIAL (r
);
4120 if (tree
*p
= ctx
->values
->get (r
))
4121 if (*p
!= NULL_TREE
)
4126 non_const_var_error (r
);
4127 *non_constant_p
= true;
4131 case DEBUG_BEGIN_STMT
:
4132 /* ??? It might be nice to retain this information somehow, so
4133 as to be able to step into a constexpr function call. */
4140 case CASE_LABEL_EXPR
:
4145 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4147 else if (tree
*p
= ctx
->values
->get (r
))
4150 /* Defer in case this is only used for its type. */;
4151 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4152 /* Defer, there's no lvalue->rvalue conversion. */;
4153 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4154 && is_really_empty_class (TREE_TYPE (t
)))
4156 /* If the class is empty, we aren't actually loading anything. */
4157 r
= build_constructor (TREE_TYPE (t
), NULL
);
4158 TREE_CONSTANT (r
) = true;
4163 error ("%qE is not a constant expression", t
);
4164 *non_constant_p
= true;
4169 case AGGR_INIT_EXPR
:
4170 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4171 non_constant_p
, overflow_p
);
4176 r
= DECL_EXPR_DECL (t
);
4177 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4178 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4182 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4183 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4184 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4188 if (tree init
= DECL_INITIAL (r
))
4190 init
= cxx_eval_constant_expression (ctx
, init
,
4192 non_constant_p
, overflow_p
);
4193 /* Don't share a CONSTRUCTOR that might be changed. */
4194 init
= unshare_constructor (init
);
4195 ctx
->values
->put (r
, init
);
4197 else if (ctx
== &new_ctx
)
4198 /* We gave it a CONSTRUCTOR above. */;
4200 ctx
->values
->put (r
, NULL_TREE
);
4205 if (!literal_type_p (TREE_TYPE (t
)))
4209 error ("temporary of non-literal type %qT in a "
4210 "constant expression", TREE_TYPE (t
));
4211 explain_non_literal_class (TREE_TYPE (t
));
4213 *non_constant_p
= true;
4216 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4218 /* We're being expanded without an explicit target, so start
4219 initializing a new object; expansion with an explicit target
4220 strips the TARGET_EXPR before we get here. */
4222 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4223 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4224 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4225 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4228 /* Pass false for 'lval' because this indicates
4229 initialization of a temporary. */
4230 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4232 non_constant_p
, overflow_p
);
4233 if (!*non_constant_p
)
4234 /* Adjust the type of the result to the type of the temporary. */
4235 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4238 tree slot
= TARGET_EXPR_SLOT (t
);
4239 r
= unshare_constructor (r
);
4240 ctx
->values
->put (slot
, r
);
4247 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4248 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4249 non_constant_p
, overflow_p
);
4253 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4255 non_constant_p
, overflow_p
);
4259 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4260 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4262 non_constant_p
, overflow_p
);
4267 /* Can happen with ({ return true; }) && false; passed to
4268 maybe_constant_value. There is nothing to jump over in this
4269 case, and the bug will be diagnosed later. */
4270 gcc_assert (ctx
->quiet
);
4271 *non_constant_p
= true;
4276 /* Avoid evaluating a SAVE_EXPR more than once. */
4277 if (tree
*p
= ctx
->values
->get (t
))
4281 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4282 non_constant_p
, overflow_p
);
4283 ctx
->values
->put (t
, r
);
4284 if (ctx
->save_exprs
)
4285 ctx
->save_exprs
->add (t
);
4289 case NON_LVALUE_EXPR
:
4290 case TRY_CATCH_EXPR
:
4292 case CLEANUP_POINT_EXPR
:
4293 case MUST_NOT_THROW_EXPR
:
4296 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4298 non_constant_p
, overflow_p
,
4302 case TRY_FINALLY_EXPR
:
4303 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4304 non_constant_p
, overflow_p
,
4306 if (!*non_constant_p
)
4307 /* Also evaluate the cleanup. */
4308 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4309 non_constant_p
, overflow_p
,
4313 /* These differ from cxx_eval_unary_expression in that this doesn't
4314 check for a constant operand or result; an address can be
4315 constant without its operand being, and vice versa. */
4318 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4319 non_constant_p
, overflow_p
);
4324 tree oldop
= TREE_OPERAND (t
, 0);
4325 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4327 non_constant_p
, overflow_p
);
4328 /* Don't VERIFY_CONSTANT here. */
4329 if (*non_constant_p
)
4331 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4332 /* This function does more aggressive folding than fold itself. */
4333 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4334 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4343 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4344 non_constant_p
, overflow_p
);
4345 if (r
== error_mark_node
)
4347 else if (r
== TREE_OPERAND (t
, 0))
4350 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4355 case FIX_TRUNC_EXPR
:
4360 case TRUTH_NOT_EXPR
:
4361 case FIXED_CONVERT_EXPR
:
4362 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4363 non_constant_p
, overflow_p
);
4367 r
= fold_sizeof_expr (t
);
4368 VERIFY_CONSTANT (r
);
4373 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4374 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4375 introduced by build_call_a. */
4376 tree op0
= TREE_OPERAND (t
, 0);
4377 tree op1
= TREE_OPERAND (t
, 1);
4379 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4380 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4381 r
= cxx_eval_constant_expression (ctx
, op0
,
4382 lval
, non_constant_p
, overflow_p
,
4386 /* Check that the LHS is constant and then discard it. */
4387 cxx_eval_constant_expression (ctx
, op0
,
4388 true, non_constant_p
, overflow_p
,
4390 if (*non_constant_p
)
4392 op1
= TREE_OPERAND (t
, 1);
4393 r
= cxx_eval_constant_expression (ctx
, op1
,
4394 lval
, non_constant_p
, overflow_p
,
4400 case POINTER_PLUS_EXPR
:
4401 case POINTER_DIFF_EXPR
:
4405 case TRUNC_DIV_EXPR
:
4407 case FLOOR_DIV_EXPR
:
4408 case ROUND_DIV_EXPR
:
4409 case TRUNC_MOD_EXPR
:
4411 case ROUND_MOD_EXPR
:
4413 case EXACT_DIV_EXPR
:
4423 case TRUTH_XOR_EXPR
:
4430 case UNORDERED_EXPR
:
4440 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4441 non_constant_p
, overflow_p
);
4444 /* fold can introduce non-IF versions of these; still treat them as
4445 short-circuiting. */
4446 case TRUTH_AND_EXPR
:
4447 case TRUTH_ANDIF_EXPR
:
4448 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4451 non_constant_p
, overflow_p
);
4455 case TRUTH_ORIF_EXPR
:
4456 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4459 non_constant_p
, overflow_p
);
4463 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4464 non_constant_p
, overflow_p
);
4468 if (is_overloaded_fn (t
))
4470 /* We can only get here in checking mode via
4471 build_non_dependent_expr, because any expression that
4472 calls or takes the address of the function will have
4473 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4474 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4475 *non_constant_p
= true;
4478 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4479 non_constant_p
, overflow_p
);
4483 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4484 non_constant_p
, overflow_p
);
4488 if (jump_target
&& *jump_target
)
4490 /* When jumping to a label, the label might be either in the
4491 then or else blocks, so process then block first in skipping
4492 mode first, and if we are still in the skipping mode at its end,
4493 process the else block too. */
4494 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4495 lval
, non_constant_p
, overflow_p
,
4498 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4499 lval
, non_constant_p
, overflow_p
,
4503 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4504 non_constant_p
, overflow_p
,
4508 r
= cxx_eval_vector_conditional_expression (ctx
, t
, non_constant_p
,
4513 if (TREE_CONSTANT (t
))
4515 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4516 VECTOR_CST if applicable. */
4517 /* FIXME after GCC 6 branches, make the verify unconditional. */
4519 verify_constructor_flags (t
);
4521 recompute_constructor_flags (t
);
4522 if (TREE_CONSTANT (t
))
4525 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4526 non_constant_p
, overflow_p
);
4530 /* We can get this in a defaulted constructor for a class with a
4531 non-static data member of array type. Either the initializer will
4532 be NULL, meaning default-initialization, or it will be an lvalue
4533 or xvalue of the same type, meaning direct-initialization from the
4534 corresponding member. */
4535 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4536 non_constant_p
, overflow_p
);
4541 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4542 non_constant_p
, overflow_p
);
4546 case VIEW_CONVERT_EXPR
:
4548 case UNARY_PLUS_EXPR
:
4550 tree oldop
= TREE_OPERAND (t
, 0);
4552 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4554 non_constant_p
, overflow_p
);
4555 if (*non_constant_p
)
4557 tree type
= TREE_TYPE (t
);
4558 if (TREE_CODE (op
) == PTRMEM_CST
4559 && !TYPE_PTRMEM_P (type
))
4560 op
= cplus_expand_constant (op
);
4561 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4563 if (same_type_ignoring_top_level_qualifiers_p (type
,
4565 || can_convert_qual (type
, op
))
4566 return cp_fold_convert (type
, op
);
4570 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4571 "a reinterpret_cast is not a constant expression");
4572 *non_constant_p
= true;
4577 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4579 if (integer_zerop (op
))
4581 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4584 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4585 "dereferencing a null pointer");
4586 *non_constant_p
= true;
4589 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4591 tree from
= TREE_TYPE (op
);
4593 if (!can_convert (type
, from
, tf_none
))
4596 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4597 "conversion of %qT null pointer to %qT "
4598 "is not a constant expression",
4600 *non_constant_p
= true;
4607 /* This detects for example:
4608 reinterpret_cast<void*>(sizeof 0)
4611 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4612 "%<reinterpret_cast<%T>(%E)%> is not "
4613 "a constant expression",
4615 *non_constant_p
= true;
4619 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4620 /* We didn't fold at the top so we could check for ptr-int
4623 if (tcode
== UNARY_PLUS_EXPR
)
4624 r
= fold_convert (TREE_TYPE (t
), op
);
4626 r
= fold_build1 (tcode
, type
, op
);
4627 /* Conversion of an out-of-range value has implementation-defined
4628 behavior; the language considers it different from arithmetic
4629 overflow, which is undefined. */
4630 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4631 TREE_OVERFLOW (r
) = false;
4635 case EMPTY_CLASS_EXPR
:
4636 /* This is good enough for a function argument that might not get
4637 used, and they can't do anything with it, so just return it. */
4640 case STATEMENT_LIST
:
4642 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4643 return cxx_eval_statement_list (&new_ctx
, t
,
4644 non_constant_p
, overflow_p
, jump_target
);
4647 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4649 non_constant_p
, overflow_p
,
4652 case PREINCREMENT_EXPR
:
4653 case POSTINCREMENT_EXPR
:
4654 case PREDECREMENT_EXPR
:
4655 case POSTDECREMENT_EXPR
:
4656 return cxx_eval_increment_expression (ctx
, t
,
4657 lval
, non_constant_p
, overflow_p
);
4663 case VEC_DELETE_EXPR
:
4666 /* GCC internal stuff. */
4669 case NON_DEPENDENT_EXPR
:
4673 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4674 "expression %qE is not a constant expression", t
);
4675 *non_constant_p
= true;
4678 case PLACEHOLDER_EXPR
:
4679 /* Use of the value or address of the current object. */
4680 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4681 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4682 non_constant_p
, overflow_p
);
4683 /* A placeholder without a referent. We can get here when
4684 checking whether NSDMIs are noexcept, or in massage_init_elt;
4685 just say it's non-constant for now. */
4686 gcc_assert (ctx
->quiet
);
4687 *non_constant_p
= true;
4692 tree cond
= TREE_OPERAND (t
, 0);
4693 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4694 non_constant_p
, overflow_p
);
4695 VERIFY_CONSTANT (cond
);
4696 if (integer_nonzerop (cond
))
4702 *jump_target
= TREE_OPERAND (t
, 0);
4703 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4704 /* Allow for jumping to a cdtor_label. */
4705 || returns (jump_target
));
4709 cxx_eval_loop_expr (ctx
, t
,
4710 non_constant_p
, overflow_p
, jump_target
);
4714 cxx_eval_switch_expr (ctx
, t
,
4715 non_constant_p
, overflow_p
, jump_target
);
4719 /* It's possible to get a requires-expression in a constant
4720 expression. For example:
4722 template<typename T> concept bool C() {
4723 return requires (T t) { t; };
4726 template<typename T> requires !C<T>() void f(T);
4728 Normalization leaves f with the associated constraint
4729 '!requires (T t) { ... }' which is not transformed into
4731 if (!processing_template_decl
)
4732 return evaluate_constraint_expression (t
, NULL_TREE
);
4734 *non_constant_p
= true;
4738 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4740 non_constant_p
, overflow_p
,
4749 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4751 /* This function doesn't know how to deal with pre-genericize
4752 statements; this can only happen with statement-expressions,
4753 so for now just fail. */
4755 error_at (EXPR_LOCATION (t
),
4756 "statement is not a constant expression");
4759 internal_error ("unexpected expression %qE of kind %s", t
,
4760 get_tree_code_name (TREE_CODE (t
)));
4761 *non_constant_p
= true;
4765 if (r
== error_mark_node
)
4766 *non_constant_p
= true;
4768 if (*non_constant_p
)
4775 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4776 bool strict
= true, tree object
= NULL_TREE
)
4778 auto_timevar
time (TV_CONSTEXPR
);
4780 bool non_constant_p
= false;
4781 bool overflow_p
= false;
4782 hash_map
<tree
,tree
> map
;
4784 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4785 allow_non_constant
, strict
};
4787 tree type
= initialized_type (t
);
4789 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4791 /* In C++14 an NSDMI can participate in aggregate initialization,
4792 and can refer to the address of the object being initialized, so
4793 we need to pass in the relevant VAR_DECL if we want to do the
4794 evaluation in a single pass. The evaluation will dynamically
4795 update ctx.values for the VAR_DECL. We use the same strategy
4796 for C++11 constexpr constructors that refer to the object being
4798 ctx
.ctor
= build_constructor (type
, NULL
);
4799 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4802 if (TREE_CODE (t
) == TARGET_EXPR
)
4803 object
= TARGET_EXPR_SLOT (t
);
4804 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4805 object
= AGGR_INIT_EXPR_SLOT (t
);
4807 ctx
.object
= object
;
4809 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4810 (type
, TREE_TYPE (object
)));
4811 if (object
&& DECL_P (object
))
4812 map
.put (object
, ctx
.ctor
);
4813 if (TREE_CODE (r
) == TARGET_EXPR
)
4814 /* Avoid creating another CONSTRUCTOR when we expand the
4816 r
= TARGET_EXPR_INITIAL (r
);
4819 r
= cxx_eval_constant_expression (&ctx
, r
,
4820 false, &non_constant_p
, &overflow_p
);
4822 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4824 /* Mutable logic is a bit tricky: we want to allow initialization of
4825 constexpr variables with mutable members, but we can't copy those
4826 members to another constexpr variable. */
4827 if (TREE_CODE (r
) == CONSTRUCTOR
4828 && CONSTRUCTOR_MUTABLE_POISON (r
))
4830 if (!allow_non_constant
)
4831 error ("%qE is not a constant expression because it refers to "
4832 "mutable subobjects of %qT", t
, type
);
4833 non_constant_p
= true;
4836 if (TREE_CODE (r
) == CONSTRUCTOR
4837 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4839 if (!allow_non_constant
)
4840 error ("%qE is not a constant expression because it refers to "
4841 "an incompletely initialized variable", t
);
4842 TREE_CONSTANT (r
) = false;
4843 non_constant_p
= true;
4846 /* Technically we should check this for all subexpressions, but that
4847 runs into problems with our internal representation of pointer
4848 subtraction and the 5.19 rules are still in flux. */
4849 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4850 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4851 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4853 if (!allow_non_constant
)
4854 error ("conversion from pointer type %qT "
4855 "to arithmetic type %qT in a constant expression",
4856 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4857 non_constant_p
= true;
4860 if (!non_constant_p
&& overflow_p
)
4861 non_constant_p
= true;
4863 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4865 bool should_unshare
= true;
4866 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4867 should_unshare
= false;
4869 if (non_constant_p
&& !allow_non_constant
)
4870 return error_mark_node
;
4871 else if (non_constant_p
&& TREE_CONSTANT (r
))
4873 /* This isn't actually constant, so unset TREE_CONSTANT.
4874 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
4875 it to be set if it is invariant address, even when it is not
4876 a valid C++ constant expression. Wrap it with a NOP_EXPR
4878 if (EXPR_P (r
) && TREE_CODE (r
) != ADDR_EXPR
)
4880 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4881 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4883 r
= build_nop (TREE_TYPE (r
), r
);
4884 TREE_CONSTANT (r
) = false;
4886 else if (non_constant_p
|| r
== t
)
4890 r
= unshare_expr (r
);
4892 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4894 if (TREE_CODE (t
) == TARGET_EXPR
4895 && TARGET_EXPR_INITIAL (t
) == r
)
4899 r
= get_target_expr (r
);
4900 TREE_CONSTANT (r
) = true;
4908 /* Returns true if T is a valid subexpression of a constant expression,
4909 even if it isn't itself a constant expression. */
4912 is_sub_constant_expr (tree t
)
4914 bool non_constant_p
= false;
4915 bool overflow_p
= false;
4916 hash_map
<tree
, tree
> map
;
4918 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4920 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4922 return !non_constant_p
&& !overflow_p
;
4925 /* If T represents a constant expression returns its reduced value.
4926 Otherwise return error_mark_node. If T is dependent, then
4930 cxx_constant_value (tree t
, tree decl
)
4932 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4935 /* Helper routine for fold_simple function. Either return simplified
4936 expression T, otherwise NULL_TREE.
4937 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4938 even if we are within template-declaration. So be careful on call, as in
4939 such case types can be undefined. */
4942 fold_simple_1 (tree t
)
4945 enum tree_code code
= TREE_CODE (t
);
4957 return fold_sizeof_expr (t
);
4965 case TRUTH_NOT_EXPR
:
4967 case VIEW_CONVERT_EXPR
:
4970 case FIX_TRUNC_EXPR
:
4971 case FIXED_CONVERT_EXPR
:
4972 case ADDR_SPACE_CONVERT_EXPR
:
4974 op1
= TREE_OPERAND (t
, 0);
4976 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4980 if (CONVERT_EXPR_CODE_P (code
)
4981 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4982 TREE_OVERFLOW (t
) = false;
4990 /* If T is a simple constant expression, returns its simplified value.
4991 Otherwise returns T. In contrast to maybe_constant_value we
4992 simplify only few operations on constant-expressions, and we don't
4993 try to simplify constexpressions. */
4996 fold_simple (tree t
)
4998 if (processing_template_decl
)
5001 tree r
= fold_simple_1 (t
);
5008 /* If T is a constant expression, returns its reduced value.
5009 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5010 Otherwise, returns a version of T without TREE_CONSTANT. */
5012 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
5015 maybe_constant_value (tree t
, tree decl
)
5019 if (!is_nondependent_constant_expression (t
))
5021 if (TREE_OVERFLOW_P (t
))
5023 t
= build_nop (TREE_TYPE (t
), t
);
5024 TREE_CONSTANT (t
) = false;
5028 else if (CONSTANT_CLASS_P (t
))
5029 /* No caching or evaluation needed. */
5032 if (cv_cache
== NULL
)
5033 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
5034 if (tree
*cached
= cv_cache
->get (t
))
5037 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
5038 gcc_checking_assert (r
== t
5039 || CONVERT_EXPR_P (t
)
5040 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5041 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5042 || !cp_tree_equal (r
, t
));
5043 cv_cache
->put (t
, r
);
5047 /* Dispose of the whole CV_CACHE. */
5050 clear_cv_cache (void)
5052 if (cv_cache
!= NULL
)
5056 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5059 clear_cv_and_fold_caches (void)
5062 clear_fold_cache ();
5065 /* Like maybe_constant_value but first fully instantiate the argument.
5067 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5068 (t, tf_none) followed by maybe_constant_value but is more efficient,
5069 because calls instantiation_dependent_expression_p and
5070 potential_constant_expression at most once. */
5073 fold_non_dependent_expr (tree t
)
5078 /* If we're in a template, but T isn't value dependent, simplify
5079 it. We're supposed to treat:
5081 template <typename T> void f(T[1 + 1]);
5082 template <typename T> void f(T[2]);
5084 as two declarations of the same function, for example. */
5085 if (processing_template_decl
)
5087 if (is_nondependent_constant_expression (t
))
5089 processing_template_decl_sentinel s
;
5090 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
5092 if (type_unknown_p (t
)
5093 || BRACE_ENCLOSED_INITIALIZER_P (t
))
5095 if (TREE_OVERFLOW_P (t
))
5097 t
= build_nop (TREE_TYPE (t
), t
);
5098 TREE_CONSTANT (t
) = false;
5103 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
5104 /* cp_tree_equal looks through NOPs, so allow them. */
5105 gcc_checking_assert (r
== t
5106 || CONVERT_EXPR_P (t
)
5107 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5108 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
5109 || !cp_tree_equal (r
, t
));
5112 else if (TREE_OVERFLOW_P (t
))
5114 t
= build_nop (TREE_TYPE (t
), t
);
5115 TREE_CONSTANT (t
) = false;
5120 return maybe_constant_value (t
);
5123 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5124 than wrapped in a TARGET_EXPR. */
5127 maybe_constant_init_1 (tree t
, tree decl
, bool allow_non_constant
)
5131 if (TREE_CODE (t
) == EXPR_STMT
)
5132 t
= TREE_OPERAND (t
, 0);
5133 if (TREE_CODE (t
) == CONVERT_EXPR
5134 && VOID_TYPE_P (TREE_TYPE (t
)))
5135 t
= TREE_OPERAND (t
, 0);
5136 if (TREE_CODE (t
) == INIT_EXPR
)
5137 t
= TREE_OPERAND (t
, 1);
5138 if (TREE_CODE (t
) == TARGET_EXPR
)
5139 t
= TARGET_EXPR_INITIAL (t
);
5140 if (!is_nondependent_static_init_expression (t
))
5141 /* Don't try to evaluate it. */;
5142 else if (CONSTANT_CLASS_P (t
) && allow_non_constant
)
5143 /* No evaluation needed. */;
5145 t
= cxx_eval_outermost_constant_expr (t
, allow_non_constant
, false, decl
);
5146 if (TREE_CODE (t
) == TARGET_EXPR
)
5148 tree init
= TARGET_EXPR_INITIAL (t
);
5149 if (TREE_CODE (init
) == CONSTRUCTOR
)
5155 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5158 maybe_constant_init (tree t
, tree decl
)
5160 return maybe_constant_init_1 (t
, decl
, true);
5163 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5166 cxx_constant_init (tree t
, tree decl
)
5168 return maybe_constant_init_1 (t
, decl
, false);
5172 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5173 /* Return true if the object referred to by REF has automatic or thread
5176 enum { ck_ok
, ck_bad
, ck_unknown
};
5178 check_automatic_or_tls (tree ref
)
5181 poly_int64 bitsize
, bitpos
;
5183 int volatilep
= 0, unsignedp
= 0;
5184 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5185 &mode
, &unsignedp
, &volatilep
, false);
5188 /* If there isn't a decl in the middle, we don't know the linkage here,
5189 and this isn't a constant expression anyway. */
5192 dk
= decl_storage_duration (decl
);
5193 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5197 /* Return true if T denotes a potentially constant expression. Issue
5198 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5199 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5200 consider the expression in the current context, independent of constexpr
5203 C++0x [expr.const] used to say
5205 6 An expression is a potential constant expression if it is
5206 a constant expression where all occurrences of function
5207 parameters are replaced by arbitrary constant expressions
5208 of the appropriate type.
5210 2 A conditional expression is a constant expression unless it
5211 involves one of the following as a potentially evaluated
5212 subexpression (3.2), but subexpressions of logical AND (5.14),
5213 logical OR (5.15), and conditional (5.16) operations that are
5214 not evaluated are not considered. */
5217 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5218 tsubst_flags_t flags
)
5220 #define RECUR(T,RV) \
5221 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5223 enum { any
= false, rval
= true };
5227 if (t
== error_mark_node
)
5231 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5232 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5234 if (flags
& tf_error
)
5235 error_at (loc
, "expression %qE has side-effects", t
);
5238 if (CONSTANT_CLASS_P (t
))
5240 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5241 && TREE_TYPE (t
) == error_mark_node
)
5244 switch (TREE_CODE (t
))
5250 case TEMPLATE_ID_EXPR
:
5253 case CASE_LABEL_EXPR
:
5259 case TEMPLATE_PARM_INDEX
:
5261 case IDENTIFIER_NODE
:
5262 case USERDEF_LITERAL
:
5263 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5268 case PLACEHOLDER_EXPR
:
5273 case DEBUG_BEGIN_STMT
:
5279 if (flags
& tf_error
)
5280 error ("%qE is not a constant expression", t
);
5285 case AGGR_INIT_EXPR
:
5287 /* -- an invocation of a function other than a constexpr function
5288 or a constexpr constructor. */
5290 tree fun
= get_function_named_in_call (t
);
5291 const int nargs
= call_expr_nargs (t
);
5294 if (fun
== NULL_TREE
)
5296 /* Reset to allow the function to continue past the end
5297 of the block below. Otherwise return early. */
5300 if (TREE_CODE (t
) == CALL_EXPR
5301 && CALL_EXPR_FN (t
) == NULL_TREE
)
5302 switch (CALL_EXPR_IFN (t
))
5304 /* These should be ignored, they are optimized away from
5305 constexpr functions. */
5306 case IFN_UBSAN_NULL
:
5307 case IFN_UBSAN_BOUNDS
:
5308 case IFN_UBSAN_VPTR
:
5309 case IFN_FALLTHROUGH
:
5312 case IFN_ADD_OVERFLOW
:
5313 case IFN_SUB_OVERFLOW
:
5314 case IFN_MUL_OVERFLOW
:
5324 /* fold_call_expr can't do anything with IFN calls. */
5325 if (flags
& tf_error
)
5326 error_at (loc
, "call to internal function %qE", t
);
5331 if (fun
&& is_overloaded_fn (fun
))
5333 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5335 if (builtin_valid_in_constant_expr_p (fun
))
5337 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5338 /* Allow any built-in function; if the expansion
5339 isn't constant, we'll deal with that then. */
5340 && !is_builtin_fn (fun
))
5342 if (flags
& tf_error
)
5344 error_at (loc
, "call to non-%<constexpr%> function %qD",
5346 explain_invalid_constexpr_fn (fun
);
5350 /* A call to a non-static member function takes the address
5351 of the object as the first argument. But in a constant
5352 expression the address will be folded away, so look
5354 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5355 && !DECL_CONSTRUCTOR_P (fun
))
5357 tree x
= get_nth_callarg (t
, 0);
5358 if (is_this_parameter (x
))
5360 /* Don't require an immediately constant value, as
5361 constexpr substitution might not use the value. */
5362 bool sub_now
= false;
5363 if (!potential_constant_expression_1 (x
, rval
, strict
,
5371 if (!RECUR (fun
, true))
5373 fun
= get_first_fn (fun
);
5375 /* Skip initial arguments to base constructors. */
5376 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5377 i
= num_artificial_parms_for (fun
);
5378 fun
= DECL_ORIGIN (fun
);
5382 if (RECUR (fun
, rval
))
5383 /* Might end up being a constant function pointer. */;
5387 for (; i
< nargs
; ++i
)
5389 tree x
= get_nth_callarg (t
, i
);
5390 /* In a template, reference arguments haven't been converted to
5391 REFERENCE_TYPE and we might not even know if the parameter
5392 is a reference, so accept lvalue constants too. */
5393 bool rv
= processing_template_decl
? any
: rval
;
5394 /* Don't require an immediately constant value, as constexpr
5395 substitution might not use the value of the argument. */
5396 bool sub_now
= false;
5397 if (!potential_constant_expression_1 (x
, rv
, strict
,
5404 case NON_LVALUE_EXPR
:
5405 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5406 -- an lvalue of integral type that refers to a non-volatile
5407 const variable or static data member initialized with
5408 constant expressions, or
5410 -- an lvalue of literal type that refers to non-volatile
5411 object defined with constexpr, or that refers to a
5412 sub-object of such an object; */
5413 return RECUR (TREE_OPERAND (t
, 0), rval
);
5416 if (DECL_HAS_VALUE_EXPR_P (t
))
5418 if (now
&& is_capture_proxy_with_ref (t
))
5420 /* -- in a lambda-expression, a reference to this or to a
5421 variable with automatic storage duration defined outside that
5422 lambda-expression, where the reference would be an
5424 if (flags
& tf_error
)
5426 tree cap
= DECL_CAPTURED_VARIABLE (t
);
5427 error ("lambda capture of %qE is not a constant expression",
5429 if (!want_rval
&& decl_constant_var_p (cap
))
5430 inform (input_location
, "because it is used as a glvalue");
5434 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5437 && !var_in_maybe_constexpr_fn (t
)
5438 && !type_dependent_expression_p (t
)
5439 && !decl_maybe_constant_var_p (t
)
5441 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5442 || (DECL_INITIAL (t
)
5443 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5444 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5445 && !is_really_empty_class (TREE_TYPE (t
)))
5447 if (flags
& tf_error
)
5448 non_const_var_error (t
);
5455 case VIEW_CONVERT_EXPR
:
5456 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5457 may change to something more specific to type-punning (DR 1312). */
5459 tree from
= TREE_OPERAND (t
, 0);
5460 if (POINTER_TYPE_P (TREE_TYPE (t
))
5461 && TREE_CODE (from
) == INTEGER_CST
5462 && !integer_zerop (from
))
5464 if (flags
& tf_error
)
5465 error_at (loc
, "reinterpret_cast from integer to pointer");
5468 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5471 case ADDRESSOF_EXPR
:
5472 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5473 t
= TREE_OPERAND (t
, 0);
5474 goto handle_addr_expr
;
5477 /* -- a unary operator & that is applied to an lvalue that
5478 designates an object with thread or automatic storage
5480 t
= TREE_OPERAND (t
, 0);
5482 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5483 /* A pointer-to-member constant. */
5488 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5489 any checking here, as we might dereference the pointer later. If
5490 we remove this code, also remove check_automatic_or_tls. */
5491 i
= check_automatic_or_tls (t
);
5496 if (flags
& tf_error
)
5497 error ("address-of an object %qE with thread local or "
5498 "automatic storage is not a constant expression", t
);
5502 return RECUR (t
, any
);
5510 /* -- a class member access unless its postfix-expression is
5511 of literal type or of pointer to literal type. */
5512 /* This test would be redundant, as it follows from the
5513 postfix-expression being a potential constant expression. */
5514 if (type_unknown_p (t
))
5516 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5518 case EXPR_PACK_EXPANSION
:
5519 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5523 tree x
= TREE_OPERAND (t
, 0);
5525 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5527 if (!var_in_maybe_constexpr_fn (x
))
5529 if (flags
& tf_error
)
5530 error_at (loc
, "use of %<this%> in a constant expression");
5535 return RECUR (x
, rval
);
5538 case STATEMENT_LIST
:
5540 tree_stmt_iterator i
;
5541 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5543 if (!RECUR (tsi_stmt (i
), any
))
5551 if (cxx_dialect
< cxx14
)
5553 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5555 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5560 if (cxx_dialect
< cxx14
)
5562 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5564 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5569 if (!RECUR (DO_COND (t
), rval
))
5571 if (!RECUR (DO_BODY (t
), any
))
5576 if (!RECUR (FOR_INIT_STMT (t
), any
))
5578 if (!RECUR (FOR_COND (t
), rval
))
5580 if (!RECUR (FOR_EXPR (t
), any
))
5582 if (!RECUR (FOR_BODY (t
), any
))
5586 case RANGE_FOR_STMT
:
5587 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5589 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5594 if (!RECUR (WHILE_COND (t
), rval
))
5596 if (!RECUR (WHILE_BODY (t
), any
))
5601 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5603 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5604 unreachable labels would be checked. */
5608 return RECUR (STMT_EXPR_STMT (t
), rval
);
5611 if (cxx_dialect
>= cxx17
)
5612 /* In C++17 lambdas can be constexpr, don't give up yet. */
5614 else if (flags
& tf_error
)
5615 error_at (loc
, "lambda-expression is not a constant expression "
5619 case DYNAMIC_CAST_EXPR
:
5620 case PSEUDO_DTOR_EXPR
:
5624 case VEC_DELETE_EXPR
:
5630 case OMP_DISTRIBUTE
:
5633 case OMP_TARGET_DATA
:
5642 case OMP_TARGET_UPDATE
:
5643 case OMP_TARGET_ENTER_DATA
:
5644 case OMP_TARGET_EXIT_DATA
:
5646 case OMP_ATOMIC_READ
:
5647 case OMP_ATOMIC_CAPTURE_OLD
:
5648 case OMP_ATOMIC_CAPTURE_NEW
:
5652 case OACC_HOST_DATA
:
5656 case OACC_ENTER_DATA
:
5657 case OACC_EXIT_DATA
:
5659 /* GCC internal stuff. */
5662 case TRANSACTION_EXPR
:
5664 case AT_ENCODE_EXPR
:
5666 if (flags
& tf_error
)
5667 error_at (loc
, "expression %qE is not a constant expression", t
);
5671 /* -- a typeid expression whose operand is of polymorphic
5674 tree e
= TREE_OPERAND (t
, 0);
5675 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5676 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5678 if (flags
& tf_error
)
5679 error_at (loc
, "typeid-expression is not a constant expression "
5680 "because %qE is of polymorphic type", e
);
5686 case POINTER_DIFF_EXPR
:
5700 case PREINCREMENT_EXPR
:
5701 case POSTINCREMENT_EXPR
:
5702 case PREDECREMENT_EXPR
:
5703 case POSTDECREMENT_EXPR
:
5704 if (cxx_dialect
< cxx14
)
5710 if (TYPE_P (TREE_OPERAND (t
, 0)))
5716 case FIX_TRUNC_EXPR
:
5720 case TRUTH_NOT_EXPR
:
5721 case FIXED_CONVERT_EXPR
:
5722 case UNARY_PLUS_EXPR
:
5723 case UNARY_LEFT_FOLD_EXPR
:
5724 case UNARY_RIGHT_FOLD_EXPR
:
5726 return RECUR (TREE_OPERAND (t
, 0), rval
);
5729 case CONST_CAST_EXPR
:
5730 case STATIC_CAST_EXPR
:
5731 case REINTERPRET_CAST_EXPR
:
5732 case IMPLICIT_CONV_EXPR
:
5733 if (cxx_dialect
< cxx11
5734 && !dependent_type_p (TREE_TYPE (t
))
5735 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5736 /* In C++98, a conversion to non-integral type can't be part of a
5737 constant expression. */
5739 if (flags
& tf_error
)
5741 "cast to non-integral type %qT in a constant expression",
5746 return (RECUR (TREE_OPERAND (t
, 0),
5747 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5750 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5752 case CLEANUP_POINT_EXPR
:
5753 case MUST_NOT_THROW_EXPR
:
5754 case TRY_CATCH_EXPR
:
5759 case NON_DEPENDENT_EXPR
:
5760 /* For convenience. */
5764 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5767 tmp
= DECL_EXPR_DECL (t
);
5768 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5770 if (TREE_STATIC (tmp
))
5772 if (flags
& tf_error
)
5773 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5774 "%<static%> in %<constexpr%> context", tmp
);
5777 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5779 if (flags
& tf_error
)
5780 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5781 "%<thread_local%> in %<constexpr%> context", tmp
);
5784 else if (!check_for_uninitialized_const_var
5785 (tmp
, /*constexpr_context_p=*/true, flags
))
5788 return RECUR (tmp
, want_rval
);
5790 case TRY_FINALLY_EXPR
:
5791 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5792 && RECUR (TREE_OPERAND (t
, 1), any
));
5795 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5798 if (!TARGET_EXPR_DIRECT_INIT_P (t
)
5799 && !literal_type_p (TREE_TYPE (t
)))
5801 if (flags
& tf_error
)
5803 error_at (loc
, "temporary of non-literal type %qT in a "
5804 "constant expression", TREE_TYPE (t
));
5805 explain_non_literal_class (TREE_TYPE (t
));
5811 return RECUR (TREE_OPERAND (t
, 1), rval
);
5815 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5816 constructor_elt
*ce
;
5817 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5818 if (!RECUR (ce
->value
, want_rval
))
5825 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5826 || DECL_P (TREE_PURPOSE (t
)));
5827 if (!RECUR (TREE_VALUE (t
), want_rval
))
5829 if (TREE_CHAIN (t
) == NULL_TREE
)
5831 return RECUR (TREE_CHAIN (t
), want_rval
);
5834 case TRUNC_DIV_EXPR
:
5836 case FLOOR_DIV_EXPR
:
5837 case ROUND_DIV_EXPR
:
5838 case TRUNC_MOD_EXPR
:
5840 case ROUND_MOD_EXPR
:
5842 tree denom
= TREE_OPERAND (t
, 1);
5843 if (!RECUR (denom
, rval
))
5845 /* We can't call cxx_eval_outermost_constant_expr on an expression
5846 that hasn't been through instantiate_non_dependent_expr yet. */
5847 if (!processing_template_decl
)
5848 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5849 if (integer_zerop (denom
))
5851 if (flags
& tf_error
)
5852 error ("division by zero is not a constant expression");
5858 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5864 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5865 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5866 introduced by build_call_a. */
5867 tree op0
= TREE_OPERAND (t
, 0);
5868 tree op1
= TREE_OPERAND (t
, 1);
5870 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5871 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5872 return RECUR (op0
, want_rval
);
5877 /* If the first operand is the non-short-circuit constant, look at
5878 the second operand; otherwise we only care about the first one for
5880 case TRUTH_AND_EXPR
:
5881 case TRUTH_ANDIF_EXPR
:
5882 tmp
= boolean_true_node
;
5885 case TRUTH_ORIF_EXPR
:
5886 tmp
= boolean_false_node
;
5889 tree op
= TREE_OPERAND (t
, 0);
5890 if (!RECUR (op
, rval
))
5892 if (!processing_template_decl
)
5893 op
= cxx_eval_outermost_constant_expr (op
, true);
5894 if (tree_int_cst_equal (op
, tmp
))
5895 return RECUR (TREE_OPERAND (t
, 1), rval
);
5902 case POINTER_PLUS_EXPR
:
5904 case EXACT_DIV_EXPR
:
5914 case TRUTH_XOR_EXPR
:
5915 case UNORDERED_EXPR
:
5928 case ARRAY_RANGE_REF
:
5932 case BINARY_LEFT_FOLD_EXPR
:
5933 case BINARY_RIGHT_FOLD_EXPR
:
5935 for (i
= 0; i
< 2; ++i
)
5936 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5942 for (i
= 0; i
< 3; ++i
)
5943 if (!RECUR (TREE_OPERAND (t
, i
), true))
5948 if (COND_EXPR_IS_VEC_DELETE (t
))
5950 if (flags
& tf_error
)
5951 error_at (loc
, "%<delete[]%> is not a constant expression");
5957 /* If the condition is a known constant, we know which of the legs we
5958 care about; otherwise we only require that the condition and
5959 either of the legs be potentially constant. */
5960 tmp
= TREE_OPERAND (t
, 0);
5961 if (!RECUR (tmp
, rval
))
5963 if (!processing_template_decl
)
5964 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5965 if (integer_zerop (tmp
))
5966 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5967 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5968 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5969 for (i
= 1; i
< 3; ++i
)
5970 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5971 want_rval
, strict
, now
, tf_none
))
5973 if (flags
& tf_error
)
5974 error_at (loc
, "expression %qE is not a constant expression", t
);
5978 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5980 if (flags
& tf_error
)
5982 error_at (loc
, "non-constant array initialization");
5983 diagnose_non_constexpr_vec_init (t
);
5989 /* We can see these in statement-expressions. */
5993 case EMPTY_CLASS_EXPR
:
5999 tree
*target
= &TREE_OPERAND (t
, 0);
6000 /* Gotos representing break and continue are OK. */
6001 if (breaks (target
) || continues (target
))
6003 if (flags
& tf_error
)
6004 error_at (loc
, "%<goto%> is not a constant expression");
6009 return RECUR (TREE_OPERAND (t
, 0), rval
);
6012 if (objc_is_property_ref (t
))
6015 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
6022 /* The main entry point to the above. */
6025 potential_constant_expression (tree t
)
6027 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
6030 /* As above, but require a constant rvalue. */
6033 potential_rvalue_constant_expression (tree t
)
6035 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
6038 /* Like above, but complain about non-constant expressions. */
6041 require_potential_constant_expression (tree t
)
6043 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
6046 /* Cross product of the above. */
6049 require_potential_rvalue_constant_expression (tree t
)
6051 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
6054 /* Like potential_constant_expression, but don't consider possible constexpr
6055 substitution of the current function. That is, PARM_DECL qualifies under
6056 potential_constant_expression, but not here.
6058 This is basically what you can check when any actual constant values might
6059 be value-dependent. */
6062 is_constant_expression (tree t
)
6064 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
6067 /* Like above, but complain about non-constant expressions. */
6070 require_constant_expression (tree t
)
6072 return potential_constant_expression_1 (t
, false, true, true,
6073 tf_warning_or_error
);
6076 /* Like is_constant_expression, but allow const variables that are not allowed
6077 under constexpr rules. */
6080 is_static_init_expression (tree t
)
6082 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
6085 /* Returns true if T is a potential constant expression that is not
6086 instantiation-dependent, and therefore a candidate for constant folding even
6090 is_nondependent_constant_expression (tree t
)
6092 return (!type_unknown_p (t
)
6093 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6094 && is_constant_expression (t
)
6095 && !instantiation_dependent_expression_p (t
));
6098 /* Returns true if T is a potential static initializer expression that is not
6099 instantiation-dependent. */
6102 is_nondependent_static_init_expression (tree t
)
6104 return (!type_unknown_p (t
)
6105 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
6106 && is_static_init_expression (t
)
6107 && !instantiation_dependent_expression_p (t
));
6110 /* Finalize constexpr processing after parsing. */
6113 fini_constexpr (void)
6115 /* The contexpr call and fundef copies tables are no longer needed. */
6116 constexpr_call_table
= NULL
;
6117 fundef_copies_table
= NULL
;
6120 #include "gt-cp-constexpr.h"