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-2017 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 the DECL if OK, otherwise NULL. */
81 ensure_literal_type_for_constexpr_object (tree decl
)
83 tree type
= TREE_TYPE (decl
);
85 && (DECL_DECLARED_CONSTEXPR_P (decl
)
86 || var_in_constexpr_fn (decl
))
87 && !processing_template_decl
)
89 tree stype
= strip_array_types (type
);
90 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
91 /* Don't complain here, we'll complain about incompleteness
92 when we try to initialize the variable. */;
93 else if (!literal_type_p (type
))
95 if (DECL_DECLARED_CONSTEXPR_P (decl
))
97 error ("the type %qT of constexpr variable %qD is not literal",
99 explain_non_literal_class (type
);
103 if (!is_instantiation_of_constexpr (current_function_decl
))
105 error ("variable %qD of non-literal type %qT in %<constexpr%> "
106 "function", decl
, type
);
107 explain_non_literal_class (type
);
109 cp_function_chain
->invalid_constexpr
= true;
117 /* Representation of entries in the constexpr function definition table. */
119 struct GTY((for_user
)) constexpr_fundef
{
124 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
126 static hashval_t
hash (constexpr_fundef
*);
127 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
130 /* This table holds all constexpr function definitions seen in
131 the current translation unit. */
133 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
135 /* Utility function used for managing the constexpr function table.
136 Return true if the entries pointed to by P and Q are for the
137 same constexpr function. */
140 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
142 return lhs
->decl
== rhs
->decl
;
145 /* Utility function used for managing the constexpr function table.
146 Return a hash value for the entry pointed to by Q. */
149 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
151 return DECL_UID (fundef
->decl
);
154 /* Return a previously saved definition of function FUN. */
156 static constexpr_fundef
*
157 retrieve_constexpr_fundef (tree fun
)
159 constexpr_fundef fundef
= { NULL
, NULL
};
160 if (constexpr_fundef_table
== NULL
)
164 return constexpr_fundef_table
->find (&fundef
);
167 /* Check whether the parameter and return types of FUN are valid for a
168 constexpr function, and complain if COMPLAIN. */
171 is_valid_constexpr_fn (tree fun
, bool complain
)
175 if (DECL_INHERITED_CTOR (fun
)
176 && TREE_CODE (fun
) == TEMPLATE_DECL
)
180 error ("inherited constructor %qD is not constexpr",
181 DECL_INHERITED_CTOR (fun
));
185 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
186 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
187 if (!literal_type_p (TREE_TYPE (parm
)))
192 error ("invalid type for parameter %d of constexpr "
193 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
194 explain_non_literal_class (TREE_TYPE (parm
));
199 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)) && cxx_dialect
< cxx17
)
203 inform (DECL_SOURCE_LOCATION (fun
),
204 "lambdas are implicitly constexpr only in C++17 and later");
206 else if (!DECL_CONSTRUCTOR_P (fun
))
208 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
209 if (!literal_type_p (rettype
))
214 error ("invalid return type %qT of constexpr function %q+D",
216 explain_non_literal_class (rettype
);
220 /* C++14 DR 1684 removed this restriction. */
221 if (cxx_dialect
< cxx14
222 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
223 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
227 && pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
228 "enclosing class of constexpr non-static member "
229 "function %q+#D is not a literal type", fun
))
230 explain_non_literal_class (DECL_CONTEXT (fun
));
233 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
237 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
243 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
244 for a member of an anonymous aggregate, INIT is the initializer for that
245 member, and VEC_OUTER is the vector of constructor elements for the class
246 whose constructor we are processing. Add the initializer to the vector
247 and return true to indicate success. */
250 build_anon_member_initialization (tree member
, tree init
,
251 vec
<constructor_elt
, va_gc
> **vec_outer
)
253 /* MEMBER presents the relevant fields from the inside out, but we need
254 to build up the initializer from the outside in so that we can reuse
255 previously built CONSTRUCTORs if this is, say, the second field in an
256 anonymous struct. So we use a vec as a stack. */
257 auto_vec
<tree
, 2> fields
;
260 fields
.safe_push (TREE_OPERAND (member
, 1));
261 member
= TREE_OPERAND (member
, 0);
263 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
264 && TREE_CODE (member
) == COMPONENT_REF
);
266 /* VEC has the constructor elements vector for the context of FIELD.
267 If FIELD is an anonymous aggregate, we will push inside it. */
268 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
270 while (field
= fields
.pop(),
271 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
274 /* If there is already an outer constructor entry for the anonymous
275 aggregate FIELD, use it; otherwise, insert one. */
276 if (vec_safe_is_empty (*vec
)
277 || (*vec
)->last().index
!= field
)
279 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
280 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
283 ctor
= (*vec
)->last().value
;
284 vec
= &CONSTRUCTOR_ELTS (ctor
);
287 /* Now we're at the innermost field, the one that isn't an anonymous
288 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
289 gcc_assert (fields
.is_empty());
290 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
295 /* Subroutine of build_constexpr_constructor_member_initializers.
296 The expression tree T represents a data member initialization
297 in a (constexpr) constructor definition. Build a pairing of
298 the data member with its initializer, and prepend that pair
299 to the existing initialization pair INITS. */
302 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
305 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
306 t
= TREE_OPERAND (t
, 0);
307 if (TREE_CODE (t
) == EXPR_STMT
)
308 t
= TREE_OPERAND (t
, 0);
309 if (t
== error_mark_node
)
311 if (TREE_CODE (t
) == STATEMENT_LIST
)
313 tree_stmt_iterator i
;
314 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
316 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
321 if (TREE_CODE (t
) == CLEANUP_STMT
)
323 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
324 but we can in a constexpr constructor for a non-literal class. Just
325 ignore it; either all the initialization will be constant, in which
326 case the cleanup can't run, or it can't be constexpr.
327 Still recurse into CLEANUP_BODY. */
328 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
330 if (TREE_CODE (t
) == CONVERT_EXPR
)
331 t
= TREE_OPERAND (t
, 0);
332 if (TREE_CODE (t
) == INIT_EXPR
333 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
334 use what this function builds for cx_check_missing_mem_inits, and
335 assignment in the ctor body doesn't count. */
336 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
338 member
= TREE_OPERAND (t
, 0);
339 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
341 else if (TREE_CODE (t
) == CALL_EXPR
)
343 tree fn
= get_callee_fndecl (t
);
344 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
345 /* We're only interested in calls to subobject constructors. */
347 member
= CALL_EXPR_ARG (t
, 0);
348 /* We don't use build_cplus_new here because it complains about
349 abstract bases. Leaving the call unwrapped means that it has the
350 wrong type, but cxx_eval_constant_expression doesn't care. */
351 init
= break_out_target_exprs (t
);
353 else if (TREE_CODE (t
) == BIND_EXPR
)
354 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
356 /* Don't add anything else to the CONSTRUCTOR. */
358 if (INDIRECT_REF_P (member
))
359 member
= TREE_OPERAND (member
, 0);
360 if (TREE_CODE (member
) == NOP_EXPR
)
364 if (TREE_CODE (op
) == ADDR_EXPR
)
366 gcc_assert (same_type_ignoring_top_level_qualifiers_p
367 (TREE_TYPE (TREE_TYPE (op
)),
368 TREE_TYPE (TREE_TYPE (member
))));
369 /* Initializing a cv-qualified member; we need to look through
373 else if (op
== current_class_ptr
374 && (same_type_ignoring_top_level_qualifiers_p
375 (TREE_TYPE (TREE_TYPE (member
)),
376 current_class_type
)))
377 /* Delegating constructor. */
381 /* This is an initializer for an empty base; keep it for now so
382 we can check it in cxx_eval_bare_aggregate. */
383 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
386 if (TREE_CODE (member
) == ADDR_EXPR
)
387 member
= TREE_OPERAND (member
, 0);
388 if (TREE_CODE (member
) == COMPONENT_REF
)
390 tree aggr
= TREE_OPERAND (member
, 0);
391 if (TREE_CODE (aggr
) == VAR_DECL
)
392 /* Initializing a local variable, don't add anything. */
394 if (TREE_CODE (aggr
) != COMPONENT_REF
)
395 /* Normal member initialization. */
396 member
= TREE_OPERAND (member
, 1);
397 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
398 /* Initializing a member of an anonymous union. */
399 return build_anon_member_initialization (member
, init
, vec
);
401 /* We're initializing a vtable pointer in a base. Leave it as
402 COMPONENT_REF so we remember the path to get to the vfield. */
403 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
406 /* Value-initialization can produce multiple initializers for the
407 same field; use the last one. */
408 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
409 (*vec
)->last().value
= init
;
411 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
415 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
416 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
417 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
420 check_constexpr_bind_expr_vars (tree t
)
422 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
424 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
425 if (TREE_CODE (var
) == TYPE_DECL
426 && DECL_IMPLICIT_TYPEDEF_P (var
)
427 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
432 /* Subroutine of check_constexpr_ctor_body. */
435 check_constexpr_ctor_body_1 (tree last
, tree list
)
437 switch (TREE_CODE (list
))
440 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
441 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
445 case CLEANUP_POINT_EXPR
:
446 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
450 if (!check_constexpr_bind_expr_vars (list
)
451 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
465 /* Make sure that there are no statements after LAST in the constructor
466 body represented by LIST. */
469 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
471 /* C++14 doesn't require a constexpr ctor to have an empty body. */
472 if (cxx_dialect
>= cxx14
)
476 if (TREE_CODE (list
) == STATEMENT_LIST
)
478 tree_stmt_iterator i
= tsi_last (list
);
479 for (; !tsi_end_p (i
); tsi_prev (&i
))
481 tree t
= tsi_stmt (i
);
484 if (!check_constexpr_ctor_body_1 (last
, t
))
491 else if (list
!= last
492 && !check_constexpr_ctor_body_1 (last
, list
))
497 error ("constexpr constructor does not have empty body");
498 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
503 /* V is a vector of constructor elements built up for the base and member
504 initializers of a constructor for TYPE. They need to be in increasing
505 offset order, which they might not be yet if TYPE has a primary base
506 which is not first in the base-clause or a vptr and at least one base
507 all of which are non-primary. */
509 static vec
<constructor_elt
, va_gc
> *
510 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
512 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
518 field_type
= BINFO_TYPE (pri
);
519 else if (TYPE_CONTAINS_VPTR_P (type
))
520 field_type
= vtbl_ptr_type_node
;
524 /* Find the element for the primary base or vptr and move it to the
525 beginning of the vec. */
526 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
527 if (TREE_TYPE (ce
->index
) == field_type
)
530 if (i
> 0 && i
< vec_safe_length (v
))
532 vec
<constructor_elt
, va_gc
> &vref
= *v
;
533 constructor_elt elt
= vref
[i
];
542 /* Build compile-time evalable representations of member-initializer list
543 for a constexpr constructor. */
546 build_constexpr_constructor_member_initializers (tree type
, tree body
)
548 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
551 switch (TREE_CODE (body
))
553 case MUST_NOT_THROW_EXPR
:
555 body
= TREE_OPERAND (body
, 0);
559 for (tree_stmt_iterator i
= tsi_start (body
);
560 !tsi_end_p (i
); tsi_next (&i
))
563 if (TREE_CODE (body
) == BIND_EXPR
)
569 body
= BIND_EXPR_BODY (body
);
576 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
578 body
= TREE_OPERAND (body
, 0);
579 if (TREE_CODE (body
) == EXPR_STMT
)
580 body
= TREE_OPERAND (body
, 0);
581 if (TREE_CODE (body
) == INIT_EXPR
582 && (same_type_ignoring_top_level_qualifiers_p
583 (TREE_TYPE (TREE_OPERAND (body
, 0)),
584 current_class_type
)))
587 return TREE_OPERAND (body
, 1);
589 ok
= build_data_member_initialization (body
, &vec
);
591 else if (TREE_CODE (body
) == STATEMENT_LIST
)
593 tree_stmt_iterator i
;
594 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
596 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
601 else if (TREE_CODE (body
) == TRY_BLOCK
)
603 error ("body of %<constexpr%> constructor cannot be "
604 "a function-try-block");
605 return error_mark_node
;
607 else if (EXPR_P (body
))
608 ok
= build_data_member_initialization (body
, &vec
);
610 gcc_assert (errorcount
> 0);
613 if (vec_safe_length (vec
) > 0)
615 /* In a delegating constructor, return the target. */
616 constructor_elt
*ce
= &(*vec
)[0];
617 if (ce
->index
== current_class_ptr
)
624 vec
= sort_constexpr_mem_initializers (type
, vec
);
625 return build_constructor (type
, vec
);
628 return error_mark_node
;
631 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
632 declared to be constexpr, or a sub-statement thereof. Returns the
633 return value if suitable, error_mark_node for a statement not allowed in
634 a constexpr function, or NULL_TREE if no return value was found. */
637 constexpr_fn_retval (tree body
)
639 switch (TREE_CODE (body
))
643 tree_stmt_iterator i
;
644 tree expr
= NULL_TREE
;
645 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
647 tree s
= constexpr_fn_retval (tsi_stmt (i
));
648 if (s
== error_mark_node
)
649 return error_mark_node
;
650 else if (s
== NULL_TREE
)
651 /* Keep iterating. */;
653 /* Multiple return statements. */
654 return error_mark_node
;
662 return break_out_target_exprs (TREE_OPERAND (body
, 0));
666 tree decl
= DECL_EXPR_DECL (body
);
667 if (TREE_CODE (decl
) == USING_DECL
668 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
669 || DECL_ARTIFICIAL (decl
))
671 return error_mark_node
;
674 case CLEANUP_POINT_EXPR
:
675 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
678 if (!check_constexpr_bind_expr_vars (body
))
679 return error_mark_node
;
680 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
686 return error_mark_node
;
690 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
691 FUN; do the necessary transformations to turn it into a single expression
692 that we can store in the hash table. */
695 massage_constexpr_body (tree fun
, tree body
)
697 if (DECL_CONSTRUCTOR_P (fun
))
698 body
= build_constexpr_constructor_member_initializers
699 (DECL_CONTEXT (fun
), body
);
700 else if (cxx_dialect
< cxx14
)
702 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
703 body
= EH_SPEC_STMTS (body
);
704 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
705 body
= TREE_OPERAND (body
, 0);
706 body
= constexpr_fn_retval (body
);
711 /* CTYPE is a type constructed from BODY. Return true if some
712 bases/fields are uninitialized, and complain if COMPLAIN. */
715 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
721 if (TREE_CODE (body
) != CONSTRUCTOR
)
723 nelts
= CONSTRUCTOR_NELTS (body
);
725 tree field
= TYPE_FIELDS (ctype
);
727 if (TREE_CODE (ctype
) == UNION_TYPE
)
729 if (nelts
== 0 && next_initializable_field (field
))
732 error ("%<constexpr%> constructor for union %qT must "
733 "initialize exactly one non-static data member", ctype
);
739 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
740 need an explicit initialization. */
742 for (unsigned i
= 0; i
<= nelts
; ++i
)
744 tree index
= NULL_TREE
;
747 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
748 /* Skip base and vtable inits. */
749 if (TREE_CODE (index
) != FIELD_DECL
750 || DECL_ARTIFICIAL (index
))
754 for (; field
!= index
; field
= DECL_CHAIN (field
))
757 if (TREE_CODE (field
) != FIELD_DECL
)
759 if (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
761 if (DECL_ARTIFICIAL (field
))
763 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
765 /* Recurse to check the anonummous aggregate member. */
766 bad
|= cx_check_missing_mem_inits
767 (TREE_TYPE (field
), NULL_TREE
, complain
);
768 if (bad
&& !complain
)
772 ftype
= strip_array_types (TREE_TYPE (field
));
773 if (type_has_constexpr_default_constructor (ftype
))
775 /* It's OK to skip a member with a trivial constexpr ctor.
776 A constexpr ctor that isn't trivial should have been
778 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
784 error ("member %qD must be initialized by mem-initializer "
785 "in %<constexpr%> constructor", field
);
786 inform (DECL_SOURCE_LOCATION (field
), "declared here");
789 if (field
== NULL_TREE
)
792 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
794 /* Check the anonymous aggregate initializer is valid. */
795 bad
|= cx_check_missing_mem_inits
796 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
797 if (bad
&& !complain
)
800 field
= DECL_CHAIN (field
);
806 /* We are processing the definition of the constexpr function FUN.
807 Check that its BODY fulfills the propriate requirements and
808 enter it in the constexpr function definition table.
809 For constructor BODY is actually the TREE_LIST of the
810 member-initializer list. */
813 register_constexpr_fundef (tree fun
, tree body
)
815 constexpr_fundef entry
;
816 constexpr_fundef
**slot
;
818 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
821 tree massaged
= massage_constexpr_body (fun
, body
);
822 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
824 if (!DECL_CONSTRUCTOR_P (fun
))
825 error ("body of constexpr function %qD not a return-statement", fun
);
829 if (!potential_rvalue_constant_expression (massaged
))
831 if (!DECL_GENERATED_P (fun
))
832 require_potential_rvalue_constant_expression (massaged
);
836 if (DECL_CONSTRUCTOR_P (fun
)
837 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
838 massaged
, !DECL_GENERATED_P (fun
)))
841 /* Create the constexpr function table if necessary. */
842 if (constexpr_fundef_table
== NULL
)
843 constexpr_fundef_table
844 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
848 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
850 gcc_assert (*slot
== NULL
);
851 *slot
= ggc_alloc
<constexpr_fundef
> ();
857 /* FUN is a non-constexpr function called in a context that requires a
858 constant expression. If it comes from a constexpr template, explain why
859 the instantiation isn't constexpr. */
862 explain_invalid_constexpr_fn (tree fun
)
864 static hash_set
<tree
> *diagnosed
;
867 /* Only diagnose defaulted functions, lambdas, or instantiations. */
868 if (!DECL_DEFAULTED_FN (fun
)
869 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
870 && !is_instantiation_of_constexpr (fun
))
872 if (diagnosed
== NULL
)
873 diagnosed
= new hash_set
<tree
>;
874 if (diagnosed
->add (fun
))
875 /* Already explained. */
878 save_loc
= input_location
;
879 if (!lambda_static_thunk_p (fun
))
881 /* Diagnostics should completely ignore the static thunk, so leave
882 input_location set to our caller's location. */
883 input_location
= DECL_SOURCE_LOCATION (fun
);
884 inform (input_location
,
885 "%qD is not usable as a constexpr function because:", fun
);
887 /* First check the declaration. */
888 if (is_valid_constexpr_fn (fun
, true))
890 /* Then if it's OK, the body. */
891 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
892 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
893 explain_implicit_non_constexpr (fun
);
896 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
897 require_potential_rvalue_constant_expression (body
);
898 if (DECL_CONSTRUCTOR_P (fun
))
899 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
902 input_location
= save_loc
;
905 /* Objects of this type represent calls to constexpr functions
906 along with the bindings of parameters to their arguments, for
907 the purpose of compile time evaluation. */
909 struct GTY((for_user
)) constexpr_call
{
910 /* Description of the constexpr function definition. */
911 constexpr_fundef
*fundef
;
912 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
913 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
914 Note: This arrangement is made to accommodate the use of
915 iterative_hash_template_arg (see pt.c). If you change this
916 representation, also change the hash calculation in
917 cxx_eval_call_expression. */
919 /* Result of the call.
920 NULL means the call is being evaluated.
921 error_mark_node means that the evaluation was erroneous;
922 otherwise, the actuall value of the call. */
924 /* The hash of this call; we remember it here to avoid having to
925 recalculate it when expanding the hash table. */
929 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
931 static hashval_t
hash (constexpr_call
*);
932 static bool equal (constexpr_call
*, constexpr_call
*);
935 enum constexpr_switch_state
{
936 /* Used when processing a switch for the first time by cxx_eval_switch_expr
937 and default: label for that switch has not been seen yet. */
938 css_default_not_seen
,
939 /* Used when processing a switch for the first time by cxx_eval_switch_expr
940 and default: label for that switch has been seen already. */
942 /* Used when processing a switch for the second time by
943 cxx_eval_switch_expr, where default: label should match. */
944 css_default_processing
947 /* The constexpr expansion context. CALL is the current function
948 expansion, CTOR is the current aggregate initializer, OBJECT is the
949 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
950 is a map of values of variables initialized within the expression. */
952 struct constexpr_ctx
{
953 /* The innermost call we're evaluating. */
954 constexpr_call
*call
;
955 /* Values for any temporaries or local variables within the
956 constant-expression. */
957 hash_map
<tree
,tree
> *values
;
958 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
959 aren't inside a loop. */
960 hash_set
<tree
> *save_exprs
;
961 /* The CONSTRUCTOR we're currently building up for an aggregate
964 /* The object we're building the CONSTRUCTOR for. */
966 /* If inside SWITCH_EXPR. */
967 constexpr_switch_state
*css_state
;
968 /* Whether we should error on a non-constant expression or fail quietly. */
970 /* Whether we are strictly conforming to constant expression rules or
971 trying harder to get a constant value. */
975 /* A table of all constexpr calls that have been evaluated by the
976 compiler in this translation unit. */
978 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
980 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
981 bool, bool *, bool *, tree
* = NULL
);
983 /* Compute a hash value for a constexpr call representation. */
986 constexpr_call_hasher::hash (constexpr_call
*info
)
991 /* Return true if the objects pointed to by P and Q represent calls
992 to the same constexpr function with the same arguments.
993 Otherwise, return false. */
996 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
1002 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
1004 lhs_bindings
= lhs
->bindings
;
1005 rhs_bindings
= rhs
->bindings
;
1006 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1008 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1009 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1010 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1011 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1013 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1014 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1016 return lhs_bindings
== rhs_bindings
;
1019 /* Initialize the constexpr call table, if needed. */
1022 maybe_initialize_constexpr_call_table (void)
1024 if (constexpr_call_table
== NULL
)
1025 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1028 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1029 a function happens to get called recursively, we unshare the callee
1030 function's body and evaluate this unshared copy instead of evaluating the
1033 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1034 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1035 that's keyed off of the original FUNCTION_DECL and whose value is a
1036 TREE_LIST of this function's unused copies awaiting reuse.
1038 This is not GC-deletable to avoid GC affecting UID generation. */
1040 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1042 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1045 maybe_initialize_fundef_copies_table ()
1047 if (fundef_copies_table
== NULL
)
1048 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1051 /* Reuse a copy or create a new unshared copy of the function FUN.
1052 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1053 is parms, TYPE is result. */
1056 get_fundef_copy (tree fun
)
1058 maybe_initialize_fundef_copies_table ();
1062 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1066 /* There is no cached function available, or in use. We can use
1067 the function directly. That the slot is now created records
1068 that this function is now in use. */
1069 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1070 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1072 else if (*slot
== NULL_TREE
)
1074 /* We've already used the function itself, so make a copy. */
1075 copy
= build_tree_list (NULL
, NULL
);
1076 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1080 /* We have a cached function available. */
1082 *slot
= TREE_CHAIN (copy
);
1088 /* Save the copy COPY of function FUN for later reuse by
1089 get_fundef_copy(). By construction, there will always be an entry
1093 save_fundef_copy (tree fun
, tree copy
)
1095 tree
*slot
= fundef_copies_table
->get (fun
);
1096 TREE_CHAIN (copy
) = *slot
;
1100 /* We have an expression tree T that represents a call, either CALL_EXPR
1101 or AGGR_INIT_EXPR. If the call is lexically to a named function,
1102 retrun the _DECL for that function. */
1105 get_function_named_in_call (tree t
)
1107 tree fun
= cp_get_callee (t
);
1108 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
1109 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
1110 fun
= TREE_OPERAND (fun
, 0);
1114 /* We have an expression tree T that represents a call, either CALL_EXPR
1115 or AGGR_INIT_EXPR. Return the Nth argument. */
1118 get_nth_callarg (tree t
, int n
)
1120 switch (TREE_CODE (t
))
1123 return CALL_EXPR_ARG (t
, n
);
1125 case AGGR_INIT_EXPR
:
1126 return AGGR_INIT_EXPR_ARG (t
, n
);
1134 /* Attempt to evaluate T which represents a call to a builtin function.
1135 We assume here that all builtin functions evaluate to scalar types
1136 represented by _CST nodes. */
1139 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1141 bool *non_constant_p
, bool *overflow_p
)
1143 const int nargs
= call_expr_nargs (t
);
1144 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1148 /* Don't fold __builtin_constant_p within a constexpr function. */
1149 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1152 && current_function_decl
1153 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1155 *non_constant_p
= true;
1159 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1160 return constant false for a non-constant argument. */
1161 constexpr_ctx new_ctx
= *ctx
;
1162 new_ctx
.quiet
= true;
1163 bool dummy1
= false, dummy2
= false;
1164 for (i
= 0; i
< nargs
; ++i
)
1166 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1167 false, &dummy1
, &dummy2
);
1169 /* For __built_in_constant_p, fold all expressions with constant values
1170 even if they aren't C++ constant-expressions. */
1171 args
[i
] = cp_fully_fold (args
[i
]);
1174 bool save_ffbcp
= force_folding_builtin_constant_p
;
1175 force_folding_builtin_constant_p
= true;
1176 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1177 CALL_EXPR_FN (t
), nargs
, args
);
1178 force_folding_builtin_constant_p
= save_ffbcp
;
1179 if (new_call
== NULL
)
1181 if (!*non_constant_p
&& !ctx
->quiet
)
1183 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1184 CALL_EXPR_FN (t
), nargs
, args
);
1185 error ("%q+E is not a constant expression", new_call
);
1187 *non_constant_p
= true;
1191 if (!is_constant_expression (new_call
))
1193 if (!*non_constant_p
&& !ctx
->quiet
)
1194 error ("%q+E is not a constant expression", new_call
);
1195 *non_constant_p
= true;
1199 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1200 non_constant_p
, overflow_p
);
1203 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1204 the type of the value to match. */
1207 adjust_temp_type (tree type
, tree temp
)
1209 if (TREE_TYPE (temp
) == type
)
1211 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1212 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1213 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1214 gcc_assert (scalarish_type_p (type
));
1215 return cp_fold_convert (type
, temp
);
1218 /* Callback for walk_tree used by unshare_constructor. */
1221 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1225 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1230 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1231 subexpression, return an unshared copy of T. Otherwise return T. */
1234 unshare_constructor (tree t
)
1236 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1237 if (ctor
!= NULL_TREE
)
1238 return unshare_expr (t
);
1242 /* Subroutine of cxx_eval_call_expression.
1243 We are processing a call expression (either CALL_EXPR or
1244 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1245 all arguments and bind their values to correspondings
1246 parameters, making up the NEW_CALL context. */
1249 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1250 constexpr_call
*new_call
,
1251 bool *non_constant_p
, bool *overflow_p
,
1252 bool *non_constant_args
)
1254 const int nargs
= call_expr_nargs (t
);
1255 tree fun
= new_call
->fundef
->decl
;
1256 tree parms
= DECL_ARGUMENTS (fun
);
1258 tree
*p
= &new_call
->bindings
;
1259 for (i
= 0; i
< nargs
; ++i
)
1262 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1263 x
= get_nth_callarg (t
, i
);
1264 /* For member function, the first argument is a pointer to the implied
1265 object. For a constructor, it might still be a dummy object, in
1266 which case we get the real argument from ctx. */
1267 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1268 && is_dummy_object (x
))
1271 /* We don't use cp_build_addr_expr here because we don't want to
1272 capture the object argument until we've chosen a non-static member
1274 x
= build_address (x
);
1277 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1278 non_constant_p
, overflow_p
);
1279 /* Don't VERIFY_CONSTANT here. */
1280 if (*non_constant_p
&& ctx
->quiet
)
1282 /* Just discard ellipsis args after checking their constantitude. */
1286 if (!*non_constant_p
)
1288 /* Make sure the binding has the same type as the parm. But
1289 only for constant args. */
1290 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1291 arg
= adjust_temp_type (type
, arg
);
1292 if (!TREE_CONSTANT (arg
))
1293 *non_constant_args
= true;
1294 *p
= build_tree_list (parms
, arg
);
1295 p
= &TREE_CHAIN (*p
);
1297 parms
= TREE_CHAIN (parms
);
1301 /* Variables and functions to manage constexpr call expansion context.
1302 These do not need to be marked for PCH or GC. */
1304 /* FIXME remember and print actual constant arguments. */
1305 static vec
<tree
> call_stack
;
1306 static int call_stack_tick
;
1307 static int last_cx_error_tick
;
1310 push_cx_call_context (tree call
)
1313 if (!EXPR_HAS_LOCATION (call
))
1314 SET_EXPR_LOCATION (call
, input_location
);
1315 call_stack
.safe_push (call
);
1316 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1322 pop_cx_call_context (void)
1329 cx_error_context (void)
1331 vec
<tree
> r
= vNULL
;
1332 if (call_stack_tick
!= last_cx_error_tick
1333 && !call_stack
.is_empty ())
1335 last_cx_error_tick
= call_stack_tick
;
1339 /* Evaluate a call T to a GCC internal function when possible and return
1340 the evaluated result or, under the control of CTX, give an error, set
1341 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1344 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1346 bool *non_constant_p
, bool *overflow_p
)
1348 enum tree_code opcode
= ERROR_MARK
;
1350 switch (CALL_EXPR_IFN (t
))
1352 case IFN_UBSAN_NULL
:
1353 case IFN_UBSAN_BOUNDS
:
1354 case IFN_UBSAN_VPTR
:
1355 case IFN_FALLTHROUGH
:
1358 case IFN_ADD_OVERFLOW
:
1361 case IFN_SUB_OVERFLOW
:
1362 opcode
= MINUS_EXPR
;
1364 case IFN_MUL_OVERFLOW
:
1369 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1370 false, non_constant_p
, overflow_p
);
1374 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1375 "call to internal function %qE", t
);
1376 *non_constant_p
= true;
1380 /* Evaluate constant arguments using OPCODE and return a complex
1381 number containing the result and the overflow bit. */
1382 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1383 non_constant_p
, overflow_p
);
1384 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1385 non_constant_p
, overflow_p
);
1387 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1389 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1390 tree type
= TREE_TYPE (TREE_TYPE (t
));
1391 tree result
= fold_binary_loc (loc
, opcode
, type
,
1392 fold_convert_loc (loc
, type
, arg0
),
1393 fold_convert_loc (loc
, type
, arg1
));
1395 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1396 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1397 if (TREE_OVERFLOW (result
))
1398 TREE_OVERFLOW (result
) = 0;
1400 return build_complex (TREE_TYPE (t
), result
, ovf
);
1403 *non_constant_p
= true;
1407 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1410 clear_no_implicit_zero (tree ctor
)
1412 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1414 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1415 tree elt
; unsigned HOST_WIDE_INT idx
;
1416 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1417 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1418 clear_no_implicit_zero (elt
);
1422 /* Subroutine of cxx_eval_constant_expression.
1423 Evaluate the call expression tree T in the context of OLD_CALL expression
1427 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1429 bool *non_constant_p
, bool *overflow_p
)
1431 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1432 tree fun
= get_function_named_in_call (t
);
1433 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1436 if (fun
== NULL_TREE
)
1437 return cxx_eval_internal_function (ctx
, t
, lval
,
1438 non_constant_p
, overflow_p
);
1440 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1442 /* Might be a constexpr function pointer. */
1443 fun
= cxx_eval_constant_expression (ctx
, fun
,
1444 /*lval*/false, non_constant_p
,
1447 if (TREE_CODE (fun
) == ADDR_EXPR
)
1448 fun
= TREE_OPERAND (fun
, 0);
1450 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1452 if (!ctx
->quiet
&& !*non_constant_p
)
1453 error_at (loc
, "expression %qE does not designate a constexpr "
1455 *non_constant_p
= true;
1458 if (DECL_CLONED_FUNCTION_P (fun
))
1459 fun
= DECL_CLONED_FUNCTION (fun
);
1461 if (is_ubsan_builtin_p (fun
))
1464 if (is_builtin_fn (fun
))
1465 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1466 lval
, non_constant_p
, overflow_p
);
1467 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1471 if (!lambda_static_thunk_p (fun
))
1472 error_at (loc
, "call to non-constexpr function %qD", fun
);
1473 explain_invalid_constexpr_fn (fun
);
1475 *non_constant_p
= true;
1479 constexpr_ctx new_ctx
= *ctx
;
1480 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1481 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1483 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1484 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1485 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1486 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1487 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1488 ctx
->values
->put (new_ctx
.object
, ctor
);
1492 /* Shortcut trivial constructor/op=. */
1493 if (trivial_fn_p (fun
))
1495 tree init
= NULL_TREE
;
1496 if (call_expr_nargs (t
) == 2)
1497 init
= convert_from_reference (get_nth_callarg (t
, 1));
1498 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1499 && AGGR_INIT_ZERO_FIRST (t
))
1500 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1503 tree op
= get_nth_callarg (t
, 0);
1504 if (is_dummy_object (op
))
1507 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1508 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1509 new_ctx
.call
= &new_call
;
1510 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1511 non_constant_p
, overflow_p
);
1515 /* We can't defer instantiating the function any longer. */
1516 if (!DECL_INITIAL (fun
)
1517 && DECL_TEMPLOID_INSTANTIATION (fun
))
1519 location_t save_loc
= input_location
;
1520 input_location
= loc
;
1522 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1524 input_location
= save_loc
;
1527 /* If in direct recursive call, optimize definition search. */
1528 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1529 new_call
.fundef
= ctx
->call
->fundef
;
1532 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1533 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1534 || fun
== current_function_decl
)
1538 /* We need to check for current_function_decl here in case we're
1539 being called during cp_fold_function, because at that point
1540 DECL_INITIAL is set properly and we have a fundef but we
1541 haven't lowered invisirefs yet (c++/70344). */
1542 if (DECL_INITIAL (fun
) == error_mark_node
1543 || fun
== current_function_decl
)
1544 error_at (loc
, "%qD called in a constant expression before its "
1545 "definition is complete", fun
);
1546 else if (DECL_INITIAL (fun
))
1548 /* The definition of fun was somehow unsuitable. But pretend
1549 that lambda static thunks don't exist. */
1550 if (!lambda_static_thunk_p (fun
))
1551 error_at (loc
, "%qD called in a constant expression", fun
);
1552 explain_invalid_constexpr_fn (fun
);
1555 error_at (loc
, "%qD used before its definition", fun
);
1557 *non_constant_p
= true;
1562 bool non_constant_args
= false;
1563 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1564 non_constant_p
, overflow_p
, &non_constant_args
);
1565 if (*non_constant_p
)
1568 depth_ok
= push_cx_call_context (t
);
1570 tree result
= NULL_TREE
;
1572 constexpr_call
*entry
= NULL
;
1573 if (depth_ok
&& !non_constant_args
)
1575 new_call
.hash
= iterative_hash_template_arg
1576 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1578 /* If we have seen this call before, we are done. */
1579 maybe_initialize_constexpr_call_table ();
1580 constexpr_call
**slot
1581 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1585 /* We need to keep a pointer to the entry, not just the slot, as the
1586 slot can move in the call to cxx_eval_builtin_function_call. */
1587 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1590 /* Calls that are in progress have their result set to NULL,
1591 so that we can detect circular dependencies. */
1592 else if (entry
->result
== NULL
)
1595 error ("call has circular dependency");
1596 *non_constant_p
= true;
1597 entry
->result
= result
= error_mark_node
;
1600 result
= entry
->result
;
1606 error ("constexpr evaluation depth exceeds maximum of %d (use "
1607 "-fconstexpr-depth= to increase the maximum)",
1608 max_constexpr_depth
);
1609 *non_constant_p
= true;
1610 result
= error_mark_node
;
1614 if (result
&& result
!= error_mark_node
)
1616 else if (!DECL_SAVED_TREE (fun
))
1618 /* When at_eof >= 2, cgraph has started throwing away
1619 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1620 late code generation for VEC_INIT_EXPR, which needs to be
1621 completely reconsidered. */
1622 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1623 *non_constant_p
= true;
1627 tree body
, parms
, res
;
1629 /* Reuse or create a new unshared copy of this function's body. */
1630 tree copy
= get_fundef_copy (fun
);
1631 body
= TREE_PURPOSE (copy
);
1632 parms
= TREE_VALUE (copy
);
1633 res
= TREE_TYPE (copy
);
1635 /* Associate the bindings with the remapped parms. */
1636 tree bound
= new_call
.bindings
;
1637 tree remapped
= parms
;
1640 tree oparm
= TREE_PURPOSE (bound
);
1641 tree arg
= TREE_VALUE (bound
);
1642 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1643 /* Don't share a CONSTRUCTOR that might be changed. */
1644 arg
= unshare_constructor (arg
);
1645 ctx
->values
->put (remapped
, arg
);
1646 bound
= TREE_CHAIN (bound
);
1647 remapped
= DECL_CHAIN (remapped
);
1649 /* Add the RESULT_DECL to the values map, too. */
1650 tree slot
= NULL_TREE
;
1651 if (DECL_BY_REFERENCE (res
))
1653 slot
= AGGR_INIT_EXPR_SLOT (t
);
1654 tree addr
= build_address (slot
);
1655 addr
= build_nop (TREE_TYPE (res
), addr
);
1656 ctx
->values
->put (res
, addr
);
1657 ctx
->values
->put (slot
, NULL_TREE
);
1660 ctx
->values
->put (res
, NULL_TREE
);
1662 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1663 their values after the call. */
1664 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1665 hash_set
<tree
> save_exprs
;
1666 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1667 ctx_with_save_exprs
.call
= &new_call
;
1669 tree jump_target
= NULL_TREE
;
1670 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1671 lval
, non_constant_p
, overflow_p
,
1674 if (DECL_CONSTRUCTOR_P (fun
))
1675 /* This can be null for a subobject constructor call, in
1676 which case what we care about is the initialization
1677 side-effects rather than the value. We could get at the
1678 value by evaluating *this, but we don't bother; there's
1679 no need to put such a call in the hash table. */
1680 result
= lval
? ctx
->object
: ctx
->ctor
;
1681 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1685 result
= *ctx
->values
->get (slot
? slot
: res
);
1686 if (result
== NULL_TREE
&& !*non_constant_p
)
1689 error ("constexpr call flows off the end "
1691 *non_constant_p
= true;
1695 /* Forget the saved values of the callee's SAVE_EXPRs. */
1696 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1697 iter
!= save_exprs
.end(); ++iter
)
1698 ctx_with_save_exprs
.values
->remove (*iter
);
1700 /* Remove the parms/result from the values map. Is it worth
1701 bothering to do this when the map itself is only live for
1702 one constexpr evaluation? If so, maybe also clear out
1703 other vars from call, maybe in BIND_EXPR handling? */
1704 ctx
->values
->remove (res
);
1706 ctx
->values
->remove (slot
);
1707 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1708 ctx
->values
->remove (parm
);
1710 /* Make the unshared function copy we used available for re-use. */
1711 save_fundef_copy (fun
, copy
);
1714 if (result
== error_mark_node
)
1715 *non_constant_p
= true;
1716 if (*non_constant_p
|| *overflow_p
)
1717 result
= error_mark_node
;
1721 entry
->result
= result
;
1724 /* The result of a constexpr function must be completely initialized. */
1725 if (TREE_CODE (result
) == CONSTRUCTOR
)
1726 clear_no_implicit_zero (result
);
1728 pop_cx_call_context ();
1729 return unshare_constructor (result
);
1732 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1735 reduced_constant_expression_p (tree t
)
1737 switch (TREE_CODE (t
))
1740 /* Even if we can't lower this yet, it's constant. */
1744 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1745 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1746 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1747 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1750 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1753 /* We're in the middle of initializing this element. */
1755 if (!reduced_constant_expression_p (val
))
1761 field
= next_initializable_field (DECL_CHAIN (field
));
1766 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1767 /* All the fields are initialized. */
1768 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1772 /* FIXME are we calling this too much? */
1773 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1777 /* Some expressions may have constant operands but are not constant
1778 themselves, such as 1/0. Call this function (or rather, the macro
1779 following it) to check for that condition.
1781 We only call this in places that require an arithmetic constant, not in
1782 places where we might have a non-constant expression that can be a
1783 component of a constant expression, such as the address of a constexpr
1784 variable that might be dereferenced later. */
1787 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1790 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1792 if (!allow_non_constant
)
1793 error ("%q+E is not a constant expression", t
);
1794 *non_constant_p
= true;
1796 if (TREE_OVERFLOW_P (t
))
1798 if (!allow_non_constant
)
1800 permerror (input_location
, "overflow in constant expression");
1801 /* If we're being permissive (and are in an enforcing
1802 context), ignore the overflow. */
1803 if (flag_permissive
)
1804 return *non_constant_p
;
1808 return *non_constant_p
;
1811 /* Check whether the shift operation with code CODE and type TYPE on LHS
1812 and RHS is undefined. If it is, give an error with an explanation,
1813 and return true; return false otherwise. */
1816 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1817 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1819 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1820 || TREE_CODE (lhs
) != INTEGER_CST
1821 || TREE_CODE (rhs
) != INTEGER_CST
)
1824 tree lhstype
= TREE_TYPE (lhs
);
1825 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1827 /* [expr.shift] The behavior is undefined if the right operand
1828 is negative, or greater than or equal to the length in bits
1829 of the promoted left operand. */
1830 if (tree_int_cst_sgn (rhs
) == -1)
1833 permerror (loc
, "right operand of shift expression %q+E is negative",
1834 build2_loc (loc
, code
, type
, lhs
, rhs
));
1835 return (!flag_permissive
|| ctx
->quiet
);
1837 if (compare_tree_int (rhs
, uprec
) >= 0)
1840 permerror (loc
, "right operand of shift expression %q+E is >= than "
1841 "the precision of the left operand",
1842 build2_loc (loc
, code
, type
, lhs
, rhs
));
1843 return (!flag_permissive
|| ctx
->quiet
);
1846 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1847 if E1 has a signed type and non-negative value, and E1x2^E2 is
1848 representable in the corresponding unsigned type of the result type,
1849 then that value, converted to the result type, is the resulting value;
1850 otherwise, the behavior is undefined. */
1851 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1852 && (cxx_dialect
>= cxx11
))
1854 if (tree_int_cst_sgn (lhs
) == -1)
1858 "left operand of shift expression %q+E is negative",
1859 build2_loc (loc
, code
, type
, lhs
, rhs
));
1860 return (!flag_permissive
|| ctx
->quiet
);
1862 /* For signed x << y the following:
1863 (unsigned) x >> ((prec (lhs) - 1) - y)
1864 if > 1, is undefined. The right-hand side of this formula
1865 is the highest bit of the LHS that can be set (starting from 0),
1866 so that the shift doesn't overflow. We then right-shift the LHS
1867 to see whether any other bit is set making the original shift
1868 undefined -- the result is not representable in the corresponding
1870 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1871 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1872 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1873 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1874 if (tree_int_cst_lt (integer_one_node
, t
))
1877 permerror (loc
, "shift expression %q+E overflows",
1878 build2_loc (loc
, code
, type
, lhs
, rhs
));
1879 return (!flag_permissive
|| ctx
->quiet
);
1885 /* Subroutine of cxx_eval_constant_expression.
1886 Attempt to reduce the unary expression tree T to a compile time value.
1887 If successful, return the value. Otherwise issue a diagnostic
1888 and return error_mark_node. */
1891 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1893 bool *non_constant_p
, bool *overflow_p
)
1896 tree orig_arg
= TREE_OPERAND (t
, 0);
1897 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1898 non_constant_p
, overflow_p
);
1899 VERIFY_CONSTANT (arg
);
1900 location_t loc
= EXPR_LOCATION (t
);
1901 enum tree_code code
= TREE_CODE (t
);
1902 tree type
= TREE_TYPE (t
);
1903 r
= fold_unary_loc (loc
, code
, type
, arg
);
1906 if (arg
== orig_arg
)
1909 r
= build1_loc (loc
, code
, type
, arg
);
1911 VERIFY_CONSTANT (r
);
1915 /* Helper function for cxx_eval_binary_expression. Try to optimize
1916 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1917 generic folding should be used. */
1920 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1921 tree lhs
, tree rhs
, bool *non_constant_p
,
1925 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1928 lhs
= TREE_OPERAND (lhs
, 0);
1930 /* &A[i] p+ j => &A[i + j] */
1931 if (TREE_CODE (lhs
) == ARRAY_REF
1932 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1933 && TREE_CODE (rhs
) == INTEGER_CST
1934 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1935 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1937 tree orig_type
= TREE_TYPE (t
);
1938 location_t loc
= EXPR_LOCATION (t
);
1939 tree type
= TREE_TYPE (lhs
);
1941 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1942 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1943 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1945 if (*non_constant_p
)
1947 /* Don't fold an out-of-bound access. */
1948 if (!tree_int_cst_le (t
, nelts
))
1950 rhs
= cp_fold_convert (ssizetype
, rhs
);
1951 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1952 constexpr int A[1]; ... (char *)&A[0] + 1 */
1953 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1954 rhs
, TYPE_SIZE_UNIT (type
))))
1956 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1958 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1959 TYPE_SIZE_UNIT (type
));
1960 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1961 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1962 t
, NULL_TREE
, NULL_TREE
);
1963 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1964 t
= cp_fold_convert (orig_type
, t
);
1965 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1966 non_constant_p
, overflow_p
);
1972 /* Subroutine of cxx_eval_constant_expression.
1973 Like cxx_eval_unary_expression, except for binary expressions. */
1976 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1978 bool *non_constant_p
, bool *overflow_p
)
1981 tree orig_lhs
= TREE_OPERAND (t
, 0);
1982 tree orig_rhs
= TREE_OPERAND (t
, 1);
1984 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1985 non_constant_p
, overflow_p
);
1986 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
1988 if (*non_constant_p
)
1990 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1991 non_constant_p
, overflow_p
);
1992 if (*non_constant_p
)
1995 location_t loc
= EXPR_LOCATION (t
);
1996 enum tree_code code
= TREE_CODE (t
);
1997 tree type
= TREE_TYPE (t
);
1999 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
2001 bool is_code_eq
= (code
== EQ_EXPR
);
2003 if (TREE_CODE (lhs
) == PTRMEM_CST
2004 && TREE_CODE (rhs
) == PTRMEM_CST
)
2005 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
2007 else if ((TREE_CODE (lhs
) == PTRMEM_CST
2008 || TREE_CODE (rhs
) == PTRMEM_CST
)
2009 && (null_member_pointer_value_p (lhs
)
2010 || null_member_pointer_value_p (rhs
)))
2011 r
= constant_boolean_node (!is_code_eq
, type
);
2012 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2013 lhs
= cplus_expand_constant (lhs
);
2014 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2015 rhs
= cplus_expand_constant (rhs
);
2017 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2018 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2021 error ("arithmetic involving a null pointer in %qE", lhs
);
2024 else if (code
== POINTER_PLUS_EXPR
)
2025 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2029 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2033 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2036 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2038 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2039 *non_constant_p
= true;
2040 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2041 a local array in a constexpr function. */
2042 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2044 VERIFY_CONSTANT (r
);
2048 /* Subroutine of cxx_eval_constant_expression.
2049 Attempt to evaluate condition expressions. Dead branches are not
2053 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2055 bool *non_constant_p
, bool *overflow_p
,
2058 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2060 non_constant_p
, overflow_p
);
2061 VERIFY_CONSTANT (val
);
2062 /* Don't VERIFY_CONSTANT the other operands. */
2063 if (integer_zerop (val
))
2064 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2066 non_constant_p
, overflow_p
,
2068 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2070 non_constant_p
, overflow_p
,
2074 /* Returns less than, equal to, or greater than zero if KEY is found to be
2075 less than, to match, or to be greater than the constructor_elt's INDEX. */
2078 array_index_cmp (tree key
, tree index
)
2080 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2082 switch (TREE_CODE (index
))
2085 return tree_int_cst_compare (key
, index
);
2088 tree lo
= TREE_OPERAND (index
, 0);
2089 tree hi
= TREE_OPERAND (index
, 1);
2090 if (tree_int_cst_lt (key
, lo
))
2092 else if (tree_int_cst_lt (hi
, key
))
2102 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2103 if none. If INSERT is true, insert a matching element rather than fail. */
2105 static HOST_WIDE_INT
2106 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2108 if (tree_int_cst_sgn (dindex
) < 0)
2111 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2112 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2113 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2115 unsigned HOST_WIDE_INT end
= len
;
2116 unsigned HOST_WIDE_INT begin
= 0;
2118 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2119 that the same is true of the other elements and index directly. */
2122 tree cindex
= (*elts
)[end
-1].index
;
2123 if (TREE_CODE (cindex
) == INTEGER_CST
2124 && compare_tree_int (cindex
, end
-1) == 0)
2133 /* Otherwise, find a matching index by means of a binary search. */
2134 while (begin
!= end
)
2136 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2137 constructor_elt
&elt
= (*elts
)[middle
];
2138 tree idx
= elt
.index
;
2140 int cmp
= array_index_cmp (dindex
, idx
);
2147 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2149 /* We need to split the range. */
2151 tree lo
= TREE_OPERAND (idx
, 0);
2152 tree hi
= TREE_OPERAND (idx
, 1);
2153 if (tree_int_cst_lt (lo
, dindex
))
2155 /* There are still some lower elts; shorten the range. */
2156 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2158 if (tree_int_cst_equal (lo
, new_hi
))
2159 /* Only one element left, no longer a range. */
2162 TREE_OPERAND (idx
, 1) = new_hi
;
2163 /* Append the element we want to insert. */
2166 e
.value
= unshare_constructor (elt
.value
);
2167 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2170 /* No lower elts, the range elt is now ours. */
2173 if (tree_int_cst_lt (dindex
, hi
))
2175 /* There are still some higher elts; append a range. */
2176 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2178 if (tree_int_cst_equal (new_lo
, hi
))
2181 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2182 e
.value
= unshare_constructor (elt
.value
);
2183 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2192 constructor_elt e
= { dindex
, NULL_TREE
};
2193 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2200 /* Under the control of CTX, issue a detailed diagnostic for
2201 an out-of-bounds subscript INDEX into the expression ARRAY. */
2204 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2208 tree arraytype
= TREE_TYPE (array
);
2210 /* Convert the unsigned array subscript to a signed integer to avoid
2211 printing huge numbers for small negative values. */
2212 tree sidx
= fold_convert (ssizetype
, index
);
2215 error ("array subscript value %qE is outside the bounds "
2216 "of array %qD of type %qT", sidx
, array
, arraytype
);
2217 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2220 error ("array subscript value %qE is outside the bounds "
2221 "of array type %qT", sidx
, arraytype
);
2225 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2226 STRING_CST STRING. */
2229 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2231 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2234 if (chars_per_elt
== 1)
2235 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2238 const unsigned char *ptr
2239 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2240 + index
* chars_per_elt
);
2241 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2246 /* Subroutine of cxx_eval_constant_expression.
2247 Attempt to reduce a reference to an array slot. */
2250 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2252 bool *non_constant_p
, bool *overflow_p
)
2254 tree oldary
= TREE_OPERAND (t
, 0);
2255 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2257 non_constant_p
, overflow_p
);
2259 HOST_WIDE_INT i
= 0;
2260 tree elem_type
= NULL_TREE
;
2261 unsigned len
= 0, elem_nchars
= 1;
2262 if (*non_constant_p
)
2264 oldidx
= TREE_OPERAND (t
, 1);
2265 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2267 non_constant_p
, overflow_p
);
2268 VERIFY_CONSTANT (index
);
2271 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2272 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2273 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2274 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2275 ary
= TREE_OPERAND (ary
, 0);
2276 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2277 len
= CONSTRUCTOR_NELTS (ary
);
2278 else if (TREE_CODE (ary
) == STRING_CST
)
2280 elem_nchars
= (TYPE_PRECISION (elem_type
)
2281 / TYPE_PRECISION (char_type_node
));
2282 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2284 else if (TREE_CODE (ary
) == VECTOR_CST
)
2285 len
= VECTOR_CST_NELTS (ary
);
2288 /* We can't do anything with other tree codes, so use
2289 VERIFY_CONSTANT to complain and fail. */
2290 VERIFY_CONSTANT (ary
);
2294 if (!tree_fits_shwi_p (index
)
2295 || (i
= tree_to_shwi (index
)) < 0)
2297 diag_array_subscript (ctx
, ary
, index
);
2298 *non_constant_p
= true;
2304 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2305 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2306 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2307 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2311 /* For VLAs, the number of elements won't be an integer constant. */
2312 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2314 VERIFY_CONSTANT (nelts
);
2316 ? !tree_int_cst_le (index
, nelts
)
2317 : !tree_int_cst_lt (index
, nelts
))
2318 || tree_int_cst_sgn (index
) < 0)
2320 diag_array_subscript (ctx
, ary
, index
);
2321 *non_constant_p
= true;
2325 if (lval
&& ary
== oldary
&& index
== oldidx
)
2328 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2331 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2333 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2344 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2345 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2346 else if (TREE_CODE (ary
) == VECTOR_CST
)
2347 r
= VECTOR_CST_ELT (ary
, i
);
2349 r
= extract_string_elt (ary
, elem_nchars
, i
);
2352 /* Don't VERIFY_CONSTANT here. */
2355 /* Otherwise the element doesn't have a value yet. */
2360 if (TREE_CODE (ary
) == CONSTRUCTOR
2361 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2363 /* 'ary' is part of the aggregate initializer we're currently
2364 building; if there's no initializer for this element yet,
2367 error ("accessing uninitialized array element");
2368 *non_constant_p
= true;
2372 /* If it's within the array bounds but doesn't have an explicit
2373 initializer, it's value-initialized. */
2374 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2375 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2379 /* Subroutine of cxx_eval_constant_expression.
2380 Attempt to reduce a field access of a value of class type. */
2383 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2385 bool *non_constant_p
, bool *overflow_p
)
2387 unsigned HOST_WIDE_INT i
;
2390 tree part
= TREE_OPERAND (t
, 1);
2391 tree orig_whole
= TREE_OPERAND (t
, 0);
2392 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2394 non_constant_p
, overflow_p
);
2395 if (TREE_CODE (whole
) == INDIRECT_REF
2396 && integer_zerop (TREE_OPERAND (whole
, 0))
2398 error ("dereferencing a null pointer in %qE", orig_whole
);
2400 if (TREE_CODE (whole
) == PTRMEM_CST
)
2401 whole
= cplus_expand_constant (whole
);
2402 if (whole
== orig_whole
)
2405 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2406 whole
, part
, NULL_TREE
);
2407 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2409 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2412 error ("%qE is not a constant expression", orig_whole
);
2413 *non_constant_p
= true;
2415 if (DECL_MUTABLE_P (part
))
2418 error ("mutable %qD is not usable in a constant expression", part
);
2419 *non_constant_p
= true;
2421 if (*non_constant_p
)
2423 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2424 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2426 /* Use name match for PMF fields, as a variant will have a
2427 different FIELD_DECL with a different type. */
2428 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2434 /* We're in the middle of initializing it. */
2438 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2439 && CONSTRUCTOR_NELTS (whole
) > 0)
2441 /* DR 1188 says we don't have to deal with this. */
2443 error ("accessing %qD member instead of initialized %qD member in "
2444 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2445 *non_constant_p
= true;
2449 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2450 classes never get represented; throw together a value now. */
2451 if (is_really_empty_class (TREE_TYPE (t
)))
2452 return build_constructor (TREE_TYPE (t
), NULL
);
2454 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2456 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2458 /* 'whole' is part of the aggregate initializer we're currently
2459 building; if there's no initializer for this member yet, that's an
2462 error ("accessing uninitialized member %qD", part
);
2463 *non_constant_p
= true;
2467 /* If there's no explicit init for this field, it's value-initialized. */
2468 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2469 return cxx_eval_constant_expression (ctx
, value
,
2471 non_constant_p
, overflow_p
);
2474 /* Subroutine of cxx_eval_constant_expression.
2475 Attempt to reduce a field access of a value of class type that is
2476 expressed as a BIT_FIELD_REF. */
2479 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2481 bool *non_constant_p
, bool *overflow_p
)
2483 tree orig_whole
= TREE_OPERAND (t
, 0);
2484 tree retval
, fldval
, utype
, mask
;
2485 bool fld_seen
= false;
2486 HOST_WIDE_INT istart
, isize
;
2487 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2489 non_constant_p
, overflow_p
);
2490 tree start
, field
, value
;
2491 unsigned HOST_WIDE_INT i
;
2493 if (whole
== orig_whole
)
2495 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2497 if (!*non_constant_p
2498 && TREE_CODE (whole
) != VECTOR_CST
2499 && TREE_CODE (whole
) != CONSTRUCTOR
)
2502 error ("%qE is not a constant expression", orig_whole
);
2503 *non_constant_p
= true;
2505 if (*non_constant_p
)
2508 if (TREE_CODE (whole
) == VECTOR_CST
)
2509 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2510 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2512 start
= TREE_OPERAND (t
, 2);
2513 istart
= tree_to_shwi (start
);
2514 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2515 utype
= TREE_TYPE (t
);
2516 if (!TYPE_UNSIGNED (utype
))
2517 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2518 retval
= build_int_cst (utype
, 0);
2519 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2521 tree bitpos
= bit_position (field
);
2522 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2524 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2525 && TREE_CODE (value
) == INTEGER_CST
2526 && tree_fits_shwi_p (bitpos
)
2527 && tree_fits_shwi_p (DECL_SIZE (field
)))
2529 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2530 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2531 HOST_WIDE_INT shift
;
2532 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2534 fldval
= fold_convert (utype
, value
);
2535 mask
= build_int_cst_type (utype
, -1);
2536 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2537 size_int (TYPE_PRECISION (utype
) - sz
));
2538 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2539 size_int (TYPE_PRECISION (utype
) - sz
));
2540 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2541 shift
= bit
- istart
;
2542 if (BYTES_BIG_ENDIAN
)
2543 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2544 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2546 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2552 return fold_convert (TREE_TYPE (t
), retval
);
2554 return error_mark_node
;
2557 /* Subroutine of cxx_eval_constant_expression.
2558 Evaluate a short-circuited logical expression T in the context
2559 of a given constexpr CALL. BAILOUT_VALUE is the value for
2560 early return. CONTINUE_VALUE is used here purely for
2561 sanity check purposes. */
2564 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2565 tree bailout_value
, tree continue_value
,
2567 bool *non_constant_p
, bool *overflow_p
)
2570 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2572 non_constant_p
, overflow_p
);
2573 VERIFY_CONSTANT (lhs
);
2574 if (tree_int_cst_equal (lhs
, bailout_value
))
2576 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2577 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2578 lval
, non_constant_p
,
2580 VERIFY_CONSTANT (r
);
2584 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2585 CONSTRUCTOR elements to initialize (part of) an object containing that
2586 field. Return a pointer to the constructor_elt corresponding to the
2587 initialization of the field. */
2589 static constructor_elt
*
2590 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2592 tree aggr
= TREE_OPERAND (ref
, 0);
2593 tree field
= TREE_OPERAND (ref
, 1);
2595 constructor_elt
*ce
;
2597 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2599 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2601 constructor_elt
*base_ce
2602 = base_field_constructor_elt (v
, aggr
);
2603 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2606 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2607 if (ce
->index
== field
)
2614 /* Some of the expressions fed to the constexpr mechanism are calls to
2615 constructors, which have type void. In that case, return the type being
2616 initialized by the constructor. */
2619 initialized_type (tree t
)
2623 tree type
= cv_unqualified (TREE_TYPE (t
));
2624 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2626 /* A constructor call has void type, so we need to look deeper. */
2627 tree fn
= get_function_named_in_call (t
);
2628 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2629 && DECL_CXX_CONSTRUCTOR_P (fn
))
2630 type
= DECL_CONTEXT (fn
);
2635 /* We're about to initialize element INDEX of an array or class from VALUE.
2636 Set up NEW_CTX appropriately by adjusting .object to refer to the
2637 subobject and creating a new CONSTRUCTOR if the element is itself
2638 a class or array. */
2641 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2642 tree index
, tree
&value
)
2646 if (index
&& TREE_CODE (index
) != INTEGER_CST
2647 && TREE_CODE (index
) != FIELD_DECL
)
2648 /* This won't have an element in the new CONSTRUCTOR. */
2651 tree type
= initialized_type (value
);
2652 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2653 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2656 /* The sub-aggregate initializer might contain a placeholder;
2657 update object to refer to the subobject and ctor to refer to
2658 the (newly created) sub-initializer. */
2660 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2661 tree elt
= build_constructor (type
, NULL
);
2662 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2665 if (TREE_CODE (value
) == TARGET_EXPR
)
2666 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2667 value
= TARGET_EXPR_INITIAL (value
);
2670 /* We're about to process an initializer for a class or array TYPE. Make
2671 sure that CTX is set up appropriately. */
2674 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2676 /* We don't bother building a ctor for an empty base subobject. */
2677 if (is_empty_class (type
))
2680 /* We're in the middle of an initializer that might involve placeholders;
2681 our caller should have created a CONSTRUCTOR for us to put the
2682 initializer into. We will either return that constructor or T. */
2683 gcc_assert (ctx
->ctor
);
2684 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2685 (type
, TREE_TYPE (ctx
->ctor
)));
2686 /* We used to check that ctx->ctor was empty, but that isn't the case when
2687 the object is zero-initialized before calling the constructor. */
2690 tree otype
= TREE_TYPE (ctx
->object
);
2691 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2692 /* Handle flexible array members. */
2693 || (TREE_CODE (otype
) == ARRAY_TYPE
2694 && TYPE_DOMAIN (otype
) == NULL_TREE
2695 && TREE_CODE (type
) == ARRAY_TYPE
2696 && (same_type_ignoring_top_level_qualifiers_p
2697 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2699 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2700 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2703 /* Subroutine of cxx_eval_constant_expression.
2704 The expression tree T denotes a C-style array or a C-style
2705 aggregate. Reduce it to a constant expression. */
2708 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2710 bool *non_constant_p
, bool *overflow_p
)
2712 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2713 bool changed
= false;
2714 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2715 tree type
= TREE_TYPE (t
);
2717 constexpr_ctx new_ctx
;
2718 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2720 /* We don't really need the ctx->ctor business for a PMF or
2721 vector, but it's simpler to use the same code. */
2723 new_ctx
.ctor
= build_constructor (type
, NULL
);
2724 new_ctx
.object
= NULL_TREE
;
2727 verify_ctor_sanity (ctx
, type
);
2728 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2729 vec_alloc (*p
, vec_safe_length (v
));
2733 bool constant_p
= true;
2734 bool side_effects_p
= false;
2735 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2737 tree orig_value
= value
;
2738 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2739 if (new_ctx
.ctor
!= ctx
->ctor
)
2740 /* If we built a new CONSTRUCTOR, attach it now so that other
2741 initializers can refer to it. */
2742 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2743 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2745 non_constant_p
, overflow_p
);
2746 /* Don't VERIFY_CONSTANT here. */
2747 if (ctx
->quiet
&& *non_constant_p
)
2749 if (elt
!= orig_value
)
2752 if (!TREE_CONSTANT (elt
))
2754 if (TREE_SIDE_EFFECTS (elt
))
2755 side_effects_p
= true;
2756 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2758 /* This is an initialization of a vfield inside a base
2759 subaggregate that we already initialized; push this
2760 initialization into the previous initialization. */
2761 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2766 && (TREE_CODE (index
) == NOP_EXPR
2767 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2769 /* This is an initializer for an empty base; now that we've
2770 checked that it's constant, we can ignore it. */
2771 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2774 else if (new_ctx
.ctor
!= ctx
->ctor
)
2776 /* We appended this element above; update the value. */
2777 gcc_assert ((*p
)->last().index
== index
);
2778 (*p
)->last().value
= elt
;
2781 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2783 if (*non_constant_p
|| !changed
)
2786 /* We're done building this CONSTRUCTOR, so now we can interpret an
2787 element without an explicit initializer as value-initialized. */
2788 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2789 TREE_CONSTANT (t
) = constant_p
;
2790 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2791 if (VECTOR_TYPE_P (type
))
2796 /* Subroutine of cxx_eval_constant_expression.
2797 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2798 initialization of a non-static data member of array type. Reduce it to a
2801 Note that apart from value-initialization (when VALUE_INIT is true),
2802 this is only intended to support value-initialization and the
2803 initializations done by defaulted constructors for classes with
2804 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2805 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2806 for the copy/move constructor. */
2809 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2810 bool value_init
, bool lval
,
2811 bool *non_constant_p
, bool *overflow_p
)
2813 tree elttype
= TREE_TYPE (atype
);
2814 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2815 verify_ctor_sanity (ctx
, atype
);
2816 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2817 vec_alloc (*p
, max
+ 1);
2818 bool pre_init
= false;
2819 unsigned HOST_WIDE_INT i
;
2821 /* For the default constructor, build up a call to the default
2822 constructor of the element type. We only need to handle class types
2823 here, as for a constructor to be constexpr, all members must be
2824 initialized, which for a defaulted default constructor means they must
2825 be of a class type with a constexpr default constructor. */
2826 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2827 /* We only do this at the lowest level. */;
2828 else if (value_init
)
2830 init
= build_value_init (elttype
, tf_warning_or_error
);
2835 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2836 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2837 &argvec
, elttype
, LOOKUP_NORMAL
,
2838 tf_warning_or_error
);
2839 release_tree_vector (argvec
);
2840 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2844 for (i
= 0; i
< max
; ++i
)
2846 tree idx
= build_int_cst (size_type_node
, i
);
2849 constexpr_ctx new_ctx
;
2850 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2851 if (new_ctx
.ctor
!= ctx
->ctor
)
2852 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2853 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2855 /* A multidimensional array; recurse. */
2856 if (value_init
|| init
== NULL_TREE
)
2858 eltinit
= NULL_TREE
;
2862 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2863 tf_warning_or_error
);
2864 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2866 non_constant_p
, overflow_p
);
2870 /* Initializing an element using value or default initialization
2871 we just pre-built above. */
2872 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2873 non_constant_p
, overflow_p
);
2878 /* Copying an element. */
2879 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2880 (atype
, TREE_TYPE (init
)));
2881 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2882 tf_warning_or_error
);
2883 if (!lvalue_p (init
))
2884 eltinit
= move (eltinit
);
2885 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2886 eltinit
= (cxx_eval_constant_expression
2887 (&new_ctx
, eltinit
, lval
,
2888 non_constant_p
, overflow_p
));
2890 if (*non_constant_p
&& !ctx
->quiet
)
2892 if (new_ctx
.ctor
!= ctx
->ctor
)
2894 /* We appended this element above; update the value. */
2895 gcc_assert ((*p
)->last().index
== idx
);
2896 (*p
)->last().value
= eltinit
;
2899 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2900 /* Reuse the result of cxx_eval_constant_expression call
2901 from the first iteration to all others if it is a constant
2902 initializer that doesn't require relocations. */
2905 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2906 == null_pointer_node
))
2908 if (new_ctx
.ctor
!= ctx
->ctor
)
2909 eltinit
= new_ctx
.ctor
;
2910 for (i
= 1; i
< max
; ++i
)
2912 idx
= build_int_cst (size_type_node
, i
);
2913 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2919 if (!*non_constant_p
)
2922 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2928 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2930 bool *non_constant_p
, bool *overflow_p
)
2932 tree atype
= TREE_TYPE (t
);
2933 tree init
= VEC_INIT_EXPR_INIT (t
);
2934 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2935 VEC_INIT_EXPR_VALUE_INIT (t
),
2936 lval
, non_constant_p
, overflow_p
);
2937 if (*non_constant_p
)
2943 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2944 match. We want to be less strict for simple *& folding; if we have a
2945 non-const temporary that we access through a const pointer, that should
2946 work. We handle this here rather than change fold_indirect_ref_1
2947 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2948 don't really make sense outside of constant expression evaluation. Also
2949 we want to allow folding to COMPONENT_REF, which could cause trouble
2950 with TBAA in fold_indirect_ref_1.
2952 Try to keep this function synced with fold_indirect_ref_1. */
2955 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2961 subtype
= TREE_TYPE (sub
);
2962 if (!POINTER_TYPE_P (subtype
))
2965 if (TREE_CODE (sub
) == ADDR_EXPR
)
2967 tree op
= TREE_OPERAND (sub
, 0);
2968 tree optype
= TREE_TYPE (op
);
2970 /* *&CONST_DECL -> to the value of the const decl. */
2971 if (TREE_CODE (op
) == CONST_DECL
)
2972 return DECL_INITIAL (op
);
2973 /* *&p => p; make sure to handle *&"str"[cst] here. */
2974 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2975 /* Also handle the case where the desired type is an array of unknown
2976 bounds because the variable has had its bounds deduced since the
2977 ADDR_EXPR was created. */
2978 || (TREE_CODE (type
) == ARRAY_TYPE
2979 && TREE_CODE (optype
) == ARRAY_TYPE
2980 && TYPE_DOMAIN (type
) == NULL_TREE
2981 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
2984 tree fop
= fold_read_from_constant_string (op
);
2990 /* *(foo *)&fooarray => fooarray[0] */
2991 else if (TREE_CODE (optype
) == ARRAY_TYPE
2992 && (same_type_ignoring_top_level_qualifiers_p
2993 (type
, TREE_TYPE (optype
))))
2995 tree type_domain
= TYPE_DOMAIN (optype
);
2996 tree min_val
= size_zero_node
;
2997 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2998 min_val
= TYPE_MIN_VALUE (type_domain
);
2999 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
3000 NULL_TREE
, NULL_TREE
);
3002 /* *(foo *)&complexfoo => __real__ complexfoo */
3003 else if (TREE_CODE (optype
) == COMPLEX_TYPE
3004 && (same_type_ignoring_top_level_qualifiers_p
3005 (type
, TREE_TYPE (optype
))))
3006 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
3007 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3008 else if (VECTOR_TYPE_P (optype
)
3009 && (same_type_ignoring_top_level_qualifiers_p
3010 (type
, TREE_TYPE (optype
))))
3012 tree part_width
= TYPE_SIZE (type
);
3013 tree index
= bitsize_int (0);
3014 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
3016 /* Also handle conversion to an empty base class, which
3017 is represented with a NOP_EXPR. */
3018 else if (is_empty_class (type
)
3019 && CLASS_TYPE_P (optype
)
3020 && DERIVED_FROM_P (type
, optype
))
3025 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3026 else if (RECORD_OR_UNION_TYPE_P (optype
))
3028 tree field
= TYPE_FIELDS (optype
);
3029 for (; field
; field
= DECL_CHAIN (field
))
3030 if (TREE_CODE (field
) == FIELD_DECL
3031 && TREE_TYPE (field
) != error_mark_node
3032 && integer_zerop (byte_position (field
))
3033 && (same_type_ignoring_top_level_qualifiers_p
3034 (TREE_TYPE (field
), type
)))
3035 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3038 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3039 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
3041 tree op00
= TREE_OPERAND (sub
, 0);
3042 tree op01
= TREE_OPERAND (sub
, 1);
3045 if (TREE_CODE (op00
) == ADDR_EXPR
)
3048 op00
= TREE_OPERAND (op00
, 0);
3049 op00type
= TREE_TYPE (op00
);
3051 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3052 if (VECTOR_TYPE_P (op00type
)
3053 && (same_type_ignoring_top_level_qualifiers_p
3054 (type
, TREE_TYPE (op00type
))))
3056 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
3057 tree part_width
= TYPE_SIZE (type
);
3058 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
3059 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
3060 tree index
= bitsize_int (indexi
);
3062 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
3063 return fold_build3_loc (loc
,
3064 BIT_FIELD_REF
, type
, op00
,
3068 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3069 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3070 && (same_type_ignoring_top_level_qualifiers_p
3071 (type
, TREE_TYPE (op00type
))))
3073 tree size
= TYPE_SIZE_UNIT (type
);
3074 if (tree_int_cst_equal (size
, op01
))
3075 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3077 /* ((foo *)&fooarray)[1] => fooarray[1] */
3078 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3079 && (same_type_ignoring_top_level_qualifiers_p
3080 (type
, TREE_TYPE (op00type
))))
3082 tree type_domain
= TYPE_DOMAIN (op00type
);
3083 tree min_val
= size_zero_node
;
3084 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3085 min_val
= TYPE_MIN_VALUE (type_domain
);
3086 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
3087 TYPE_SIZE_UNIT (type
));
3088 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
3089 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3090 NULL_TREE
, NULL_TREE
);
3092 /* Also handle conversion to an empty base class, which
3093 is represented with a NOP_EXPR. */
3094 else if (is_empty_class (type
)
3095 && CLASS_TYPE_P (op00type
)
3096 && DERIVED_FROM_P (type
, op00type
))
3101 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3102 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3104 tree field
= TYPE_FIELDS (op00type
);
3105 for (; field
; field
= DECL_CHAIN (field
))
3106 if (TREE_CODE (field
) == FIELD_DECL
3107 && TREE_TYPE (field
) != error_mark_node
3108 && tree_int_cst_equal (byte_position (field
), op01
)
3109 && (same_type_ignoring_top_level_qualifiers_p
3110 (TREE_TYPE (field
), type
)))
3111 return fold_build3 (COMPONENT_REF
, type
, op00
,
3116 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3117 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3118 && (same_type_ignoring_top_level_qualifiers_p
3119 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3122 tree min_val
= size_zero_node
;
3123 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3127 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3128 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3129 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3130 min_val
= TYPE_MIN_VALUE (type_domain
);
3131 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3139 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3141 bool *non_constant_p
, bool *overflow_p
)
3143 tree orig_op0
= TREE_OPERAND (t
, 0);
3144 bool empty_base
= false;
3146 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3147 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3149 if (TREE_CODE (t
) == MEM_REF
3150 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3152 gcc_assert (ctx
->quiet
);
3153 *non_constant_p
= true;
3157 /* First try to simplify it directly. */
3158 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3162 /* If that didn't work, evaluate the operand first. */
3163 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3164 /*lval*/false, non_constant_p
,
3166 /* Don't VERIFY_CONSTANT here. */
3167 if (*non_constant_p
)
3170 if (!lval
&& integer_zerop (op0
))
3173 error ("dereferencing a null pointer");
3174 *non_constant_p
= true;
3178 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3182 /* We couldn't fold to a constant value. Make sure it's not
3183 something we should have been able to fold. */
3186 if (TREE_CODE (sub
) == ADDR_EXPR
)
3188 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3189 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3190 /* DR 1188 says we don't have to deal with this. */
3192 error ("accessing value of %qE through a %qT glvalue in a "
3193 "constant expression", build_fold_indirect_ref (sub
),
3195 *non_constant_p
= true;
3199 if (lval
&& op0
!= orig_op0
)
3200 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3202 VERIFY_CONSTANT (t
);
3207 r
= cxx_eval_constant_expression (ctx
, r
,
3208 lval
, non_constant_p
, overflow_p
);
3209 if (*non_constant_p
)
3212 /* If we're pulling out the value of an empty base, just return an empty
3214 if (empty_base
&& !lval
)
3216 r
= build_constructor (TREE_TYPE (t
), NULL
);
3217 TREE_CONSTANT (r
) = true;
3223 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3224 Shared between potential_constant_expression and
3225 cxx_eval_constant_expression. */
3228 non_const_var_error (tree r
)
3230 tree type
= TREE_TYPE (r
);
3231 error ("the value of %qD is not usable in a constant "
3233 /* Avoid error cascade. */
3234 if (DECL_INITIAL (r
) == error_mark_node
)
3236 if (DECL_DECLARED_CONSTEXPR_P (r
))
3237 inform (DECL_SOURCE_LOCATION (r
),
3238 "%qD used in its own initializer", r
);
3239 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3241 if (!CP_TYPE_CONST_P (type
))
3242 inform (DECL_SOURCE_LOCATION (r
),
3243 "%q#D is not const", r
);
3244 else if (CP_TYPE_VOLATILE_P (type
))
3245 inform (DECL_SOURCE_LOCATION (r
),
3246 "%q#D is volatile", r
);
3247 else if (!DECL_INITIAL (r
)
3248 || !TREE_CONSTANT (DECL_INITIAL (r
))
3249 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3250 inform (DECL_SOURCE_LOCATION (r
),
3251 "%qD was not initialized with a constant "
3256 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3257 inform (DECL_SOURCE_LOCATION (r
),
3258 "%qD was not initialized with a constant "
3262 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3263 inform (DECL_SOURCE_LOCATION (r
),
3264 "%qD was not declared %<constexpr%>", r
);
3266 inform (DECL_SOURCE_LOCATION (r
),
3267 "%qD does not have integral or enumeration type",
3272 /* Subroutine of cxx_eval_constant_expression.
3273 Like cxx_eval_unary_expression, except for trinary expressions. */
3276 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3278 bool *non_constant_p
, bool *overflow_p
)
3284 for (i
= 0; i
< 3; i
++)
3286 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3288 non_constant_p
, overflow_p
);
3289 VERIFY_CONSTANT (args
[i
]);
3292 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3293 args
[0], args
[1], args
[2]);
3294 if (val
== NULL_TREE
)
3296 VERIFY_CONSTANT (val
);
3300 /* True if T was declared in a function declared to be constexpr, and
3301 therefore potentially constant in C++14. */
3304 var_in_constexpr_fn (tree t
)
3306 tree ctx
= DECL_CONTEXT (t
);
3307 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3308 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3311 /* True if T was declared in a function that might be constexpr: either a
3312 function that was declared constexpr, or a C++17 lambda op(). */
3315 var_in_maybe_constexpr_fn (tree t
)
3317 if (cxx_dialect
>= cxx17
3318 && DECL_FUNCTION_SCOPE_P (t
)
3319 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3321 return var_in_constexpr_fn (t
);
3324 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3325 build_over_call we implement trivial copy of a class with tail padding using
3326 assignment of character arrays, which is valid in normal code, but not in
3327 constexpr evaluation. We don't need to worry about clobbering tail padding
3328 in constexpr evaluation, so strip the type punning. */
3331 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3333 if (TREE_CODE (target
) == MEM_REF
3334 && TREE_CODE (init
) == MEM_REF
3335 && TREE_TYPE (target
) == TREE_TYPE (init
)
3336 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3337 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3339 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3340 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3344 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3347 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3349 bool *non_constant_p
, bool *overflow_p
)
3351 constexpr_ctx new_ctx
= *ctx
;
3353 tree init
= TREE_OPERAND (t
, 1);
3354 if (TREE_CLOBBER_P (init
))
3355 /* Just ignore clobbers. */
3358 /* First we figure out where we're storing to. */
3359 tree target
= TREE_OPERAND (t
, 0);
3361 maybe_simplify_trivial_copy (target
, init
);
3363 tree type
= TREE_TYPE (target
);
3364 target
= cxx_eval_constant_expression (ctx
, target
,
3366 non_constant_p
, overflow_p
);
3367 if (*non_constant_p
)
3370 /* cxx_eval_array_reference for lval = true allows references one past
3371 end of array, because it does not know if it is just taking address
3372 (which is valid), or actual dereference. Here we know it is
3373 a dereference, so diagnose it here. */
3374 for (tree probe
= target
; probe
; )
3376 switch (TREE_CODE (probe
))
3380 ary
= TREE_OPERAND (probe
, 0);
3381 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3382 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3383 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3384 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3387 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3388 non_constant_p
, overflow_p
);
3389 VERIFY_CONSTANT (nelts
);
3390 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3391 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3392 if (wi::to_widest (TREE_OPERAND (probe
, 1)) == wi::to_widest (nelts
))
3394 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3395 *non_constant_p
= true;
3402 probe
= TREE_OPERAND (probe
, 0);
3411 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3413 /* For initialization of an empty base, the original target will be
3414 *(base*)this, which the above evaluation resolves to the object
3415 argument, which has the derived type rather than the base type. In
3416 this situation, just evaluate the initializer and return, since
3417 there's no actual data to store. */
3418 gcc_assert (is_empty_class (type
));
3419 return cxx_eval_constant_expression (ctx
, init
, false,
3420 non_constant_p
, overflow_p
);
3423 /* And then find the underlying variable. */
3424 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3425 tree object
= NULL_TREE
;
3426 for (tree probe
= target
; object
== NULL_TREE
; )
3428 switch (TREE_CODE (probe
))
3433 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3434 vec_safe_push (refs
, TREE_TYPE (probe
));
3435 probe
= TREE_OPERAND (probe
, 0);
3443 /* And then find/build up our initializer for the path to the subobject
3444 we're initializing. */
3446 if (object
== ctx
->object
&& VAR_P (object
)
3447 && DECL_NAME (object
) && ctx
->call
== NULL
)
3448 /* The variable we're building up an aggregate initializer for is outside
3449 the constant-expression, so don't evaluate the store. We check
3450 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3452 else if (DECL_P (object
))
3453 valp
= ctx
->values
->get (object
);
3458 /* A constant-expression cannot modify objects from outside the
3459 constant-expression. */
3461 error ("modification of %qE is not a constant expression", object
);
3462 *non_constant_p
= true;
3465 type
= TREE_TYPE (object
);
3466 bool no_zero_init
= true;
3468 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3469 while (!refs
->is_empty())
3471 if (*valp
== NULL_TREE
)
3473 *valp
= build_constructor (type
, NULL
);
3474 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3476 else if (TREE_CODE (*valp
) == STRING_CST
)
3478 /* An array was initialized with a string constant, and now
3479 we're writing into one of its elements. Explode the
3480 single initialization into a set of element
3482 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3484 tree string
= *valp
;
3485 tree elt_type
= TREE_TYPE (type
);
3486 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3487 / TYPE_PRECISION (char_type_node
));
3488 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3489 tree ary_ctor
= build_constructor (type
, NULL
);
3491 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3492 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3494 constructor_elt elt
=
3496 build_int_cst (size_type_node
, ix
),
3497 extract_string_elt (string
, chars_per_elt
, ix
)
3499 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3505 /* If the value of object is already zero-initialized, any new ctors for
3506 subobjects will also be zero-initialized. */
3507 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3509 vec_safe_push (ctors
, *valp
);
3511 enum tree_code code
= TREE_CODE (type
);
3513 tree index
= refs
->pop();
3515 constructor_elt
*cep
= NULL
;
3516 if (code
== ARRAY_TYPE
)
3519 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3520 gcc_assert (i
>= 0);
3521 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3522 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3526 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3528 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3529 Usually we meet initializers in that order, but it is
3530 possible for base types to be placed not in program
3532 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3533 unsigned HOST_WIDE_INT idx
;
3535 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3536 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3537 /* Changing active member. */
3538 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3541 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3542 idx
++, fields
= DECL_CHAIN (fields
))
3544 if (index
== cep
->index
)
3547 /* The field we're initializing must be on the field
3548 list. Look to see if it is present before the
3549 field the current ELT initializes. */
3550 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3551 if (index
== fields
)
3555 /* We fell off the end of the CONSTRUCTOR, so insert a new
3556 entry at the end. */
3559 constructor_elt ce
= { index
, NULL_TREE
};
3561 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3562 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3568 release_tree_vector (refs
);
3570 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3572 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3573 wants to modify it. */
3574 if (*valp
== NULL_TREE
)
3576 *valp
= build_constructor (type
, NULL
);
3577 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3579 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3580 *valp
= cplus_expand_constant (*valp
);
3581 new_ctx
.ctor
= *valp
;
3582 new_ctx
.object
= target
;
3585 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3586 non_constant_p
, overflow_p
);
3587 /* Don't share a CONSTRUCTOR that might be changed later. */
3588 init
= unshare_constructor (init
);
3589 if (target
== object
)
3590 /* The hash table might have moved since the get earlier. */
3591 valp
= ctx
->values
->get (object
);
3593 if (TREE_CODE (init
) == CONSTRUCTOR
)
3595 /* An outer ctx->ctor might be pointing to *valp, so replace
3597 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3598 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3599 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3600 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3601 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3606 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3607 CONSTRUCTORs, if any. */
3610 bool c
= TREE_CONSTANT (init
);
3611 bool s
= TREE_SIDE_EFFECTS (init
);
3613 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3616 TREE_CONSTANT (elt
) = false;
3618 TREE_SIDE_EFFECTS (elt
) = true;
3620 release_tree_vector (ctors
);
3622 if (*non_constant_p
)
3630 /* Evaluate a ++ or -- expression. */
3633 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3635 bool *non_constant_p
, bool *overflow_p
)
3637 enum tree_code code
= TREE_CODE (t
);
3638 tree type
= TREE_TYPE (t
);
3639 tree op
= TREE_OPERAND (t
, 0);
3640 tree offset
= TREE_OPERAND (t
, 1);
3641 gcc_assert (TREE_CONSTANT (offset
));
3643 /* The operand as an lvalue. */
3644 op
= cxx_eval_constant_expression (ctx
, op
, true,
3645 non_constant_p
, overflow_p
);
3647 /* The operand as an rvalue. */
3649 = cxx_eval_constant_expression (ctx
, op
, false,
3650 non_constant_p
, overflow_p
);
3651 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3652 a local array in a constexpr function. */
3653 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3655 VERIFY_CONSTANT (val
);
3657 /* The modified value. */
3658 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3660 if (POINTER_TYPE_P (type
))
3662 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3663 offset
= convert_to_ptrofftype (offset
);
3665 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3666 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3669 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3671 VERIFY_CONSTANT (mod
);
3673 /* Storing the modified value. */
3674 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3675 cxx_eval_constant_expression (ctx
, store
,
3676 true, non_constant_p
, overflow_p
);
3678 /* And the value of the expression. */
3679 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3681 /* Prefix ops are lvalues. */
3685 /* But we optimize when the caller wants an rvalue. */
3689 /* Postfix ops are rvalues. */
3693 /* Predicates for the meaning of *jump_target. */
3696 returns (tree
*jump_target
)
3699 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3700 || (TREE_CODE (*jump_target
) == LABEL_DECL
3701 && LABEL_DECL_CDTOR (*jump_target
)));
3705 breaks (tree
*jump_target
)
3708 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3709 && LABEL_DECL_BREAK (*jump_target
))
3710 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3714 continues (tree
*jump_target
)
3717 && TREE_CODE (*jump_target
) == LABEL_DECL
3718 && LABEL_DECL_CONTINUE (*jump_target
);
3722 switches (tree
*jump_target
)
3725 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3728 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3729 STMT matches *jump_target. If we're looking for a case label and we see
3730 the default label, note it in ctx->css_state. */
3733 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3735 switch (TREE_CODE (*jump_target
))
3738 if (TREE_CODE (stmt
) == LABEL_EXPR
3739 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3744 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3746 gcc_assert (ctx
->css_state
!= NULL
);
3747 if (!CASE_LOW (stmt
))
3749 /* default: should appear just once in a SWITCH_EXPR
3750 body (excluding nested SWITCH_EXPR). */
3751 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3752 /* When evaluating SWITCH_EXPR body for the second time,
3753 return true for the default: label. */
3754 if (*ctx
->css_state
== css_default_processing
)
3756 *ctx
->css_state
= css_default_seen
;
3758 else if (CASE_HIGH (stmt
))
3760 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3761 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3764 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3775 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3776 semantics, for switch, break, continue, and return. */
3779 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3780 bool *non_constant_p
, bool *overflow_p
,
3783 tree_stmt_iterator i
;
3785 /* In a statement-expression we want to return the last value.
3786 For empty statement expression return void_node. */
3790 local_target
= NULL_TREE
;
3791 jump_target
= &local_target
;
3793 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3795 tree stmt
= tsi_stmt (i
);
3796 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3797 non_constant_p
, overflow_p
,
3799 if (*non_constant_p
)
3801 if (returns (jump_target
) || breaks (jump_target
))
3807 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3808 semantics; continue semantics are covered by cxx_eval_statement_list. */
3811 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3812 bool *non_constant_p
, bool *overflow_p
,
3815 constexpr_ctx new_ctx
= *ctx
;
3817 tree body
= TREE_OPERAND (t
, 0);
3821 hash_set
<tree
> save_exprs
;
3822 new_ctx
.save_exprs
= &save_exprs
;
3824 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3825 non_constant_p
, overflow_p
, jump_target
);
3827 /* Forget saved values of SAVE_EXPRs. */
3828 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3829 iter
!= save_exprs
.end(); ++iter
)
3830 new_ctx
.values
->remove (*iter
);
3831 if (++count
>= constexpr_loop_limit
)
3834 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3835 "constexpr loop iteration count exceeds limit of %d "
3836 "(use -fconstexpr-loop-limit= to increase the limit)",
3837 constexpr_loop_limit
);
3838 *non_constant_p
= true;
3842 while (!returns (jump_target
)
3843 && !breaks (jump_target
)
3844 && !switches (jump_target
)
3845 && !*non_constant_p
);
3847 if (breaks (jump_target
))
3848 *jump_target
= NULL_TREE
;
3853 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3857 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3858 bool *non_constant_p
, bool *overflow_p
,
3861 tree cond
= TREE_OPERAND (t
, 0);
3862 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3863 non_constant_p
, overflow_p
);
3864 VERIFY_CONSTANT (cond
);
3865 *jump_target
= cond
;
3867 tree body
= TREE_OPERAND (t
, 1);
3868 constexpr_ctx new_ctx
= *ctx
;
3869 constexpr_switch_state css
= css_default_not_seen
;
3870 new_ctx
.css_state
= &css
;
3871 cxx_eval_constant_expression (&new_ctx
, body
, false,
3872 non_constant_p
, overflow_p
, jump_target
);
3873 if (switches (jump_target
) && css
== css_default_seen
)
3875 /* If the SWITCH_EXPR body has default: label, process it once again,
3876 this time instructing label_matches to return true for default:
3877 label on switches (jump_target). */
3878 css
= css_default_processing
;
3879 cxx_eval_constant_expression (&new_ctx
, body
, false,
3880 non_constant_p
, overflow_p
, jump_target
);
3882 if (breaks (jump_target
) || switches (jump_target
))
3883 *jump_target
= NULL_TREE
;
3887 /* Find the object of TYPE under initialization in CTX. */
3890 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3895 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3896 can is a minor optimization. */
3897 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
3903 /* Since an object cannot have a field of its own type, we can search outward
3904 from ctx->object to find the unique containing object of TYPE. */
3905 tree ob
= ctx
->object
;
3908 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
3910 if (handled_component_p (ob
))
3911 ob
= TREE_OPERAND (ob
, 0);
3919 /* Attempt to reduce the expression T to a constant value.
3920 On failure, issue diagnostic and return error_mark_node. */
3921 /* FIXME unify with c_fully_fold */
3922 /* FIXME overflow_p is too global */
3925 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3927 bool *non_constant_p
, bool *overflow_p
,
3930 constexpr_ctx new_ctx
;
3933 if (jump_target
&& *jump_target
)
3935 /* If we are jumping, ignore all statements/expressions except those
3936 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
3937 switch (TREE_CODE (t
))
3940 case STATEMENT_LIST
:
3945 case CASE_LABEL_EXPR
:
3946 if (label_matches (ctx
, jump_target
, t
))
3948 *jump_target
= NULL_TREE
;
3954 if (t
== error_mark_node
)
3956 *non_constant_p
= true;
3959 if (CONSTANT_CLASS_P (t
))
3961 if (TREE_OVERFLOW (t
))
3964 permerror (input_location
, "overflow in constant expression");
3965 if (!flag_permissive
|| ctx
->quiet
)
3969 if (TREE_CODE (t
) == INTEGER_CST
3970 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
3971 && !integer_zerop (t
))
3974 error ("value %qE of type %qT is not a constant expression",
3976 *non_constant_p
= true;
3982 tree_code tcode
= TREE_CODE (t
);
3988 /* We ask for an rvalue for the RESULT_DECL when indirecting
3989 through an invisible reference, or in named return value
3991 return (*ctx
->values
->get (t
));
3994 if (DECL_HAS_VALUE_EXPR_P (t
))
3995 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
3996 lval
, non_constant_p
, overflow_p
);
3999 /* We used to not check lval for CONST_DECL, but darwin.c uses
4000 CONST_DECL for aggregate constants. */
4003 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4004 && is_really_empty_class (TREE_TYPE (t
)))
4006 /* If the class is empty, we aren't actually loading anything. */
4007 r
= build_constructor (TREE_TYPE (t
), NULL
);
4008 TREE_CONSTANT (r
) = true;
4010 else if (ctx
->strict
)
4011 r
= decl_really_constant_value (t
);
4013 r
= decl_constant_value (t
);
4014 if (TREE_CODE (r
) == TARGET_EXPR
4015 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4016 r
= TARGET_EXPR_INITIAL (r
);
4018 if (tree
*p
= ctx
->values
->get (r
))
4019 if (*p
!= NULL_TREE
)
4024 non_const_var_error (r
);
4025 *non_constant_p
= true;
4033 case CASE_LABEL_EXPR
:
4038 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4040 else if (tree
*p
= ctx
->values
->get (r
))
4043 /* Defer in case this is only used for its type. */;
4044 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4045 /* Defer, there's no lvalue->rvalue conversion. */;
4046 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4047 && is_really_empty_class (TREE_TYPE (t
)))
4049 /* If the class is empty, we aren't actually loading anything. */
4050 r
= build_constructor (TREE_TYPE (t
), NULL
);
4051 TREE_CONSTANT (r
) = true;
4056 error ("%qE is not a constant expression", t
);
4057 *non_constant_p
= true;
4062 case AGGR_INIT_EXPR
:
4063 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4064 non_constant_p
, overflow_p
);
4069 r
= DECL_EXPR_DECL (t
);
4070 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4071 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4075 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4076 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4077 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4081 if (tree init
= DECL_INITIAL (r
))
4083 init
= cxx_eval_constant_expression (ctx
, init
,
4085 non_constant_p
, overflow_p
);
4086 /* Don't share a CONSTRUCTOR that might be changed. */
4087 init
= unshare_constructor (init
);
4088 ctx
->values
->put (r
, init
);
4090 else if (ctx
== &new_ctx
)
4091 /* We gave it a CONSTRUCTOR above. */;
4093 ctx
->values
->put (r
, NULL_TREE
);
4098 if (!literal_type_p (TREE_TYPE (t
)))
4102 error ("temporary of non-literal type %qT in a "
4103 "constant expression", TREE_TYPE (t
));
4104 explain_non_literal_class (TREE_TYPE (t
));
4106 *non_constant_p
= true;
4109 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4111 /* We're being expanded without an explicit target, so start
4112 initializing a new object; expansion with an explicit target
4113 strips the TARGET_EXPR before we get here. */
4115 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4116 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4117 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4118 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4121 /* Pass false for 'lval' because this indicates
4122 initialization of a temporary. */
4123 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4125 non_constant_p
, overflow_p
);
4126 if (!*non_constant_p
)
4127 /* Adjust the type of the result to the type of the temporary. */
4128 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4131 tree slot
= TARGET_EXPR_SLOT (t
);
4132 r
= unshare_constructor (r
);
4133 ctx
->values
->put (slot
, r
);
4140 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4141 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4142 non_constant_p
, overflow_p
);
4146 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4148 non_constant_p
, overflow_p
);
4152 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4153 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4155 non_constant_p
, overflow_p
);
4160 /* Avoid evaluating a SAVE_EXPR more than once. */
4161 if (tree
*p
= ctx
->values
->get (t
))
4165 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4166 non_constant_p
, overflow_p
);
4167 ctx
->values
->put (t
, r
);
4168 if (ctx
->save_exprs
)
4169 ctx
->save_exprs
->add (t
);
4173 case NON_LVALUE_EXPR
:
4174 case TRY_CATCH_EXPR
:
4176 case CLEANUP_POINT_EXPR
:
4177 case MUST_NOT_THROW_EXPR
:
4180 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4182 non_constant_p
, overflow_p
,
4186 case TRY_FINALLY_EXPR
:
4187 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4188 non_constant_p
, overflow_p
,
4190 if (!*non_constant_p
)
4191 /* Also evaluate the cleanup. */
4192 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4193 non_constant_p
, overflow_p
,
4197 /* These differ from cxx_eval_unary_expression in that this doesn't
4198 check for a constant operand or result; an address can be
4199 constant without its operand being, and vice versa. */
4202 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4203 non_constant_p
, overflow_p
);
4208 tree oldop
= TREE_OPERAND (t
, 0);
4209 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4211 non_constant_p
, overflow_p
);
4212 /* Don't VERIFY_CONSTANT here. */
4213 if (*non_constant_p
)
4215 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4216 /* This function does more aggressive folding than fold itself. */
4217 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4218 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4227 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4228 non_constant_p
, overflow_p
);
4229 if (r
== error_mark_node
)
4231 else if (r
== TREE_OPERAND (t
, 0))
4234 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4239 case FIX_TRUNC_EXPR
:
4244 case TRUTH_NOT_EXPR
:
4245 case FIXED_CONVERT_EXPR
:
4246 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4247 non_constant_p
, overflow_p
);
4251 r
= fold_sizeof_expr (t
);
4252 VERIFY_CONSTANT (r
);
4257 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4258 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4259 introduced by build_call_a. */
4260 tree op0
= TREE_OPERAND (t
, 0);
4261 tree op1
= TREE_OPERAND (t
, 1);
4263 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4264 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4265 r
= cxx_eval_constant_expression (ctx
, op0
,
4266 lval
, non_constant_p
, overflow_p
,
4270 /* Check that the LHS is constant and then discard it. */
4271 cxx_eval_constant_expression (ctx
, op0
,
4272 true, non_constant_p
, overflow_p
,
4274 if (*non_constant_p
)
4276 op1
= TREE_OPERAND (t
, 1);
4277 r
= cxx_eval_constant_expression (ctx
, op1
,
4278 lval
, non_constant_p
, overflow_p
,
4284 case POINTER_PLUS_EXPR
:
4288 case TRUNC_DIV_EXPR
:
4290 case FLOOR_DIV_EXPR
:
4291 case ROUND_DIV_EXPR
:
4292 case TRUNC_MOD_EXPR
:
4294 case ROUND_MOD_EXPR
:
4296 case EXACT_DIV_EXPR
:
4306 case TRUTH_XOR_EXPR
:
4313 case UNORDERED_EXPR
:
4323 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4324 non_constant_p
, overflow_p
);
4327 /* fold can introduce non-IF versions of these; still treat them as
4328 short-circuiting. */
4329 case TRUTH_AND_EXPR
:
4330 case TRUTH_ANDIF_EXPR
:
4331 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4334 non_constant_p
, overflow_p
);
4338 case TRUTH_ORIF_EXPR
:
4339 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4342 non_constant_p
, overflow_p
);
4346 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4347 non_constant_p
, overflow_p
);
4351 if (is_overloaded_fn (t
))
4353 /* We can only get here in checking mode via
4354 build_non_dependent_expr, because any expression that
4355 calls or takes the address of the function will have
4356 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4357 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4358 *non_constant_p
= true;
4361 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4362 non_constant_p
, overflow_p
);
4366 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4367 non_constant_p
, overflow_p
);
4371 if (jump_target
&& *jump_target
)
4373 /* When jumping to a label, the label might be either in the
4374 then or else blocks, so process then block first in skipping
4375 mode first, and if we are still in the skipping mode at its end,
4376 process the else block too. */
4377 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4378 lval
, non_constant_p
, overflow_p
,
4381 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4382 lval
, non_constant_p
, overflow_p
,
4388 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4389 non_constant_p
, overflow_p
,
4394 if (TREE_CONSTANT (t
))
4396 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4397 VECTOR_CST if applicable. */
4398 /* FIXME after GCC 6 branches, make the verify unconditional. */
4400 verify_constructor_flags (t
);
4402 recompute_constructor_flags (t
);
4403 if (TREE_CONSTANT (t
))
4406 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4407 non_constant_p
, overflow_p
);
4411 /* We can get this in a defaulted constructor for a class with a
4412 non-static data member of array type. Either the initializer will
4413 be NULL, meaning default-initialization, or it will be an lvalue
4414 or xvalue of the same type, meaning direct-initialization from the
4415 corresponding member. */
4416 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4417 non_constant_p
, overflow_p
);
4422 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4423 non_constant_p
, overflow_p
);
4427 case VIEW_CONVERT_EXPR
:
4429 case UNARY_PLUS_EXPR
:
4431 tree oldop
= TREE_OPERAND (t
, 0);
4433 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4435 non_constant_p
, overflow_p
);
4436 if (*non_constant_p
)
4438 tree type
= TREE_TYPE (t
);
4439 if (TREE_CODE (op
) == PTRMEM_CST
4440 && !TYPE_PTRMEM_P (type
))
4441 op
= cplus_expand_constant (op
);
4442 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4444 if (same_type_ignoring_top_level_qualifiers_p (type
,
4446 || can_convert_qual (type
, op
))
4447 return cp_fold_convert (type
, op
);
4451 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4452 "a reinterpret_cast is not a constant expression");
4453 *non_constant_p
= true;
4458 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4460 if (integer_zerop (op
))
4462 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4465 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4466 "dereferencing a null pointer");
4467 *non_constant_p
= true;
4470 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4472 tree from
= TREE_TYPE (op
);
4474 if (!can_convert (type
, from
, tf_none
))
4477 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4478 "conversion of %qT null pointer to %qT "
4479 "is not a constant expression",
4481 *non_constant_p
= true;
4488 /* This detects for example:
4489 reinterpret_cast<void*>(sizeof 0)
4492 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4493 "%<reinterpret_cast<%T>(%E)%> is not "
4494 "a constant expression",
4496 *non_constant_p
= true;
4500 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4501 /* We didn't fold at the top so we could check for ptr-int
4504 if (tcode
== UNARY_PLUS_EXPR
)
4505 r
= fold_convert (TREE_TYPE (t
), op
);
4507 r
= fold_build1 (tcode
, type
, op
);
4508 /* Conversion of an out-of-range value has implementation-defined
4509 behavior; the language considers it different from arithmetic
4510 overflow, which is undefined. */
4511 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4512 TREE_OVERFLOW (r
) = false;
4516 case EMPTY_CLASS_EXPR
:
4517 /* This is good enough for a function argument that might not get
4518 used, and they can't do anything with it, so just return it. */
4521 case STATEMENT_LIST
:
4523 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4524 return cxx_eval_statement_list (&new_ctx
, t
,
4525 non_constant_p
, overflow_p
, jump_target
);
4528 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4530 non_constant_p
, overflow_p
,
4533 case PREINCREMENT_EXPR
:
4534 case POSTINCREMENT_EXPR
:
4535 case PREDECREMENT_EXPR
:
4536 case POSTDECREMENT_EXPR
:
4537 return cxx_eval_increment_expression (ctx
, t
,
4538 lval
, non_constant_p
, overflow_p
);
4544 case VEC_DELETE_EXPR
:
4547 /* GCC internal stuff. */
4550 case NON_DEPENDENT_EXPR
:
4554 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4555 "expression %qE is not a constant expression", t
);
4556 *non_constant_p
= true;
4559 case PLACEHOLDER_EXPR
:
4560 /* Use of the value or address of the current object. */
4561 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4562 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4563 non_constant_p
, overflow_p
);
4564 /* A placeholder without a referent. We can get here when
4565 checking whether NSDMIs are noexcept, or in massage_init_elt;
4566 just say it's non-constant for now. */
4567 gcc_assert (ctx
->quiet
);
4568 *non_constant_p
= true;
4573 tree cond
= TREE_OPERAND (t
, 0);
4574 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4575 non_constant_p
, overflow_p
);
4576 VERIFY_CONSTANT (cond
);
4577 if (integer_nonzerop (cond
))
4583 *jump_target
= TREE_OPERAND (t
, 0);
4584 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4585 /* Allow for jumping to a cdtor_label. */
4586 || returns (jump_target
));
4590 cxx_eval_loop_expr (ctx
, t
,
4591 non_constant_p
, overflow_p
, jump_target
);
4595 cxx_eval_switch_expr (ctx
, t
,
4596 non_constant_p
, overflow_p
, jump_target
);
4600 /* It's possible to get a requires-expression in a constant
4601 expression. For example:
4603 template<typename T> concept bool C() {
4604 return requires (T t) { t; };
4607 template<typename T> requires !C<T>() void f(T);
4609 Normalization leaves f with the associated constraint
4610 '!requires (T t) { ... }' which is not transformed into
4612 if (!processing_template_decl
)
4613 return evaluate_constraint_expression (t
, NULL_TREE
);
4615 *non_constant_p
= true;
4619 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
4620 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4622 non_constant_p
, overflow_p
,
4627 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4629 /* This function doesn't know how to deal with pre-genericize
4630 statements; this can only happen with statement-expressions,
4631 so for now just fail. */
4633 error_at (EXPR_LOCATION (t
),
4634 "statement is not a constant expression");
4637 internal_error ("unexpected expression %qE of kind %s", t
,
4638 get_tree_code_name (TREE_CODE (t
)));
4639 *non_constant_p
= true;
4643 if (r
== error_mark_node
)
4644 *non_constant_p
= true;
4646 if (*non_constant_p
)
4653 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4654 bool strict
= true, tree object
= NULL_TREE
)
4656 auto_timevar
time (TV_CONSTEXPR
);
4658 bool non_constant_p
= false;
4659 bool overflow_p
= false;
4660 hash_map
<tree
,tree
> map
;
4662 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4663 allow_non_constant
, strict
};
4665 tree type
= initialized_type (t
);
4667 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4669 /* In C++14 an NSDMI can participate in aggregate initialization,
4670 and can refer to the address of the object being initialized, so
4671 we need to pass in the relevant VAR_DECL if we want to do the
4672 evaluation in a single pass. The evaluation will dynamically
4673 update ctx.values for the VAR_DECL. We use the same strategy
4674 for C++11 constexpr constructors that refer to the object being
4676 ctx
.ctor
= build_constructor (type
, NULL
);
4677 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4680 if (TREE_CODE (t
) == TARGET_EXPR
)
4681 object
= TARGET_EXPR_SLOT (t
);
4682 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4683 object
= AGGR_INIT_EXPR_SLOT (t
);
4685 ctx
.object
= object
;
4687 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4688 (type
, TREE_TYPE (object
)));
4689 if (object
&& DECL_P (object
))
4690 map
.put (object
, ctx
.ctor
);
4691 if (TREE_CODE (r
) == TARGET_EXPR
)
4692 /* Avoid creating another CONSTRUCTOR when we expand the
4694 r
= TARGET_EXPR_INITIAL (r
);
4697 r
= cxx_eval_constant_expression (&ctx
, r
,
4698 false, &non_constant_p
, &overflow_p
);
4700 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4702 /* Mutable logic is a bit tricky: we want to allow initialization of
4703 constexpr variables with mutable members, but we can't copy those
4704 members to another constexpr variable. */
4705 if (TREE_CODE (r
) == CONSTRUCTOR
4706 && CONSTRUCTOR_MUTABLE_POISON (r
))
4708 if (!allow_non_constant
)
4709 error ("%qE is not a constant expression because it refers to "
4710 "mutable subobjects of %qT", t
, type
);
4711 non_constant_p
= true;
4714 if (TREE_CODE (r
) == CONSTRUCTOR
4715 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4717 if (!allow_non_constant
)
4718 error ("%qE is not a constant expression because it refers to "
4719 "an incompletely initialized variable", t
);
4720 TREE_CONSTANT (r
) = false;
4721 non_constant_p
= true;
4724 /* Technically we should check this for all subexpressions, but that
4725 runs into problems with our internal representation of pointer
4726 subtraction and the 5.19 rules are still in flux. */
4727 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4728 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4729 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4731 if (!allow_non_constant
)
4732 error ("conversion from pointer type %qT "
4733 "to arithmetic type %qT in a constant expression",
4734 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4735 non_constant_p
= true;
4738 if (!non_constant_p
&& overflow_p
)
4739 non_constant_p
= true;
4741 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4743 bool should_unshare
= true;
4744 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4745 should_unshare
= false;
4747 if (non_constant_p
&& !allow_non_constant
)
4748 return error_mark_node
;
4749 else if (non_constant_p
&& TREE_CONSTANT (r
))
4751 /* This isn't actually constant, so unset TREE_CONSTANT. */
4754 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4755 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4757 r
= build_nop (TREE_TYPE (r
), r
);
4758 TREE_CONSTANT (r
) = false;
4760 else if (non_constant_p
|| r
== t
)
4764 r
= unshare_expr (r
);
4766 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4768 if (TREE_CODE (t
) == TARGET_EXPR
4769 && TARGET_EXPR_INITIAL (t
) == r
)
4773 r
= get_target_expr (r
);
4774 TREE_CONSTANT (r
) = true;
4782 /* Returns true if T is a valid subexpression of a constant expression,
4783 even if it isn't itself a constant expression. */
4786 is_sub_constant_expr (tree t
)
4788 bool non_constant_p
= false;
4789 bool overflow_p
= false;
4790 hash_map
<tree
, tree
> map
;
4792 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4794 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4796 return !non_constant_p
&& !overflow_p
;
4799 /* If T represents a constant expression returns its reduced value.
4800 Otherwise return error_mark_node. If T is dependent, then
4804 cxx_constant_value (tree t
, tree decl
)
4806 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4809 /* Helper routine for fold_simple function. Either return simplified
4810 expression T, otherwise NULL_TREE.
4811 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4812 even if we are within template-declaration. So be careful on call, as in
4813 such case types can be undefined. */
4816 fold_simple_1 (tree t
)
4819 enum tree_code code
= TREE_CODE (t
);
4831 return fold_sizeof_expr (t
);
4839 case TRUTH_NOT_EXPR
:
4841 case VIEW_CONVERT_EXPR
:
4844 case FIX_TRUNC_EXPR
:
4845 case FIXED_CONVERT_EXPR
:
4846 case ADDR_SPACE_CONVERT_EXPR
:
4848 op1
= TREE_OPERAND (t
, 0);
4850 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4854 if (CONVERT_EXPR_CODE_P (code
)
4855 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4856 TREE_OVERFLOW (t
) = false;
4864 /* If T is a simple constant expression, returns its simplified value.
4865 Otherwise returns T. In contrast to maybe_constant_value do we
4866 simplify only few operations on constant-expressions, and we don't
4867 try to simplify constexpressions. */
4870 fold_simple (tree t
)
4873 if (processing_template_decl
)
4876 r
= fold_simple_1 (t
);
4883 /* If T is a constant expression, returns its reduced value.
4884 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4885 Otherwise, returns a version of T without TREE_CONSTANT. */
4887 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4890 maybe_constant_value (tree t
, tree decl
)
4894 if (!is_nondependent_constant_expression (t
))
4896 if (TREE_OVERFLOW_P (t
))
4898 t
= build_nop (TREE_TYPE (t
), t
);
4899 TREE_CONSTANT (t
) = false;
4903 else if (CONSTANT_CLASS_P (t
))
4904 /* No caching or evaluation needed. */
4907 if (cv_cache
== NULL
)
4908 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4909 if (tree
*cached
= cv_cache
->get (t
))
4912 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4913 gcc_checking_assert (r
== t
4914 || CONVERT_EXPR_P (t
)
4915 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4916 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4917 || !cp_tree_equal (r
, t
));
4918 cv_cache
->put (t
, r
);
4922 /* Dispose of the whole CV_CACHE. */
4925 clear_cv_cache (void)
4927 if (cv_cache
!= NULL
)
4931 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4934 clear_cv_and_fold_caches (void)
4937 clear_fold_cache ();
4940 /* Like maybe_constant_value but first fully instantiate the argument.
4942 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4943 (t, tf_none) followed by maybe_constant_value but is more efficient,
4944 because calls instantiation_dependent_expression_p and
4945 potential_constant_expression at most once. */
4948 fold_non_dependent_expr (tree t
)
4953 /* If we're in a template, but T isn't value dependent, simplify
4954 it. We're supposed to treat:
4956 template <typename T> void f(T[1 + 1]);
4957 template <typename T> void f(T[2]);
4959 as two declarations of the same function, for example. */
4960 if (processing_template_decl
)
4962 if (is_nondependent_constant_expression (t
))
4964 processing_template_decl_sentinel s
;
4965 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4967 if (type_unknown_p (t
)
4968 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4970 if (TREE_OVERFLOW_P (t
))
4972 t
= build_nop (TREE_TYPE (t
), t
);
4973 TREE_CONSTANT (t
) = false;
4978 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4979 /* cp_tree_equal looks through NOPs, so allow them. */
4980 gcc_checking_assert (r
== t
4981 || CONVERT_EXPR_P (t
)
4982 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4983 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4984 || !cp_tree_equal (r
, t
));
4987 else if (TREE_OVERFLOW_P (t
))
4989 t
= build_nop (TREE_TYPE (t
), t
);
4990 TREE_CONSTANT (t
) = false;
4995 return maybe_constant_value (t
);
4998 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4999 than wrapped in a TARGET_EXPR. */
5002 maybe_constant_init (tree t
, tree decl
)
5006 if (TREE_CODE (t
) == EXPR_STMT
)
5007 t
= TREE_OPERAND (t
, 0);
5008 if (TREE_CODE (t
) == CONVERT_EXPR
5009 && VOID_TYPE_P (TREE_TYPE (t
)))
5010 t
= TREE_OPERAND (t
, 0);
5011 if (TREE_CODE (t
) == INIT_EXPR
)
5012 t
= TREE_OPERAND (t
, 1);
5013 if (TREE_CODE (t
) == TARGET_EXPR
)
5014 t
= TARGET_EXPR_INITIAL (t
);
5015 if (!is_nondependent_static_init_expression (t
))
5016 /* Don't try to evaluate it. */;
5017 else if (CONSTANT_CLASS_P (t
))
5018 /* No evaluation needed. */;
5020 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
5021 if (TREE_CODE (t
) == TARGET_EXPR
)
5023 tree init
= TARGET_EXPR_INITIAL (t
);
5024 if (TREE_CODE (init
) == CONSTRUCTOR
)
5031 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5032 /* Return true if the object referred to by REF has automatic or thread
5035 enum { ck_ok
, ck_bad
, ck_unknown
};
5037 check_automatic_or_tls (tree ref
)
5040 HOST_WIDE_INT bitsize
, bitpos
;
5042 int volatilep
= 0, unsignedp
= 0;
5043 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5044 &mode
, &unsignedp
, &volatilep
, false);
5047 /* If there isn't a decl in the middle, we don't know the linkage here,
5048 and this isn't a constant expression anyway. */
5051 dk
= decl_storage_duration (decl
);
5052 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5056 /* Return true if T denotes a potentially constant expression. Issue
5057 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5058 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5059 consider the expression in the current context, independent of constexpr
5062 C++0x [expr.const] used to say
5064 6 An expression is a potential constant expression if it is
5065 a constant expression where all occurrences of function
5066 parameters are replaced by arbitrary constant expressions
5067 of the appropriate type.
5069 2 A conditional expression is a constant expression unless it
5070 involves one of the following as a potentially evaluated
5071 subexpression (3.2), but subexpressions of logical AND (5.14),
5072 logical OR (5.15), and conditional (5.16) operations that are
5073 not evaluated are not considered. */
5076 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5077 tsubst_flags_t flags
)
5079 #define RECUR(T,RV) \
5080 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5082 enum { any
= false, rval
= true };
5086 if (t
== error_mark_node
)
5090 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5091 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5093 if (flags
& tf_error
)
5094 error_at (loc
, "expression %qE has side-effects", t
);
5097 if (CONSTANT_CLASS_P (t
))
5099 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5100 && TREE_TYPE (t
) == error_mark_node
)
5103 switch (TREE_CODE (t
))
5109 case TEMPLATE_ID_EXPR
:
5112 case CASE_LABEL_EXPR
:
5118 case TEMPLATE_PARM_INDEX
:
5120 case IDENTIFIER_NODE
:
5121 case USERDEF_LITERAL
:
5122 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5127 case PLACEHOLDER_EXPR
:
5137 if (flags
& tf_error
)
5138 error ("%qE is not a constant expression", t
);
5143 case AGGR_INIT_EXPR
:
5145 /* -- an invocation of a function other than a constexpr function
5146 or a constexpr constructor. */
5148 tree fun
= get_function_named_in_call (t
);
5149 const int nargs
= call_expr_nargs (t
);
5152 if (fun
== NULL_TREE
)
5154 /* Reset to allow the function to continue past the end
5155 of the block below. Otherwise return early. */
5158 if (TREE_CODE (t
) == CALL_EXPR
5159 && CALL_EXPR_FN (t
) == NULL_TREE
)
5160 switch (CALL_EXPR_IFN (t
))
5162 /* These should be ignored, they are optimized away from
5163 constexpr functions. */
5164 case IFN_UBSAN_NULL
:
5165 case IFN_UBSAN_BOUNDS
:
5166 case IFN_UBSAN_VPTR
:
5167 case IFN_FALLTHROUGH
:
5170 case IFN_ADD_OVERFLOW
:
5171 case IFN_SUB_OVERFLOW
:
5172 case IFN_MUL_OVERFLOW
:
5182 /* fold_call_expr can't do anything with IFN calls. */
5183 if (flags
& tf_error
)
5184 error_at (loc
, "call to internal function %qE", t
);
5189 if (fun
&& is_overloaded_fn (fun
))
5191 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5193 if (builtin_valid_in_constant_expr_p (fun
))
5195 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5196 /* Allow any built-in function; if the expansion
5197 isn't constant, we'll deal with that then. */
5198 && !is_builtin_fn (fun
))
5200 if (flags
& tf_error
)
5202 error_at (loc
, "call to non-constexpr function %qD",
5204 explain_invalid_constexpr_fn (fun
);
5208 /* A call to a non-static member function takes the address
5209 of the object as the first argument. But in a constant
5210 expression the address will be folded away, so look
5212 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5213 && !DECL_CONSTRUCTOR_P (fun
))
5215 tree x
= get_nth_callarg (t
, 0);
5216 if (is_this_parameter (x
))
5218 /* Don't require an immediately constant value, as
5219 constexpr substitution might not use the value. */
5220 bool sub_now
= false;
5221 if (!potential_constant_expression_1 (x
, rval
, strict
,
5229 if (!RECUR (fun
, true))
5231 fun
= get_first_fn (fun
);
5233 /* Skip initial arguments to base constructors. */
5234 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5235 i
= num_artificial_parms_for (fun
);
5236 fun
= DECL_ORIGIN (fun
);
5240 if (RECUR (fun
, rval
))
5241 /* Might end up being a constant function pointer. */;
5245 for (; i
< nargs
; ++i
)
5247 tree x
= get_nth_callarg (t
, i
);
5248 /* In a template, reference arguments haven't been converted to
5249 REFERENCE_TYPE and we might not even know if the parameter
5250 is a reference, so accept lvalue constants too. */
5251 bool rv
= processing_template_decl
? any
: rval
;
5252 /* Don't require an immediately constant value, as constexpr
5253 substitution might not use the value of the argument. */
5254 bool sub_now
= false;
5255 if (!potential_constant_expression_1 (x
, rv
, strict
,
5262 case NON_LVALUE_EXPR
:
5263 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5264 -- an lvalue of integral type that refers to a non-volatile
5265 const variable or static data member initialized with
5266 constant expressions, or
5268 -- an lvalue of literal type that refers to non-volatile
5269 object defined with constexpr, or that refers to a
5270 sub-object of such an object; */
5271 return RECUR (TREE_OPERAND (t
, 0), rval
);
5274 if (DECL_HAS_VALUE_EXPR_P (t
))
5275 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5277 && !var_in_maybe_constexpr_fn (t
)
5278 && !type_dependent_expression_p (t
)
5279 && !decl_maybe_constant_var_p (t
)
5281 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5282 || (DECL_INITIAL (t
)
5283 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5284 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5285 && !is_really_empty_class (TREE_TYPE (t
)))
5287 if (flags
& tf_error
)
5288 non_const_var_error (t
);
5295 case VIEW_CONVERT_EXPR
:
5296 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5297 may change to something more specific to type-punning (DR 1312). */
5299 tree from
= TREE_OPERAND (t
, 0);
5300 if (POINTER_TYPE_P (TREE_TYPE (t
))
5301 && TREE_CODE (from
) == INTEGER_CST
5302 && !integer_zerop (from
))
5304 if (flags
& tf_error
)
5305 error_at (loc
, "reinterpret_cast from integer to pointer");
5308 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5311 case ADDRESSOF_EXPR
:
5312 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5313 t
= TREE_OPERAND (t
, 0);
5314 goto handle_addr_expr
;
5317 /* -- a unary operator & that is applied to an lvalue that
5318 designates an object with thread or automatic storage
5320 t
= TREE_OPERAND (t
, 0);
5322 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5323 /* A pointer-to-member constant. */
5328 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5329 any checking here, as we might dereference the pointer later. If
5330 we remove this code, also remove check_automatic_or_tls. */
5331 i
= check_automatic_or_tls (t
);
5336 if (flags
& tf_error
)
5337 error ("address-of an object %qE with thread local or "
5338 "automatic storage is not a constant expression", t
);
5342 return RECUR (t
, any
);
5350 /* -- a class member access unless its postfix-expression is
5351 of literal type or of pointer to literal type. */
5352 /* This test would be redundant, as it follows from the
5353 postfix-expression being a potential constant expression. */
5354 if (type_unknown_p (t
))
5356 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5358 case EXPR_PACK_EXPANSION
:
5359 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5363 tree x
= TREE_OPERAND (t
, 0);
5365 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5367 if (!var_in_maybe_constexpr_fn (x
))
5369 if (flags
& tf_error
)
5370 error_at (loc
, "use of %<this%> in a constant expression");
5375 return RECUR (x
, rval
);
5378 case STATEMENT_LIST
:
5380 tree_stmt_iterator i
;
5381 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5383 if (!RECUR (tsi_stmt (i
), any
))
5391 if (cxx_dialect
< cxx14
)
5393 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5395 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5400 if (cxx_dialect
< cxx14
)
5402 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5404 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5409 if (!RECUR (DO_COND (t
), rval
))
5411 if (!RECUR (DO_BODY (t
), any
))
5416 if (!RECUR (FOR_INIT_STMT (t
), any
))
5418 if (!RECUR (FOR_COND (t
), rval
))
5420 if (!RECUR (FOR_EXPR (t
), any
))
5422 if (!RECUR (FOR_BODY (t
), any
))
5426 case RANGE_FOR_STMT
:
5427 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5429 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5434 if (!RECUR (WHILE_COND (t
), rval
))
5436 if (!RECUR (WHILE_BODY (t
), any
))
5441 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5443 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5444 unreachable labels would be checked. */
5448 return RECUR (STMT_EXPR_STMT (t
), rval
);
5451 case DYNAMIC_CAST_EXPR
:
5452 case PSEUDO_DTOR_EXPR
:
5456 case VEC_DELETE_EXPR
:
5461 case OMP_DISTRIBUTE
:
5464 case OMP_TARGET_DATA
:
5473 case OMP_TARGET_UPDATE
:
5474 case OMP_TARGET_ENTER_DATA
:
5475 case OMP_TARGET_EXIT_DATA
:
5477 case OMP_ATOMIC_READ
:
5478 case OMP_ATOMIC_CAPTURE_OLD
:
5479 case OMP_ATOMIC_CAPTURE_NEW
:
5483 case OACC_HOST_DATA
:
5487 case OACC_ENTER_DATA
:
5488 case OACC_EXIT_DATA
:
5492 /* GCC internal stuff. */
5495 case TRANSACTION_EXPR
:
5497 case AT_ENCODE_EXPR
:
5499 if (flags
& tf_error
)
5500 error_at (loc
, "expression %qE is not a constant expression", t
);
5504 /* -- a typeid expression whose operand is of polymorphic
5507 tree e
= TREE_OPERAND (t
, 0);
5508 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5509 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5511 if (flags
& tf_error
)
5512 error_at (loc
, "typeid-expression is not a constant expression "
5513 "because %qE is of polymorphic type", e
);
5532 case PREINCREMENT_EXPR
:
5533 case POSTINCREMENT_EXPR
:
5534 case PREDECREMENT_EXPR
:
5535 case POSTDECREMENT_EXPR
:
5536 if (cxx_dialect
< cxx14
)
5542 if (TYPE_P (TREE_OPERAND (t
, 0)))
5548 case FIX_TRUNC_EXPR
:
5552 case TRUTH_NOT_EXPR
:
5553 case FIXED_CONVERT_EXPR
:
5554 case UNARY_PLUS_EXPR
:
5555 case UNARY_LEFT_FOLD_EXPR
:
5556 case UNARY_RIGHT_FOLD_EXPR
:
5558 return RECUR (TREE_OPERAND (t
, 0), rval
);
5561 case CONST_CAST_EXPR
:
5562 case STATIC_CAST_EXPR
:
5563 case REINTERPRET_CAST_EXPR
:
5564 case IMPLICIT_CONV_EXPR
:
5565 if (cxx_dialect
< cxx11
5566 && !dependent_type_p (TREE_TYPE (t
))
5567 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5568 /* In C++98, a conversion to non-integral type can't be part of a
5569 constant expression. */
5571 if (flags
& tf_error
)
5573 "cast to non-integral type %qT in a constant expression",
5578 return (RECUR (TREE_OPERAND (t
, 0),
5579 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5582 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5584 case CLEANUP_POINT_EXPR
:
5585 case MUST_NOT_THROW_EXPR
:
5586 case TRY_CATCH_EXPR
:
5591 case NON_DEPENDENT_EXPR
:
5592 /* For convenience. */
5596 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5599 tmp
= DECL_EXPR_DECL (t
);
5600 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5602 if (TREE_STATIC (tmp
))
5604 if (flags
& tf_error
)
5605 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5606 "%<static%> in %<constexpr%> context", tmp
);
5609 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5611 if (flags
& tf_error
)
5612 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5613 "%<thread_local%> in %<constexpr%> context", tmp
);
5616 else if (!DECL_NONTRIVIALLY_INITIALIZED_P (tmp
))
5618 if (flags
& tf_error
)
5619 error_at (DECL_SOURCE_LOCATION (tmp
), "uninitialized "
5620 "variable %qD in %<constexpr%> context", tmp
);
5624 return RECUR (tmp
, want_rval
);
5626 case TRY_FINALLY_EXPR
:
5627 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5628 && RECUR (TREE_OPERAND (t
, 1), any
));
5631 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5634 if (!literal_type_p (TREE_TYPE (t
)))
5636 if (flags
& tf_error
)
5638 error_at (loc
, "temporary of non-literal type %qT in a "
5639 "constant expression", TREE_TYPE (t
));
5640 explain_non_literal_class (TREE_TYPE (t
));
5646 return RECUR (TREE_OPERAND (t
, 1), rval
);
5650 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5651 constructor_elt
*ce
;
5652 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5653 if (!RECUR (ce
->value
, want_rval
))
5660 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5661 || DECL_P (TREE_PURPOSE (t
)));
5662 if (!RECUR (TREE_VALUE (t
), want_rval
))
5664 if (TREE_CHAIN (t
) == NULL_TREE
)
5666 return RECUR (TREE_CHAIN (t
), want_rval
);
5669 case TRUNC_DIV_EXPR
:
5671 case FLOOR_DIV_EXPR
:
5672 case ROUND_DIV_EXPR
:
5673 case TRUNC_MOD_EXPR
:
5675 case ROUND_MOD_EXPR
:
5677 tree denom
= TREE_OPERAND (t
, 1);
5678 if (!RECUR (denom
, rval
))
5680 /* We can't call cxx_eval_outermost_constant_expr on an expression
5681 that hasn't been through instantiate_non_dependent_expr yet. */
5682 if (!processing_template_decl
)
5683 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5684 if (integer_zerop (denom
))
5686 if (flags
& tf_error
)
5687 error ("division by zero is not a constant expression");
5693 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5699 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5700 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5701 introduced by build_call_a. */
5702 tree op0
= TREE_OPERAND (t
, 0);
5703 tree op1
= TREE_OPERAND (t
, 1);
5705 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5706 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5707 return RECUR (op0
, want_rval
);
5712 /* If the first operand is the non-short-circuit constant, look at
5713 the second operand; otherwise we only care about the first one for
5715 case TRUTH_AND_EXPR
:
5716 case TRUTH_ANDIF_EXPR
:
5717 tmp
= boolean_true_node
;
5720 case TRUTH_ORIF_EXPR
:
5721 tmp
= boolean_false_node
;
5724 tree op
= TREE_OPERAND (t
, 0);
5725 if (!RECUR (op
, rval
))
5727 if (!processing_template_decl
)
5728 op
= cxx_eval_outermost_constant_expr (op
, true);
5729 if (tree_int_cst_equal (op
, tmp
))
5730 return RECUR (TREE_OPERAND (t
, 1), rval
);
5737 case POINTER_PLUS_EXPR
:
5739 case EXACT_DIV_EXPR
:
5749 case TRUTH_XOR_EXPR
:
5750 case UNORDERED_EXPR
:
5763 case ARRAY_RANGE_REF
:
5767 case BINARY_LEFT_FOLD_EXPR
:
5768 case BINARY_RIGHT_FOLD_EXPR
:
5770 for (i
= 0; i
< 2; ++i
)
5771 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5775 case CILK_SYNC_STMT
:
5776 case CILK_SPAWN_STMT
:
5777 case ARRAY_NOTATION_REF
:
5782 for (i
= 0; i
< 3; ++i
)
5783 if (!RECUR (TREE_OPERAND (t
, i
), true))
5788 if (COND_EXPR_IS_VEC_DELETE (t
))
5790 if (flags
& tf_error
)
5791 error_at (loc
, "%<delete[]%> is not a constant expression");
5797 /* If the condition is a known constant, we know which of the legs we
5798 care about; otherwise we only require that the condition and
5799 either of the legs be potentially constant. */
5800 tmp
= TREE_OPERAND (t
, 0);
5801 if (!RECUR (tmp
, rval
))
5803 if (!processing_template_decl
)
5804 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5805 if (integer_zerop (tmp
))
5806 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5807 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5808 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5809 for (i
= 1; i
< 3; ++i
)
5810 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5811 want_rval
, strict
, now
, tf_none
))
5813 if (flags
& tf_error
)
5814 error_at (loc
, "expression %qE is not a constant expression", t
);
5818 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5820 if (flags
& tf_error
)
5822 error_at (loc
, "non-constant array initialization");
5823 diagnose_non_constexpr_vec_init (t
);
5829 /* We can see these in statement-expressions. */
5833 case EMPTY_CLASS_EXPR
:
5839 tree
*target
= &TREE_OPERAND (t
, 0);
5840 /* Gotos representing break and continue are OK. */
5841 if (breaks (target
) || continues (target
))
5843 if (flags
& tf_error
)
5844 error_at (loc
, "%<goto%> is not a constant expression");
5849 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
5850 return RECUR (TREE_OPERAND (t
, 0), rval
);
5853 if (objc_is_property_ref (t
))
5856 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5863 /* The main entry point to the above. */
5866 potential_constant_expression (tree t
)
5868 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
5871 /* As above, but require a constant rvalue. */
5874 potential_rvalue_constant_expression (tree t
)
5876 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
5879 /* Like above, but complain about non-constant expressions. */
5882 require_potential_constant_expression (tree t
)
5884 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
5887 /* Cross product of the above. */
5890 require_potential_rvalue_constant_expression (tree t
)
5892 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
5895 /* Like potential_constant_expression, but don't consider possible constexpr
5896 substitution of the current function. That is, PARM_DECL qualifies under
5897 potential_constant_expression, but not here.
5899 This is basically what you can check when any actual constant values might
5900 be value-dependent. */
5903 is_constant_expression (tree t
)
5905 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
5908 /* Like above, but complain about non-constant expressions. */
5911 require_constant_expression (tree t
)
5913 return potential_constant_expression_1 (t
, false, true, true,
5914 tf_warning_or_error
);
5917 /* Like is_constant_expression, but allow const variables that are not allowed
5918 under constexpr rules. */
5921 is_static_init_expression (tree t
)
5923 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
5926 /* Returns true if T is a potential constant expression that is not
5927 instantiation-dependent, and therefore a candidate for constant folding even
5931 is_nondependent_constant_expression (tree t
)
5933 return (!type_unknown_p (t
)
5934 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5935 && is_constant_expression (t
)
5936 && !instantiation_dependent_expression_p (t
));
5939 /* Returns true if T is a potential static initializer expression that is not
5940 instantiation-dependent. */
5943 is_nondependent_static_init_expression (tree t
)
5945 return (!type_unknown_p (t
)
5946 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5947 && is_static_init_expression (t
)
5948 && !instantiation_dependent_expression_p (t
));
5951 /* Finalize constexpr processing after parsing. */
5954 fini_constexpr (void)
5956 /* The contexpr call and fundef copies tables are no longer needed. */
5957 constexpr_call_table
= NULL
;
5958 fundef_copies_table
= NULL
;
5961 #include "gt-cp-constexpr.h"