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-2015 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"
29 #include "double-int.h"
39 #include "c-family/c-objc.h"
40 #include "tree-iterator.h"
43 #include "tree-inline.h"
46 static bool verify_constant (tree
, bool, bool *, bool *);
47 #define VERIFY_CONSTANT(X) \
49 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
53 /* Returns true iff FUN is an instantiation of a constexpr function
54 template or a defaulted constexpr function. */
57 is_instantiation_of_constexpr (tree fun
)
59 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
60 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
61 || (DECL_DEFAULTED_FN (fun
)
62 && DECL_DECLARED_CONSTEXPR_P (fun
)));
65 /* Return true if T is a literal type. */
68 literal_type_p (tree t
)
71 || TREE_CODE (t
) == VECTOR_TYPE
72 || TREE_CODE (t
) == REFERENCE_TYPE
73 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
77 t
= complete_type (t
);
78 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
79 return CLASSTYPE_LITERAL_P (t
);
81 if (TREE_CODE (t
) == ARRAY_TYPE
)
82 return literal_type_p (strip_array_types (t
));
86 /* If DECL is a variable declared `constexpr', require its type
87 be literal. Return the DECL if OK, otherwise NULL. */
90 ensure_literal_type_for_constexpr_object (tree decl
)
92 tree type
= TREE_TYPE (decl
);
94 && (DECL_DECLARED_CONSTEXPR_P (decl
)
95 || var_in_constexpr_fn (decl
))
96 && !processing_template_decl
)
98 tree stype
= strip_array_types (type
);
99 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
100 /* Don't complain here, we'll complain about incompleteness
101 when we try to initialize the variable. */;
102 else if (!literal_type_p (type
))
104 if (DECL_DECLARED_CONSTEXPR_P (decl
))
106 error ("the type %qT of constexpr variable %qD is not literal",
108 explain_non_literal_class (type
);
112 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
114 error ("variable %qD of non-literal type %qT in %<constexpr%> "
115 "function", decl
, type
);
116 explain_non_literal_class (type
);
118 cp_function_chain
->invalid_constexpr
= true;
126 /* Representation of entries in the constexpr function definition table. */
128 struct GTY((for_user
)) constexpr_fundef
{
133 struct constexpr_fundef_hasher
: ggc_hasher
<constexpr_fundef
*>
135 static hashval_t
hash (constexpr_fundef
*);
136 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
139 /* This table holds all constexpr function definitions seen in
140 the current translation unit. */
142 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
144 /* Utility function used for managing the constexpr function table.
145 Return true if the entries pointed to by P and Q are for the
146 same constexpr function. */
149 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
151 return lhs
->decl
== rhs
->decl
;
154 /* Utility function used for managing the constexpr function table.
155 Return a hash value for the entry pointed to by Q. */
158 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
160 return DECL_UID (fundef
->decl
);
163 /* Return a previously saved definition of function FUN. */
165 static constexpr_fundef
*
166 retrieve_constexpr_fundef (tree fun
)
168 constexpr_fundef fundef
= { NULL
, NULL
};
169 if (constexpr_fundef_table
== NULL
)
173 return constexpr_fundef_table
->find (&fundef
);
176 /* Check whether the parameter and return types of FUN are valid for a
177 constexpr function, and complain if COMPLAIN. */
180 is_valid_constexpr_fn (tree fun
, bool complain
)
184 if (DECL_INHERITED_CTOR_BASE (fun
)
185 && TREE_CODE (fun
) == TEMPLATE_DECL
)
189 error ("inherited constructor %qD is not constexpr",
190 get_inherited_ctor (fun
));
194 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
195 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
196 if (!literal_type_p (TREE_TYPE (parm
)))
201 error ("invalid type for parameter %d of constexpr "
202 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
203 explain_non_literal_class (TREE_TYPE (parm
));
208 if (!DECL_CONSTRUCTOR_P (fun
))
210 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
211 if (!literal_type_p (rettype
))
216 error ("invalid return type %qT of constexpr function %q+D",
218 explain_non_literal_class (rettype
);
222 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
223 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
228 error ("enclosing class of constexpr non-static member "
229 "function %q+#D is not a literal type", fun
);
230 explain_non_literal_class (DECL_CONTEXT (fun
));
234 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
238 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
244 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
245 for a member of an anonymous aggregate, INIT is the initializer for that
246 member, and VEC_OUTER is the vector of constructor elements for the class
247 whose constructor we are processing. Add the initializer to the vector
248 and return true to indicate success. */
251 build_anon_member_initialization (tree member
, tree init
,
252 vec
<constructor_elt
, va_gc
> **vec_outer
)
254 /* MEMBER presents the relevant fields from the inside out, but we need
255 to build up the initializer from the outside in so that we can reuse
256 previously built CONSTRUCTORs if this is, say, the second field in an
257 anonymous struct. So we use a vec as a stack. */
258 auto_vec
<tree
, 2> fields
;
261 fields
.safe_push (TREE_OPERAND (member
, 1));
262 member
= TREE_OPERAND (member
, 0);
264 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
265 && TREE_CODE (member
) == COMPONENT_REF
);
267 /* VEC has the constructor elements vector for the context of FIELD.
268 If FIELD is an anonymous aggregate, we will push inside it. */
269 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
271 while (field
= fields
.pop(),
272 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
275 /* If there is already an outer constructor entry for the anonymous
276 aggregate FIELD, use it; otherwise, insert one. */
277 if (vec_safe_is_empty (*vec
)
278 || (*vec
)->last().index
!= field
)
280 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
281 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
284 ctor
= (*vec
)->last().value
;
285 vec
= &CONSTRUCTOR_ELTS (ctor
);
288 /* Now we're at the innermost field, the one that isn't an anonymous
289 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
290 gcc_assert (fields
.is_empty());
291 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
296 /* Subroutine of build_constexpr_constructor_member_initializers.
297 The expression tree T represents a data member initialization
298 in a (constexpr) constructor definition. Build a pairing of
299 the data member with its initializer, and prepend that pair
300 to the existing initialization pair INITS. */
303 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
306 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
307 t
= TREE_OPERAND (t
, 0);
308 if (TREE_CODE (t
) == EXPR_STMT
)
309 t
= TREE_OPERAND (t
, 0);
310 if (t
== error_mark_node
)
312 if (TREE_CODE (t
) == STATEMENT_LIST
)
314 tree_stmt_iterator i
;
315 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
317 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
322 if (TREE_CODE (t
) == CLEANUP_STMT
)
324 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
325 but we can in a constexpr constructor for a non-literal class. Just
326 ignore it; either all the initialization will be constant, in which
327 case the cleanup can't run, or it can't be constexpr.
328 Still recurse into CLEANUP_BODY. */
329 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
331 if (TREE_CODE (t
) == CONVERT_EXPR
)
332 t
= TREE_OPERAND (t
, 0);
333 if (TREE_CODE (t
) == INIT_EXPR
334 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
335 use what this function builds for cx_check_missing_mem_inits, and
336 assignment in the ctor body doesn't count. */
337 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
339 member
= TREE_OPERAND (t
, 0);
340 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
342 else if (TREE_CODE (t
) == CALL_EXPR
)
344 tree fn
= get_callee_fndecl (t
);
345 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
346 /* We're only interested in calls to subobject constructors. */
348 member
= CALL_EXPR_ARG (t
, 0);
349 /* We don't use build_cplus_new here because it complains about
350 abstract bases. Leaving the call unwrapped means that it has the
351 wrong type, but cxx_eval_constant_expression doesn't care. */
352 init
= break_out_target_exprs (t
);
354 else if (TREE_CODE (t
) == BIND_EXPR
)
355 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
357 /* Don't add anything else to the CONSTRUCTOR. */
359 if (INDIRECT_REF_P (member
))
360 member
= TREE_OPERAND (member
, 0);
361 if (TREE_CODE (member
) == NOP_EXPR
)
365 if (TREE_CODE (op
) == ADDR_EXPR
)
367 gcc_assert (same_type_ignoring_top_level_qualifiers_p
368 (TREE_TYPE (TREE_TYPE (op
)),
369 TREE_TYPE (TREE_TYPE (member
))));
370 /* Initializing a cv-qualified member; we need to look through
374 else if (op
== current_class_ptr
375 && (same_type_ignoring_top_level_qualifiers_p
376 (TREE_TYPE (TREE_TYPE (member
)),
377 current_class_type
)))
378 /* Delegating constructor. */
382 /* This is an initializer for an empty base; keep it for now so
383 we can check it in cxx_eval_bare_aggregate. */
384 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
387 if (TREE_CODE (member
) == ADDR_EXPR
)
388 member
= TREE_OPERAND (member
, 0);
389 if (TREE_CODE (member
) == COMPONENT_REF
)
391 tree aggr
= TREE_OPERAND (member
, 0);
392 if (TREE_CODE (aggr
) != COMPONENT_REF
)
393 /* Normal member initialization. */
394 member
= TREE_OPERAND (member
, 1);
395 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
396 /* Initializing a member of an anonymous union. */
397 return build_anon_member_initialization (member
, init
, vec
);
399 /* We're initializing a vtable pointer in a base. Leave it as
400 COMPONENT_REF so we remember the path to get to the vfield. */
401 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
404 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
408 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
409 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
410 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
413 check_constexpr_bind_expr_vars (tree t
)
415 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
417 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
418 if (TREE_CODE (var
) == TYPE_DECL
419 && DECL_IMPLICIT_TYPEDEF_P (var
))
424 /* Subroutine of check_constexpr_ctor_body. */
427 check_constexpr_ctor_body_1 (tree last
, tree list
)
429 switch (TREE_CODE (list
))
432 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
)
436 case CLEANUP_POINT_EXPR
:
437 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
441 if (!check_constexpr_bind_expr_vars (list
)
442 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
456 /* Make sure that there are no statements after LAST in the constructor
457 body represented by LIST. */
460 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
462 /* C++14 doesn't require a constexpr ctor to have an empty body. */
463 if (cxx_dialect
>= cxx14
)
467 if (TREE_CODE (list
) == STATEMENT_LIST
)
469 tree_stmt_iterator i
= tsi_last (list
);
470 for (; !tsi_end_p (i
); tsi_prev (&i
))
472 tree t
= tsi_stmt (i
);
475 if (!check_constexpr_ctor_body_1 (last
, t
))
482 else if (list
!= last
483 && !check_constexpr_ctor_body_1 (last
, list
))
488 error ("constexpr constructor does not have empty body");
489 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
494 /* V is a vector of constructor elements built up for the base and member
495 initializers of a constructor for TYPE. They need to be in increasing
496 offset order, which they might not be yet if TYPE has a primary base
497 which is not first in the base-clause or a vptr and at least one base
498 all of which are non-primary. */
500 static vec
<constructor_elt
, va_gc
> *
501 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
503 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
509 field_type
= BINFO_TYPE (pri
);
510 else if (TYPE_CONTAINS_VPTR_P (type
))
511 field_type
= vtbl_ptr_type_node
;
515 /* Find the element for the primary base or vptr and move it to the
516 beginning of the vec. */
517 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
518 if (TREE_TYPE (ce
->index
) == field_type
)
521 if (i
> 0 && i
< vec_safe_length (v
))
523 vec
<constructor_elt
, va_gc
> &vref
= *v
;
524 constructor_elt elt
= vref
[i
];
533 /* Build compile-time evalable representations of member-initializer list
534 for a constexpr constructor. */
537 build_constexpr_constructor_member_initializers (tree type
, tree body
)
539 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
541 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
542 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
543 body
= TREE_OPERAND (body
, 0);
544 if (TREE_CODE (body
) == STATEMENT_LIST
)
545 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
546 body
= BIND_EXPR_BODY (body
);
547 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
549 body
= TREE_OPERAND (body
, 0);
550 if (TREE_CODE (body
) == EXPR_STMT
)
551 body
= TREE_OPERAND (body
, 0);
552 if (TREE_CODE (body
) == INIT_EXPR
553 && (same_type_ignoring_top_level_qualifiers_p
554 (TREE_TYPE (TREE_OPERAND (body
, 0)),
555 current_class_type
)))
558 return TREE_OPERAND (body
, 1);
560 ok
= build_data_member_initialization (body
, &vec
);
562 else if (TREE_CODE (body
) == STATEMENT_LIST
)
564 tree_stmt_iterator i
;
565 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
567 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
572 else if (TREE_CODE (body
) == TRY_BLOCK
)
574 error ("body of %<constexpr%> constructor cannot be "
575 "a function-try-block");
576 return error_mark_node
;
578 else if (EXPR_P (body
))
579 ok
= build_data_member_initialization (body
, &vec
);
581 gcc_assert (errorcount
> 0);
584 if (vec_safe_length (vec
) > 0)
586 /* In a delegating constructor, return the target. */
587 constructor_elt
*ce
= &(*vec
)[0];
588 if (ce
->index
== current_class_ptr
)
595 vec
= sort_constexpr_mem_initializers (type
, vec
);
596 return build_constructor (type
, vec
);
599 return error_mark_node
;
602 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
603 declared to be constexpr, or a sub-statement thereof. Returns the
604 return value if suitable, error_mark_node for a statement not allowed in
605 a constexpr function, or NULL_TREE if no return value was found. */
608 constexpr_fn_retval (tree body
)
610 switch (TREE_CODE (body
))
614 tree_stmt_iterator i
;
615 tree expr
= NULL_TREE
;
616 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
618 tree s
= constexpr_fn_retval (tsi_stmt (i
));
619 if (s
== error_mark_node
)
620 return error_mark_node
;
621 else if (s
== NULL_TREE
)
622 /* Keep iterating. */;
624 /* Multiple return statements. */
625 return error_mark_node
;
633 return break_out_target_exprs (TREE_OPERAND (body
, 0));
637 tree decl
= DECL_EXPR_DECL (body
);
638 if (TREE_CODE (decl
) == USING_DECL
639 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
640 || DECL_ARTIFICIAL (decl
))
642 return error_mark_node
;
645 case CLEANUP_POINT_EXPR
:
646 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
649 if (!check_constexpr_bind_expr_vars (body
))
650 return error_mark_node
;
651 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
657 return error_mark_node
;
661 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
662 FUN; do the necessary transformations to turn it into a single expression
663 that we can store in the hash table. */
666 massage_constexpr_body (tree fun
, tree body
)
668 if (DECL_CONSTRUCTOR_P (fun
))
669 body
= build_constexpr_constructor_member_initializers
670 (DECL_CONTEXT (fun
), body
);
671 else if (cxx_dialect
< cxx14
)
673 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
674 body
= EH_SPEC_STMTS (body
);
675 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
676 body
= TREE_OPERAND (body
, 0);
677 body
= constexpr_fn_retval (body
);
682 /* FUN is a constexpr constructor with massaged body BODY. Return true
683 if some bases/fields are uninitialized, and complain if COMPLAIN. */
686 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
693 if (TREE_CODE (body
) != CONSTRUCTOR
)
696 nelts
= CONSTRUCTOR_NELTS (body
);
697 ctype
= DECL_CONTEXT (fun
);
698 field
= TYPE_FIELDS (ctype
);
700 if (TREE_CODE (ctype
) == UNION_TYPE
)
702 if (nelts
== 0 && next_initializable_field (field
))
705 error ("%<constexpr%> constructor for union %qT must "
706 "initialize exactly one non-static data member", ctype
);
713 for (i
= 0; i
<= nelts
; ++i
)
720 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
721 /* Skip base and vtable inits. */
722 if (TREE_CODE (index
) != FIELD_DECL
723 || DECL_ARTIFICIAL (index
))
726 for (; field
!= index
; field
= DECL_CHAIN (field
))
729 if (TREE_CODE (field
) != FIELD_DECL
730 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
731 || DECL_ARTIFICIAL (field
))
733 ftype
= strip_array_types (TREE_TYPE (field
));
734 if (type_has_constexpr_default_constructor (ftype
))
736 /* It's OK to skip a member with a trivial constexpr ctor.
737 A constexpr ctor that isn't trivial should have been
739 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
745 error ("member %qD must be initialized by mem-initializer "
746 "in %<constexpr%> constructor", field
);
747 inform (DECL_SOURCE_LOCATION (field
), "declared here");
750 if (field
== NULL_TREE
)
752 field
= DECL_CHAIN (field
);
758 /* We are processing the definition of the constexpr function FUN.
759 Check that its BODY fulfills the propriate requirements and
760 enter it in the constexpr function definition table.
761 For constructor BODY is actually the TREE_LIST of the
762 member-initializer list. */
765 register_constexpr_fundef (tree fun
, tree body
)
767 constexpr_fundef entry
;
768 constexpr_fundef
**slot
;
770 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
773 body
= massage_constexpr_body (fun
, body
);
774 if (body
== NULL_TREE
|| body
== error_mark_node
)
776 if (!DECL_CONSTRUCTOR_P (fun
))
777 error ("body of constexpr function %qD not a return-statement", fun
);
781 if (!potential_rvalue_constant_expression (body
))
783 if (!DECL_GENERATED_P (fun
))
784 require_potential_rvalue_constant_expression (body
);
788 if (DECL_CONSTRUCTOR_P (fun
)
789 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
792 /* Create the constexpr function table if necessary. */
793 if (constexpr_fundef_table
== NULL
)
794 constexpr_fundef_table
795 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
799 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
801 gcc_assert (*slot
== NULL
);
802 *slot
= ggc_alloc
<constexpr_fundef
> ();
808 /* FUN is a non-constexpr function called in a context that requires a
809 constant expression. If it comes from a constexpr template, explain why
810 the instantiation isn't constexpr. */
813 explain_invalid_constexpr_fn (tree fun
)
815 static hash_set
<tree
> *diagnosed
;
818 /* Only diagnose defaulted functions or instantiations. */
819 if (!DECL_DEFAULTED_FN (fun
)
820 && !is_instantiation_of_constexpr (fun
))
822 if (diagnosed
== NULL
)
823 diagnosed
= new hash_set
<tree
>;
824 if (diagnosed
->add (fun
))
825 /* Already explained. */
828 save_loc
= input_location
;
829 input_location
= DECL_SOURCE_LOCATION (fun
);
830 inform (0, "%q+D 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_hasher
<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 /* Look up the binding of the function parameter T in a constexpr
1003 function call context CALL. */
1006 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
1008 tree b
= purpose_member (t
, call
->bindings
);
1009 return TREE_VALUE (b
);
1012 /* Attempt to evaluate T which represents a call to a builtin function.
1013 We assume here that all builtin functions evaluate to scalar types
1014 represented by _CST nodes. */
1017 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
,
1019 bool *non_constant_p
, bool *overflow_p
)
1021 const int nargs
= call_expr_nargs (t
);
1022 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1025 for (i
= 0; i
< nargs
; ++i
)
1027 args
[i
] = cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, i
),
1029 non_constant_p
, overflow_p
);
1030 if (ctx
->quiet
&& *non_constant_p
)
1033 if (*non_constant_p
)
1035 new_call
= fold_build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1036 CALL_EXPR_FN (t
), nargs
, args
);
1037 VERIFY_CONSTANT (new_call
);
1041 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1042 the type of the value to match. */
1045 adjust_temp_type (tree type
, tree temp
)
1047 if (TREE_TYPE (temp
) == type
)
1049 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1050 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1051 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1052 gcc_assert (scalarish_type_p (type
));
1053 return cp_fold_convert (type
, temp
);
1056 /* True if we want to use the new handling of constexpr calls based on
1058 #define use_new_call true
1060 /* Subroutine of cxx_eval_call_expression.
1061 We are processing a call expression (either CALL_EXPR or
1062 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1063 all arguments and bind their values to correspondings
1064 parameters, making up the NEW_CALL context. */
1067 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1068 constexpr_call
*new_call
,
1069 bool *non_constant_p
, bool *overflow_p
,
1070 bool *non_constant_args
)
1072 const int nargs
= call_expr_nargs (t
);
1073 tree fun
= new_call
->fundef
->decl
;
1074 tree parms
= DECL_ARGUMENTS (fun
);
1076 tree
*p
= &new_call
->bindings
;
1077 for (i
= 0; i
< nargs
; ++i
)
1080 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1081 x
= get_nth_callarg (t
, i
);
1082 /* For member function, the first argument is a pointer to the implied
1083 object. For a constructor, it might still be a dummy object, in
1084 which case we get the real argument from ctx. */
1085 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1086 && is_dummy_object (x
))
1089 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1092 if (parms
&& DECL_BY_REFERENCE (parms
) && !use_new_call
)
1094 /* cp_genericize made this a reference for argument passing, but
1095 we don't want to treat it like one for C++11 constexpr
1096 evaluation. C++14 constexpr evaluation uses the genericized
1098 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1099 gcc_assert (TREE_CODE (TREE_TYPE (x
)) == REFERENCE_TYPE
);
1100 type
= TREE_TYPE (type
);
1101 x
= convert_from_reference (x
);
1104 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1105 non_constant_p
, overflow_p
);
1106 /* Don't VERIFY_CONSTANT here. */
1107 if (*non_constant_p
&& ctx
->quiet
)
1109 /* Just discard ellipsis args after checking their constantitude. */
1112 if (*non_constant_p
)
1113 /* Don't try to adjust the type of non-constant args. */
1116 /* Make sure the binding has the same type as the parm. */
1117 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1118 arg
= adjust_temp_type (type
, arg
);
1119 if (!TREE_CONSTANT (arg
))
1120 *non_constant_args
= true;
1121 *p
= build_tree_list (parms
, arg
);
1122 p
= &TREE_CHAIN (*p
);
1124 parms
= TREE_CHAIN (parms
);
1128 /* Variables and functions to manage constexpr call expansion context.
1129 These do not need to be marked for PCH or GC. */
1131 /* FIXME remember and print actual constant arguments. */
1132 static vec
<tree
> call_stack
= vNULL
;
1133 static int call_stack_tick
;
1134 static int last_cx_error_tick
;
1137 push_cx_call_context (tree call
)
1140 if (!EXPR_HAS_LOCATION (call
))
1141 SET_EXPR_LOCATION (call
, input_location
);
1142 call_stack
.safe_push (call
);
1143 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1149 pop_cx_call_context (void)
1156 cx_error_context (void)
1158 vec
<tree
> r
= vNULL
;
1159 if (call_stack_tick
!= last_cx_error_tick
1160 && !call_stack
.is_empty ())
1162 last_cx_error_tick
= call_stack_tick
;
1166 /* Subroutine of cxx_eval_constant_expression.
1167 Evaluate the call expression tree T in the context of OLD_CALL expression
1171 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1173 bool *non_constant_p
, bool *overflow_p
)
1175 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1176 tree fun
= get_function_named_in_call (t
);
1177 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1180 if (fun
== NULL_TREE
)
1181 switch (CALL_EXPR_IFN (t
))
1183 case IFN_UBSAN_NULL
:
1184 case IFN_UBSAN_BOUNDS
:
1185 case IFN_UBSAN_VPTR
:
1189 error_at (loc
, "call to internal function");
1190 *non_constant_p
= true;
1194 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1196 /* Might be a constexpr function pointer. */
1197 fun
= cxx_eval_constant_expression (ctx
, fun
,
1198 /*lval*/false, non_constant_p
,
1201 if (TREE_CODE (fun
) == ADDR_EXPR
)
1202 fun
= TREE_OPERAND (fun
, 0);
1204 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1206 if (!ctx
->quiet
&& !*non_constant_p
)
1207 error_at (loc
, "expression %qE does not designate a constexpr "
1209 *non_constant_p
= true;
1212 if (DECL_CLONED_FUNCTION_P (fun
))
1213 fun
= DECL_CLONED_FUNCTION (fun
);
1215 if (is_ubsan_builtin_p (fun
))
1218 if (is_builtin_fn (fun
))
1219 return cxx_eval_builtin_function_call (ctx
, t
,
1220 lval
, non_constant_p
, overflow_p
);
1221 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1225 error_at (loc
, "call to non-constexpr function %qD", fun
);
1226 explain_invalid_constexpr_fn (fun
);
1228 *non_constant_p
= true;
1232 /* Shortcut trivial constructor/op=. */
1233 if (trivial_fn_p (fun
))
1235 if (call_expr_nargs (t
) == 2)
1237 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
1238 return cxx_eval_constant_expression (ctx
, arg
,
1239 lval
, non_constant_p
,
1242 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1243 && AGGR_INIT_ZERO_FIRST (t
))
1244 return build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1247 /* If in direct recursive call, optimize definition search. */
1248 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1249 new_call
.fundef
= ctx
->call
->fundef
;
1252 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1253 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
1257 if (DECL_INITIAL (fun
))
1259 /* The definition of fun was somehow unsuitable. */
1260 error_at (loc
, "%qD called in a constant expression", fun
);
1261 explain_invalid_constexpr_fn (fun
);
1264 error_at (loc
, "%qD used before its definition", fun
);
1266 *non_constant_p
= true;
1271 constexpr_ctx new_ctx
= *ctx
;
1272 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1273 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1275 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1276 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1277 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1278 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1279 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1280 ctx
->values
->put (new_ctx
.object
, ctor
);
1284 bool non_constant_args
= false;
1285 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1286 non_constant_p
, overflow_p
, &non_constant_args
);
1287 if (*non_constant_p
)
1290 depth_ok
= push_cx_call_context (t
);
1292 tree result
= NULL_TREE
;
1294 constexpr_call
*entry
= NULL
;
1295 if (!non_constant_args
)
1297 new_call
.hash
= iterative_hash_template_arg
1298 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1300 /* If we have seen this call before, we are done. */
1301 maybe_initialize_constexpr_call_table ();
1302 constexpr_call
**slot
1303 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1307 /* We need to keep a pointer to the entry, not just the slot, as the
1308 slot can move in the call to cxx_eval_builtin_function_call. */
1309 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1312 /* Calls which are in progress have their result set to NULL
1313 so that we can detect circular dependencies. */
1314 else if (entry
->result
== NULL
)
1317 error ("call has circular dependency");
1318 *non_constant_p
= true;
1319 entry
->result
= result
= error_mark_node
;
1322 result
= entry
->result
;
1328 error ("constexpr evaluation depth exceeds maximum of %d (use "
1329 "-fconstexpr-depth= to increase the maximum)",
1330 max_constexpr_depth
);
1331 *non_constant_p
= true;
1332 result
= error_mark_node
;
1336 if (!result
|| result
== error_mark_node
)
1340 new_ctx
.call
= &new_call
;
1341 result
= (cxx_eval_constant_expression
1342 (&new_ctx
, new_call
.fundef
->body
,
1344 non_constant_p
, overflow_p
));
1348 if (DECL_SAVED_TREE (fun
) == NULL_TREE
1349 && (DECL_CONSTRUCTOR_P (fun
) || DECL_DESTRUCTOR_P (fun
)))
1350 /* The maybe-in-charge 'tor had its DECL_SAVED_TREE
1351 cleared, try a clone. */
1352 for (fun
= DECL_CHAIN (fun
);
1353 fun
&& DECL_CLONED_FUNCTION_P (fun
);
1354 fun
= DECL_CHAIN (fun
))
1355 if (DECL_SAVED_TREE (fun
))
1357 gcc_assert (DECL_SAVED_TREE (fun
));
1360 /* Unshare the whole function body. */
1361 tree body
= copy_fn (fun
, parms
, res
);
1363 /* Associate the bindings with the remapped parms. */
1364 tree bound
= new_call
.bindings
;
1365 tree remapped
= parms
;
1368 tree oparm
= TREE_PURPOSE (bound
);
1369 tree arg
= TREE_VALUE (bound
);
1370 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1371 ctx
->values
->put (remapped
, arg
);
1372 bound
= TREE_CHAIN (bound
);
1373 remapped
= DECL_CHAIN (remapped
);
1375 /* Add the RESULT_DECL to the values map, too. */
1376 tree slot
= NULL_TREE
;
1377 if (DECL_BY_REFERENCE (res
))
1379 slot
= AGGR_INIT_EXPR_SLOT (t
);
1380 tree addr
= build_address (slot
);
1381 addr
= build_nop (TREE_TYPE (res
), addr
);
1382 ctx
->values
->put (res
, addr
);
1383 ctx
->values
->put (slot
, NULL_TREE
);
1386 ctx
->values
->put (res
, NULL_TREE
);
1388 tree jump_target
= NULL_TREE
;
1389 cxx_eval_constant_expression (ctx
, body
,
1390 lval
, non_constant_p
, overflow_p
,
1393 if (DECL_CONSTRUCTOR_P (fun
))
1394 /* This can be null for a subobject constructor call, in
1395 which case what we care about is the initialization
1396 side-effects rather than the value. We could get at the
1397 value by evaluating *this, but we don't bother; there's
1398 no need to put such a call in the hash table. */
1399 result
= lval
? ctx
->object
: ctx
->ctor
;
1400 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1404 result
= *ctx
->values
->get (slot
? slot
: res
);
1405 if (result
== NULL_TREE
&& !*non_constant_p
)
1408 error ("constexpr call flows off the end "
1410 *non_constant_p
= true;
1414 /* Remove the parms/result from the values map. Is it worth
1415 bothering to do this when the map itself is only live for
1416 one constexpr evaluation? If so, maybe also clear out
1417 other vars from call, maybe in BIND_EXPR handling? */
1418 ctx
->values
->remove (res
);
1420 ctx
->values
->remove (slot
);
1421 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1422 ctx
->values
->remove (parm
);
1426 if (result
== error_mark_node
)
1427 *non_constant_p
= true;
1428 if (*non_constant_p
)
1429 result
= error_mark_node
;
1432 /* If this was a call to initialize an object, set the type of
1433 the CONSTRUCTOR to the type of that object. */
1434 if (DECL_CONSTRUCTOR_P (fun
) && !use_new_call
)
1436 tree ob_arg
= get_nth_callarg (t
, 0);
1437 STRIP_NOPS (ob_arg
);
1438 gcc_assert (TYPE_PTR_P (TREE_TYPE (ob_arg
))
1439 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
1440 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
1447 entry
->result
= result
;
1450 pop_cx_call_context ();
1451 return unshare_expr (result
);
1454 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1457 reduced_constant_expression_p (tree t
)
1459 switch (TREE_CODE (t
))
1462 /* Even if we can't lower this yet, it's constant. */
1466 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1467 tree elt
; unsigned HOST_WIDE_INT idx
;
1468 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1469 if (!reduced_constant_expression_p (elt
))
1474 /* FIXME are we calling this too much? */
1475 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1479 /* Some expressions may have constant operands but are not constant
1480 themselves, such as 1/0. Call this function (or rather, the macro
1481 following it) to check for that condition.
1483 We only call this in places that require an arithmetic constant, not in
1484 places where we might have a non-constant expression that can be a
1485 component of a constant expression, such as the address of a constexpr
1486 variable that might be dereferenced later. */
1489 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1492 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1494 if (!allow_non_constant
)
1495 error ("%q+E is not a constant expression", t
);
1496 *non_constant_p
= true;
1498 if (TREE_OVERFLOW_P (t
))
1500 if (!allow_non_constant
)
1502 permerror (input_location
, "overflow in constant expression");
1503 /* If we're being permissive (and are in an enforcing
1504 context), ignore the overflow. */
1505 if (flag_permissive
)
1506 return *non_constant_p
;
1510 return *non_constant_p
;
1513 /* Check whether the shift operation with code CODE and type TYPE on LHS
1514 and RHS is undefined. If it is, give an error with an explanation,
1515 and return true; return false otherwise. */
1518 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1519 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1521 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1522 || TREE_CODE (lhs
) != INTEGER_CST
1523 || TREE_CODE (rhs
) != INTEGER_CST
)
1526 tree lhstype
= TREE_TYPE (lhs
);
1527 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1529 /* [expr.shift] The behavior is undefined if the right operand
1530 is negative, or greater than or equal to the length in bits
1531 of the promoted left operand. */
1532 if (tree_int_cst_sgn (rhs
) == -1)
1535 error_at (loc
, "right operand of shift expression %q+E is negative",
1536 build2_loc (loc
, code
, type
, lhs
, rhs
));
1539 if (compare_tree_int (rhs
, uprec
) >= 0)
1542 error_at (loc
, "right operand of shift expression %q+E is >= than "
1543 "the precision of the left operand",
1544 build2_loc (loc
, code
, type
, lhs
, rhs
));
1548 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1549 if E1 has a signed type and non-negative value, and E1x2^E2 is
1550 representable in the corresponding unsigned type of the result type,
1551 then that value, converted to the result type, is the resulting value;
1552 otherwise, the behavior is undefined. */
1553 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1554 && (cxx_dialect
>= cxx11
))
1556 if (tree_int_cst_sgn (lhs
) == -1)
1559 error_at (loc
, "left operand of shift expression %q+E is negative",
1560 build2_loc (loc
, code
, type
, lhs
, rhs
));
1563 /* For signed x << y the following:
1564 (unsigned) x >> ((prec (lhs) - 1) - y)
1565 if > 1, is undefined. The right-hand side of this formula
1566 is the highest bit of the LHS that can be set (starting from 0),
1567 so that the shift doesn't overflow. We then right-shift the LHS
1568 to see whether any other bit is set making the original shift
1569 undefined -- the result is not representable in the corresponding
1571 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1572 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1573 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1574 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1575 if (tree_int_cst_lt (integer_one_node
, t
))
1578 error_at (loc
, "shift expression %q+E overflows",
1579 build2_loc (loc
, code
, type
, lhs
, rhs
));
1586 /* Subroutine of cxx_eval_constant_expression.
1587 Attempt to reduce the unary expression tree T to a compile time value.
1588 If successful, return the value. Otherwise issue a diagnostic
1589 and return error_mark_node. */
1592 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1594 bool *non_constant_p
, bool *overflow_p
)
1597 tree orig_arg
= TREE_OPERAND (t
, 0);
1598 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1599 non_constant_p
, overflow_p
);
1600 VERIFY_CONSTANT (arg
);
1601 location_t loc
= EXPR_LOCATION (t
);
1602 enum tree_code code
= TREE_CODE (t
);
1603 tree type
= TREE_TYPE (t
);
1604 r
= fold_unary_loc (loc
, code
, type
, arg
);
1607 if (arg
== orig_arg
)
1610 r
= build1_loc (loc
, code
, type
, arg
);
1612 VERIFY_CONSTANT (r
);
1616 /* Subroutine of cxx_eval_constant_expression.
1617 Like cxx_eval_unary_expression, except for binary expressions. */
1620 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1622 bool *non_constant_p
, bool *overflow_p
)
1625 tree orig_lhs
= TREE_OPERAND (t
, 0);
1626 tree orig_rhs
= TREE_OPERAND (t
, 1);
1628 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1629 non_constant_p
, overflow_p
);
1630 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1631 a local array in a constexpr function. */
1632 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1634 VERIFY_CONSTANT (lhs
);
1635 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1636 non_constant_p
, overflow_p
);
1638 VERIFY_CONSTANT (rhs
);
1640 location_t loc
= EXPR_LOCATION (t
);
1641 enum tree_code code
= TREE_CODE (t
);
1642 tree type
= TREE_TYPE (t
);
1643 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1646 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1649 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1651 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1652 *non_constant_p
= true;
1654 VERIFY_CONSTANT (r
);
1658 /* Subroutine of cxx_eval_constant_expression.
1659 Attempt to evaluate condition expressions. Dead branches are not
1663 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1665 bool *non_constant_p
, bool *overflow_p
,
1668 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1670 non_constant_p
, overflow_p
);
1671 VERIFY_CONSTANT (val
);
1672 /* Don't VERIFY_CONSTANT the other operands. */
1673 if (integer_zerop (val
))
1674 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1676 non_constant_p
, overflow_p
,
1678 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1680 non_constant_p
, overflow_p
,
1684 /* Subroutine of cxx_eval_constant_expression.
1685 Attempt to reduce a reference to an array slot. */
1688 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
1690 bool *non_constant_p
, bool *overflow_p
)
1692 tree oldary
= TREE_OPERAND (t
, 0);
1693 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
1695 non_constant_p
, overflow_p
);
1699 unsigned len
, elem_nchars
= 1;
1700 if (*non_constant_p
)
1702 oldidx
= TREE_OPERAND (t
, 1);
1703 index
= cxx_eval_constant_expression (ctx
, oldidx
,
1705 non_constant_p
, overflow_p
);
1706 VERIFY_CONSTANT (index
);
1707 if (lval
&& ary
== oldary
&& index
== oldidx
)
1710 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
1711 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
1712 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1713 len
= CONSTRUCTOR_NELTS (ary
);
1714 else if (TREE_CODE (ary
) == STRING_CST
)
1716 elem_nchars
= (TYPE_PRECISION (elem_type
)
1717 / TYPE_PRECISION (char_type_node
));
1718 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
1722 /* We can't do anything with other tree codes, so use
1723 VERIFY_CONSTANT to complain and fail. */
1724 VERIFY_CONSTANT (ary
);
1727 if (compare_tree_int (index
, len
) >= 0)
1729 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
1731 /* If it's within the array bounds but doesn't have an explicit
1732 initializer, it's value-initialized. */
1733 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
1734 return cxx_eval_constant_expression (ctx
, val
,
1736 non_constant_p
, overflow_p
);
1740 error ("array subscript out of bound");
1741 *non_constant_p
= true;
1744 else if (tree_int_cst_lt (index
, integer_zero_node
))
1747 error ("negative array subscript");
1748 *non_constant_p
= true;
1751 i
= tree_to_shwi (index
);
1752 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1753 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
1754 else if (elem_nchars
== 1)
1755 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
1756 TREE_STRING_POINTER (ary
)[i
]);
1759 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
1760 return native_interpret_expr (type
, (const unsigned char *)
1761 TREE_STRING_POINTER (ary
)
1762 + i
* elem_nchars
, elem_nchars
);
1764 /* Don't VERIFY_CONSTANT here. */
1767 /* Subroutine of cxx_eval_constant_expression.
1768 Attempt to reduce a field access of a value of class type. */
1771 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
1773 bool *non_constant_p
, bool *overflow_p
)
1775 unsigned HOST_WIDE_INT i
;
1778 tree part
= TREE_OPERAND (t
, 1);
1779 tree orig_whole
= TREE_OPERAND (t
, 0);
1780 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1782 non_constant_p
, overflow_p
);
1783 if (whole
== orig_whole
)
1786 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
1787 whole
, part
, NULL_TREE
);
1788 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1790 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
1793 error ("%qE is not a constant expression", orig_whole
);
1794 *non_constant_p
= true;
1796 if (DECL_MUTABLE_P (part
))
1799 error ("mutable %qD is not usable in a constant expression", part
);
1800 *non_constant_p
= true;
1802 if (*non_constant_p
)
1804 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1811 /* We're in the middle of initializing it. */
1815 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
1816 && CONSTRUCTOR_NELTS (whole
) > 0)
1818 /* DR 1188 says we don't have to deal with this. */
1820 error ("accessing %qD member instead of initialized %qD member in "
1821 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
1822 *non_constant_p
= true;
1826 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
1828 /* 'whole' is part of the aggregate initializer we're currently
1829 building; if there's no initializer for this member yet, that's an
1832 error ("accessing uninitialized member %qD", part
);
1833 *non_constant_p
= true;
1837 /* If there's no explicit init for this field, it's value-initialized. */
1838 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
1839 return cxx_eval_constant_expression (ctx
, value
,
1841 non_constant_p
, overflow_p
);
1844 /* Subroutine of cxx_eval_constant_expression.
1845 Attempt to reduce a field access of a value of class type that is
1846 expressed as a BIT_FIELD_REF. */
1849 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
1851 bool *non_constant_p
, bool *overflow_p
)
1853 tree orig_whole
= TREE_OPERAND (t
, 0);
1854 tree retval
, fldval
, utype
, mask
;
1855 bool fld_seen
= false;
1856 HOST_WIDE_INT istart
, isize
;
1857 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1859 non_constant_p
, overflow_p
);
1860 tree start
, field
, value
;
1861 unsigned HOST_WIDE_INT i
;
1863 if (whole
== orig_whole
)
1865 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1867 if (!*non_constant_p
1868 && TREE_CODE (whole
) != VECTOR_CST
1869 && TREE_CODE (whole
) != CONSTRUCTOR
)
1872 error ("%qE is not a constant expression", orig_whole
);
1873 *non_constant_p
= true;
1875 if (*non_constant_p
)
1878 if (TREE_CODE (whole
) == VECTOR_CST
)
1879 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
1880 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
1882 start
= TREE_OPERAND (t
, 2);
1883 istart
= tree_to_shwi (start
);
1884 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
1885 utype
= TREE_TYPE (t
);
1886 if (!TYPE_UNSIGNED (utype
))
1887 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
1888 retval
= build_int_cst (utype
, 0);
1889 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1891 tree bitpos
= bit_position (field
);
1892 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
1894 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
1895 && TREE_CODE (value
) == INTEGER_CST
1896 && tree_fits_shwi_p (bitpos
)
1897 && tree_fits_shwi_p (DECL_SIZE (field
)))
1899 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
1900 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
1901 HOST_WIDE_INT shift
;
1902 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
1904 fldval
= fold_convert (utype
, value
);
1905 mask
= build_int_cst_type (utype
, -1);
1906 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
1907 size_int (TYPE_PRECISION (utype
) - sz
));
1908 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
1909 size_int (TYPE_PRECISION (utype
) - sz
));
1910 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
1911 shift
= bit
- istart
;
1912 if (BYTES_BIG_ENDIAN
)
1913 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
1914 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
1916 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
1922 return fold_convert (TREE_TYPE (t
), retval
);
1924 return error_mark_node
;
1927 /* Subroutine of cxx_eval_constant_expression.
1928 Evaluate a short-circuited logical expression T in the context
1929 of a given constexpr CALL. BAILOUT_VALUE is the value for
1930 early return. CONTINUE_VALUE is used here purely for
1931 sanity check purposes. */
1934 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
1935 tree bailout_value
, tree continue_value
,
1937 bool *non_constant_p
, bool *overflow_p
)
1940 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1942 non_constant_p
, overflow_p
);
1943 VERIFY_CONSTANT (lhs
);
1944 if (tree_int_cst_equal (lhs
, bailout_value
))
1946 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
1947 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1948 lval
, non_constant_p
,
1950 VERIFY_CONSTANT (r
);
1954 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
1955 CONSTRUCTOR elements to initialize (part of) an object containing that
1956 field. Return a pointer to the constructor_elt corresponding to the
1957 initialization of the field. */
1959 static constructor_elt
*
1960 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
1962 tree aggr
= TREE_OPERAND (ref
, 0);
1963 tree field
= TREE_OPERAND (ref
, 1);
1965 constructor_elt
*ce
;
1967 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
1969 if (TREE_CODE (aggr
) == COMPONENT_REF
)
1971 constructor_elt
*base_ce
1972 = base_field_constructor_elt (v
, aggr
);
1973 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
1976 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
1977 if (ce
->index
== field
)
1984 /* Some of the expressions fed to the constexpr mechanism are calls to
1985 constructors, which have type void. In that case, return the type being
1986 initialized by the constructor. */
1989 initialized_type (tree t
)
1993 tree type
= cv_unqualified (TREE_TYPE (t
));
1994 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
1996 /* A constructor call has void type, so we need to look deeper. */
1997 tree fn
= get_function_named_in_call (t
);
1998 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
1999 && DECL_CXX_CONSTRUCTOR_P (fn
))
2000 type
= DECL_CONTEXT (fn
);
2005 /* We're about to initialize element INDEX of an array or class from VALUE.
2006 Set up NEW_CTX appropriately by adjusting .object to refer to the
2007 subobject and creating a new CONSTRUCTOR if the element is itself
2008 a class or array. */
2011 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2012 tree index
, tree
&value
)
2016 if (index
&& TREE_CODE (index
) != INTEGER_CST
2017 && TREE_CODE (index
) != FIELD_DECL
)
2018 /* This won't have an element in the new CONSTRUCTOR. */
2021 tree type
= initialized_type (value
);
2022 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2023 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2026 /* The sub-aggregate initializer might contain a placeholder;
2027 update object to refer to the subobject and ctor to refer to
2028 the (newly created) sub-initializer. */
2030 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2031 tree elt
= build_constructor (type
, NULL
);
2032 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2035 if (TREE_CODE (value
) == TARGET_EXPR
)
2036 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2037 value
= TARGET_EXPR_INITIAL (value
);
2040 /* We're about to process an initializer for a class or array TYPE. Make
2041 sure that CTX is set up appropriately. */
2044 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2046 /* We don't bother building a ctor for an empty base subobject. */
2047 if (is_empty_class (type
))
2050 /* We're in the middle of an initializer that might involve placeholders;
2051 our caller should have created a CONSTRUCTOR for us to put the
2052 initializer into. We will either return that constructor or T. */
2053 gcc_assert (ctx
->ctor
);
2054 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2055 (type
, TREE_TYPE (ctx
->ctor
)));
2056 gcc_assert (CONSTRUCTOR_NELTS (ctx
->ctor
) == 0);
2058 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2059 (type
, TREE_TYPE (ctx
->object
)));
2060 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2061 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2064 /* Subroutine of cxx_eval_constant_expression.
2065 The expression tree T denotes a C-style array or a C-style
2066 aggregate. Reduce it to a constant expression. */
2069 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2071 bool *non_constant_p
, bool *overflow_p
)
2073 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2074 bool changed
= false;
2075 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2077 verify_ctor_sanity (ctx
, TREE_TYPE (t
));
2078 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2079 vec_alloc (*p
, vec_safe_length (v
));
2081 unsigned i
; tree index
, value
;
2082 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2084 constexpr_ctx new_ctx
;
2085 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2086 if (new_ctx
.ctor
!= ctx
->ctor
)
2087 /* If we built a new CONSTRUCTOR, attach it now so that other
2088 initializers can refer to it. */
2089 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2090 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2092 non_constant_p
, overflow_p
);
2093 /* Don't VERIFY_CONSTANT here. */
2094 if (ctx
->quiet
&& *non_constant_p
)
2098 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2100 /* This is an initialization of a vfield inside a base
2101 subaggregate that we already initialized; push this
2102 initialization into the previous initialization. */
2103 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2108 && (TREE_CODE (index
) == NOP_EXPR
2109 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2111 /* This is an initializer for an empty base; now that we've
2112 checked that it's constant, we can ignore it. */
2113 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2116 else if (new_ctx
.ctor
!= ctx
->ctor
)
2118 /* We appended this element above; update the value. */
2119 gcc_assert ((*p
)->last().index
== index
);
2120 (*p
)->last().value
= elt
;
2123 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2125 if (*non_constant_p
|| !changed
)
2128 /* We're done building this CONSTRUCTOR, so now we can interpret an
2129 element without an explicit initializer as value-initialized. */
2130 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2131 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2136 /* Subroutine of cxx_eval_constant_expression.
2137 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2138 initialization of a non-static data member of array type. Reduce it to a
2141 Note that apart from value-initialization (when VALUE_INIT is true),
2142 this is only intended to support value-initialization and the
2143 initializations done by defaulted constructors for classes with
2144 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2145 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2146 for the copy/move constructor. */
2149 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2150 bool value_init
, bool lval
,
2151 bool *non_constant_p
, bool *overflow_p
)
2153 tree elttype
= TREE_TYPE (atype
);
2154 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2155 verify_ctor_sanity (ctx
, atype
);
2156 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2157 vec_alloc (*p
, max
+ 1);
2158 bool pre_init
= false;
2159 unsigned HOST_WIDE_INT i
;
2161 /* For the default constructor, build up a call to the default
2162 constructor of the element type. We only need to handle class types
2163 here, as for a constructor to be constexpr, all members must be
2164 initialized, which for a defaulted default constructor means they must
2165 be of a class type with a constexpr default constructor. */
2166 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2167 /* We only do this at the lowest level. */;
2168 else if (value_init
)
2170 init
= build_value_init (elttype
, tf_warning_or_error
);
2175 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2176 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2177 &argvec
, elttype
, LOOKUP_NORMAL
,
2178 tf_warning_or_error
);
2179 release_tree_vector (argvec
);
2180 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2184 for (i
= 0; i
< max
; ++i
)
2186 tree idx
= build_int_cst (size_type_node
, i
);
2188 constexpr_ctx new_ctx
;
2189 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2190 if (new_ctx
.ctor
!= ctx
->ctor
)
2191 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2192 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2194 /* A multidimensional array; recurse. */
2195 if (value_init
|| init
== NULL_TREE
)
2196 eltinit
= NULL_TREE
;
2198 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2199 tf_warning_or_error
);
2200 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2202 non_constant_p
, overflow_p
);
2206 /* Initializing an element using value or default initialization
2207 we just pre-built above. */
2208 eltinit
= (cxx_eval_constant_expression
2210 lval
, non_constant_p
, overflow_p
));
2214 /* Copying an element. */
2215 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2216 (atype
, TREE_TYPE (init
)));
2217 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2218 tf_warning_or_error
);
2219 if (!real_lvalue_p (init
))
2220 eltinit
= move (eltinit
);
2221 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2222 eltinit
= (cxx_eval_constant_expression
2223 (&new_ctx
, eltinit
, lval
,
2224 non_constant_p
, overflow_p
));
2226 if (*non_constant_p
&& !ctx
->quiet
)
2228 if (new_ctx
.ctor
!= ctx
->ctor
)
2230 /* We appended this element above; update the value. */
2231 gcc_assert ((*p
)->last().index
== idx
);
2232 (*p
)->last().value
= eltinit
;
2235 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2238 if (!*non_constant_p
)
2241 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2247 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2249 bool *non_constant_p
, bool *overflow_p
)
2251 tree atype
= TREE_TYPE (t
);
2252 tree init
= VEC_INIT_EXPR_INIT (t
);
2253 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2254 VEC_INIT_EXPR_VALUE_INIT (t
),
2255 lval
, non_constant_p
, overflow_p
);
2256 if (*non_constant_p
)
2262 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2263 match. We want to be less strict for simple *& folding; if we have a
2264 non-const temporary that we access through a const pointer, that should
2265 work. We handle this here rather than change fold_indirect_ref_1
2266 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2267 don't really make sense outside of constant expression evaluation. Also
2268 we want to allow folding to COMPONENT_REF, which could cause trouble
2269 with TBAA in fold_indirect_ref_1.
2271 Try to keep this function synced with fold_indirect_ref_1. */
2274 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2280 subtype
= TREE_TYPE (sub
);
2281 if (!POINTER_TYPE_P (subtype
))
2284 if (TREE_CODE (sub
) == ADDR_EXPR
)
2286 tree op
= TREE_OPERAND (sub
, 0);
2287 tree optype
= TREE_TYPE (op
);
2289 /* *&CONST_DECL -> to the value of the const decl. */
2290 if (TREE_CODE (op
) == CONST_DECL
)
2291 return DECL_INITIAL (op
);
2292 /* *&p => p; make sure to handle *&"str"[cst] here. */
2293 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
2295 tree fop
= fold_read_from_constant_string (op
);
2301 /* *(foo *)&fooarray => fooarray[0] */
2302 else if (TREE_CODE (optype
) == ARRAY_TYPE
2303 && (same_type_ignoring_top_level_qualifiers_p
2304 (type
, TREE_TYPE (optype
))))
2306 tree type_domain
= TYPE_DOMAIN (optype
);
2307 tree min_val
= size_zero_node
;
2308 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2309 min_val
= TYPE_MIN_VALUE (type_domain
);
2310 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2311 NULL_TREE
, NULL_TREE
);
2313 /* *(foo *)&complexfoo => __real__ complexfoo */
2314 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2315 && (same_type_ignoring_top_level_qualifiers_p
2316 (type
, TREE_TYPE (optype
))))
2317 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2318 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2319 else if (TREE_CODE (optype
) == VECTOR_TYPE
2320 && (same_type_ignoring_top_level_qualifiers_p
2321 (type
, TREE_TYPE (optype
))))
2323 tree part_width
= TYPE_SIZE (type
);
2324 tree index
= bitsize_int (0);
2325 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2327 /* Also handle conversion to an empty base class, which
2328 is represented with a NOP_EXPR. */
2329 else if (is_empty_class (type
)
2330 && CLASS_TYPE_P (optype
)
2331 && DERIVED_FROM_P (type
, optype
))
2336 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2337 else if (RECORD_OR_UNION_TYPE_P (optype
))
2339 tree field
= TYPE_FIELDS (optype
);
2340 for (; field
; field
= DECL_CHAIN (field
))
2341 if (TREE_CODE (field
) == FIELD_DECL
2342 && integer_zerop (byte_position (field
))
2343 && (same_type_ignoring_top_level_qualifiers_p
2344 (TREE_TYPE (field
), type
)))
2346 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2351 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2352 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2354 tree op00
= TREE_OPERAND (sub
, 0);
2355 tree op01
= TREE_OPERAND (sub
, 1);
2358 if (TREE_CODE (op00
) == ADDR_EXPR
)
2361 op00
= TREE_OPERAND (op00
, 0);
2362 op00type
= TREE_TYPE (op00
);
2364 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2365 if (TREE_CODE (op00type
) == VECTOR_TYPE
2366 && (same_type_ignoring_top_level_qualifiers_p
2367 (type
, TREE_TYPE (op00type
))))
2369 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2370 tree part_width
= TYPE_SIZE (type
);
2371 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2372 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2373 tree index
= bitsize_int (indexi
);
2375 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2376 return fold_build3_loc (loc
,
2377 BIT_FIELD_REF
, type
, op00
,
2381 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2382 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2383 && (same_type_ignoring_top_level_qualifiers_p
2384 (type
, TREE_TYPE (op00type
))))
2386 tree size
= TYPE_SIZE_UNIT (type
);
2387 if (tree_int_cst_equal (size
, op01
))
2388 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2390 /* ((foo *)&fooarray)[1] => fooarray[1] */
2391 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2392 && (same_type_ignoring_top_level_qualifiers_p
2393 (type
, TREE_TYPE (op00type
))))
2395 tree type_domain
= TYPE_DOMAIN (op00type
);
2396 tree min_val
= size_zero_node
;
2397 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2398 min_val
= TYPE_MIN_VALUE (type_domain
);
2399 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2400 TYPE_SIZE_UNIT (type
));
2401 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2402 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2403 NULL_TREE
, NULL_TREE
);
2405 /* Also handle conversion to an empty base class, which
2406 is represented with a NOP_EXPR. */
2407 else if (is_empty_class (type
)
2408 && CLASS_TYPE_P (op00type
)
2409 && DERIVED_FROM_P (type
, op00type
))
2414 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2415 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2417 tree field
= TYPE_FIELDS (op00type
);
2418 for (; field
; field
= DECL_CHAIN (field
))
2419 if (TREE_CODE (field
) == FIELD_DECL
2420 && tree_int_cst_equal (byte_position (field
), op01
)
2421 && (same_type_ignoring_top_level_qualifiers_p
2422 (TREE_TYPE (field
), type
)))
2424 return fold_build3 (COMPONENT_REF
, type
, op00
,
2431 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2432 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2433 && (same_type_ignoring_top_level_qualifiers_p
2434 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2437 tree min_val
= size_zero_node
;
2438 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2442 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2443 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2444 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2445 min_val
= TYPE_MIN_VALUE (type_domain
);
2446 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2454 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2456 bool *non_constant_p
, bool *overflow_p
)
2458 tree orig_op0
= TREE_OPERAND (t
, 0);
2459 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2460 /*lval*/false, non_constant_p
,
2462 bool empty_base
= false;
2465 /* Don't VERIFY_CONSTANT here. */
2466 if (*non_constant_p
)
2469 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2473 r
= cxx_eval_constant_expression (ctx
, r
,
2474 lval
, non_constant_p
, overflow_p
);
2479 if (TREE_CODE (sub
) == ADDR_EXPR
)
2481 /* We couldn't fold to a constant value. Make sure it's not
2482 something we should have been able to fold. */
2483 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2484 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
2485 /* DR 1188 says we don't have to deal with this. */
2487 error ("accessing value of %qE through a %qT glvalue in a "
2488 "constant expression", build_fold_indirect_ref (sub
),
2490 *non_constant_p
= true;
2495 /* If we're pulling out the value of an empty base, make sure
2496 that the whole object is constant and then return an empty
2498 if (empty_base
&& !lval
)
2500 VERIFY_CONSTANT (r
);
2501 r
= build_constructor (TREE_TYPE (t
), NULL
);
2502 TREE_CONSTANT (r
) = true;
2507 if (lval
&& op0
!= orig_op0
)
2508 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
2510 VERIFY_CONSTANT (t
);
2516 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2517 Shared between potential_constant_expression and
2518 cxx_eval_constant_expression. */
2521 non_const_var_error (tree r
)
2523 tree type
= TREE_TYPE (r
);
2524 error ("the value of %qD is not usable in a constant "
2526 /* Avoid error cascade. */
2527 if (DECL_INITIAL (r
) == error_mark_node
)
2529 if (DECL_DECLARED_CONSTEXPR_P (r
))
2530 inform (DECL_SOURCE_LOCATION (r
),
2531 "%qD used in its own initializer", r
);
2532 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
2534 if (!CP_TYPE_CONST_P (type
))
2535 inform (DECL_SOURCE_LOCATION (r
),
2536 "%q#D is not const", r
);
2537 else if (CP_TYPE_VOLATILE_P (type
))
2538 inform (DECL_SOURCE_LOCATION (r
),
2539 "%q#D is volatile", r
);
2540 else if (!DECL_INITIAL (r
)
2541 || !TREE_CONSTANT (DECL_INITIAL (r
)))
2542 inform (DECL_SOURCE_LOCATION (r
),
2543 "%qD was not initialized with a constant "
2550 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
2551 inform (DECL_SOURCE_LOCATION (r
),
2552 "%qD was not declared %<constexpr%>", r
);
2554 inform (DECL_SOURCE_LOCATION (r
),
2555 "%qD does not have integral or enumeration type",
2560 /* Subroutine of cxx_eval_constant_expression.
2561 Like cxx_eval_unary_expression, except for trinary expressions. */
2564 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
2566 bool *non_constant_p
, bool *overflow_p
)
2572 for (i
= 0; i
< 3; i
++)
2574 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
2576 non_constant_p
, overflow_p
);
2577 VERIFY_CONSTANT (args
[i
]);
2580 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
2581 args
[0], args
[1], args
[2]);
2582 if (val
== NULL_TREE
)
2584 VERIFY_CONSTANT (val
);
2589 var_in_constexpr_fn (tree t
)
2591 tree ctx
= DECL_CONTEXT (t
);
2592 return (cxx_dialect
>= cxx14
&& ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
2593 && DECL_DECLARED_CONSTEXPR_P (ctx
));
2596 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
2599 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
2601 bool *non_constant_p
, bool *overflow_p
)
2603 constexpr_ctx new_ctx
= *ctx
;
2605 /* First we figure out where we're storing to. */
2606 tree target
= TREE_OPERAND (t
, 0);
2607 target
= cxx_eval_constant_expression (ctx
, target
,
2609 non_constant_p
, overflow_p
);
2610 if (*non_constant_p
)
2613 /* And then find the underlying variable. */
2614 vec
<tree
,va_gc
> *refs
= make_tree_vector();
2615 tree object
= NULL_TREE
;
2616 for (tree probe
= target
; object
== NULL_TREE
; )
2618 switch (TREE_CODE (probe
))
2623 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
2624 vec_safe_push (refs
, TREE_TYPE (probe
));
2625 probe
= TREE_OPERAND (probe
, 0);
2633 /* And then find/build up our initializer for the path to the subobject
2634 we're initializing. */
2636 if (DECL_P (object
))
2637 valp
= ctx
->values
->get (object
);
2642 /* A constant-expression cannot modify objects from outside the
2643 constant-expression. */
2645 error ("modification of %qE is not a constant-expression", object
);
2646 *non_constant_p
= true;
2649 tree type
= TREE_TYPE (object
);
2650 while (!refs
->is_empty())
2652 if (*valp
== NULL_TREE
)
2654 *valp
= build_constructor (type
, NULL
);
2655 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = true;
2660 ce
.index
= refs
->pop();
2661 ce
.value
= NULL_TREE
;
2663 unsigned HOST_WIDE_INT idx
= 0;
2664 constructor_elt
*cep
= NULL
;
2666 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
2669 if (cp_tree_equal (ce
.index
, cep
->index
))
2672 cep
= vec_safe_push (CONSTRUCTOR_ELTS (*valp
), ce
);
2675 release_tree_vector (refs
);
2677 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
2679 /* Create a new CONSTRUCTOR in case evaluation of the initializer
2680 wants to modify it. */
2681 *valp
= new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
2682 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
2683 new_ctx
.object
= target
;
2686 tree init
= cxx_eval_constant_expression (&new_ctx
, TREE_OPERAND (t
, 1),
2688 non_constant_p
, overflow_p
);
2689 if (target
== object
)
2690 /* The hash table might have moved since the get earlier. */
2691 ctx
->values
->put (object
, init
);
2695 if (*non_constant_p
)
2703 /* Evaluate a ++ or -- expression. */
2706 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
2708 bool *non_constant_p
, bool *overflow_p
)
2710 enum tree_code code
= TREE_CODE (t
);
2711 tree type
= TREE_TYPE (t
);
2712 tree op
= TREE_OPERAND (t
, 0);
2713 tree offset
= TREE_OPERAND (t
, 1);
2714 gcc_assert (TREE_CONSTANT (offset
));
2716 /* The operand as an lvalue. */
2717 op
= cxx_eval_constant_expression (ctx
, op
, true,
2718 non_constant_p
, overflow_p
);
2720 /* The operand as an rvalue. */
2721 tree val
= rvalue (op
);
2722 val
= cxx_eval_constant_expression (ctx
, val
, false,
2723 non_constant_p
, overflow_p
);
2724 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2725 a local array in a constexpr function. */
2726 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
2728 VERIFY_CONSTANT (val
);
2730 /* The modified value. */
2731 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
2733 if (POINTER_TYPE_P (type
))
2735 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
2736 offset
= convert_to_ptrofftype (offset
);
2738 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
2739 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
2742 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
2744 VERIFY_CONSTANT (mod
);
2746 /* Storing the modified value. */
2747 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
2748 cxx_eval_constant_expression (ctx
, store
,
2749 true, non_constant_p
, overflow_p
);
2751 /* And the value of the expression. */
2752 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
2754 /* Prefix ops are lvalues. */
2758 /* But we optimize when the caller wants an rvalue. */
2762 /* Postfix ops are rvalues. */
2766 /* Predicates for the meaning of *jump_target. */
2769 returns (tree
*jump_target
)
2772 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
2776 breaks (tree
*jump_target
)
2779 && TREE_CODE (*jump_target
) == LABEL_DECL
2780 && LABEL_DECL_BREAK (*jump_target
);
2784 continues (tree
*jump_target
)
2787 && TREE_CODE (*jump_target
) == LABEL_DECL
2788 && LABEL_DECL_CONTINUE (*jump_target
);
2792 switches (tree
*jump_target
)
2795 && TREE_CODE (*jump_target
) == INTEGER_CST
;
2798 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
2799 at I matches *jump_target. If we're looking for a case label and we see
2800 the default label, copy I into DEFAULT_LABEL. */
2803 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
2804 tree_stmt_iterator
& default_label
)
2806 tree stmt
= tsi_stmt (i
);
2807 switch (TREE_CODE (*jump_target
))
2810 if (TREE_CODE (stmt
) == LABEL_EXPR
2811 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
2816 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
2818 if (!CASE_LOW (stmt
))
2820 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
2831 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
2832 semantics, for switch, break, continue, and return. */
2835 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
2836 bool *non_constant_p
, bool *overflow_p
,
2839 tree_stmt_iterator i
;
2840 tree_stmt_iterator default_label
= tree_stmt_iterator();
2842 /* In a statement-expression we want to return the last value. */
2846 local_target
= NULL_TREE
;
2847 jump_target
= &local_target
;
2849 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
2852 tree stmt
= tsi_stmt (i
);
2855 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
2856 /* The label we want might be inside. */;
2857 else if (label_matches (jump_target
, i
, default_label
))
2859 *jump_target
= NULL_TREE
;
2863 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
2864 non_constant_p
, overflow_p
,
2866 if (*non_constant_p
)
2868 if (returns (jump_target
) || breaks (jump_target
))
2871 if (switches (jump_target
) && !tsi_end_p (default_label
))
2874 *jump_target
= NULL_TREE
;
2880 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
2881 semantics; continue semantics are covered by cxx_eval_statement_list. */
2884 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
2885 bool *non_constant_p
, bool *overflow_p
,
2888 tree body
= TREE_OPERAND (t
, 0);
2891 cxx_eval_statement_list (ctx
, body
,
2892 non_constant_p
, overflow_p
, jump_target
);
2893 if (returns (jump_target
) || breaks (jump_target
) || *non_constant_p
)
2896 if (breaks (jump_target
))
2897 *jump_target
= NULL_TREE
;
2901 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
2905 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
2906 bool *non_constant_p
, bool *overflow_p
,
2909 tree cond
= TREE_OPERAND (t
, 0);
2910 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
2911 non_constant_p
, overflow_p
);
2912 VERIFY_CONSTANT (cond
);
2913 *jump_target
= cond
;
2915 tree body
= TREE_OPERAND (t
, 1);
2916 cxx_eval_statement_list (ctx
, body
,
2917 non_constant_p
, overflow_p
, jump_target
);
2918 if (breaks (jump_target
) || switches (jump_target
))
2919 *jump_target
= NULL_TREE
;
2923 /* Attempt to reduce the expression T to a constant value.
2924 On failure, issue diagnostic and return error_mark_node. */
2925 /* FIXME unify with c_fully_fold */
2926 /* FIXME overflow_p is too global */
2929 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
2931 bool *non_constant_p
, bool *overflow_p
,
2934 constexpr_ctx new_ctx
;
2937 if (t
== error_mark_node
)
2939 *non_constant_p
= true;
2942 if (CONSTANT_CLASS_P (t
))
2944 if (TREE_CODE (t
) == PTRMEM_CST
)
2945 t
= cplus_expand_constant (t
);
2946 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| ctx
->quiet
))
2951 switch (TREE_CODE (t
))
2956 /* We ask for an rvalue for the RESULT_DECL when indirecting
2957 through an invisible reference. */
2958 gcc_assert (DECL_BY_REFERENCE (t
));
2959 return (*ctx
->values
->get (t
));
2963 /* We used to not check lval for CONST_DECL, but darwin.c uses
2964 CONST_DECL for aggregate constants. */
2968 r
= decl_really_constant_value (t
);
2970 r
= decl_constant_value (t
);
2971 if (TREE_CODE (r
) == TARGET_EXPR
2972 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
2973 r
= TARGET_EXPR_INITIAL (r
);
2974 if (TREE_CODE (r
) == VAR_DECL
)
2975 if (tree
*p
= ctx
->values
->get (r
))
2980 non_const_var_error (r
);
2981 *non_constant_p
= true;
2989 case CASE_LABEL_EXPR
:
2993 if (!use_new_call
&& ctx
2994 && ctx
->call
&& DECL_CONTEXT (t
) == ctx
->call
->fundef
->decl
)
2995 r
= lookup_parameter_binding (ctx
->call
, t
);
2996 else if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
2998 else if (tree
*p
= ctx
->values
->get (r
))
3001 /* Defer in case this is only used for its type. */;
3002 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3003 /* Defer, there's no lvalue->rvalue conversion. */;
3004 else if (is_empty_class (TREE_TYPE (t
)))
3006 /* If the class is empty, we aren't actually loading anything. */
3007 r
= build_constructor (TREE_TYPE (t
), NULL
);
3008 TREE_CONSTANT (r
) = true;
3013 error ("%qE is not a constant expression", t
);
3014 *non_constant_p
= true;
3019 case AGGR_INIT_EXPR
:
3020 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3021 non_constant_p
, overflow_p
);
3026 r
= DECL_EXPR_DECL (t
);
3027 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3028 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3032 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3033 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3034 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3038 if (tree init
= DECL_INITIAL (r
))
3040 init
= cxx_eval_constant_expression (ctx
, init
,
3042 non_constant_p
, overflow_p
);
3043 ctx
->values
->put (r
, init
);
3045 else if (ctx
== &new_ctx
)
3046 /* We gave it a CONSTRUCTOR above. */;
3048 ctx
->values
->put (r
, NULL_TREE
);
3053 if (!literal_type_p (TREE_TYPE (t
)))
3057 error ("temporary of non-literal type %qT in a "
3058 "constant expression", TREE_TYPE (t
));
3059 explain_non_literal_class (TREE_TYPE (t
));
3061 *non_constant_p
= true;
3064 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3066 /* We're being expanded without an explicit target, so start
3067 initializing a new object; expansion with an explicit target
3068 strips the TARGET_EXPR before we get here. */
3070 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3071 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3072 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3073 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3076 /* Pass false for 'lval' because this indicates
3077 initialization of a temporary. */
3078 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3080 non_constant_p
, overflow_p
);
3081 if (!*non_constant_p
)
3082 /* Adjust the type of the result to the type of the temporary. */
3083 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3086 tree slot
= TARGET_EXPR_SLOT (t
);
3087 ctx
->values
->put (slot
, r
);
3095 /* In C++11 constexpr evaluation we are looking for the value,
3096 not the side-effect of the initialization. */
3097 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3099 non_constant_p
, overflow_p
);
3102 /* else fall through */
3104 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3105 non_constant_p
, overflow_p
);
3109 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3111 non_constant_p
, overflow_p
);
3115 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3117 non_constant_p
, overflow_p
);
3122 /* Avoid evaluating a SAVE_EXPR more than once. */
3123 if (tree
*p
= ctx
->values
->get (t
))
3127 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3128 non_constant_p
, overflow_p
);
3129 ctx
->values
->put (t
, r
);
3133 case NON_LVALUE_EXPR
:
3134 case TRY_CATCH_EXPR
:
3135 case CLEANUP_POINT_EXPR
:
3136 case MUST_NOT_THROW_EXPR
:
3139 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3141 non_constant_p
, overflow_p
,
3145 /* These differ from cxx_eval_unary_expression in that this doesn't
3146 check for a constant operand or result; an address can be
3147 constant without its operand being, and vice versa. */
3149 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3150 non_constant_p
, overflow_p
);
3155 tree oldop
= TREE_OPERAND (t
, 0);
3156 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3158 non_constant_p
, overflow_p
);
3159 /* Don't VERIFY_CONSTANT here. */
3160 if (*non_constant_p
)
3162 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3163 /* This function does more aggressive folding than fold itself. */
3164 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3165 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3173 case FIX_TRUNC_EXPR
:
3178 case TRUTH_NOT_EXPR
:
3179 case FIXED_CONVERT_EXPR
:
3180 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3181 non_constant_p
, overflow_p
);
3185 if (SIZEOF_EXPR_TYPE_P (t
))
3186 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
3187 SIZEOF_EXPR
, false);
3188 else if (TYPE_P (TREE_OPERAND (t
, 0)))
3189 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3192 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3194 if (r
== error_mark_node
)
3196 VERIFY_CONSTANT (r
);
3201 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3202 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3203 introduced by build_call_a. */
3204 tree op0
= TREE_OPERAND (t
, 0);
3205 tree op1
= TREE_OPERAND (t
, 1);
3207 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3208 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3209 r
= cxx_eval_constant_expression (ctx
, op0
,
3210 lval
, non_constant_p
, overflow_p
,
3214 /* Check that the LHS is constant and then discard it. */
3215 cxx_eval_constant_expression (ctx
, op0
,
3216 true, non_constant_p
, overflow_p
,
3218 op1
= TREE_OPERAND (t
, 1);
3219 r
= cxx_eval_constant_expression (ctx
, op1
,
3220 lval
, non_constant_p
, overflow_p
,
3226 case POINTER_PLUS_EXPR
:
3230 case TRUNC_DIV_EXPR
:
3232 case FLOOR_DIV_EXPR
:
3233 case ROUND_DIV_EXPR
:
3234 case TRUNC_MOD_EXPR
:
3236 case ROUND_MOD_EXPR
:
3238 case EXACT_DIV_EXPR
:
3248 case TRUTH_XOR_EXPR
:
3255 case UNORDERED_EXPR
:
3265 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3266 non_constant_p
, overflow_p
);
3269 /* fold can introduce non-IF versions of these; still treat them as
3270 short-circuiting. */
3271 case TRUTH_AND_EXPR
:
3272 case TRUTH_ANDIF_EXPR
:
3273 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
3276 non_constant_p
, overflow_p
);
3280 case TRUTH_ORIF_EXPR
:
3281 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
3284 non_constant_p
, overflow_p
);
3288 r
= cxx_eval_array_reference (ctx
, t
, lval
,
3289 non_constant_p
, overflow_p
);
3293 if (is_overloaded_fn (t
))
3295 /* We can only get here in checking mode via
3296 build_non_dependent_expr, because any expression that
3297 calls or takes the address of the function will have
3298 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3299 gcc_checking_assert (ctx
->quiet
|| errorcount
);
3300 *non_constant_p
= true;
3303 r
= cxx_eval_component_reference (ctx
, t
, lval
,
3304 non_constant_p
, overflow_p
);
3308 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
3309 non_constant_p
, overflow_p
);
3314 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
3315 non_constant_p
, overflow_p
,
3320 if (TREE_CONSTANT (t
))
3321 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3322 VECTOR_CST if applicable. */
3324 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
3325 non_constant_p
, overflow_p
);
3329 /* We can get this in a defaulted constructor for a class with a
3330 non-static data member of array type. Either the initializer will
3331 be NULL, meaning default-initialization, or it will be an lvalue
3332 or xvalue of the same type, meaning direct-initialization from the
3333 corresponding member. */
3334 r
= cxx_eval_vec_init (ctx
, t
, lval
,
3335 non_constant_p
, overflow_p
);
3340 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
3341 non_constant_p
, overflow_p
);
3345 case VIEW_CONVERT_EXPR
:
3348 tree oldop
= TREE_OPERAND (t
, 0);
3349 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3351 non_constant_p
, overflow_p
);
3352 if (*non_constant_p
)
3354 if (POINTER_TYPE_P (TREE_TYPE (t
))
3355 && TREE_CODE (op
) == INTEGER_CST
3356 && !integer_zerop (op
))
3359 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3360 "reinterpret_cast from integer to pointer");
3361 *non_constant_p
= true;
3365 /* We didn't fold at the top so we could check for ptr-int
3368 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
3369 /* Conversion of an out-of-range value has implementation-defined
3370 behavior; the language considers it different from arithmetic
3371 overflow, which is undefined. */
3372 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
3373 TREE_OVERFLOW (r
) = false;
3377 case EMPTY_CLASS_EXPR
:
3378 /* This is good enough for a function argument that might not get
3379 used, and they can't do anything with it, so just return it. */
3382 case STATEMENT_LIST
:
3384 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3385 return cxx_eval_statement_list (&new_ctx
, t
,
3386 non_constant_p
, overflow_p
, jump_target
);
3389 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
3391 non_constant_p
, overflow_p
,
3394 case PREINCREMENT_EXPR
:
3395 case POSTINCREMENT_EXPR
:
3396 case PREDECREMENT_EXPR
:
3397 case POSTDECREMENT_EXPR
:
3398 return cxx_eval_increment_expression (ctx
, t
,
3399 lval
, non_constant_p
, overflow_p
);
3405 case VEC_DELETE_EXPR
:
3408 /* GCC internal stuff. */
3411 case WITH_CLEANUP_EXPR
:
3412 case NON_DEPENDENT_EXPR
:
3416 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3417 "expression %qE is not a constant-expression", t
);
3418 *non_constant_p
= true;
3421 case PLACEHOLDER_EXPR
:
3422 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
))
3424 /* A placeholder without a referent. We can get here when
3425 checking whether NSDMIs are noexcept, or in massage_init_elt;
3426 just say it's non-constant for now. */
3427 gcc_assert (ctx
->quiet
);
3428 *non_constant_p
= true;
3433 /* Use of the value or address of the current object. We could
3434 use ctx->object unconditionally, but using ctx->ctor when we
3435 can is a minor optimization. */
3436 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
3437 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3438 (TREE_TYPE (t
), TREE_TYPE (ctor
)));
3439 return cxx_eval_constant_expression
3441 non_constant_p
, overflow_p
);
3446 *jump_target
= TREE_OPERAND (t
, 0);
3447 gcc_assert (breaks (jump_target
) || continues (jump_target
));
3451 cxx_eval_loop_expr (ctx
, t
,
3452 non_constant_p
, overflow_p
, jump_target
);
3456 cxx_eval_switch_expr (ctx
, t
,
3457 non_constant_p
, overflow_p
, jump_target
);
3461 if (STATEMENT_CODE_P (TREE_CODE (t
)))
3463 /* This function doesn't know how to deal with pre-genericize
3464 statements; this can only happen with statement-expressions,
3465 so for now just fail. */
3467 error_at (EXPR_LOCATION (t
),
3468 "statement is not a constant-expression");
3471 internal_error ("unexpected expression %qE of kind %s", t
,
3472 get_tree_code_name (TREE_CODE (t
)));
3473 *non_constant_p
= true;
3477 if (r
== error_mark_node
)
3478 *non_constant_p
= true;
3480 if (*non_constant_p
)
3487 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
3488 bool strict
= true, tree object
= NULL_TREE
)
3490 bool non_constant_p
= false;
3491 bool overflow_p
= false;
3492 hash_map
<tree
,tree
> map
;
3493 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, allow_non_constant
, strict
};
3494 tree type
= initialized_type (t
);
3496 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3498 /* In C++14 an NSDMI can participate in aggregate initialization,
3499 and can refer to the address of the object being initialized, so
3500 we need to pass in the relevant VAR_DECL if we want to do the
3501 evaluation in a single pass. The evaluation will dynamically
3502 update ctx.values for the VAR_DECL. We use the same strategy
3503 for C++11 constexpr constructors that refer to the object being
3505 ctx
.ctor
= build_constructor (type
, NULL
);
3506 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
3509 if (TREE_CODE (t
) == TARGET_EXPR
)
3510 object
= TARGET_EXPR_SLOT (t
);
3511 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3512 object
= AGGR_INIT_EXPR_SLOT (t
);
3514 ctx
.object
= object
;
3516 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3517 (type
, TREE_TYPE (object
)));
3518 if (object
&& DECL_P (object
))
3519 map
.put (object
, ctx
.ctor
);
3520 if (TREE_CODE (r
) == TARGET_EXPR
)
3521 /* Avoid creating another CONSTRUCTOR when we expand the
3523 r
= TARGET_EXPR_INITIAL (r
);
3526 r
= cxx_eval_constant_expression (&ctx
, r
,
3527 false, &non_constant_p
, &overflow_p
);
3529 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
3531 /* Mutable logic is a bit tricky: we want to allow initialization of
3532 constexpr variables with mutable members, but we can't copy those
3533 members to another constexpr variable. */
3534 if (TREE_CODE (r
) == CONSTRUCTOR
3535 && CONSTRUCTOR_MUTABLE_POISON (r
))
3537 if (!allow_non_constant
)
3538 error ("%qE is not a constant expression because it refers to "
3539 "mutable subobjects of %qT", t
, type
);
3540 non_constant_p
= true;
3543 /* Technically we should check this for all subexpressions, but that
3544 runs into problems with our internal representation of pointer
3545 subtraction and the 5.19 rules are still in flux. */
3546 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
3547 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
3548 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
3550 if (!allow_non_constant
)
3551 error ("conversion from pointer type %qT "
3552 "to arithmetic type %qT in a constant-expression",
3553 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
3554 non_constant_p
= true;
3557 if (!non_constant_p
&& overflow_p
)
3558 non_constant_p
= true;
3560 if (non_constant_p
&& !allow_non_constant
)
3561 return error_mark_node
;
3562 else if (non_constant_p
&& TREE_CONSTANT (r
))
3564 /* This isn't actually constant, so unset TREE_CONSTANT. */
3567 else if (TREE_CODE (r
) == CONSTRUCTOR
)
3568 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
3570 r
= build_nop (TREE_TYPE (r
), r
);
3571 TREE_CONSTANT (r
) = false;
3573 else if (non_constant_p
|| r
== t
)
3576 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
3578 if (TREE_CODE (t
) == TARGET_EXPR
3579 && TARGET_EXPR_INITIAL (t
) == r
)
3583 r
= get_target_expr (r
);
3584 TREE_CONSTANT (r
) = true;
3592 /* Returns true if T is a valid subexpression of a constant expression,
3593 even if it isn't itself a constant expression. */
3596 is_sub_constant_expr (tree t
)
3598 bool non_constant_p
= false;
3599 bool overflow_p
= false;
3600 hash_map
<tree
, tree
> map
;
3601 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, true, true };
3602 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
3604 return !non_constant_p
&& !overflow_p
;
3607 /* If T represents a constant expression returns its reduced value.
3608 Otherwise return error_mark_node. If T is dependent, then
3612 cxx_constant_value (tree t
, tree decl
)
3614 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
3617 /* If T is a constant expression, returns its reduced value.
3618 Otherwise, if T does not have TREE_CONSTANT set, returns T.
3619 Otherwise, returns a version of T without TREE_CONSTANT. */
3622 maybe_constant_value (tree t
, tree decl
)
3626 if (instantiation_dependent_expression_p (t
)
3627 || type_unknown_p (t
)
3628 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3629 || !potential_constant_expression (t
))
3631 if (TREE_OVERFLOW_P (t
))
3633 t
= build_nop (TREE_TYPE (t
), t
);
3634 TREE_CONSTANT (t
) = false;
3639 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
3640 #ifdef ENABLE_CHECKING
3641 /* cp_tree_equal looks through NOPs, so allow them. */
3643 || CONVERT_EXPR_P (t
)
3644 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3645 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3646 || !cp_tree_equal (r
, t
));
3651 /* Like maybe_constant_value but first fully instantiate the argument.
3653 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3654 (t, tf_none) followed by maybe_constant_value but is more efficient,
3655 because calls instantiation_dependent_expression_p and
3656 potential_constant_expression at most once. */
3659 fold_non_dependent_expr (tree t
)
3664 /* If we're in a template, but T isn't value dependent, simplify
3665 it. We're supposed to treat:
3667 template <typename T> void f(T[1 + 1]);
3668 template <typename T> void f(T[2]);
3670 as two declarations of the same function, for example. */
3671 if (processing_template_decl
)
3673 if (!instantiation_dependent_expression_p (t
)
3674 && potential_constant_expression (t
))
3676 processing_template_decl_sentinel s
;
3677 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
3679 if (type_unknown_p (t
)
3680 || BRACE_ENCLOSED_INITIALIZER_P (t
))
3682 if (TREE_OVERFLOW_P (t
))
3684 t
= build_nop (TREE_TYPE (t
), t
);
3685 TREE_CONSTANT (t
) = false;
3690 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
3691 #ifdef ENABLE_CHECKING
3692 /* cp_tree_equal looks through NOPs, so allow them. */
3694 || CONVERT_EXPR_P (t
)
3695 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3696 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3697 || !cp_tree_equal (r
, t
));
3701 else if (TREE_OVERFLOW_P (t
))
3703 t
= build_nop (TREE_TYPE (t
), t
);
3704 TREE_CONSTANT (t
) = false;
3709 return maybe_constant_value (t
);
3712 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3713 than wrapped in a TARGET_EXPR. */
3716 maybe_constant_init (tree t
, tree decl
)
3718 if (TREE_CODE (t
) == EXPR_STMT
)
3719 t
= TREE_OPERAND (t
, 0);
3720 if (TREE_CODE (t
) == CONVERT_EXPR
3721 && VOID_TYPE_P (TREE_TYPE (t
)))
3722 t
= TREE_OPERAND (t
, 0);
3723 if (TREE_CODE (t
) == INIT_EXPR
)
3724 t
= TREE_OPERAND (t
, 1);
3725 if (instantiation_dependent_expression_p (t
)
3726 || type_unknown_p (t
)
3727 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3728 || !potential_static_init_expression (t
))
3729 /* Don't try to evaluate it. */;
3731 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
3732 if (TREE_CODE (t
) == TARGET_EXPR
)
3734 tree init
= TARGET_EXPR_INITIAL (t
);
3735 if (TREE_CODE (init
) == CONSTRUCTOR
)
3742 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
3743 /* Return true if the object referred to by REF has automatic or thread
3746 enum { ck_ok
, ck_bad
, ck_unknown
};
3748 check_automatic_or_tls (tree ref
)
3751 HOST_WIDE_INT bitsize
, bitpos
;
3753 int volatilep
= 0, unsignedp
= 0;
3754 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
3755 &mode
, &unsignedp
, &volatilep
, false);
3758 /* If there isn't a decl in the middle, we don't know the linkage here,
3759 and this isn't a constant expression anyway. */
3762 dk
= decl_storage_duration (decl
);
3763 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
3767 /* Return true if T denotes a potentially constant expression. Issue
3768 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
3769 an lvalue-rvalue conversion is implied.
3771 C++0x [expr.const] used to say
3773 6 An expression is a potential constant expression if it is
3774 a constant expression where all occurrences of function
3775 parameters are replaced by arbitrary constant expressions
3776 of the appropriate type.
3778 2 A conditional expression is a constant expression unless it
3779 involves one of the following as a potentially evaluated
3780 subexpression (3.2), but subexpressions of logical AND (5.14),
3781 logical OR (5.15), and conditional (5.16) operations that are
3782 not evaluated are not considered. */
3785 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
3786 tsubst_flags_t flags
)
3788 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
3789 enum { any
= false, rval
= true };
3793 if (t
== error_mark_node
)
3797 if (TREE_THIS_VOLATILE (t
))
3799 if (flags
& tf_error
)
3800 error ("expression %qE has side-effects", t
);
3803 if (CONSTANT_CLASS_P (t
))
3806 switch (TREE_CODE (t
))
3812 case TEMPLATE_ID_EXPR
:
3815 case CASE_LABEL_EXPR
:
3821 case TEMPLATE_PARM_INDEX
:
3823 case IDENTIFIER_NODE
:
3824 case USERDEF_LITERAL
:
3825 /* We can see a FIELD_DECL in a pointer-to-member expression. */
3830 case PLACEHOLDER_EXPR
:
3835 case AGGR_INIT_EXPR
:
3837 /* -- an invocation of a function other than a constexpr function
3838 or a constexpr constructor. */
3840 tree fun
= get_function_named_in_call (t
);
3841 const int nargs
= call_expr_nargs (t
);
3844 if (fun
== NULL_TREE
)
3846 if (TREE_CODE (t
) == CALL_EXPR
3847 && CALL_EXPR_FN (t
) == NULL_TREE
)
3848 switch (CALL_EXPR_IFN (t
))
3850 /* These should be ignored, they are optimized away from
3851 constexpr functions. */
3852 case IFN_UBSAN_NULL
:
3853 case IFN_UBSAN_BOUNDS
:
3854 case IFN_UBSAN_VPTR
:
3859 /* fold_call_expr can't do anything with IFN calls. */
3860 if (flags
& tf_error
)
3861 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3862 "call to internal function");
3865 if (is_overloaded_fn (fun
))
3867 if (TREE_CODE (fun
) == FUNCTION_DECL
)
3869 if (builtin_valid_in_constant_expr_p (fun
))
3871 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
3872 /* Allow any built-in function; if the expansion
3873 isn't constant, we'll deal with that then. */
3874 && !is_builtin_fn (fun
))
3876 if (flags
& tf_error
)
3878 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3879 "call to non-constexpr function %qD", fun
);
3880 explain_invalid_constexpr_fn (fun
);
3884 /* A call to a non-static member function takes the address
3885 of the object as the first argument. But in a constant
3886 expression the address will be folded away, so look
3888 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
3889 && !DECL_CONSTRUCTOR_P (fun
))
3891 tree x
= get_nth_callarg (t
, 0);
3892 if (is_this_parameter (x
))
3894 else if (!RECUR (x
, rval
))
3901 if (!RECUR (fun
, true))
3903 fun
= get_first_fn (fun
);
3905 /* Skip initial arguments to base constructors. */
3906 if (DECL_BASE_CONSTRUCTOR_P (fun
))
3907 i
= num_artificial_parms_for (fun
);
3908 fun
= DECL_ORIGIN (fun
);
3912 if (RECUR (fun
, rval
))
3913 /* Might end up being a constant function pointer. */;
3917 for (; i
< nargs
; ++i
)
3919 tree x
= get_nth_callarg (t
, i
);
3920 /* In a template, reference arguments haven't been converted to
3921 REFERENCE_TYPE and we might not even know if the parameter
3922 is a reference, so accept lvalue constants too. */
3923 bool rv
= processing_template_decl
? any
: rval
;
3930 case NON_LVALUE_EXPR
:
3931 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
3932 -- an lvalue of integral type that refers to a non-volatile
3933 const variable or static data member initialized with
3934 constant expressions, or
3936 -- an lvalue of literal type that refers to non-volatile
3937 object defined with constexpr, or that refers to a
3938 sub-object of such an object; */
3939 return RECUR (TREE_OPERAND (t
, 0), rval
);
3943 && !decl_constant_var_p (t
)
3945 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
3946 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
3947 && !var_in_constexpr_fn (t
)
3948 && !type_dependent_expression_p (t
))
3950 if (flags
& tf_error
)
3951 non_const_var_error (t
);
3958 case VIEW_CONVERT_EXPR
:
3959 /* -- a reinterpret_cast. FIXME not implemented, and this rule
3960 may change to something more specific to type-punning (DR 1312). */
3962 tree from
= TREE_OPERAND (t
, 0);
3963 if (POINTER_TYPE_P (TREE_TYPE (t
))
3964 && TREE_CODE (from
) == INTEGER_CST
3965 && !integer_zerop (from
))
3967 if (flags
& tf_error
)
3968 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3969 "reinterpret_cast from integer to pointer");
3972 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
3976 /* -- a unary operator & that is applied to an lvalue that
3977 designates an object with thread or automatic storage
3979 t
= TREE_OPERAND (t
, 0);
3981 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
3982 /* A pointer-to-member constant. */
3986 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
3987 any checking here, as we might dereference the pointer later. If
3988 we remove this code, also remove check_automatic_or_tls. */
3989 i
= check_automatic_or_tls (t
);
3994 if (flags
& tf_error
)
3995 error ("address-of an object %qE with thread local or "
3996 "automatic storage is not a constant expression", t
);
4000 return RECUR (t
, any
);
4006 /* -- a class member access unless its postfix-expression is
4007 of literal type or of pointer to literal type. */
4008 /* This test would be redundant, as it follows from the
4009 postfix-expression being a potential constant expression. */
4010 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4012 case EXPR_PACK_EXPANSION
:
4013 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
4017 tree x
= TREE_OPERAND (t
, 0);
4019 if (is_this_parameter (x
))
4021 if (DECL_CONTEXT (x
)
4022 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4024 if (flags
& tf_error
)
4025 error ("use of %<this%> in a constant expression");
4030 return RECUR (x
, rval
);
4033 case STATEMENT_LIST
:
4035 tree_stmt_iterator i
;
4036 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4038 if (!RECUR (tsi_stmt (i
), any
))
4046 if (cxx_dialect
< cxx14
)
4048 if (!RECUR (TREE_OPERAND (t
, 0), any
))
4050 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
4055 if (cxx_dialect
< cxx14
)
4057 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
4059 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
4064 if (!RECUR (IF_COND (t
), rval
))
4066 if (!RECUR (THEN_CLAUSE (t
), any
))
4068 if (!RECUR (ELSE_CLAUSE (t
), any
))
4073 if (!RECUR (DO_COND (t
), rval
))
4075 if (!RECUR (DO_BODY (t
), any
))
4080 if (!RECUR (FOR_INIT_STMT (t
), any
))
4082 if (!RECUR (FOR_COND (t
), rval
))
4084 if (!RECUR (FOR_EXPR (t
), any
))
4086 if (!RECUR (FOR_BODY (t
), any
))
4091 if (!RECUR (WHILE_COND (t
), rval
))
4093 if (!RECUR (WHILE_BODY (t
), any
))
4098 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
4100 if (!RECUR (SWITCH_STMT_BODY (t
), any
))
4105 return RECUR (STMT_EXPR_STMT (t
), rval
);
4108 case DYNAMIC_CAST_EXPR
:
4109 case PSEUDO_DTOR_EXPR
:
4113 case VEC_DELETE_EXPR
:
4116 case OMP_ATOMIC_READ
:
4117 case OMP_ATOMIC_CAPTURE_OLD
:
4118 case OMP_ATOMIC_CAPTURE_NEW
:
4119 /* GCC internal stuff. */
4122 case TRANSACTION_EXPR
:
4125 if (flags
& tf_error
)
4126 error ("expression %qE is not a constant-expression", t
);
4130 /* -- a typeid expression whose operand is of polymorphic
4133 tree e
= TREE_OPERAND (t
, 0);
4134 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
4135 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
4137 if (flags
& tf_error
)
4138 error ("typeid-expression is not a constant expression "
4139 "because %qE is of polymorphic type", e
);
4146 /* -- a subtraction where both operands are pointers. */
4147 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
4148 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
4150 if (flags
& tf_error
)
4151 error ("difference of two pointer expressions is not "
4152 "a constant expression");
4164 /* -- a relational or equality operator where at least
4165 one of the operands is a pointer. */
4166 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
4167 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
4169 if (flags
& tf_error
)
4170 error ("pointer comparison expression is not a "
4171 "constant expression");
4177 case PREINCREMENT_EXPR
:
4178 case POSTINCREMENT_EXPR
:
4179 case PREDECREMENT_EXPR
:
4180 case POSTDECREMENT_EXPR
:
4181 if (cxx_dialect
< cxx14
)
4187 if (TYPE_P (TREE_OPERAND (t
, 0)))
4189 /* else fall through. */
4195 case FIX_TRUNC_EXPR
:
4199 case TRUTH_NOT_EXPR
:
4200 case FIXED_CONVERT_EXPR
:
4201 case UNARY_PLUS_EXPR
:
4203 return RECUR (TREE_OPERAND (t
, 0), rval
);
4206 case CONST_CAST_EXPR
:
4207 case STATIC_CAST_EXPR
:
4208 case REINTERPRET_CAST_EXPR
:
4209 case IMPLICIT_CONV_EXPR
:
4210 if (cxx_dialect
< cxx11
4211 && !dependent_type_p (TREE_TYPE (t
))
4212 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
4213 /* In C++98, a conversion to non-integral type can't be part of a
4214 constant expression. */
4216 if (flags
& tf_error
)
4217 error ("cast to non-integral type %qT in a constant expression",
4222 return (RECUR (TREE_OPERAND (t
, 0),
4223 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
4226 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
4228 case WITH_CLEANUP_EXPR
:
4229 case CLEANUP_POINT_EXPR
:
4230 case MUST_NOT_THROW_EXPR
:
4231 case TRY_CATCH_EXPR
:
4236 case NON_DEPENDENT_EXPR
:
4237 /* For convenience. */
4239 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4242 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4245 if (!literal_type_p (TREE_TYPE (t
)))
4247 if (flags
& tf_error
)
4249 error ("temporary of non-literal type %qT in a "
4250 "constant expression", TREE_TYPE (t
));
4251 explain_non_literal_class (TREE_TYPE (t
));
4256 return RECUR (TREE_OPERAND (t
, 1), rval
);
4260 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4261 constructor_elt
*ce
;
4262 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4263 if (!RECUR (ce
->value
, want_rval
))
4270 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
4271 || DECL_P (TREE_PURPOSE (t
)));
4272 if (!RECUR (TREE_VALUE (t
), want_rval
))
4274 if (TREE_CHAIN (t
) == NULL_TREE
)
4276 return RECUR (TREE_CHAIN (t
), want_rval
);
4279 case TRUNC_DIV_EXPR
:
4281 case FLOOR_DIV_EXPR
:
4282 case ROUND_DIV_EXPR
:
4283 case TRUNC_MOD_EXPR
:
4285 case ROUND_MOD_EXPR
:
4287 tree denom
= TREE_OPERAND (t
, 1);
4288 if (!RECUR (denom
, rval
))
4290 /* We can't call cxx_eval_outermost_constant_expr on an expression
4291 that hasn't been through instantiate_non_dependent_expr yet. */
4292 if (!processing_template_decl
)
4293 denom
= cxx_eval_outermost_constant_expr (denom
, true);
4294 if (integer_zerop (denom
))
4296 if (flags
& tf_error
)
4297 error ("division by zero is not a constant-expression");
4303 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4309 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4310 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4311 introduced by build_call_a. */
4312 tree op0
= TREE_OPERAND (t
, 0);
4313 tree op1
= TREE_OPERAND (t
, 1);
4315 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4316 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4317 return RECUR (op0
, want_rval
);
4322 /* If the first operand is the non-short-circuit constant, look at
4323 the second operand; otherwise we only care about the first one for
4325 case TRUTH_AND_EXPR
:
4326 case TRUTH_ANDIF_EXPR
:
4327 tmp
= boolean_true_node
;
4330 case TRUTH_ORIF_EXPR
:
4331 tmp
= boolean_false_node
;
4334 tree op
= TREE_OPERAND (t
, 0);
4335 if (!RECUR (op
, rval
))
4337 if (!processing_template_decl
)
4338 op
= cxx_eval_outermost_constant_expr (op
, true);
4339 if (tree_int_cst_equal (op
, tmp
))
4340 return RECUR (TREE_OPERAND (t
, 1), rval
);
4347 case POINTER_PLUS_EXPR
:
4349 case EXACT_DIV_EXPR
:
4359 case TRUTH_XOR_EXPR
:
4360 case UNORDERED_EXPR
:
4373 case ARRAY_RANGE_REF
:
4377 for (i
= 0; i
< 2; ++i
)
4378 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
4382 case CILK_SYNC_STMT
:
4383 case CILK_SPAWN_STMT
:
4384 case ARRAY_NOTATION_REF
:
4389 for (i
= 0; i
< 3; ++i
)
4390 if (!RECUR (TREE_OPERAND (t
, i
), true))
4396 /* If the condition is a known constant, we know which of the legs we
4397 care about; otherwise we only require that the condition and
4398 either of the legs be potentially constant. */
4399 tmp
= TREE_OPERAND (t
, 0);
4400 if (!RECUR (tmp
, rval
))
4402 if (!processing_template_decl
)
4403 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
4404 if (integer_zerop (tmp
))
4405 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
4406 else if (TREE_CODE (tmp
) == INTEGER_CST
)
4407 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4408 for (i
= 1; i
< 3; ++i
)
4409 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
4410 want_rval
, strict
, tf_none
))
4412 if (flags
& tf_error
)
4413 error ("expression %qE is not a constant-expression", t
);
4417 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
4419 if (flags
& tf_error
)
4421 error ("non-constant array initialization");
4422 diagnose_non_constexpr_vec_init (t
);
4427 if (objc_is_property_ref (t
))
4430 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
4437 /* The main entry point to the above. */
4440 potential_constant_expression (tree t
)
4442 return potential_constant_expression_1 (t
, false, true, tf_none
);
4446 potential_static_init_expression (tree t
)
4448 return potential_constant_expression_1 (t
, false, false, tf_none
);
4451 /* As above, but require a constant rvalue. */
4454 potential_rvalue_constant_expression (tree t
)
4456 return potential_constant_expression_1 (t
, true, true, tf_none
);
4459 /* Like above, but complain about non-constant expressions. */
4462 require_potential_constant_expression (tree t
)
4464 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
4467 /* Cross product of the above. */
4470 require_potential_rvalue_constant_expression (tree t
)
4472 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
4475 #include "gt-cp-constexpr.h"