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-2016 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"
35 static bool verify_constant (tree
, bool, bool *, bool *);
36 #define VERIFY_CONSTANT(X) \
38 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
42 /* Returns true iff FUN is an instantiation of a constexpr function
43 template or a defaulted constexpr function. */
46 is_instantiation_of_constexpr (tree fun
)
48 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
49 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
50 || (DECL_DEFAULTED_FN (fun
)
51 && DECL_DECLARED_CONSTEXPR_P (fun
)));
54 /* Return true if T is a literal type. */
57 literal_type_p (tree t
)
61 || TREE_CODE (t
) == REFERENCE_TYPE
62 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
66 t
= complete_type (t
);
67 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
68 return CLASSTYPE_LITERAL_P (t
);
70 if (TREE_CODE (t
) == ARRAY_TYPE
)
71 return literal_type_p (strip_array_types (t
));
75 /* If DECL is a variable declared `constexpr', require its type
76 be literal. Return the DECL if OK, otherwise NULL. */
79 ensure_literal_type_for_constexpr_object (tree decl
)
81 tree type
= TREE_TYPE (decl
);
83 && (DECL_DECLARED_CONSTEXPR_P (decl
)
84 || var_in_constexpr_fn (decl
))
85 && !processing_template_decl
)
87 tree stype
= strip_array_types (type
);
88 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
89 /* Don't complain here, we'll complain about incompleteness
90 when we try to initialize the variable. */;
91 else if (!literal_type_p (type
))
93 if (DECL_DECLARED_CONSTEXPR_P (decl
))
95 error ("the type %qT of constexpr variable %qD is not literal",
97 explain_non_literal_class (type
);
101 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
103 error ("variable %qD of non-literal type %qT in %<constexpr%> "
104 "function", decl
, type
);
105 explain_non_literal_class (type
);
107 cp_function_chain
->invalid_constexpr
= true;
115 /* Representation of entries in the constexpr function definition table. */
117 struct GTY((for_user
)) constexpr_fundef
{
122 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
124 static hashval_t
hash (constexpr_fundef
*);
125 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
128 /* This table holds all constexpr function definitions seen in
129 the current translation unit. */
131 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
133 /* Utility function used for managing the constexpr function table.
134 Return true if the entries pointed to by P and Q are for the
135 same constexpr function. */
138 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
140 return lhs
->decl
== rhs
->decl
;
143 /* Utility function used for managing the constexpr function table.
144 Return a hash value for the entry pointed to by Q. */
147 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
149 return DECL_UID (fundef
->decl
);
152 /* Return a previously saved definition of function FUN. */
154 static constexpr_fundef
*
155 retrieve_constexpr_fundef (tree fun
)
157 constexpr_fundef fundef
= { NULL
, NULL
};
158 if (constexpr_fundef_table
== NULL
)
162 return constexpr_fundef_table
->find (&fundef
);
165 /* Check whether the parameter and return types of FUN are valid for a
166 constexpr function, and complain if COMPLAIN. */
169 is_valid_constexpr_fn (tree fun
, bool complain
)
173 if (DECL_INHERITED_CTOR_BASE (fun
)
174 && TREE_CODE (fun
) == TEMPLATE_DECL
)
178 error ("inherited constructor %qD is not constexpr",
179 get_inherited_ctor (fun
));
183 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
184 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
185 if (!literal_type_p (TREE_TYPE (parm
)))
190 error ("invalid type for parameter %d of constexpr "
191 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
192 explain_non_literal_class (TREE_TYPE (parm
));
197 if (!DECL_CONSTRUCTOR_P (fun
))
199 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
200 if (!literal_type_p (rettype
))
205 error ("invalid return type %qT of constexpr function %q+D",
207 explain_non_literal_class (rettype
);
211 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
212 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
217 error ("enclosing class of constexpr non-static member "
218 "function %q+#D is not a literal type", fun
);
219 explain_non_literal_class (DECL_CONTEXT (fun
));
223 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
227 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
233 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
234 for a member of an anonymous aggregate, INIT is the initializer for that
235 member, and VEC_OUTER is the vector of constructor elements for the class
236 whose constructor we are processing. Add the initializer to the vector
237 and return true to indicate success. */
240 build_anon_member_initialization (tree member
, tree init
,
241 vec
<constructor_elt
, va_gc
> **vec_outer
)
243 /* MEMBER presents the relevant fields from the inside out, but we need
244 to build up the initializer from the outside in so that we can reuse
245 previously built CONSTRUCTORs if this is, say, the second field in an
246 anonymous struct. So we use a vec as a stack. */
247 auto_vec
<tree
, 2> fields
;
250 fields
.safe_push (TREE_OPERAND (member
, 1));
251 member
= TREE_OPERAND (member
, 0);
253 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
254 && TREE_CODE (member
) == COMPONENT_REF
);
256 /* VEC has the constructor elements vector for the context of FIELD.
257 If FIELD is an anonymous aggregate, we will push inside it. */
258 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
260 while (field
= fields
.pop(),
261 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
264 /* If there is already an outer constructor entry for the anonymous
265 aggregate FIELD, use it; otherwise, insert one. */
266 if (vec_safe_is_empty (*vec
)
267 || (*vec
)->last().index
!= field
)
269 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
270 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
273 ctor
= (*vec
)->last().value
;
274 vec
= &CONSTRUCTOR_ELTS (ctor
);
277 /* Now we're at the innermost field, the one that isn't an anonymous
278 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
279 gcc_assert (fields
.is_empty());
280 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
285 /* Subroutine of build_constexpr_constructor_member_initializers.
286 The expression tree T represents a data member initialization
287 in a (constexpr) constructor definition. Build a pairing of
288 the data member with its initializer, and prepend that pair
289 to the existing initialization pair INITS. */
292 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
295 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
296 t
= TREE_OPERAND (t
, 0);
297 if (TREE_CODE (t
) == EXPR_STMT
)
298 t
= TREE_OPERAND (t
, 0);
299 if (t
== error_mark_node
)
301 if (TREE_CODE (t
) == STATEMENT_LIST
)
303 tree_stmt_iterator i
;
304 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
306 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
311 if (TREE_CODE (t
) == CLEANUP_STMT
)
313 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
314 but we can in a constexpr constructor for a non-literal class. Just
315 ignore it; either all the initialization will be constant, in which
316 case the cleanup can't run, or it can't be constexpr.
317 Still recurse into CLEANUP_BODY. */
318 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
320 if (TREE_CODE (t
) == CONVERT_EXPR
)
321 t
= TREE_OPERAND (t
, 0);
322 if (TREE_CODE (t
) == INIT_EXPR
323 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
324 use what this function builds for cx_check_missing_mem_inits, and
325 assignment in the ctor body doesn't count. */
326 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
328 member
= TREE_OPERAND (t
, 0);
329 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
331 else if (TREE_CODE (t
) == CALL_EXPR
)
333 tree fn
= get_callee_fndecl (t
);
334 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
335 /* We're only interested in calls to subobject constructors. */
337 member
= CALL_EXPR_ARG (t
, 0);
338 /* We don't use build_cplus_new here because it complains about
339 abstract bases. Leaving the call unwrapped means that it has the
340 wrong type, but cxx_eval_constant_expression doesn't care. */
341 init
= break_out_target_exprs (t
);
343 else if (TREE_CODE (t
) == BIND_EXPR
)
344 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
346 /* Don't add anything else to the CONSTRUCTOR. */
348 if (INDIRECT_REF_P (member
))
349 member
= TREE_OPERAND (member
, 0);
350 if (TREE_CODE (member
) == NOP_EXPR
)
354 if (TREE_CODE (op
) == ADDR_EXPR
)
356 gcc_assert (same_type_ignoring_top_level_qualifiers_p
357 (TREE_TYPE (TREE_TYPE (op
)),
358 TREE_TYPE (TREE_TYPE (member
))));
359 /* Initializing a cv-qualified member; we need to look through
363 else if (op
== current_class_ptr
364 && (same_type_ignoring_top_level_qualifiers_p
365 (TREE_TYPE (TREE_TYPE (member
)),
366 current_class_type
)))
367 /* Delegating constructor. */
371 /* This is an initializer for an empty base; keep it for now so
372 we can check it in cxx_eval_bare_aggregate. */
373 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
376 if (TREE_CODE (member
) == ADDR_EXPR
)
377 member
= TREE_OPERAND (member
, 0);
378 if (TREE_CODE (member
) == COMPONENT_REF
)
380 tree aggr
= TREE_OPERAND (member
, 0);
381 if (TREE_CODE (aggr
) != COMPONENT_REF
)
382 /* Normal member initialization. */
383 member
= TREE_OPERAND (member
, 1);
384 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
385 /* Initializing a member of an anonymous union. */
386 return build_anon_member_initialization (member
, init
, vec
);
388 /* We're initializing a vtable pointer in a base. Leave it as
389 COMPONENT_REF so we remember the path to get to the vfield. */
390 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
393 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
397 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
398 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
399 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
402 check_constexpr_bind_expr_vars (tree t
)
404 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
406 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
407 if (TREE_CODE (var
) == TYPE_DECL
408 && DECL_IMPLICIT_TYPEDEF_P (var
)
409 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
414 /* Subroutine of check_constexpr_ctor_body. */
417 check_constexpr_ctor_body_1 (tree last
, tree list
)
419 switch (TREE_CODE (list
))
422 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
)
426 case CLEANUP_POINT_EXPR
:
427 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
431 if (!check_constexpr_bind_expr_vars (list
)
432 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
446 /* Make sure that there are no statements after LAST in the constructor
447 body represented by LIST. */
450 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
452 /* C++14 doesn't require a constexpr ctor to have an empty body. */
453 if (cxx_dialect
>= cxx14
)
457 if (TREE_CODE (list
) == STATEMENT_LIST
)
459 tree_stmt_iterator i
= tsi_last (list
);
460 for (; !tsi_end_p (i
); tsi_prev (&i
))
462 tree t
= tsi_stmt (i
);
465 if (!check_constexpr_ctor_body_1 (last
, t
))
472 else if (list
!= last
473 && !check_constexpr_ctor_body_1 (last
, list
))
478 error ("constexpr constructor does not have empty body");
479 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
484 /* V is a vector of constructor elements built up for the base and member
485 initializers of a constructor for TYPE. They need to be in increasing
486 offset order, which they might not be yet if TYPE has a primary base
487 which is not first in the base-clause or a vptr and at least one base
488 all of which are non-primary. */
490 static vec
<constructor_elt
, va_gc
> *
491 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
493 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
499 field_type
= BINFO_TYPE (pri
);
500 else if (TYPE_CONTAINS_VPTR_P (type
))
501 field_type
= vtbl_ptr_type_node
;
505 /* Find the element for the primary base or vptr and move it to the
506 beginning of the vec. */
507 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
508 if (TREE_TYPE (ce
->index
) == field_type
)
511 if (i
> 0 && i
< vec_safe_length (v
))
513 vec
<constructor_elt
, va_gc
> &vref
= *v
;
514 constructor_elt elt
= vref
[i
];
523 /* Build compile-time evalable representations of member-initializer list
524 for a constexpr constructor. */
527 build_constexpr_constructor_member_initializers (tree type
, tree body
)
529 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
531 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
532 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
533 body
= TREE_OPERAND (body
, 0);
534 if (TREE_CODE (body
) == STATEMENT_LIST
)
536 for (tree_stmt_iterator i
= tsi_start (body
);
537 !tsi_end_p (i
); tsi_next (&i
))
540 if (TREE_CODE (body
) == BIND_EXPR
)
544 if (TREE_CODE (body
) == BIND_EXPR
)
545 body
= BIND_EXPR_BODY (body
);
546 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
548 body
= TREE_OPERAND (body
, 0);
549 if (TREE_CODE (body
) == EXPR_STMT
)
550 body
= TREE_OPERAND (body
, 0);
551 if (TREE_CODE (body
) == INIT_EXPR
552 && (same_type_ignoring_top_level_qualifiers_p
553 (TREE_TYPE (TREE_OPERAND (body
, 0)),
554 current_class_type
)))
557 return TREE_OPERAND (body
, 1);
559 ok
= build_data_member_initialization (body
, &vec
);
561 else if (TREE_CODE (body
) == STATEMENT_LIST
)
563 tree_stmt_iterator i
;
564 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
566 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
571 else if (TREE_CODE (body
) == TRY_BLOCK
)
573 error ("body of %<constexpr%> constructor cannot be "
574 "a function-try-block");
575 return error_mark_node
;
577 else if (EXPR_P (body
))
578 ok
= build_data_member_initialization (body
, &vec
);
580 gcc_assert (errorcount
> 0);
583 if (vec_safe_length (vec
) > 0)
585 /* In a delegating constructor, return the target. */
586 constructor_elt
*ce
= &(*vec
)[0];
587 if (ce
->index
== current_class_ptr
)
594 vec
= sort_constexpr_mem_initializers (type
, vec
);
595 return build_constructor (type
, vec
);
598 return error_mark_node
;
601 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
602 declared to be constexpr, or a sub-statement thereof. Returns the
603 return value if suitable, error_mark_node for a statement not allowed in
604 a constexpr function, or NULL_TREE if no return value was found. */
607 constexpr_fn_retval (tree body
)
609 switch (TREE_CODE (body
))
613 tree_stmt_iterator i
;
614 tree expr
= NULL_TREE
;
615 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
617 tree s
= constexpr_fn_retval (tsi_stmt (i
));
618 if (s
== error_mark_node
)
619 return error_mark_node
;
620 else if (s
== NULL_TREE
)
621 /* Keep iterating. */;
623 /* Multiple return statements. */
624 return error_mark_node
;
632 return break_out_target_exprs (TREE_OPERAND (body
, 0));
636 tree decl
= DECL_EXPR_DECL (body
);
637 if (TREE_CODE (decl
) == USING_DECL
638 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
639 || DECL_ARTIFICIAL (decl
))
641 return error_mark_node
;
644 case CLEANUP_POINT_EXPR
:
645 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
648 if (!check_constexpr_bind_expr_vars (body
))
649 return error_mark_node
;
650 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
656 return error_mark_node
;
660 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
661 FUN; do the necessary transformations to turn it into a single expression
662 that we can store in the hash table. */
665 massage_constexpr_body (tree fun
, tree body
)
667 if (DECL_CONSTRUCTOR_P (fun
))
668 body
= build_constexpr_constructor_member_initializers
669 (DECL_CONTEXT (fun
), body
);
670 else if (cxx_dialect
< cxx14
)
672 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
673 body
= EH_SPEC_STMTS (body
);
674 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
675 body
= TREE_OPERAND (body
, 0);
676 body
= constexpr_fn_retval (body
);
681 /* FUN is a constexpr constructor with massaged body BODY. Return true
682 if some bases/fields are uninitialized, and complain if COMPLAIN. */
685 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
692 if (TREE_CODE (body
) != CONSTRUCTOR
)
695 nelts
= CONSTRUCTOR_NELTS (body
);
696 ctype
= DECL_CONTEXT (fun
);
697 field
= TYPE_FIELDS (ctype
);
699 if (TREE_CODE (ctype
) == UNION_TYPE
)
701 if (nelts
== 0 && next_initializable_field (field
))
704 error ("%<constexpr%> constructor for union %qT must "
705 "initialize exactly one non-static data member", ctype
);
712 for (i
= 0; i
<= nelts
; ++i
)
719 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
720 /* Skip base and vtable inits. */
721 if (TREE_CODE (index
) != FIELD_DECL
722 || DECL_ARTIFICIAL (index
))
725 for (; field
!= index
; field
= DECL_CHAIN (field
))
728 if (TREE_CODE (field
) != FIELD_DECL
729 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
730 || DECL_ARTIFICIAL (field
))
732 ftype
= strip_array_types (TREE_TYPE (field
));
733 if (type_has_constexpr_default_constructor (ftype
))
735 /* It's OK to skip a member with a trivial constexpr ctor.
736 A constexpr ctor that isn't trivial should have been
738 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
744 error ("member %qD must be initialized by mem-initializer "
745 "in %<constexpr%> constructor", field
);
746 inform (DECL_SOURCE_LOCATION (field
), "declared here");
749 if (field
== NULL_TREE
)
751 field
= DECL_CHAIN (field
);
757 /* We are processing the definition of the constexpr function FUN.
758 Check that its BODY fulfills the propriate requirements and
759 enter it in the constexpr function definition table.
760 For constructor BODY is actually the TREE_LIST of the
761 member-initializer list. */
764 register_constexpr_fundef (tree fun
, tree body
)
766 constexpr_fundef entry
;
767 constexpr_fundef
**slot
;
769 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
772 tree massaged
= massage_constexpr_body (fun
, body
);
773 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
775 if (!DECL_CONSTRUCTOR_P (fun
))
776 error ("body of constexpr function %qD not a return-statement", fun
);
780 if (!potential_rvalue_constant_expression (massaged
))
782 if (!DECL_GENERATED_P (fun
))
783 require_potential_rvalue_constant_expression (massaged
);
787 if (DECL_CONSTRUCTOR_P (fun
)
788 && cx_check_missing_mem_inits (fun
, massaged
, !DECL_GENERATED_P (fun
)))
791 /* Create the constexpr function table if necessary. */
792 if (constexpr_fundef_table
== NULL
)
793 constexpr_fundef_table
794 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
798 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
800 gcc_assert (*slot
== NULL
);
801 *slot
= ggc_alloc
<constexpr_fundef
> ();
807 /* FUN is a non-constexpr function called in a context that requires a
808 constant expression. If it comes from a constexpr template, explain why
809 the instantiation isn't constexpr. */
812 explain_invalid_constexpr_fn (tree fun
)
814 static hash_set
<tree
> *diagnosed
;
817 /* Only diagnose defaulted functions or instantiations. */
818 if (!DECL_DEFAULTED_FN (fun
)
819 && !is_instantiation_of_constexpr (fun
))
821 if (diagnosed
== NULL
)
822 diagnosed
= new hash_set
<tree
>;
823 if (diagnosed
->add (fun
))
824 /* Already explained. */
827 save_loc
= input_location
;
828 input_location
= DECL_SOURCE_LOCATION (fun
);
829 inform (input_location
,
830 "%qD is not usable as a constexpr function because:", fun
);
831 /* First check the declaration. */
832 if (is_valid_constexpr_fn (fun
, true))
834 /* Then if it's OK, the body. */
835 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
836 explain_implicit_non_constexpr (fun
);
839 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
840 require_potential_rvalue_constant_expression (body
);
841 if (DECL_CONSTRUCTOR_P (fun
))
842 cx_check_missing_mem_inits (fun
, body
, true);
845 input_location
= save_loc
;
848 /* Objects of this type represent calls to constexpr functions
849 along with the bindings of parameters to their arguments, for
850 the purpose of compile time evaluation. */
852 struct GTY((for_user
)) constexpr_call
{
853 /* Description of the constexpr function definition. */
854 constexpr_fundef
*fundef
;
855 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
856 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
857 Note: This arrangement is made to accommodate the use of
858 iterative_hash_template_arg (see pt.c). If you change this
859 representation, also change the hash calculation in
860 cxx_eval_call_expression. */
862 /* Result of the call.
863 NULL means the call is being evaluated.
864 error_mark_node means that the evaluation was erroneous;
865 otherwise, the actuall value of the call. */
867 /* The hash of this call; we remember it here to avoid having to
868 recalculate it when expanding the hash table. */
872 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
874 static hashval_t
hash (constexpr_call
*);
875 static bool equal (constexpr_call
*, constexpr_call
*);
878 /* The constexpr expansion context. CALL is the current function
879 expansion, CTOR is the current aggregate initializer, OBJECT is the
880 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
881 is a map of values of variables initialized within the expression. */
883 struct constexpr_ctx
{
884 /* The innermost call we're evaluating. */
885 constexpr_call
*call
;
886 /* Values for any temporaries or local variables within the
887 constant-expression. */
888 hash_map
<tree
,tree
> *values
;
889 /* The CONSTRUCTOR we're currently building up for an aggregate
892 /* The object we're building the CONSTRUCTOR for. */
894 /* Whether we should error on a non-constant expression or fail quietly. */
896 /* Whether we are strictly conforming to constant expression rules or
897 trying harder to get a constant value. */
901 /* A table of all constexpr calls that have been evaluated by the
902 compiler in this translation unit. */
904 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
906 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
907 bool, bool *, bool *, tree
* = NULL
);
909 /* Compute a hash value for a constexpr call representation. */
912 constexpr_call_hasher::hash (constexpr_call
*info
)
917 /* Return true if the objects pointed to by P and Q represent calls
918 to the same constexpr function with the same arguments.
919 Otherwise, return false. */
922 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
928 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
930 lhs_bindings
= lhs
->bindings
;
931 rhs_bindings
= rhs
->bindings
;
932 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
934 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
935 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
936 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
937 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
939 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
940 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
942 return lhs_bindings
== rhs_bindings
;
945 /* Initialize the constexpr call table, if needed. */
948 maybe_initialize_constexpr_call_table (void)
950 if (constexpr_call_table
== NULL
)
951 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
954 /* We have an expression tree T that represents a call, either CALL_EXPR
955 or AGGR_INIT_EXPR. If the call is lexically to a named function,
956 retrun the _DECL for that function. */
959 get_function_named_in_call (tree t
)
962 switch (TREE_CODE (t
))
965 fun
= CALL_EXPR_FN (t
);
969 fun
= AGGR_INIT_EXPR_FN (t
);
976 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
977 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
978 fun
= TREE_OPERAND (fun
, 0);
982 /* We have an expression tree T that represents a call, either CALL_EXPR
983 or AGGR_INIT_EXPR. Return the Nth argument. */
986 get_nth_callarg (tree t
, int n
)
988 switch (TREE_CODE (t
))
991 return CALL_EXPR_ARG (t
, n
);
994 return AGGR_INIT_EXPR_ARG (t
, n
);
1002 /* Attempt to evaluate T which represents a call to a builtin function.
1003 We assume here that all builtin functions evaluate to scalar types
1004 represented by _CST nodes. */
1007 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1009 bool *non_constant_p
, bool *overflow_p
)
1011 const int nargs
= call_expr_nargs (t
);
1012 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1016 /* Don't fold __builtin_constant_p within a constexpr function. */
1017 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1020 && current_function_decl
1021 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1023 *non_constant_p
= true;
1027 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1028 return constant false for a non-constant argument. */
1029 constexpr_ctx new_ctx
= *ctx
;
1030 new_ctx
.quiet
= true;
1031 bool dummy1
= false, dummy2
= false;
1032 for (i
= 0; i
< nargs
; ++i
)
1034 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1035 lval
, &dummy1
, &dummy2
);
1037 /* For __built_in_constant_p, fold all expressions with constant values
1038 even if they aren't C++ constant-expressions. */
1039 args
[i
] = cp_fully_fold (args
[i
]);
1042 bool save_ffbcp
= force_folding_builtin_constant_p
;
1043 force_folding_builtin_constant_p
= true;
1044 new_call
= fold_build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1045 CALL_EXPR_FN (t
), nargs
, args
);
1046 /* Fold away the NOP_EXPR from fold_builtin_n. */
1047 new_call
= fold (new_call
);
1048 force_folding_builtin_constant_p
= save_ffbcp
;
1049 VERIFY_CONSTANT (new_call
);
1053 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1054 the type of the value to match. */
1057 adjust_temp_type (tree type
, tree temp
)
1059 if (TREE_TYPE (temp
) == type
)
1061 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1062 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1063 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1064 gcc_assert (scalarish_type_p (type
));
1065 return cp_fold_convert (type
, temp
);
1068 /* Subroutine of cxx_eval_call_expression.
1069 We are processing a call expression (either CALL_EXPR or
1070 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1071 all arguments and bind their values to correspondings
1072 parameters, making up the NEW_CALL context. */
1075 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1076 constexpr_call
*new_call
,
1077 bool *non_constant_p
, bool *overflow_p
,
1078 bool *non_constant_args
)
1080 const int nargs
= call_expr_nargs (t
);
1081 tree fun
= new_call
->fundef
->decl
;
1082 tree parms
= DECL_ARGUMENTS (fun
);
1084 tree
*p
= &new_call
->bindings
;
1085 for (i
= 0; i
< nargs
; ++i
)
1088 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1089 x
= get_nth_callarg (t
, i
);
1090 /* For member function, the first argument is a pointer to the implied
1091 object. For a constructor, it might still be a dummy object, in
1092 which case we get the real argument from ctx. */
1093 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1094 && is_dummy_object (x
))
1097 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1100 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1101 non_constant_p
, overflow_p
);
1102 /* Don't VERIFY_CONSTANT here. */
1103 if (*non_constant_p
&& ctx
->quiet
)
1105 /* Just discard ellipsis args after checking their constantitude. */
1108 if (*non_constant_p
)
1109 /* Don't try to adjust the type of non-constant args. */
1112 /* Make sure the binding has the same type as the parm. */
1113 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1114 arg
= adjust_temp_type (type
, arg
);
1115 if (!TREE_CONSTANT (arg
))
1116 *non_constant_args
= true;
1117 *p
= build_tree_list (parms
, arg
);
1118 p
= &TREE_CHAIN (*p
);
1120 parms
= TREE_CHAIN (parms
);
1124 /* Variables and functions to manage constexpr call expansion context.
1125 These do not need to be marked for PCH or GC. */
1127 /* FIXME remember and print actual constant arguments. */
1128 static vec
<tree
> call_stack
= vNULL
;
1129 static int call_stack_tick
;
1130 static int last_cx_error_tick
;
1133 push_cx_call_context (tree call
)
1136 if (!EXPR_HAS_LOCATION (call
))
1137 SET_EXPR_LOCATION (call
, input_location
);
1138 call_stack
.safe_push (call
);
1139 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1145 pop_cx_call_context (void)
1152 cx_error_context (void)
1154 vec
<tree
> r
= vNULL
;
1155 if (call_stack_tick
!= last_cx_error_tick
1156 && !call_stack
.is_empty ())
1158 last_cx_error_tick
= call_stack_tick
;
1162 /* Subroutine of cxx_eval_constant_expression.
1163 Evaluate the call expression tree T in the context of OLD_CALL expression
1167 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1169 bool *non_constant_p
, bool *overflow_p
)
1171 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1172 tree fun
= get_function_named_in_call (t
);
1173 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1176 if (fun
== NULL_TREE
)
1177 switch (CALL_EXPR_IFN (t
))
1179 case IFN_UBSAN_NULL
:
1180 case IFN_UBSAN_BOUNDS
:
1181 case IFN_UBSAN_VPTR
:
1185 error_at (loc
, "call to internal function");
1186 *non_constant_p
= true;
1190 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1192 /* Might be a constexpr function pointer. */
1193 fun
= cxx_eval_constant_expression (ctx
, fun
,
1194 /*lval*/false, non_constant_p
,
1197 if (TREE_CODE (fun
) == ADDR_EXPR
)
1198 fun
= TREE_OPERAND (fun
, 0);
1200 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1202 if (!ctx
->quiet
&& !*non_constant_p
)
1203 error_at (loc
, "expression %qE does not designate a constexpr "
1205 *non_constant_p
= true;
1208 if (DECL_CLONED_FUNCTION_P (fun
))
1209 fun
= DECL_CLONED_FUNCTION (fun
);
1211 if (is_ubsan_builtin_p (fun
))
1214 if (is_builtin_fn (fun
))
1215 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1216 lval
, non_constant_p
, overflow_p
);
1217 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1221 error_at (loc
, "call to non-constexpr function %qD", fun
);
1222 explain_invalid_constexpr_fn (fun
);
1224 *non_constant_p
= true;
1228 /* Shortcut trivial constructor/op=. */
1229 if (trivial_fn_p (fun
))
1231 if (call_expr_nargs (t
) == 2)
1233 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
1234 return cxx_eval_constant_expression (ctx
, arg
,
1235 lval
, non_constant_p
,
1238 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1239 && AGGR_INIT_ZERO_FIRST (t
))
1240 return build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1243 /* We can't defer instantiating the function any longer. */
1244 if (!DECL_INITIAL (fun
)
1245 && DECL_TEMPLOID_INSTANTIATION (fun
))
1248 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1252 /* If in direct recursive call, optimize definition search. */
1253 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1254 new_call
.fundef
= ctx
->call
->fundef
;
1257 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1258 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
1262 if (DECL_INITIAL (fun
))
1264 /* The definition of fun was somehow unsuitable. */
1265 error_at (loc
, "%qD called in a constant expression", fun
);
1266 explain_invalid_constexpr_fn (fun
);
1269 error_at (loc
, "%qD used before its definition", fun
);
1271 *non_constant_p
= true;
1276 constexpr_ctx new_ctx
= *ctx
;
1277 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1278 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1280 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1281 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1282 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1283 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1284 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1285 ctx
->values
->put (new_ctx
.object
, ctor
);
1289 bool non_constant_args
= false;
1290 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1291 non_constant_p
, overflow_p
, &non_constant_args
);
1292 if (*non_constant_p
)
1295 depth_ok
= push_cx_call_context (t
);
1297 tree result
= NULL_TREE
;
1299 constexpr_call
*entry
= NULL
;
1300 if (depth_ok
&& !non_constant_args
)
1302 new_call
.hash
= iterative_hash_template_arg
1303 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1305 /* If we have seen this call before, we are done. */
1306 maybe_initialize_constexpr_call_table ();
1307 constexpr_call
**slot
1308 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1312 /* We need to keep a pointer to the entry, not just the slot, as the
1313 slot can move in the call to cxx_eval_builtin_function_call. */
1314 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1317 /* Calls which are in progress have their result set to NULL
1318 so that we can detect circular dependencies. */
1319 else if (entry
->result
== NULL
)
1322 error ("call has circular dependency");
1323 *non_constant_p
= true;
1324 entry
->result
= result
= error_mark_node
;
1327 result
= entry
->result
;
1333 error ("constexpr evaluation depth exceeds maximum of %d (use "
1334 "-fconstexpr-depth= to increase the maximum)",
1335 max_constexpr_depth
);
1336 *non_constant_p
= true;
1337 result
= error_mark_node
;
1341 if (!result
|| result
== error_mark_node
)
1343 gcc_assert (DECL_SAVED_TREE (fun
));
1346 /* Unshare the whole function body. */
1347 tree body
= copy_fn (fun
, parms
, res
);
1349 /* Associate the bindings with the remapped parms. */
1350 tree bound
= new_call
.bindings
;
1351 tree remapped
= parms
;
1354 tree oparm
= TREE_PURPOSE (bound
);
1355 tree arg
= TREE_VALUE (bound
);
1356 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1357 ctx
->values
->put (remapped
, arg
);
1358 bound
= TREE_CHAIN (bound
);
1359 remapped
= DECL_CHAIN (remapped
);
1361 /* Add the RESULT_DECL to the values map, too. */
1362 tree slot
= NULL_TREE
;
1363 if (DECL_BY_REFERENCE (res
))
1365 slot
= AGGR_INIT_EXPR_SLOT (t
);
1366 tree addr
= build_address (slot
);
1367 addr
= build_nop (TREE_TYPE (res
), addr
);
1368 ctx
->values
->put (res
, addr
);
1369 ctx
->values
->put (slot
, NULL_TREE
);
1372 ctx
->values
->put (res
, NULL_TREE
);
1374 tree jump_target
= NULL_TREE
;
1375 cxx_eval_constant_expression (ctx
, body
,
1376 lval
, non_constant_p
, overflow_p
,
1379 if (DECL_CONSTRUCTOR_P (fun
))
1380 /* This can be null for a subobject constructor call, in
1381 which case what we care about is the initialization
1382 side-effects rather than the value. We could get at the
1383 value by evaluating *this, but we don't bother; there's
1384 no need to put such a call in the hash table. */
1385 result
= lval
? ctx
->object
: ctx
->ctor
;
1386 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1390 result
= *ctx
->values
->get (slot
? slot
: res
);
1391 if (result
== NULL_TREE
&& !*non_constant_p
)
1394 error ("constexpr call flows off the end "
1396 *non_constant_p
= true;
1400 /* Remove the parms/result from the values map. Is it worth
1401 bothering to do this when the map itself is only live for
1402 one constexpr evaluation? If so, maybe also clear out
1403 other vars from call, maybe in BIND_EXPR handling? */
1404 ctx
->values
->remove (res
);
1406 ctx
->values
->remove (slot
);
1407 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1408 ctx
->values
->remove (parm
);
1411 if (result
== error_mark_node
)
1412 *non_constant_p
= true;
1413 if (*non_constant_p
)
1414 result
= error_mark_node
;
1418 entry
->result
= result
;
1421 pop_cx_call_context ();
1422 return unshare_expr (result
);
1425 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1428 reduced_constant_expression_p (tree t
)
1430 switch (TREE_CODE (t
))
1433 /* Even if we can't lower this yet, it's constant. */
1437 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1438 tree elt
; unsigned HOST_WIDE_INT idx
;
1439 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1440 if (!reduced_constant_expression_p (elt
))
1445 /* FIXME are we calling this too much? */
1446 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1450 /* Some expressions may have constant operands but are not constant
1451 themselves, such as 1/0. Call this function (or rather, the macro
1452 following it) to check for that condition.
1454 We only call this in places that require an arithmetic constant, not in
1455 places where we might have a non-constant expression that can be a
1456 component of a constant expression, such as the address of a constexpr
1457 variable that might be dereferenced later. */
1460 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1463 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1465 if (!allow_non_constant
)
1466 error ("%q+E is not a constant expression", t
);
1467 *non_constant_p
= true;
1469 if (TREE_OVERFLOW_P (t
))
1471 if (!allow_non_constant
)
1473 permerror (input_location
, "overflow in constant expression");
1474 /* If we're being permissive (and are in an enforcing
1475 context), ignore the overflow. */
1476 if (flag_permissive
)
1477 return *non_constant_p
;
1481 return *non_constant_p
;
1484 /* Check whether the shift operation with code CODE and type TYPE on LHS
1485 and RHS is undefined. If it is, give an error with an explanation,
1486 and return true; return false otherwise. */
1489 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1490 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1492 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1493 || TREE_CODE (lhs
) != INTEGER_CST
1494 || TREE_CODE (rhs
) != INTEGER_CST
)
1497 tree lhstype
= TREE_TYPE (lhs
);
1498 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1500 /* [expr.shift] The behavior is undefined if the right operand
1501 is negative, or greater than or equal to the length in bits
1502 of the promoted left operand. */
1503 if (tree_int_cst_sgn (rhs
) == -1)
1506 permerror (loc
, "right operand of shift expression %q+E is negative",
1507 build2_loc (loc
, code
, type
, lhs
, rhs
));
1508 return (!flag_permissive
|| ctx
->quiet
);
1510 if (compare_tree_int (rhs
, uprec
) >= 0)
1513 permerror (loc
, "right operand of shift expression %q+E is >= than "
1514 "the precision of the left operand",
1515 build2_loc (loc
, code
, type
, lhs
, rhs
));
1516 return (!flag_permissive
|| ctx
->quiet
);
1519 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1520 if E1 has a signed type and non-negative value, and E1x2^E2 is
1521 representable in the corresponding unsigned type of the result type,
1522 then that value, converted to the result type, is the resulting value;
1523 otherwise, the behavior is undefined. */
1524 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1525 && (cxx_dialect
>= cxx11
))
1527 if (tree_int_cst_sgn (lhs
) == -1)
1531 "left operand of shift expression %q+E is negative",
1532 build2_loc (loc
, code
, type
, lhs
, rhs
));
1533 return (!flag_permissive
|| ctx
->quiet
);
1535 /* For signed x << y the following:
1536 (unsigned) x >> ((prec (lhs) - 1) - y)
1537 if > 1, is undefined. The right-hand side of this formula
1538 is the highest bit of the LHS that can be set (starting from 0),
1539 so that the shift doesn't overflow. We then right-shift the LHS
1540 to see whether any other bit is set making the original shift
1541 undefined -- the result is not representable in the corresponding
1543 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1544 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1545 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1546 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1547 if (tree_int_cst_lt (integer_one_node
, t
))
1550 permerror (loc
, "shift expression %q+E overflows",
1551 build2_loc (loc
, code
, type
, lhs
, rhs
));
1552 return (!flag_permissive
|| ctx
->quiet
);
1558 /* Subroutine of cxx_eval_constant_expression.
1559 Attempt to reduce the unary expression tree T to a compile time value.
1560 If successful, return the value. Otherwise issue a diagnostic
1561 and return error_mark_node. */
1564 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1566 bool *non_constant_p
, bool *overflow_p
)
1569 tree orig_arg
= TREE_OPERAND (t
, 0);
1570 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1571 non_constant_p
, overflow_p
);
1572 VERIFY_CONSTANT (arg
);
1573 location_t loc
= EXPR_LOCATION (t
);
1574 enum tree_code code
= TREE_CODE (t
);
1575 tree type
= TREE_TYPE (t
);
1576 r
= fold_unary_loc (loc
, code
, type
, arg
);
1579 if (arg
== orig_arg
)
1582 r
= build1_loc (loc
, code
, type
, arg
);
1584 VERIFY_CONSTANT (r
);
1588 /* Subroutine of cxx_eval_constant_expression.
1589 Like cxx_eval_unary_expression, except for binary expressions. */
1592 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1594 bool *non_constant_p
, bool *overflow_p
)
1597 tree orig_lhs
= TREE_OPERAND (t
, 0);
1598 tree orig_rhs
= TREE_OPERAND (t
, 1);
1600 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1601 non_constant_p
, overflow_p
);
1602 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1603 a local array in a constexpr function. */
1604 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1606 VERIFY_CONSTANT (lhs
);
1607 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1608 non_constant_p
, overflow_p
);
1610 VERIFY_CONSTANT (rhs
);
1612 location_t loc
= EXPR_LOCATION (t
);
1613 enum tree_code code
= TREE_CODE (t
);
1614 tree type
= TREE_TYPE (t
);
1616 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
1618 bool is_code_eq
= (code
== EQ_EXPR
);
1620 if (TREE_CODE (lhs
) == PTRMEM_CST
1621 && TREE_CODE (rhs
) == PTRMEM_CST
)
1622 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
1624 else if ((TREE_CODE (lhs
) == PTRMEM_CST
1625 || TREE_CODE (rhs
) == PTRMEM_CST
)
1626 && (null_member_pointer_value_p (lhs
)
1627 || null_member_pointer_value_p (rhs
)))
1628 r
= constant_boolean_node (!is_code_eq
, type
);
1632 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1636 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1639 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1641 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1642 *non_constant_p
= true;
1644 VERIFY_CONSTANT (r
);
1648 /* Subroutine of cxx_eval_constant_expression.
1649 Attempt to evaluate condition expressions. Dead branches are not
1653 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1655 bool *non_constant_p
, bool *overflow_p
,
1658 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1660 non_constant_p
, overflow_p
);
1661 VERIFY_CONSTANT (val
);
1662 /* Don't VERIFY_CONSTANT the other operands. */
1663 if (integer_zerop (val
))
1664 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1666 non_constant_p
, overflow_p
,
1668 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1670 non_constant_p
, overflow_p
,
1674 /* Returns less than, equal to, or greater than zero if KEY is found to be
1675 less than, to match, or to be greater than the constructor_elt's INDEX. */
1678 array_index_cmp (tree key
, tree index
)
1680 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
1682 switch (TREE_CODE (index
))
1685 return tree_int_cst_compare (key
, index
);
1688 tree lo
= TREE_OPERAND (index
, 0);
1689 tree hi
= TREE_OPERAND (index
, 1);
1690 if (tree_int_cst_lt (key
, lo
))
1692 else if (tree_int_cst_lt (hi
, key
))
1702 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
1703 if none. If INSERT is true, insert a matching element rather than fail. */
1705 static HOST_WIDE_INT
1706 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
1708 if (tree_int_cst_sgn (dindex
) < 0)
1711 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
1712 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
1713 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
1715 unsigned HOST_WIDE_INT end
= len
;
1716 unsigned HOST_WIDE_INT begin
= 0;
1718 /* If the last element of the CONSTRUCTOR has its own index, we can assume
1719 that the same is true of the other elements and index directly. */
1722 tree cindex
= (*elts
)[end
-1].index
;
1723 if (TREE_CODE (cindex
) == INTEGER_CST
1724 && compare_tree_int (cindex
, end
-1) == 0)
1733 /* Otherwise, find a matching index by means of a binary search. */
1734 while (begin
!= end
)
1736 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
1737 constructor_elt
&elt
= (*elts
)[middle
];
1738 tree idx
= elt
.index
;
1740 int cmp
= array_index_cmp (dindex
, idx
);
1747 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
1749 /* We need to split the range. */
1751 tree lo
= TREE_OPERAND (idx
, 0);
1752 tree hi
= TREE_OPERAND (idx
, 1);
1753 if (tree_int_cst_lt (lo
, dindex
))
1755 /* There are still some lower elts; shorten the range. */
1756 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
1758 if (tree_int_cst_equal (lo
, new_hi
))
1759 /* Only one element left, no longer a range. */
1762 TREE_OPERAND (idx
, 1) = new_hi
;
1763 /* Append the element we want to insert. */
1766 e
.value
= unshare_expr (elt
.value
);
1767 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
1770 /* No lower elts, the range elt is now ours. */
1773 if (tree_int_cst_lt (dindex
, hi
))
1775 /* There are still some higher elts; append a range. */
1776 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
1778 if (tree_int_cst_equal (new_lo
, hi
))
1781 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
1782 e
.value
= unshare_expr (elt
.value
);
1783 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
1792 constructor_elt e
= { dindex
, NULL_TREE
};
1793 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
1801 /* Subroutine of cxx_eval_constant_expression.
1802 Attempt to reduce a reference to an array slot. */
1805 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
1807 bool *non_constant_p
, bool *overflow_p
)
1809 tree oldary
= TREE_OPERAND (t
, 0);
1810 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
1812 non_constant_p
, overflow_p
);
1816 unsigned len
, elem_nchars
= 1;
1817 if (*non_constant_p
)
1819 oldidx
= TREE_OPERAND (t
, 1);
1820 index
= cxx_eval_constant_expression (ctx
, oldidx
,
1822 non_constant_p
, overflow_p
);
1823 VERIFY_CONSTANT (index
);
1824 if (lval
&& ary
== oldary
&& index
== oldidx
)
1827 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
1828 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
1829 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1830 len
= CONSTRUCTOR_NELTS (ary
);
1831 else if (TREE_CODE (ary
) == STRING_CST
)
1833 elem_nchars
= (TYPE_PRECISION (elem_type
)
1834 / TYPE_PRECISION (char_type_node
));
1835 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
1839 /* We can't do anything with other tree codes, so use
1840 VERIFY_CONSTANT to complain and fail. */
1841 VERIFY_CONSTANT (ary
);
1845 if (!tree_fits_shwi_p (index
)
1846 || (i
= tree_to_shwi (index
)) < 0)
1849 error ("negative array subscript");
1850 *non_constant_p
= true;
1854 tree nelts
= array_type_nelts_top (TREE_TYPE (ary
));
1855 /* For VLAs, the number of elements won't be an integer constant. */
1856 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1858 VERIFY_CONSTANT (nelts
);
1859 if (!tree_int_cst_lt (index
, nelts
))
1862 error ("array subscript out of bound");
1863 *non_constant_p
= true;
1868 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1870 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
1880 if (TREE_CODE (ary
) == CONSTRUCTOR
1881 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
1883 /* 'ary' is part of the aggregate initializer we're currently
1884 building; if there's no initializer for this element yet,
1887 error ("accessing uninitialized array element");
1888 *non_constant_p
= true;
1892 /* If it's within the array bounds but doesn't have an explicit
1893 initializer, it's value-initialized. */
1894 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
1895 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
1899 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1900 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
1901 else if (elem_nchars
== 1)
1902 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
1903 TREE_STRING_POINTER (ary
)[i
]);
1906 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
1907 return native_interpret_expr (type
, (const unsigned char *)
1908 TREE_STRING_POINTER (ary
)
1909 + i
* elem_nchars
, elem_nchars
);
1911 /* Don't VERIFY_CONSTANT here. */
1914 /* Subroutine of cxx_eval_constant_expression.
1915 Attempt to reduce a field access of a value of class type. */
1918 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
1920 bool *non_constant_p
, bool *overflow_p
)
1922 unsigned HOST_WIDE_INT i
;
1925 tree part
= TREE_OPERAND (t
, 1);
1926 tree orig_whole
= TREE_OPERAND (t
, 0);
1927 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1929 non_constant_p
, overflow_p
);
1930 if (TREE_CODE (whole
) == PTRMEM_CST
)
1931 whole
= cplus_expand_constant (whole
);
1932 if (whole
== orig_whole
)
1935 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
1936 whole
, part
, NULL_TREE
);
1937 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1939 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
1942 error ("%qE is not a constant expression", orig_whole
);
1943 *non_constant_p
= true;
1945 if (DECL_MUTABLE_P (part
))
1948 error ("mutable %qD is not usable in a constant expression", part
);
1949 *non_constant_p
= true;
1951 if (*non_constant_p
)
1953 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1960 /* We're in the middle of initializing it. */
1964 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
1965 && CONSTRUCTOR_NELTS (whole
) > 0)
1967 /* DR 1188 says we don't have to deal with this. */
1969 error ("accessing %qD member instead of initialized %qD member in "
1970 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
1971 *non_constant_p
= true;
1975 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
1977 /* 'whole' is part of the aggregate initializer we're currently
1978 building; if there's no initializer for this member yet, that's an
1981 error ("accessing uninitialized member %qD", part
);
1982 *non_constant_p
= true;
1986 /* If there's no explicit init for this field, it's value-initialized. */
1987 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
1988 return cxx_eval_constant_expression (ctx
, value
,
1990 non_constant_p
, overflow_p
);
1993 /* Subroutine of cxx_eval_constant_expression.
1994 Attempt to reduce a field access of a value of class type that is
1995 expressed as a BIT_FIELD_REF. */
1998 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2000 bool *non_constant_p
, bool *overflow_p
)
2002 tree orig_whole
= TREE_OPERAND (t
, 0);
2003 tree retval
, fldval
, utype
, mask
;
2004 bool fld_seen
= false;
2005 HOST_WIDE_INT istart
, isize
;
2006 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2008 non_constant_p
, overflow_p
);
2009 tree start
, field
, value
;
2010 unsigned HOST_WIDE_INT i
;
2012 if (whole
== orig_whole
)
2014 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2016 if (!*non_constant_p
2017 && TREE_CODE (whole
) != VECTOR_CST
2018 && TREE_CODE (whole
) != CONSTRUCTOR
)
2021 error ("%qE is not a constant expression", orig_whole
);
2022 *non_constant_p
= true;
2024 if (*non_constant_p
)
2027 if (TREE_CODE (whole
) == VECTOR_CST
)
2028 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2029 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2031 start
= TREE_OPERAND (t
, 2);
2032 istart
= tree_to_shwi (start
);
2033 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2034 utype
= TREE_TYPE (t
);
2035 if (!TYPE_UNSIGNED (utype
))
2036 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2037 retval
= build_int_cst (utype
, 0);
2038 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2040 tree bitpos
= bit_position (field
);
2041 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2043 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2044 && TREE_CODE (value
) == INTEGER_CST
2045 && tree_fits_shwi_p (bitpos
)
2046 && tree_fits_shwi_p (DECL_SIZE (field
)))
2048 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2049 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2050 HOST_WIDE_INT shift
;
2051 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2053 fldval
= fold_convert (utype
, value
);
2054 mask
= build_int_cst_type (utype
, -1);
2055 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2056 size_int (TYPE_PRECISION (utype
) - sz
));
2057 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2058 size_int (TYPE_PRECISION (utype
) - sz
));
2059 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2060 shift
= bit
- istart
;
2061 if (BYTES_BIG_ENDIAN
)
2062 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2063 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2065 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2071 return fold_convert (TREE_TYPE (t
), retval
);
2073 return error_mark_node
;
2076 /* Subroutine of cxx_eval_constant_expression.
2077 Evaluate a short-circuited logical expression T in the context
2078 of a given constexpr CALL. BAILOUT_VALUE is the value for
2079 early return. CONTINUE_VALUE is used here purely for
2080 sanity check purposes. */
2083 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2084 tree bailout_value
, tree continue_value
,
2086 bool *non_constant_p
, bool *overflow_p
)
2089 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2091 non_constant_p
, overflow_p
);
2092 VERIFY_CONSTANT (lhs
);
2093 if (tree_int_cst_equal (lhs
, bailout_value
))
2095 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2096 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2097 lval
, non_constant_p
,
2099 VERIFY_CONSTANT (r
);
2103 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2104 CONSTRUCTOR elements to initialize (part of) an object containing that
2105 field. Return a pointer to the constructor_elt corresponding to the
2106 initialization of the field. */
2108 static constructor_elt
*
2109 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2111 tree aggr
= TREE_OPERAND (ref
, 0);
2112 tree field
= TREE_OPERAND (ref
, 1);
2114 constructor_elt
*ce
;
2116 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2118 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2120 constructor_elt
*base_ce
2121 = base_field_constructor_elt (v
, aggr
);
2122 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2125 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2126 if (ce
->index
== field
)
2133 /* Some of the expressions fed to the constexpr mechanism are calls to
2134 constructors, which have type void. In that case, return the type being
2135 initialized by the constructor. */
2138 initialized_type (tree t
)
2142 tree type
= cv_unqualified (TREE_TYPE (t
));
2143 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2145 /* A constructor call has void type, so we need to look deeper. */
2146 tree fn
= get_function_named_in_call (t
);
2147 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2148 && DECL_CXX_CONSTRUCTOR_P (fn
))
2149 type
= DECL_CONTEXT (fn
);
2154 /* We're about to initialize element INDEX of an array or class from VALUE.
2155 Set up NEW_CTX appropriately by adjusting .object to refer to the
2156 subobject and creating a new CONSTRUCTOR if the element is itself
2157 a class or array. */
2160 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2161 tree index
, tree
&value
)
2165 if (index
&& TREE_CODE (index
) != INTEGER_CST
2166 && TREE_CODE (index
) != FIELD_DECL
)
2167 /* This won't have an element in the new CONSTRUCTOR. */
2170 tree type
= initialized_type (value
);
2171 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2172 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2175 /* The sub-aggregate initializer might contain a placeholder;
2176 update object to refer to the subobject and ctor to refer to
2177 the (newly created) sub-initializer. */
2179 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2180 tree elt
= build_constructor (type
, NULL
);
2181 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2184 if (TREE_CODE (value
) == TARGET_EXPR
)
2185 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2186 value
= TARGET_EXPR_INITIAL (value
);
2189 /* We're about to process an initializer for a class or array TYPE. Make
2190 sure that CTX is set up appropriately. */
2193 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2195 /* We don't bother building a ctor for an empty base subobject. */
2196 if (is_empty_class (type
))
2199 /* We're in the middle of an initializer that might involve placeholders;
2200 our caller should have created a CONSTRUCTOR for us to put the
2201 initializer into. We will either return that constructor or T. */
2202 gcc_assert (ctx
->ctor
);
2203 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2204 (type
, TREE_TYPE (ctx
->ctor
)));
2205 /* We used to check that ctx->ctor was empty, but that isn't the case when
2206 the object is zero-initialized before calling the constructor. */
2208 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2209 (type
, TREE_TYPE (ctx
->object
)));
2210 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2211 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2214 /* Subroutine of cxx_eval_constant_expression.
2215 The expression tree T denotes a C-style array or a C-style
2216 aggregate. Reduce it to a constant expression. */
2219 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2221 bool *non_constant_p
, bool *overflow_p
)
2223 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2224 bool changed
= false;
2225 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2227 verify_ctor_sanity (ctx
, TREE_TYPE (t
));
2228 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2229 vec_alloc (*p
, vec_safe_length (v
));
2233 bool constant_p
= true;
2234 bool side_effects_p
= false;
2235 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2237 constexpr_ctx new_ctx
;
2238 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2239 if (new_ctx
.ctor
!= ctx
->ctor
)
2240 /* If we built a new CONSTRUCTOR, attach it now so that other
2241 initializers can refer to it. */
2242 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2243 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2245 non_constant_p
, overflow_p
);
2246 /* Don't VERIFY_CONSTANT here. */
2247 if (ctx
->quiet
&& *non_constant_p
)
2252 if (!TREE_CONSTANT (elt
))
2254 if (TREE_SIDE_EFFECTS (elt
))
2255 side_effects_p
= true;
2256 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2258 /* This is an initialization of a vfield inside a base
2259 subaggregate that we already initialized; push this
2260 initialization into the previous initialization. */
2261 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2266 && (TREE_CODE (index
) == NOP_EXPR
2267 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2269 /* This is an initializer for an empty base; now that we've
2270 checked that it's constant, we can ignore it. */
2271 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2274 else if (new_ctx
.ctor
!= ctx
->ctor
)
2276 /* We appended this element above; update the value. */
2277 gcc_assert ((*p
)->last().index
== index
);
2278 (*p
)->last().value
= elt
;
2281 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2283 if (*non_constant_p
|| !changed
)
2286 /* We're done building this CONSTRUCTOR, so now we can interpret an
2287 element without an explicit initializer as value-initialized. */
2288 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2289 TREE_CONSTANT (t
) = constant_p
;
2290 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2291 if (VECTOR_TYPE_P (TREE_TYPE (t
)))
2296 /* Subroutine of cxx_eval_constant_expression.
2297 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2298 initialization of a non-static data member of array type. Reduce it to a
2301 Note that apart from value-initialization (when VALUE_INIT is true),
2302 this is only intended to support value-initialization and the
2303 initializations done by defaulted constructors for classes with
2304 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2305 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2306 for the copy/move constructor. */
2309 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2310 bool value_init
, bool lval
,
2311 bool *non_constant_p
, bool *overflow_p
)
2313 tree elttype
= TREE_TYPE (atype
);
2314 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2315 verify_ctor_sanity (ctx
, atype
);
2316 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2317 vec_alloc (*p
, max
+ 1);
2318 bool pre_init
= false;
2319 unsigned HOST_WIDE_INT i
;
2321 /* For the default constructor, build up a call to the default
2322 constructor of the element type. We only need to handle class types
2323 here, as for a constructor to be constexpr, all members must be
2324 initialized, which for a defaulted default constructor means they must
2325 be of a class type with a constexpr default constructor. */
2326 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2327 /* We only do this at the lowest level. */;
2328 else if (value_init
)
2330 init
= build_value_init (elttype
, tf_warning_or_error
);
2335 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2336 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2337 &argvec
, elttype
, LOOKUP_NORMAL
,
2338 tf_warning_or_error
);
2339 release_tree_vector (argvec
);
2340 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2344 for (i
= 0; i
< max
; ++i
)
2346 tree idx
= build_int_cst (size_type_node
, i
);
2348 constexpr_ctx new_ctx
;
2349 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2350 if (new_ctx
.ctor
!= ctx
->ctor
)
2351 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2352 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2354 /* A multidimensional array; recurse. */
2355 if (value_init
|| init
== NULL_TREE
)
2356 eltinit
= NULL_TREE
;
2358 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2359 tf_warning_or_error
);
2360 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2362 non_constant_p
, overflow_p
);
2366 /* Initializing an element using value or default initialization
2367 we just pre-built above. */
2368 eltinit
= (cxx_eval_constant_expression
2370 lval
, non_constant_p
, overflow_p
));
2374 /* Copying an element. */
2375 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2376 (atype
, TREE_TYPE (init
)));
2377 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2378 tf_warning_or_error
);
2379 if (!real_lvalue_p (init
))
2380 eltinit
= move (eltinit
);
2381 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2382 eltinit
= (cxx_eval_constant_expression
2383 (&new_ctx
, eltinit
, lval
,
2384 non_constant_p
, overflow_p
));
2386 if (*non_constant_p
&& !ctx
->quiet
)
2388 if (new_ctx
.ctor
!= ctx
->ctor
)
2390 /* We appended this element above; update the value. */
2391 gcc_assert ((*p
)->last().index
== idx
);
2392 (*p
)->last().value
= eltinit
;
2395 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2398 if (!*non_constant_p
)
2401 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2407 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2409 bool *non_constant_p
, bool *overflow_p
)
2411 tree atype
= TREE_TYPE (t
);
2412 tree init
= VEC_INIT_EXPR_INIT (t
);
2413 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2414 VEC_INIT_EXPR_VALUE_INIT (t
),
2415 lval
, non_constant_p
, overflow_p
);
2416 if (*non_constant_p
)
2422 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2423 match. We want to be less strict for simple *& folding; if we have a
2424 non-const temporary that we access through a const pointer, that should
2425 work. We handle this here rather than change fold_indirect_ref_1
2426 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2427 don't really make sense outside of constant expression evaluation. Also
2428 we want to allow folding to COMPONENT_REF, which could cause trouble
2429 with TBAA in fold_indirect_ref_1.
2431 Try to keep this function synced with fold_indirect_ref_1. */
2434 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2440 subtype
= TREE_TYPE (sub
);
2441 if (!POINTER_TYPE_P (subtype
))
2444 if (TREE_CODE (sub
) == ADDR_EXPR
)
2446 tree op
= TREE_OPERAND (sub
, 0);
2447 tree optype
= TREE_TYPE (op
);
2449 /* *&CONST_DECL -> to the value of the const decl. */
2450 if (TREE_CODE (op
) == CONST_DECL
)
2451 return DECL_INITIAL (op
);
2452 /* *&p => p; make sure to handle *&"str"[cst] here. */
2453 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2454 /* Also handle the case where the desired type is an array of unknown
2455 bounds because the variable has had its bounds deduced since the
2456 ADDR_EXPR was created. */
2457 || (TREE_CODE (type
) == ARRAY_TYPE
2458 && TREE_CODE (optype
) == ARRAY_TYPE
2459 && TYPE_DOMAIN (type
) == NULL_TREE
2460 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
2463 tree fop
= fold_read_from_constant_string (op
);
2469 /* *(foo *)&fooarray => fooarray[0] */
2470 else if (TREE_CODE (optype
) == ARRAY_TYPE
2471 && (same_type_ignoring_top_level_qualifiers_p
2472 (type
, TREE_TYPE (optype
))))
2474 tree type_domain
= TYPE_DOMAIN (optype
);
2475 tree min_val
= size_zero_node
;
2476 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2477 min_val
= TYPE_MIN_VALUE (type_domain
);
2478 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2479 NULL_TREE
, NULL_TREE
);
2481 /* *(foo *)&complexfoo => __real__ complexfoo */
2482 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2483 && (same_type_ignoring_top_level_qualifiers_p
2484 (type
, TREE_TYPE (optype
))))
2485 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2486 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2487 else if (VECTOR_TYPE_P (optype
)
2488 && (same_type_ignoring_top_level_qualifiers_p
2489 (type
, TREE_TYPE (optype
))))
2491 tree part_width
= TYPE_SIZE (type
);
2492 tree index
= bitsize_int (0);
2493 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2495 /* Also handle conversion to an empty base class, which
2496 is represented with a NOP_EXPR. */
2497 else if (is_empty_class (type
)
2498 && CLASS_TYPE_P (optype
)
2499 && DERIVED_FROM_P (type
, optype
))
2504 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2505 else if (RECORD_OR_UNION_TYPE_P (optype
))
2507 tree field
= TYPE_FIELDS (optype
);
2508 for (; field
; field
= DECL_CHAIN (field
))
2509 if (TREE_CODE (field
) == FIELD_DECL
2510 && integer_zerop (byte_position (field
))
2511 && (same_type_ignoring_top_level_qualifiers_p
2512 (TREE_TYPE (field
), type
)))
2514 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2519 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2520 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2522 tree op00
= TREE_OPERAND (sub
, 0);
2523 tree op01
= TREE_OPERAND (sub
, 1);
2526 if (TREE_CODE (op00
) == ADDR_EXPR
)
2529 op00
= TREE_OPERAND (op00
, 0);
2530 op00type
= TREE_TYPE (op00
);
2532 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2533 if (VECTOR_TYPE_P (op00type
)
2534 && (same_type_ignoring_top_level_qualifiers_p
2535 (type
, TREE_TYPE (op00type
))))
2537 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2538 tree part_width
= TYPE_SIZE (type
);
2539 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2540 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2541 tree index
= bitsize_int (indexi
);
2543 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2544 return fold_build3_loc (loc
,
2545 BIT_FIELD_REF
, type
, op00
,
2549 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2550 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2551 && (same_type_ignoring_top_level_qualifiers_p
2552 (type
, TREE_TYPE (op00type
))))
2554 tree size
= TYPE_SIZE_UNIT (type
);
2555 if (tree_int_cst_equal (size
, op01
))
2556 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2558 /* ((foo *)&fooarray)[1] => fooarray[1] */
2559 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2560 && (same_type_ignoring_top_level_qualifiers_p
2561 (type
, TREE_TYPE (op00type
))))
2563 tree type_domain
= TYPE_DOMAIN (op00type
);
2564 tree min_val
= size_zero_node
;
2565 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2566 min_val
= TYPE_MIN_VALUE (type_domain
);
2567 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2568 TYPE_SIZE_UNIT (type
));
2569 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2570 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2571 NULL_TREE
, NULL_TREE
);
2573 /* Also handle conversion to an empty base class, which
2574 is represented with a NOP_EXPR. */
2575 else if (is_empty_class (type
)
2576 && CLASS_TYPE_P (op00type
)
2577 && DERIVED_FROM_P (type
, op00type
))
2582 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2583 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2585 tree field
= TYPE_FIELDS (op00type
);
2586 for (; field
; field
= DECL_CHAIN (field
))
2587 if (TREE_CODE (field
) == FIELD_DECL
2588 && tree_int_cst_equal (byte_position (field
), op01
)
2589 && (same_type_ignoring_top_level_qualifiers_p
2590 (TREE_TYPE (field
), type
)))
2592 return fold_build3 (COMPONENT_REF
, type
, op00
,
2599 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2600 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2601 && (same_type_ignoring_top_level_qualifiers_p
2602 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2605 tree min_val
= size_zero_node
;
2606 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2610 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2611 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2612 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2613 min_val
= TYPE_MIN_VALUE (type_domain
);
2614 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2622 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2624 bool *non_constant_p
, bool *overflow_p
)
2626 tree orig_op0
= TREE_OPERAND (t
, 0);
2627 bool empty_base
= false;
2629 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
2630 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
2632 if (TREE_CODE (t
) == MEM_REF
2633 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
2635 gcc_assert (ctx
->quiet
);
2636 *non_constant_p
= true;
2640 /* First try to simplify it directly. */
2641 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
2645 /* If that didn't work, evaluate the operand first. */
2646 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2647 /*lval*/false, non_constant_p
,
2649 /* Don't VERIFY_CONSTANT here. */
2650 if (*non_constant_p
)
2653 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2657 /* We couldn't fold to a constant value. Make sure it's not
2658 something we should have been able to fold. */
2661 if (TREE_CODE (sub
) == ADDR_EXPR
)
2663 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2664 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
2665 /* DR 1188 says we don't have to deal with this. */
2667 error ("accessing value of %qE through a %qT glvalue in a "
2668 "constant expression", build_fold_indirect_ref (sub
),
2670 *non_constant_p
= true;
2674 if (lval
&& op0
!= orig_op0
)
2675 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
2677 VERIFY_CONSTANT (t
);
2682 r
= cxx_eval_constant_expression (ctx
, r
,
2683 lval
, non_constant_p
, overflow_p
);
2684 if (*non_constant_p
)
2687 /* If we're pulling out the value of an empty base, make sure
2688 that the whole object is constant and then return an empty
2690 if (empty_base
&& !lval
)
2692 VERIFY_CONSTANT (r
);
2693 r
= build_constructor (TREE_TYPE (t
), NULL
);
2694 TREE_CONSTANT (r
) = true;
2700 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2701 Shared between potential_constant_expression and
2702 cxx_eval_constant_expression. */
2705 non_const_var_error (tree r
)
2707 tree type
= TREE_TYPE (r
);
2708 error ("the value of %qD is not usable in a constant "
2710 /* Avoid error cascade. */
2711 if (DECL_INITIAL (r
) == error_mark_node
)
2713 if (DECL_DECLARED_CONSTEXPR_P (r
))
2714 inform (DECL_SOURCE_LOCATION (r
),
2715 "%qD used in its own initializer", r
);
2716 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
2718 if (!CP_TYPE_CONST_P (type
))
2719 inform (DECL_SOURCE_LOCATION (r
),
2720 "%q#D is not const", r
);
2721 else if (CP_TYPE_VOLATILE_P (type
))
2722 inform (DECL_SOURCE_LOCATION (r
),
2723 "%q#D is volatile", r
);
2724 else if (!DECL_INITIAL (r
)
2725 || !TREE_CONSTANT (DECL_INITIAL (r
)))
2726 inform (DECL_SOURCE_LOCATION (r
),
2727 "%qD was not initialized with a constant "
2734 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
2735 inform (DECL_SOURCE_LOCATION (r
),
2736 "%qD was not declared %<constexpr%>", r
);
2738 inform (DECL_SOURCE_LOCATION (r
),
2739 "%qD does not have integral or enumeration type",
2744 /* Subroutine of cxx_eval_constant_expression.
2745 Like cxx_eval_unary_expression, except for trinary expressions. */
2748 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
2750 bool *non_constant_p
, bool *overflow_p
)
2756 for (i
= 0; i
< 3; i
++)
2758 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
2760 non_constant_p
, overflow_p
);
2761 VERIFY_CONSTANT (args
[i
]);
2764 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
2765 args
[0], args
[1], args
[2]);
2766 if (val
== NULL_TREE
)
2768 VERIFY_CONSTANT (val
);
2773 var_in_constexpr_fn (tree t
)
2775 tree ctx
= DECL_CONTEXT (t
);
2776 return (cxx_dialect
>= cxx14
&& ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
2777 && DECL_DECLARED_CONSTEXPR_P (ctx
));
2780 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
2783 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
2785 bool *non_constant_p
, bool *overflow_p
)
2787 constexpr_ctx new_ctx
= *ctx
;
2789 tree init
= TREE_OPERAND (t
, 1);
2790 if (TREE_CLOBBER_P (init
))
2791 /* Just ignore clobbers. */
2794 /* First we figure out where we're storing to. */
2795 tree target
= TREE_OPERAND (t
, 0);
2796 tree type
= TREE_TYPE (target
);
2797 target
= cxx_eval_constant_expression (ctx
, target
,
2799 non_constant_p
, overflow_p
);
2800 if (*non_constant_p
)
2803 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
2805 /* For initialization of an empty base, the original target will be
2806 *(base*)this, which the above evaluation resolves to the object
2807 argument, which has the derived type rather than the base type. In
2808 this situation, just evaluate the initializer and return, since
2809 there's no actual data to store. */
2810 gcc_assert (is_empty_class (type
));
2811 return cxx_eval_constant_expression (ctx
, init
, false,
2812 non_constant_p
, overflow_p
);
2815 /* And then find the underlying variable. */
2816 vec
<tree
,va_gc
> *refs
= make_tree_vector();
2817 tree object
= NULL_TREE
;
2818 for (tree probe
= target
; object
== NULL_TREE
; )
2820 switch (TREE_CODE (probe
))
2825 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
2826 vec_safe_push (refs
, TREE_TYPE (probe
));
2827 probe
= TREE_OPERAND (probe
, 0);
2835 /* And then find/build up our initializer for the path to the subobject
2836 we're initializing. */
2838 if (DECL_P (object
))
2839 valp
= ctx
->values
->get (object
);
2844 /* A constant-expression cannot modify objects from outside the
2845 constant-expression. */
2847 error ("modification of %qE is not a constant-expression", object
);
2848 *non_constant_p
= true;
2851 type
= TREE_TYPE (object
);
2852 bool no_zero_init
= true;
2854 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
2855 while (!refs
->is_empty())
2857 if (*valp
== NULL_TREE
)
2859 *valp
= build_constructor (type
, NULL
);
2860 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
2862 /* If the value of object is already zero-initialized, any new ctors for
2863 subobjects will also be zero-initialized. */
2864 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
2866 vec_safe_push (ctors
, *valp
);
2868 enum tree_code code
= TREE_CODE (type
);
2870 tree index
= refs
->pop();
2872 constructor_elt
*cep
= NULL
;
2873 if (code
== ARRAY_TYPE
)
2876 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
2877 gcc_assert (i
>= 0);
2878 cep
= CONSTRUCTOR_ELT (*valp
, i
);
2879 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
2883 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
2884 for (unsigned HOST_WIDE_INT idx
= 0;
2885 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
2887 if (index
== cep
->index
)
2891 constructor_elt ce
= { index
, NULL_TREE
};
2892 cep
= vec_safe_push (CONSTRUCTOR_ELTS (*valp
), ce
);
2897 release_tree_vector (refs
);
2899 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
2901 /* Create a new CONSTRUCTOR in case evaluation of the initializer
2902 wants to modify it. */
2903 if (*valp
== NULL_TREE
)
2905 *valp
= new_ctx
.ctor
= build_constructor (type
, NULL
);
2906 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = no_zero_init
;
2909 new_ctx
.ctor
= *valp
;
2910 new_ctx
.object
= target
;
2913 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
2914 non_constant_p
, overflow_p
);
2915 if (target
== object
)
2917 /* The hash table might have moved since the get earlier. */
2918 valp
= ctx
->values
->get (object
);
2919 if (TREE_CODE (init
) == CONSTRUCTOR
)
2921 /* An outer ctx->ctor might be pointing to *valp, so replace
2923 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
2924 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
2925 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
2934 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
2938 bool c
= TREE_CONSTANT (init
);
2939 bool s
= TREE_SIDE_EFFECTS (init
);
2941 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
2944 TREE_CONSTANT (elt
) = false;
2946 TREE_SIDE_EFFECTS (elt
) = true;
2949 release_tree_vector (ctors
);
2951 if (*non_constant_p
)
2959 /* Evaluate a ++ or -- expression. */
2962 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
2964 bool *non_constant_p
, bool *overflow_p
)
2966 enum tree_code code
= TREE_CODE (t
);
2967 tree type
= TREE_TYPE (t
);
2968 tree op
= TREE_OPERAND (t
, 0);
2969 tree offset
= TREE_OPERAND (t
, 1);
2970 gcc_assert (TREE_CONSTANT (offset
));
2972 /* The operand as an lvalue. */
2973 op
= cxx_eval_constant_expression (ctx
, op
, true,
2974 non_constant_p
, overflow_p
);
2976 /* The operand as an rvalue. */
2977 tree val
= rvalue (op
);
2978 val
= cxx_eval_constant_expression (ctx
, val
, false,
2979 non_constant_p
, overflow_p
);
2980 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2981 a local array in a constexpr function. */
2982 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
2984 VERIFY_CONSTANT (val
);
2986 /* The modified value. */
2987 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
2989 if (POINTER_TYPE_P (type
))
2991 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
2992 offset
= convert_to_ptrofftype (offset
);
2994 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
2995 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
2998 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3000 VERIFY_CONSTANT (mod
);
3002 /* Storing the modified value. */
3003 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3004 cxx_eval_constant_expression (ctx
, store
,
3005 true, non_constant_p
, overflow_p
);
3007 /* And the value of the expression. */
3008 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3010 /* Prefix ops are lvalues. */
3014 /* But we optimize when the caller wants an rvalue. */
3018 /* Postfix ops are rvalues. */
3022 /* Predicates for the meaning of *jump_target. */
3025 returns (tree
*jump_target
)
3028 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
3032 breaks (tree
*jump_target
)
3035 && TREE_CODE (*jump_target
) == LABEL_DECL
3036 && LABEL_DECL_BREAK (*jump_target
);
3040 continues (tree
*jump_target
)
3043 && TREE_CODE (*jump_target
) == LABEL_DECL
3044 && LABEL_DECL_CONTINUE (*jump_target
);
3048 switches (tree
*jump_target
)
3051 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3054 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3055 at I matches *jump_target. If we're looking for a case label and we see
3056 the default label, copy I into DEFAULT_LABEL. */
3059 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
3060 tree_stmt_iterator
& default_label
)
3062 tree stmt
= tsi_stmt (i
);
3063 switch (TREE_CODE (*jump_target
))
3066 if (TREE_CODE (stmt
) == LABEL_EXPR
3067 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3072 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3074 if (!CASE_LOW (stmt
))
3076 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3087 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3088 semantics, for switch, break, continue, and return. */
3091 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3092 bool *non_constant_p
, bool *overflow_p
,
3095 tree_stmt_iterator i
;
3096 tree_stmt_iterator default_label
= tree_stmt_iterator();
3098 /* In a statement-expression we want to return the last value. */
3102 local_target
= NULL_TREE
;
3103 jump_target
= &local_target
;
3105 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3108 tree stmt
= tsi_stmt (i
);
3111 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
3112 /* The label we want might be inside. */;
3113 else if (label_matches (jump_target
, i
, default_label
))
3115 *jump_target
= NULL_TREE
;
3119 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3120 non_constant_p
, overflow_p
,
3122 if (*non_constant_p
)
3124 if (returns (jump_target
) || breaks (jump_target
))
3127 if (switches (jump_target
) && !tsi_end_p (default_label
))
3130 *jump_target
= NULL_TREE
;
3136 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3137 semantics; continue semantics are covered by cxx_eval_statement_list. */
3140 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3141 bool *non_constant_p
, bool *overflow_p
,
3144 tree body
= TREE_OPERAND (t
, 0);
3147 cxx_eval_statement_list (ctx
, body
,
3148 non_constant_p
, overflow_p
, jump_target
);
3149 if (returns (jump_target
) || breaks (jump_target
) || *non_constant_p
)
3152 if (breaks (jump_target
))
3153 *jump_target
= NULL_TREE
;
3157 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3161 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3162 bool *non_constant_p
, bool *overflow_p
,
3165 tree cond
= TREE_OPERAND (t
, 0);
3166 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3167 non_constant_p
, overflow_p
);
3168 VERIFY_CONSTANT (cond
);
3169 *jump_target
= cond
;
3171 tree body
= TREE_OPERAND (t
, 1);
3172 cxx_eval_statement_list (ctx
, body
,
3173 non_constant_p
, overflow_p
, jump_target
);
3174 if (breaks (jump_target
) || switches (jump_target
))
3175 *jump_target
= NULL_TREE
;
3179 /* Subroutine of cxx_eval_constant_expression.
3180 Attempt to reduce a POINTER_PLUS_EXPR expression T. */
3183 cxx_eval_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
3184 bool lval
, bool *non_constant_p
,
3187 tree orig_type
= TREE_TYPE (t
);
3188 tree op00
= TREE_OPERAND (t
, 0);
3189 tree op01
= TREE_OPERAND (t
, 1);
3190 location_t loc
= EXPR_LOCATION (t
);
3192 op00
= cxx_eval_constant_expression (ctx
, op00
, lval
,
3193 non_constant_p
, overflow_p
);
3196 if (TREE_CODE (op00
) != ADDR_EXPR
)
3199 op01
= cxx_eval_constant_expression (ctx
, op01
, lval
,
3200 non_constant_p
, overflow_p
);
3201 op00
= TREE_OPERAND (op00
, 0);
3203 /* &A[i] p+ j => &A[i + j] */
3204 if (TREE_CODE (op00
) == ARRAY_REF
3205 && TREE_CODE (TREE_OPERAND (op00
, 1)) == INTEGER_CST
3206 && TREE_CODE (op01
) == INTEGER_CST
3207 && TYPE_SIZE_UNIT (TREE_TYPE (op00
))
3208 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (op00
))) == INTEGER_CST
)
3210 tree type
= TREE_TYPE (op00
);
3211 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (op00
, 1));
3212 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (op00
, 0)));
3213 /* Don't fold an out-of-bound access. */
3214 if (!tree_int_cst_le (t
, nelts
))
3216 op01
= cp_fold_convert (ssizetype
, op01
);
3217 /* Don't fold if op01 can't be divided exactly by TYPE_SIZE_UNIT.
3218 constexpr int A[1]; ... (char *)&A[0] + 1 */
3219 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
3220 op01
, TYPE_SIZE_UNIT (type
))))
3222 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
3224 op01
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, op01
,
3225 TYPE_SIZE_UNIT (type
));
3226 t
= size_binop_loc (loc
, PLUS_EXPR
, op01
, t
);
3227 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (op00
, 0),
3228 t
, NULL_TREE
, NULL_TREE
);
3229 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
3230 t
= cp_fold_convert (orig_type
, t
);
3231 return cxx_eval_constant_expression (ctx
, t
, lval
, non_constant_p
,
3238 /* Attempt to reduce the expression T to a constant value.
3239 On failure, issue diagnostic and return error_mark_node. */
3240 /* FIXME unify with c_fully_fold */
3241 /* FIXME overflow_p is too global */
3244 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3246 bool *non_constant_p
, bool *overflow_p
,
3249 constexpr_ctx new_ctx
;
3252 if (t
== error_mark_node
)
3254 *non_constant_p
= true;
3257 if (CONSTANT_CLASS_P (t
))
3259 if (TREE_OVERFLOW (t
) && (!flag_permissive
|| ctx
->quiet
))
3264 switch (TREE_CODE (t
))
3269 /* We ask for an rvalue for the RESULT_DECL when indirecting
3270 through an invisible reference, or in named return value
3272 return (*ctx
->values
->get (t
));
3276 /* We used to not check lval for CONST_DECL, but darwin.c uses
3277 CONST_DECL for aggregate constants. */
3281 r
= decl_really_constant_value (t
);
3283 r
= decl_constant_value (t
);
3284 if (TREE_CODE (r
) == TARGET_EXPR
3285 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3286 r
= TARGET_EXPR_INITIAL (r
);
3288 if (tree
*p
= ctx
->values
->get (r
))
3289 if (*p
!= NULL_TREE
)
3294 non_const_var_error (r
);
3295 *non_constant_p
= true;
3303 case CASE_LABEL_EXPR
:
3307 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
3309 else if (tree
*p
= ctx
->values
->get (r
))
3312 /* Defer in case this is only used for its type. */;
3313 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3314 /* Defer, there's no lvalue->rvalue conversion. */;
3315 else if (is_empty_class (TREE_TYPE (t
)))
3317 /* If the class is empty, we aren't actually loading anything. */
3318 r
= build_constructor (TREE_TYPE (t
), NULL
);
3319 TREE_CONSTANT (r
) = true;
3324 error ("%qE is not a constant expression", t
);
3325 *non_constant_p
= true;
3330 case AGGR_INIT_EXPR
:
3331 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3332 non_constant_p
, overflow_p
);
3337 r
= DECL_EXPR_DECL (t
);
3338 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3339 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3343 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3344 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3345 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3349 if (tree init
= DECL_INITIAL (r
))
3351 init
= cxx_eval_constant_expression (ctx
, init
,
3353 non_constant_p
, overflow_p
);
3354 ctx
->values
->put (r
, init
);
3356 else if (ctx
== &new_ctx
)
3357 /* We gave it a CONSTRUCTOR above. */;
3359 ctx
->values
->put (r
, NULL_TREE
);
3364 if (!literal_type_p (TREE_TYPE (t
)))
3368 error ("temporary of non-literal type %qT in a "
3369 "constant expression", TREE_TYPE (t
));
3370 explain_non_literal_class (TREE_TYPE (t
));
3372 *non_constant_p
= true;
3375 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3377 /* We're being expanded without an explicit target, so start
3378 initializing a new object; expansion with an explicit target
3379 strips the TARGET_EXPR before we get here. */
3381 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3382 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3383 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3384 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3387 /* Pass false for 'lval' because this indicates
3388 initialization of a temporary. */
3389 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3391 non_constant_p
, overflow_p
);
3392 if (!*non_constant_p
)
3393 /* Adjust the type of the result to the type of the temporary. */
3394 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3397 tree slot
= TARGET_EXPR_SLOT (t
);
3398 ctx
->values
->put (slot
, r
);
3405 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3406 non_constant_p
, overflow_p
);
3410 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3412 non_constant_p
, overflow_p
);
3416 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
3417 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3419 non_constant_p
, overflow_p
);
3424 /* Avoid evaluating a SAVE_EXPR more than once. */
3425 if (tree
*p
= ctx
->values
->get (t
))
3429 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3430 non_constant_p
, overflow_p
);
3431 ctx
->values
->put (t
, r
);
3435 case NON_LVALUE_EXPR
:
3436 case TRY_CATCH_EXPR
:
3438 case CLEANUP_POINT_EXPR
:
3439 case MUST_NOT_THROW_EXPR
:
3442 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3444 non_constant_p
, overflow_p
,
3448 case TRY_FINALLY_EXPR
:
3449 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
3450 non_constant_p
, overflow_p
,
3452 if (!*non_constant_p
)
3453 /* Also evaluate the cleanup. */
3454 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
3455 non_constant_p
, overflow_p
,
3459 /* These differ from cxx_eval_unary_expression in that this doesn't
3460 check for a constant operand or result; an address can be
3461 constant without its operand being, and vice versa. */
3464 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3465 non_constant_p
, overflow_p
);
3470 tree oldop
= TREE_OPERAND (t
, 0);
3471 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3473 non_constant_p
, overflow_p
);
3474 /* Don't VERIFY_CONSTANT here. */
3475 if (*non_constant_p
)
3477 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3478 /* This function does more aggressive folding than fold itself. */
3479 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3480 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3488 case FIX_TRUNC_EXPR
:
3493 case TRUTH_NOT_EXPR
:
3494 case FIXED_CONVERT_EXPR
:
3495 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3496 non_constant_p
, overflow_p
);
3500 r
= fold_sizeof_expr (t
);
3501 VERIFY_CONSTANT (r
);
3506 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3507 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3508 introduced by build_call_a. */
3509 tree op0
= TREE_OPERAND (t
, 0);
3510 tree op1
= TREE_OPERAND (t
, 1);
3512 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3513 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3514 r
= cxx_eval_constant_expression (ctx
, op0
,
3515 lval
, non_constant_p
, overflow_p
,
3519 /* Check that the LHS is constant and then discard it. */
3520 cxx_eval_constant_expression (ctx
, op0
,
3521 true, non_constant_p
, overflow_p
,
3523 op1
= TREE_OPERAND (t
, 1);
3524 r
= cxx_eval_constant_expression (ctx
, op1
,
3525 lval
, non_constant_p
, overflow_p
,
3531 case POINTER_PLUS_EXPR
:
3532 r
= cxx_eval_pointer_plus_expression (ctx
, t
, lval
, non_constant_p
,
3536 /* else fall through */
3541 case TRUNC_DIV_EXPR
:
3543 case FLOOR_DIV_EXPR
:
3544 case ROUND_DIV_EXPR
:
3545 case TRUNC_MOD_EXPR
:
3547 case ROUND_MOD_EXPR
:
3549 case EXACT_DIV_EXPR
:
3559 case TRUTH_XOR_EXPR
:
3566 case UNORDERED_EXPR
:
3576 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3577 non_constant_p
, overflow_p
);
3580 /* fold can introduce non-IF versions of these; still treat them as
3581 short-circuiting. */
3582 case TRUTH_AND_EXPR
:
3583 case TRUTH_ANDIF_EXPR
:
3584 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
3587 non_constant_p
, overflow_p
);
3591 case TRUTH_ORIF_EXPR
:
3592 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
3595 non_constant_p
, overflow_p
);
3599 r
= cxx_eval_array_reference (ctx
, t
, lval
,
3600 non_constant_p
, overflow_p
);
3604 if (is_overloaded_fn (t
))
3606 /* We can only get here in checking mode via
3607 build_non_dependent_expr, because any expression that
3608 calls or takes the address of the function will have
3609 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3610 gcc_checking_assert (ctx
->quiet
|| errorcount
);
3611 *non_constant_p
= true;
3614 r
= cxx_eval_component_reference (ctx
, t
, lval
,
3615 non_constant_p
, overflow_p
);
3619 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
3620 non_constant_p
, overflow_p
);
3625 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
3626 non_constant_p
, overflow_p
,
3631 if (TREE_CONSTANT (t
))
3633 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3634 VECTOR_CST if applicable. */
3635 /* FIXME after GCC 6 branches, make the verify unconditional. */
3637 verify_constructor_flags (t
);
3639 recompute_constructor_flags (t
);
3640 if (TREE_CONSTANT (t
))
3643 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
3644 non_constant_p
, overflow_p
);
3648 /* We can get this in a defaulted constructor for a class with a
3649 non-static data member of array type. Either the initializer will
3650 be NULL, meaning default-initialization, or it will be an lvalue
3651 or xvalue of the same type, meaning direct-initialization from the
3652 corresponding member. */
3653 r
= cxx_eval_vec_init (ctx
, t
, lval
,
3654 non_constant_p
, overflow_p
);
3659 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
3660 non_constant_p
, overflow_p
);
3664 case VIEW_CONVERT_EXPR
:
3666 case UNARY_PLUS_EXPR
:
3668 enum tree_code tcode
= TREE_CODE (t
);
3669 tree oldop
= TREE_OPERAND (t
, 0);
3671 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3673 non_constant_p
, overflow_p
);
3674 if (*non_constant_p
)
3676 tree type
= TREE_TYPE (t
);
3677 if (TREE_CODE (op
) == PTRMEM_CST
3678 && !TYPE_PTRMEM_P (type
))
3679 op
= cplus_expand_constant (op
);
3680 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
3682 if (same_type_ignoring_top_level_qualifiers_p (type
,
3688 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3689 "a reinterpret_cast is not a constant-expression");
3690 *non_constant_p
= true;
3694 if (POINTER_TYPE_P (type
)
3695 && TREE_CODE (op
) == INTEGER_CST
3696 && !integer_zerop (op
))
3699 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3700 "reinterpret_cast from integer to pointer");
3701 *non_constant_p
= true;
3704 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
3705 /* We didn't fold at the top so we could check for ptr-int
3708 if (tcode
== UNARY_PLUS_EXPR
)
3709 r
= fold_convert (TREE_TYPE (t
), op
);
3711 r
= fold_build1 (tcode
, type
, op
);
3712 /* Conversion of an out-of-range value has implementation-defined
3713 behavior; the language considers it different from arithmetic
3714 overflow, which is undefined. */
3715 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
3716 TREE_OVERFLOW (r
) = false;
3720 case EMPTY_CLASS_EXPR
:
3721 /* This is good enough for a function argument that might not get
3722 used, and they can't do anything with it, so just return it. */
3725 case STATEMENT_LIST
:
3727 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3728 return cxx_eval_statement_list (&new_ctx
, t
,
3729 non_constant_p
, overflow_p
, jump_target
);
3732 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
3734 non_constant_p
, overflow_p
,
3737 case PREINCREMENT_EXPR
:
3738 case POSTINCREMENT_EXPR
:
3739 case PREDECREMENT_EXPR
:
3740 case POSTDECREMENT_EXPR
:
3741 return cxx_eval_increment_expression (ctx
, t
,
3742 lval
, non_constant_p
, overflow_p
);
3748 case VEC_DELETE_EXPR
:
3751 /* GCC internal stuff. */
3754 case WITH_CLEANUP_EXPR
:
3755 case NON_DEPENDENT_EXPR
:
3759 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3760 "expression %qE is not a constant-expression", t
);
3761 *non_constant_p
= true;
3764 case PLACEHOLDER_EXPR
:
3765 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
)
3766 || !(same_type_ignoring_top_level_qualifiers_p
3767 (TREE_TYPE (t
), TREE_TYPE (ctx
->ctor
))))
3769 /* A placeholder without a referent. We can get here when
3770 checking whether NSDMIs are noexcept, or in massage_init_elt;
3771 just say it's non-constant for now. */
3772 gcc_assert (ctx
->quiet
);
3773 *non_constant_p
= true;
3778 /* Use of the value or address of the current object. We could
3779 use ctx->object unconditionally, but using ctx->ctor when we
3780 can is a minor optimization. */
3781 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
3782 return cxx_eval_constant_expression
3784 non_constant_p
, overflow_p
);
3789 *jump_target
= TREE_OPERAND (t
, 0);
3790 gcc_assert (breaks (jump_target
) || continues (jump_target
));
3794 cxx_eval_loop_expr (ctx
, t
,
3795 non_constant_p
, overflow_p
, jump_target
);
3799 cxx_eval_switch_expr (ctx
, t
,
3800 non_constant_p
, overflow_p
, jump_target
);
3804 /* It's possible to get a requires-expression in a constant
3805 expression. For example:
3807 template<typename T> concept bool C() {
3808 return requires (T t) { t; };
3811 template<typename T> requires !C<T>() void f(T);
3813 Normalization leaves f with the associated constraint
3814 '!requires (T t) { ... }' which is not transformed into
3816 if (!processing_template_decl
)
3817 return evaluate_constraint_expression (t
, NULL_TREE
);
3819 *non_constant_p
= true;
3823 if (STATEMENT_CODE_P (TREE_CODE (t
)))
3825 /* This function doesn't know how to deal with pre-genericize
3826 statements; this can only happen with statement-expressions,
3827 so for now just fail. */
3829 error_at (EXPR_LOCATION (t
),
3830 "statement is not a constant-expression");
3833 internal_error ("unexpected expression %qE of kind %s", t
,
3834 get_tree_code_name (TREE_CODE (t
)));
3835 *non_constant_p
= true;
3839 if (r
== error_mark_node
)
3840 *non_constant_p
= true;
3842 if (*non_constant_p
)
3849 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
3850 bool strict
= true, tree object
= NULL_TREE
)
3852 bool non_constant_p
= false;
3853 bool overflow_p
= false;
3854 hash_map
<tree
,tree
> map
;
3855 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, allow_non_constant
, strict
};
3856 tree type
= initialized_type (t
);
3858 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3860 /* In C++14 an NSDMI can participate in aggregate initialization,
3861 and can refer to the address of the object being initialized, so
3862 we need to pass in the relevant VAR_DECL if we want to do the
3863 evaluation in a single pass. The evaluation will dynamically
3864 update ctx.values for the VAR_DECL. We use the same strategy
3865 for C++11 constexpr constructors that refer to the object being
3867 ctx
.ctor
= build_constructor (type
, NULL
);
3868 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
3871 if (TREE_CODE (t
) == TARGET_EXPR
)
3872 object
= TARGET_EXPR_SLOT (t
);
3873 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3874 object
= AGGR_INIT_EXPR_SLOT (t
);
3876 ctx
.object
= object
;
3878 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3879 (type
, TREE_TYPE (object
)));
3880 if (object
&& DECL_P (object
))
3881 map
.put (object
, ctx
.ctor
);
3882 if (TREE_CODE (r
) == TARGET_EXPR
)
3883 /* Avoid creating another CONSTRUCTOR when we expand the
3885 r
= TARGET_EXPR_INITIAL (r
);
3888 r
= cxx_eval_constant_expression (&ctx
, r
,
3889 false, &non_constant_p
, &overflow_p
);
3891 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
3893 /* Mutable logic is a bit tricky: we want to allow initialization of
3894 constexpr variables with mutable members, but we can't copy those
3895 members to another constexpr variable. */
3896 if (TREE_CODE (r
) == CONSTRUCTOR
3897 && CONSTRUCTOR_MUTABLE_POISON (r
))
3899 if (!allow_non_constant
)
3900 error ("%qE is not a constant expression because it refers to "
3901 "mutable subobjects of %qT", t
, type
);
3902 non_constant_p
= true;
3905 /* Technically we should check this for all subexpressions, but that
3906 runs into problems with our internal representation of pointer
3907 subtraction and the 5.19 rules are still in flux. */
3908 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
3909 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
3910 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
3912 if (!allow_non_constant
)
3913 error ("conversion from pointer type %qT "
3914 "to arithmetic type %qT in a constant-expression",
3915 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
3916 non_constant_p
= true;
3919 if (!non_constant_p
&& overflow_p
)
3920 non_constant_p
= true;
3922 if (non_constant_p
&& !allow_non_constant
)
3923 return error_mark_node
;
3924 else if (non_constant_p
&& TREE_CONSTANT (r
))
3926 /* This isn't actually constant, so unset TREE_CONSTANT. */
3929 else if (TREE_CODE (r
) == CONSTRUCTOR
)
3930 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
3932 r
= build_nop (TREE_TYPE (r
), r
);
3933 TREE_CONSTANT (r
) = false;
3935 else if (non_constant_p
|| r
== t
)
3938 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
3940 if (TREE_CODE (t
) == TARGET_EXPR
3941 && TARGET_EXPR_INITIAL (t
) == r
)
3945 r
= get_target_expr (r
);
3946 TREE_CONSTANT (r
) = true;
3954 /* Returns true if T is a valid subexpression of a constant expression,
3955 even if it isn't itself a constant expression. */
3958 is_sub_constant_expr (tree t
)
3960 bool non_constant_p
= false;
3961 bool overflow_p
= false;
3962 hash_map
<tree
, tree
> map
;
3963 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, true, true };
3964 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
3966 return !non_constant_p
&& !overflow_p
;
3969 /* If T represents a constant expression returns its reduced value.
3970 Otherwise return error_mark_node. If T is dependent, then
3974 cxx_constant_value (tree t
, tree decl
)
3976 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
3979 /* Helper routine for fold_simple function. Either return simplified
3980 expression T, otherwise NULL_TREE.
3981 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
3982 even if we are within template-declaration. So be careful on call, as in
3983 such case types can be undefined. */
3986 fold_simple_1 (tree t
)
3989 enum tree_code code
= TREE_CODE (t
);
4001 return fold_sizeof_expr (t
);
4009 case TRUTH_NOT_EXPR
:
4011 case VIEW_CONVERT_EXPR
:
4014 case FIX_TRUNC_EXPR
:
4015 case FIXED_CONVERT_EXPR
:
4016 case ADDR_SPACE_CONVERT_EXPR
:
4018 op1
= TREE_OPERAND (t
, 0);
4020 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4024 if (CONVERT_EXPR_CODE_P (code
)
4025 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4026 TREE_OVERFLOW (t
) = false;
4034 /* If T is a simple constant expression, returns its simplified value.
4035 Otherwise returns T. In contrast to maybe_constant_value do we
4036 simplify only few operations on constant-expressions, and we don't
4037 try to simplify constexpressions. */
4040 fold_simple (tree t
)
4043 if (processing_template_decl
)
4046 r
= fold_simple_1 (t
);
4053 /* If T is a constant expression, returns its reduced value.
4054 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4055 Otherwise, returns a version of T without TREE_CONSTANT. */
4058 maybe_constant_value_1 (tree t
, tree decl
)
4062 if (instantiation_dependent_expression_p (t
)
4063 || type_unknown_p (t
)
4064 || BRACE_ENCLOSED_INITIALIZER_P (t
)
4065 || !potential_constant_expression (t
))
4067 if (TREE_OVERFLOW_P (t
))
4069 t
= build_nop (TREE_TYPE (t
), t
);
4070 TREE_CONSTANT (t
) = false;
4075 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4076 gcc_checking_assert (r
== t
4077 || CONVERT_EXPR_P (t
)
4078 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4079 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4080 || !cp_tree_equal (r
, t
));
4084 static GTY((cache
, deletable
)) cache_map cv_cache
;
4086 /* If T is a constant expression, returns its reduced value.
4087 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4088 Otherwise, returns a version of T without TREE_CONSTANT. */
4091 maybe_constant_value (tree t
, tree decl
)
4093 tree ret
= cv_cache
.get (t
);
4096 ret
= maybe_constant_value_1 (t
, decl
);
4097 cv_cache
.put (t
, ret
);
4102 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4105 clear_cv_and_fold_caches (void)
4107 gt_cleare_cache (cv_cache
);
4108 clear_fold_cache ();
4111 /* Like maybe_constant_value but first fully instantiate the argument.
4113 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4114 (t, tf_none) followed by maybe_constant_value but is more efficient,
4115 because calls instantiation_dependent_expression_p and
4116 potential_constant_expression at most once. */
4119 fold_non_dependent_expr (tree t
)
4124 /* If we're in a template, but T isn't value dependent, simplify
4125 it. We're supposed to treat:
4127 template <typename T> void f(T[1 + 1]);
4128 template <typename T> void f(T[2]);
4130 as two declarations of the same function, for example. */
4131 if (processing_template_decl
)
4133 if (!instantiation_dependent_expression_p (t
)
4134 && potential_constant_expression (t
))
4136 processing_template_decl_sentinel s
;
4137 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4139 if (type_unknown_p (t
)
4140 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4142 if (TREE_OVERFLOW_P (t
))
4144 t
= build_nop (TREE_TYPE (t
), t
);
4145 TREE_CONSTANT (t
) = false;
4150 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4151 /* cp_tree_equal looks through NOPs, so allow them. */
4152 gcc_checking_assert (r
== t
4153 || CONVERT_EXPR_P (t
)
4154 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4155 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4156 || !cp_tree_equal (r
, t
));
4159 else if (TREE_OVERFLOW_P (t
))
4161 t
= build_nop (TREE_TYPE (t
), t
);
4162 TREE_CONSTANT (t
) = false;
4167 return maybe_constant_value (t
);
4170 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4171 than wrapped in a TARGET_EXPR. */
4174 maybe_constant_init (tree t
, tree decl
)
4178 if (TREE_CODE (t
) == EXPR_STMT
)
4179 t
= TREE_OPERAND (t
, 0);
4180 if (TREE_CODE (t
) == CONVERT_EXPR
4181 && VOID_TYPE_P (TREE_TYPE (t
)))
4182 t
= TREE_OPERAND (t
, 0);
4183 if (TREE_CODE (t
) == INIT_EXPR
)
4184 t
= TREE_OPERAND (t
, 1);
4185 if (instantiation_dependent_expression_p (t
)
4186 || type_unknown_p (t
)
4187 || BRACE_ENCLOSED_INITIALIZER_P (t
)
4188 || !potential_static_init_expression (t
))
4189 /* Don't try to evaluate it. */;
4191 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
4192 if (TREE_CODE (t
) == TARGET_EXPR
)
4194 tree init
= TARGET_EXPR_INITIAL (t
);
4195 if (TREE_CODE (init
) == CONSTRUCTOR
)
4202 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
4203 /* Return true if the object referred to by REF has automatic or thread
4206 enum { ck_ok
, ck_bad
, ck_unknown
};
4208 check_automatic_or_tls (tree ref
)
4211 HOST_WIDE_INT bitsize
, bitpos
;
4213 int volatilep
= 0, unsignedp
= 0;
4214 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
4215 &mode
, &unsignedp
, &volatilep
, false);
4218 /* If there isn't a decl in the middle, we don't know the linkage here,
4219 and this isn't a constant expression anyway. */
4222 dk
= decl_storage_duration (decl
);
4223 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
4227 /* Return true if T denotes a potentially constant expression. Issue
4228 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
4229 an lvalue-rvalue conversion is implied.
4231 C++0x [expr.const] used to say
4233 6 An expression is a potential constant expression if it is
4234 a constant expression where all occurrences of function
4235 parameters are replaced by arbitrary constant expressions
4236 of the appropriate type.
4238 2 A conditional expression is a constant expression unless it
4239 involves one of the following as a potentially evaluated
4240 subexpression (3.2), but subexpressions of logical AND (5.14),
4241 logical OR (5.15), and conditional (5.16) operations that are
4242 not evaluated are not considered. */
4245 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
4246 tsubst_flags_t flags
)
4248 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
4249 enum { any
= false, rval
= true };
4253 if (t
== error_mark_node
)
4257 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
4259 if (flags
& tf_error
)
4260 error ("expression %qE has side-effects", t
);
4263 if (CONSTANT_CLASS_P (t
))
4266 switch (TREE_CODE (t
))
4272 case TEMPLATE_ID_EXPR
:
4275 case CASE_LABEL_EXPR
:
4281 case TEMPLATE_PARM_INDEX
:
4283 case IDENTIFIER_NODE
:
4284 case USERDEF_LITERAL
:
4285 /* We can see a FIELD_DECL in a pointer-to-member expression. */
4291 case PLACEHOLDER_EXPR
:
4297 case AGGR_INIT_EXPR
:
4299 /* -- an invocation of a function other than a constexpr function
4300 or a constexpr constructor. */
4302 tree fun
= get_function_named_in_call (t
);
4303 const int nargs
= call_expr_nargs (t
);
4306 if (fun
== NULL_TREE
)
4308 if (TREE_CODE (t
) == CALL_EXPR
4309 && CALL_EXPR_FN (t
) == NULL_TREE
)
4310 switch (CALL_EXPR_IFN (t
))
4312 /* These should be ignored, they are optimized away from
4313 constexpr functions. */
4314 case IFN_UBSAN_NULL
:
4315 case IFN_UBSAN_BOUNDS
:
4316 case IFN_UBSAN_VPTR
:
4321 /* fold_call_expr can't do anything with IFN calls. */
4322 if (flags
& tf_error
)
4323 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4324 "call to internal function");
4327 if (is_overloaded_fn (fun
))
4329 if (TREE_CODE (fun
) == FUNCTION_DECL
)
4331 if (builtin_valid_in_constant_expr_p (fun
))
4333 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
4334 /* Allow any built-in function; if the expansion
4335 isn't constant, we'll deal with that then. */
4336 && !is_builtin_fn (fun
))
4338 if (flags
& tf_error
)
4340 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4341 "call to non-constexpr function %qD", fun
);
4342 explain_invalid_constexpr_fn (fun
);
4346 /* A call to a non-static member function takes the address
4347 of the object as the first argument. But in a constant
4348 expression the address will be folded away, so look
4350 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
4351 && !DECL_CONSTRUCTOR_P (fun
))
4353 tree x
= get_nth_callarg (t
, 0);
4354 if (is_this_parameter (x
))
4356 else if (!RECUR (x
, rval
))
4363 if (!RECUR (fun
, true))
4365 fun
= get_first_fn (fun
);
4367 /* Skip initial arguments to base constructors. */
4368 if (DECL_BASE_CONSTRUCTOR_P (fun
))
4369 i
= num_artificial_parms_for (fun
);
4370 fun
= DECL_ORIGIN (fun
);
4374 if (RECUR (fun
, rval
))
4375 /* Might end up being a constant function pointer. */;
4379 for (; i
< nargs
; ++i
)
4381 tree x
= get_nth_callarg (t
, i
);
4382 /* In a template, reference arguments haven't been converted to
4383 REFERENCE_TYPE and we might not even know if the parameter
4384 is a reference, so accept lvalue constants too. */
4385 bool rv
= processing_template_decl
? any
: rval
;
4392 case NON_LVALUE_EXPR
:
4393 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
4394 -- an lvalue of integral type that refers to a non-volatile
4395 const variable or static data member initialized with
4396 constant expressions, or
4398 -- an lvalue of literal type that refers to non-volatile
4399 object defined with constexpr, or that refers to a
4400 sub-object of such an object; */
4401 return RECUR (TREE_OPERAND (t
, 0), rval
);
4405 && !decl_constant_var_p (t
)
4407 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
4408 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
4409 && !var_in_constexpr_fn (t
)
4410 && !type_dependent_expression_p (t
))
4412 if (flags
& tf_error
)
4413 non_const_var_error (t
);
4420 case VIEW_CONVERT_EXPR
:
4421 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4422 may change to something more specific to type-punning (DR 1312). */
4424 tree from
= TREE_OPERAND (t
, 0);
4425 if (POINTER_TYPE_P (TREE_TYPE (t
))
4426 && TREE_CODE (from
) == INTEGER_CST
4427 && !integer_zerop (from
))
4429 if (flags
& tf_error
)
4430 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4431 "reinterpret_cast from integer to pointer");
4434 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
4438 /* -- a unary operator & that is applied to an lvalue that
4439 designates an object with thread or automatic storage
4441 t
= TREE_OPERAND (t
, 0);
4443 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
4444 /* A pointer-to-member constant. */
4448 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4449 any checking here, as we might dereference the pointer later. If
4450 we remove this code, also remove check_automatic_or_tls. */
4451 i
= check_automatic_or_tls (t
);
4456 if (flags
& tf_error
)
4457 error ("address-of an object %qE with thread local or "
4458 "automatic storage is not a constant expression", t
);
4462 return RECUR (t
, any
);
4468 /* -- a class member access unless its postfix-expression is
4469 of literal type or of pointer to literal type. */
4470 /* This test would be redundant, as it follows from the
4471 postfix-expression being a potential constant expression. */
4472 if (type_unknown_p (t
))
4474 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4476 case EXPR_PACK_EXPANSION
:
4477 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
4481 tree x
= TREE_OPERAND (t
, 0);
4483 if (is_this_parameter (x
))
4485 if (DECL_CONTEXT (x
)
4486 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4488 if (flags
& tf_error
)
4489 error ("use of %<this%> in a constant expression");
4494 return RECUR (x
, rval
);
4497 case STATEMENT_LIST
:
4499 tree_stmt_iterator i
;
4500 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4502 if (!RECUR (tsi_stmt (i
), any
))
4510 if (cxx_dialect
< cxx14
)
4512 if (!RECUR (TREE_OPERAND (t
, 0), any
))
4514 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
4519 if (cxx_dialect
< cxx14
)
4521 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
4523 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
4528 if (!RECUR (DO_COND (t
), rval
))
4530 if (!RECUR (DO_BODY (t
), any
))
4535 if (!RECUR (FOR_INIT_STMT (t
), any
))
4537 if (!RECUR (FOR_COND (t
), rval
))
4539 if (!RECUR (FOR_EXPR (t
), any
))
4541 if (!RECUR (FOR_BODY (t
), any
))
4546 if (!RECUR (WHILE_COND (t
), rval
))
4548 if (!RECUR (WHILE_BODY (t
), any
))
4553 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
4555 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
4556 unreachable labels would be checked. */
4560 return RECUR (STMT_EXPR_STMT (t
), rval
);
4563 case DYNAMIC_CAST_EXPR
:
4564 case PSEUDO_DTOR_EXPR
:
4568 case VEC_DELETE_EXPR
:
4571 case OMP_ATOMIC_READ
:
4572 case OMP_ATOMIC_CAPTURE_OLD
:
4573 case OMP_ATOMIC_CAPTURE_NEW
:
4574 /* GCC internal stuff. */
4577 case TRANSACTION_EXPR
:
4579 case AT_ENCODE_EXPR
:
4581 if (flags
& tf_error
)
4582 error ("expression %qE is not a constant-expression", t
);
4586 /* -- a typeid expression whose operand is of polymorphic
4589 tree e
= TREE_OPERAND (t
, 0);
4590 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
4591 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
4593 if (flags
& tf_error
)
4594 error ("typeid-expression is not a constant expression "
4595 "because %qE is of polymorphic type", e
);
4614 case PREINCREMENT_EXPR
:
4615 case POSTINCREMENT_EXPR
:
4616 case PREDECREMENT_EXPR
:
4617 case POSTDECREMENT_EXPR
:
4618 if (cxx_dialect
< cxx14
)
4624 if (TYPE_P (TREE_OPERAND (t
, 0)))
4626 /* else fall through. */
4632 case FIX_TRUNC_EXPR
:
4636 case TRUTH_NOT_EXPR
:
4637 case FIXED_CONVERT_EXPR
:
4638 case UNARY_PLUS_EXPR
:
4639 case UNARY_LEFT_FOLD_EXPR
:
4640 case UNARY_RIGHT_FOLD_EXPR
:
4642 return RECUR (TREE_OPERAND (t
, 0), rval
);
4645 case CONST_CAST_EXPR
:
4646 case STATIC_CAST_EXPR
:
4647 case REINTERPRET_CAST_EXPR
:
4648 case IMPLICIT_CONV_EXPR
:
4649 if (cxx_dialect
< cxx11
4650 && !dependent_type_p (TREE_TYPE (t
))
4651 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
4652 /* In C++98, a conversion to non-integral type can't be part of a
4653 constant expression. */
4655 if (flags
& tf_error
)
4656 error ("cast to non-integral type %qT in a constant expression",
4661 return (RECUR (TREE_OPERAND (t
, 0),
4662 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
4665 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
4667 case WITH_CLEANUP_EXPR
:
4668 case CLEANUP_POINT_EXPR
:
4669 case MUST_NOT_THROW_EXPR
:
4670 case TRY_CATCH_EXPR
:
4676 case NON_DEPENDENT_EXPR
:
4677 /* For convenience. */
4679 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4681 case TRY_FINALLY_EXPR
:
4682 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
4683 && RECUR (TREE_OPERAND (t
, 1), any
));
4686 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4689 if (!literal_type_p (TREE_TYPE (t
)))
4691 if (flags
& tf_error
)
4693 error ("temporary of non-literal type %qT in a "
4694 "constant expression", TREE_TYPE (t
));
4695 explain_non_literal_class (TREE_TYPE (t
));
4700 return RECUR (TREE_OPERAND (t
, 1), rval
);
4704 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4705 constructor_elt
*ce
;
4706 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4707 if (!RECUR (ce
->value
, want_rval
))
4714 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
4715 || DECL_P (TREE_PURPOSE (t
)));
4716 if (!RECUR (TREE_VALUE (t
), want_rval
))
4718 if (TREE_CHAIN (t
) == NULL_TREE
)
4720 return RECUR (TREE_CHAIN (t
), want_rval
);
4723 case TRUNC_DIV_EXPR
:
4725 case FLOOR_DIV_EXPR
:
4726 case ROUND_DIV_EXPR
:
4727 case TRUNC_MOD_EXPR
:
4729 case ROUND_MOD_EXPR
:
4731 tree denom
= TREE_OPERAND (t
, 1);
4732 if (!RECUR (denom
, rval
))
4734 /* We can't call cxx_eval_outermost_constant_expr on an expression
4735 that hasn't been through instantiate_non_dependent_expr yet. */
4736 if (!processing_template_decl
)
4737 denom
= cxx_eval_outermost_constant_expr (denom
, true);
4738 if (integer_zerop (denom
))
4740 if (flags
& tf_error
)
4741 error ("division by zero is not a constant-expression");
4747 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4753 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4754 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4755 introduced by build_call_a. */
4756 tree op0
= TREE_OPERAND (t
, 0);
4757 tree op1
= TREE_OPERAND (t
, 1);
4759 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4760 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4761 return RECUR (op0
, want_rval
);
4766 /* If the first operand is the non-short-circuit constant, look at
4767 the second operand; otherwise we only care about the first one for
4769 case TRUTH_AND_EXPR
:
4770 case TRUTH_ANDIF_EXPR
:
4771 tmp
= boolean_true_node
;
4774 case TRUTH_ORIF_EXPR
:
4775 tmp
= boolean_false_node
;
4778 tree op
= TREE_OPERAND (t
, 0);
4779 if (!RECUR (op
, rval
))
4781 if (!processing_template_decl
)
4782 op
= cxx_eval_outermost_constant_expr (op
, true);
4783 if (tree_int_cst_equal (op
, tmp
))
4784 return RECUR (TREE_OPERAND (t
, 1), rval
);
4791 case POINTER_PLUS_EXPR
:
4793 case EXACT_DIV_EXPR
:
4803 case TRUTH_XOR_EXPR
:
4804 case UNORDERED_EXPR
:
4817 case ARRAY_RANGE_REF
:
4821 case BINARY_LEFT_FOLD_EXPR
:
4822 case BINARY_RIGHT_FOLD_EXPR
:
4824 for (i
= 0; i
< 2; ++i
)
4825 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
4829 case CILK_SYNC_STMT
:
4830 case CILK_SPAWN_STMT
:
4831 case ARRAY_NOTATION_REF
:
4836 for (i
= 0; i
< 3; ++i
)
4837 if (!RECUR (TREE_OPERAND (t
, i
), true))
4844 /* If the condition is a known constant, we know which of the legs we
4845 care about; otherwise we only require that the condition and
4846 either of the legs be potentially constant. */
4847 tmp
= TREE_OPERAND (t
, 0);
4848 if (!RECUR (tmp
, rval
))
4850 if (!processing_template_decl
)
4851 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
4852 if (integer_zerop (tmp
))
4853 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
4854 else if (TREE_CODE (tmp
) == INTEGER_CST
)
4855 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4856 for (i
= 1; i
< 3; ++i
)
4857 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
4858 want_rval
, strict
, tf_none
))
4860 if (flags
& tf_error
)
4861 error ("expression %qE is not a constant-expression", t
);
4865 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
4867 if (flags
& tf_error
)
4869 error ("non-constant array initialization");
4870 diagnose_non_constexpr_vec_init (t
);
4876 /* We can see these in statement-expressions. */
4879 case EMPTY_CLASS_EXPR
:
4883 if (objc_is_property_ref (t
))
4886 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
4893 /* The main entry point to the above. */
4896 potential_constant_expression (tree t
)
4898 return potential_constant_expression_1 (t
, false, true, tf_none
);
4902 potential_static_init_expression (tree t
)
4904 return potential_constant_expression_1 (t
, false, false, tf_none
);
4907 /* As above, but require a constant rvalue. */
4910 potential_rvalue_constant_expression (tree t
)
4912 return potential_constant_expression_1 (t
, true, true, tf_none
);
4915 /* Like above, but complain about non-constant expressions. */
4918 require_potential_constant_expression (tree t
)
4920 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
4923 /* Cross product of the above. */
4926 require_potential_rvalue_constant_expression (tree t
)
4928 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
4931 #include "gt-cp-constexpr.h"