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"
31 #include "c-family/c-objc.h"
32 #include "tree-iterator.h"
35 #include "tree-inline.h"
38 static bool verify_constant (tree
, bool, bool *, bool *);
39 #define VERIFY_CONSTANT(X) \
41 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
45 /* Returns true iff FUN is an instantiation of a constexpr function
46 template or a defaulted constexpr function. */
49 is_instantiation_of_constexpr (tree fun
)
51 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
52 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
53 || (DECL_DEFAULTED_FN (fun
)
54 && DECL_DECLARED_CONSTEXPR_P (fun
)));
57 /* Return true if T is a literal type. */
60 literal_type_p (tree t
)
64 || TREE_CODE (t
) == REFERENCE_TYPE
65 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
69 t
= complete_type (t
);
70 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
71 return CLASSTYPE_LITERAL_P (t
);
73 if (TREE_CODE (t
) == ARRAY_TYPE
)
74 return literal_type_p (strip_array_types (t
));
78 /* If DECL is a variable declared `constexpr', require its type
79 be literal. Return the DECL if OK, otherwise NULL. */
82 ensure_literal_type_for_constexpr_object (tree decl
)
84 tree type
= TREE_TYPE (decl
);
86 && (DECL_DECLARED_CONSTEXPR_P (decl
)
87 || var_in_constexpr_fn (decl
))
88 && !processing_template_decl
)
90 tree stype
= strip_array_types (type
);
91 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
92 /* Don't complain here, we'll complain about incompleteness
93 when we try to initialize the variable. */;
94 else if (!literal_type_p (type
))
96 if (DECL_DECLARED_CONSTEXPR_P (decl
))
98 error ("the type %qT of constexpr variable %qD is not literal",
100 explain_non_literal_class (type
);
104 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
106 error ("variable %qD of non-literal type %qT in %<constexpr%> "
107 "function", decl
, type
);
108 explain_non_literal_class (type
);
110 cp_function_chain
->invalid_constexpr
= true;
118 /* Representation of entries in the constexpr function definition table. */
120 struct GTY((for_user
)) constexpr_fundef
{
125 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
127 static hashval_t
hash (constexpr_fundef
*);
128 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
131 /* This table holds all constexpr function definitions seen in
132 the current translation unit. */
134 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
136 /* Utility function used for managing the constexpr function table.
137 Return true if the entries pointed to by P and Q are for the
138 same constexpr function. */
141 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
143 return lhs
->decl
== rhs
->decl
;
146 /* Utility function used for managing the constexpr function table.
147 Return a hash value for the entry pointed to by Q. */
150 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
152 return DECL_UID (fundef
->decl
);
155 /* Return a previously saved definition of function FUN. */
157 static constexpr_fundef
*
158 retrieve_constexpr_fundef (tree fun
)
160 constexpr_fundef fundef
= { NULL
, NULL
};
161 if (constexpr_fundef_table
== NULL
)
165 return constexpr_fundef_table
->find (&fundef
);
168 /* Check whether the parameter and return types of FUN are valid for a
169 constexpr function, and complain if COMPLAIN. */
172 is_valid_constexpr_fn (tree fun
, bool complain
)
176 if (DECL_INHERITED_CTOR_BASE (fun
)
177 && TREE_CODE (fun
) == TEMPLATE_DECL
)
181 error ("inherited constructor %qD is not constexpr",
182 get_inherited_ctor (fun
));
186 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
187 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
188 if (!literal_type_p (TREE_TYPE (parm
)))
193 error ("invalid type for parameter %d of constexpr "
194 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
195 explain_non_literal_class (TREE_TYPE (parm
));
200 if (!DECL_CONSTRUCTOR_P (fun
))
202 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
203 if (!literal_type_p (rettype
))
208 error ("invalid return type %qT of constexpr function %q+D",
210 explain_non_literal_class (rettype
);
214 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
215 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
220 error ("enclosing class of constexpr non-static member "
221 "function %q+#D is not a literal type", fun
);
222 explain_non_literal_class (DECL_CONTEXT (fun
));
226 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
230 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
236 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
237 for a member of an anonymous aggregate, INIT is the initializer for that
238 member, and VEC_OUTER is the vector of constructor elements for the class
239 whose constructor we are processing. Add the initializer to the vector
240 and return true to indicate success. */
243 build_anon_member_initialization (tree member
, tree init
,
244 vec
<constructor_elt
, va_gc
> **vec_outer
)
246 /* MEMBER presents the relevant fields from the inside out, but we need
247 to build up the initializer from the outside in so that we can reuse
248 previously built CONSTRUCTORs if this is, say, the second field in an
249 anonymous struct. So we use a vec as a stack. */
250 auto_vec
<tree
, 2> fields
;
253 fields
.safe_push (TREE_OPERAND (member
, 1));
254 member
= TREE_OPERAND (member
, 0);
256 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
257 && TREE_CODE (member
) == COMPONENT_REF
);
259 /* VEC has the constructor elements vector for the context of FIELD.
260 If FIELD is an anonymous aggregate, we will push inside it. */
261 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
263 while (field
= fields
.pop(),
264 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
267 /* If there is already an outer constructor entry for the anonymous
268 aggregate FIELD, use it; otherwise, insert one. */
269 if (vec_safe_is_empty (*vec
)
270 || (*vec
)->last().index
!= field
)
272 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
273 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
276 ctor
= (*vec
)->last().value
;
277 vec
= &CONSTRUCTOR_ELTS (ctor
);
280 /* Now we're at the innermost field, the one that isn't an anonymous
281 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
282 gcc_assert (fields
.is_empty());
283 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
288 /* Subroutine of build_constexpr_constructor_member_initializers.
289 The expression tree T represents a data member initialization
290 in a (constexpr) constructor definition. Build a pairing of
291 the data member with its initializer, and prepend that pair
292 to the existing initialization pair INITS. */
295 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
298 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
299 t
= TREE_OPERAND (t
, 0);
300 if (TREE_CODE (t
) == EXPR_STMT
)
301 t
= TREE_OPERAND (t
, 0);
302 if (t
== error_mark_node
)
304 if (TREE_CODE (t
) == STATEMENT_LIST
)
306 tree_stmt_iterator i
;
307 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
309 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
314 if (TREE_CODE (t
) == CLEANUP_STMT
)
316 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
317 but we can in a constexpr constructor for a non-literal class. Just
318 ignore it; either all the initialization will be constant, in which
319 case the cleanup can't run, or it can't be constexpr.
320 Still recurse into CLEANUP_BODY. */
321 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
323 if (TREE_CODE (t
) == CONVERT_EXPR
)
324 t
= TREE_OPERAND (t
, 0);
325 if (TREE_CODE (t
) == INIT_EXPR
326 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
327 use what this function builds for cx_check_missing_mem_inits, and
328 assignment in the ctor body doesn't count. */
329 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
331 member
= TREE_OPERAND (t
, 0);
332 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
334 else if (TREE_CODE (t
) == CALL_EXPR
)
336 tree fn
= get_callee_fndecl (t
);
337 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
338 /* We're only interested in calls to subobject constructors. */
340 member
= CALL_EXPR_ARG (t
, 0);
341 /* We don't use build_cplus_new here because it complains about
342 abstract bases. Leaving the call unwrapped means that it has the
343 wrong type, but cxx_eval_constant_expression doesn't care. */
344 init
= break_out_target_exprs (t
);
346 else if (TREE_CODE (t
) == BIND_EXPR
)
347 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
349 /* Don't add anything else to the CONSTRUCTOR. */
351 if (INDIRECT_REF_P (member
))
352 member
= TREE_OPERAND (member
, 0);
353 if (TREE_CODE (member
) == NOP_EXPR
)
357 if (TREE_CODE (op
) == ADDR_EXPR
)
359 gcc_assert (same_type_ignoring_top_level_qualifiers_p
360 (TREE_TYPE (TREE_TYPE (op
)),
361 TREE_TYPE (TREE_TYPE (member
))));
362 /* Initializing a cv-qualified member; we need to look through
366 else if (op
== current_class_ptr
367 && (same_type_ignoring_top_level_qualifiers_p
368 (TREE_TYPE (TREE_TYPE (member
)),
369 current_class_type
)))
370 /* Delegating constructor. */
374 /* This is an initializer for an empty base; keep it for now so
375 we can check it in cxx_eval_bare_aggregate. */
376 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
379 if (TREE_CODE (member
) == ADDR_EXPR
)
380 member
= TREE_OPERAND (member
, 0);
381 if (TREE_CODE (member
) == COMPONENT_REF
)
383 tree aggr
= TREE_OPERAND (member
, 0);
384 if (TREE_CODE (aggr
) != COMPONENT_REF
)
385 /* Normal member initialization. */
386 member
= TREE_OPERAND (member
, 1);
387 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
388 /* Initializing a member of an anonymous union. */
389 return build_anon_member_initialization (member
, init
, vec
);
391 /* We're initializing a vtable pointer in a base. Leave it as
392 COMPONENT_REF so we remember the path to get to the vfield. */
393 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
396 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
400 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
401 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
402 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
405 check_constexpr_bind_expr_vars (tree t
)
407 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
409 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
410 if (TREE_CODE (var
) == TYPE_DECL
411 && DECL_IMPLICIT_TYPEDEF_P (var
)
412 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
417 /* Subroutine of check_constexpr_ctor_body. */
420 check_constexpr_ctor_body_1 (tree last
, tree list
)
422 switch (TREE_CODE (list
))
425 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
)
429 case CLEANUP_POINT_EXPR
:
430 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
434 if (!check_constexpr_bind_expr_vars (list
)
435 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
449 /* Make sure that there are no statements after LAST in the constructor
450 body represented by LIST. */
453 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
455 /* C++14 doesn't require a constexpr ctor to have an empty body. */
456 if (cxx_dialect
>= cxx14
)
460 if (TREE_CODE (list
) == STATEMENT_LIST
)
462 tree_stmt_iterator i
= tsi_last (list
);
463 for (; !tsi_end_p (i
); tsi_prev (&i
))
465 tree t
= tsi_stmt (i
);
468 if (!check_constexpr_ctor_body_1 (last
, t
))
475 else if (list
!= last
476 && !check_constexpr_ctor_body_1 (last
, list
))
481 error ("constexpr constructor does not have empty body");
482 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
487 /* V is a vector of constructor elements built up for the base and member
488 initializers of a constructor for TYPE. They need to be in increasing
489 offset order, which they might not be yet if TYPE has a primary base
490 which is not first in the base-clause or a vptr and at least one base
491 all of which are non-primary. */
493 static vec
<constructor_elt
, va_gc
> *
494 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
496 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
502 field_type
= BINFO_TYPE (pri
);
503 else if (TYPE_CONTAINS_VPTR_P (type
))
504 field_type
= vtbl_ptr_type_node
;
508 /* Find the element for the primary base or vptr and move it to the
509 beginning of the vec. */
510 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
511 if (TREE_TYPE (ce
->index
) == field_type
)
514 if (i
> 0 && i
< vec_safe_length (v
))
516 vec
<constructor_elt
, va_gc
> &vref
= *v
;
517 constructor_elt elt
= vref
[i
];
526 /* Build compile-time evalable representations of member-initializer list
527 for a constexpr constructor. */
530 build_constexpr_constructor_member_initializers (tree type
, tree body
)
532 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
534 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
535 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
536 body
= TREE_OPERAND (body
, 0);
537 if (TREE_CODE (body
) == STATEMENT_LIST
)
539 for (tree_stmt_iterator i
= tsi_start (body
);
540 !tsi_end_p (i
); tsi_next (&i
))
543 if (TREE_CODE (body
) == BIND_EXPR
)
547 if (TREE_CODE (body
) == BIND_EXPR
)
548 body
= BIND_EXPR_BODY (body
);
549 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
551 body
= TREE_OPERAND (body
, 0);
552 if (TREE_CODE (body
) == EXPR_STMT
)
553 body
= TREE_OPERAND (body
, 0);
554 if (TREE_CODE (body
) == INIT_EXPR
555 && (same_type_ignoring_top_level_qualifiers_p
556 (TREE_TYPE (TREE_OPERAND (body
, 0)),
557 current_class_type
)))
560 return TREE_OPERAND (body
, 1);
562 ok
= build_data_member_initialization (body
, &vec
);
564 else if (TREE_CODE (body
) == STATEMENT_LIST
)
566 tree_stmt_iterator i
;
567 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
569 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
574 else if (TREE_CODE (body
) == TRY_BLOCK
)
576 error ("body of %<constexpr%> constructor cannot be "
577 "a function-try-block");
578 return error_mark_node
;
580 else if (EXPR_P (body
))
581 ok
= build_data_member_initialization (body
, &vec
);
583 gcc_assert (errorcount
> 0);
586 if (vec_safe_length (vec
) > 0)
588 /* In a delegating constructor, return the target. */
589 constructor_elt
*ce
= &(*vec
)[0];
590 if (ce
->index
== current_class_ptr
)
597 vec
= sort_constexpr_mem_initializers (type
, vec
);
598 return build_constructor (type
, vec
);
601 return error_mark_node
;
604 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
605 declared to be constexpr, or a sub-statement thereof. Returns the
606 return value if suitable, error_mark_node for a statement not allowed in
607 a constexpr function, or NULL_TREE if no return value was found. */
610 constexpr_fn_retval (tree body
)
612 switch (TREE_CODE (body
))
616 tree_stmt_iterator i
;
617 tree expr
= NULL_TREE
;
618 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
620 tree s
= constexpr_fn_retval (tsi_stmt (i
));
621 if (s
== error_mark_node
)
622 return error_mark_node
;
623 else if (s
== NULL_TREE
)
624 /* Keep iterating. */;
626 /* Multiple return statements. */
627 return error_mark_node
;
635 return break_out_target_exprs (TREE_OPERAND (body
, 0));
639 tree decl
= DECL_EXPR_DECL (body
);
640 if (TREE_CODE (decl
) == USING_DECL
641 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
642 || DECL_ARTIFICIAL (decl
))
644 return error_mark_node
;
647 case CLEANUP_POINT_EXPR
:
648 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
651 if (!check_constexpr_bind_expr_vars (body
))
652 return error_mark_node
;
653 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
659 return error_mark_node
;
663 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
664 FUN; do the necessary transformations to turn it into a single expression
665 that we can store in the hash table. */
668 massage_constexpr_body (tree fun
, tree body
)
670 if (DECL_CONSTRUCTOR_P (fun
))
671 body
= build_constexpr_constructor_member_initializers
672 (DECL_CONTEXT (fun
), body
);
673 else if (cxx_dialect
< cxx14
)
675 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
676 body
= EH_SPEC_STMTS (body
);
677 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
678 body
= TREE_OPERAND (body
, 0);
679 body
= constexpr_fn_retval (body
);
684 /* FUN is a constexpr constructor with massaged body BODY. Return true
685 if some bases/fields are uninitialized, and complain if COMPLAIN. */
688 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
695 if (TREE_CODE (body
) != CONSTRUCTOR
)
698 nelts
= CONSTRUCTOR_NELTS (body
);
699 ctype
= DECL_CONTEXT (fun
);
700 field
= TYPE_FIELDS (ctype
);
702 if (TREE_CODE (ctype
) == UNION_TYPE
)
704 if (nelts
== 0 && next_initializable_field (field
))
707 error ("%<constexpr%> constructor for union %qT must "
708 "initialize exactly one non-static data member", ctype
);
715 for (i
= 0; i
<= nelts
; ++i
)
722 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
723 /* Skip base and vtable inits. */
724 if (TREE_CODE (index
) != FIELD_DECL
725 || DECL_ARTIFICIAL (index
))
728 for (; field
!= index
; field
= DECL_CHAIN (field
))
731 if (TREE_CODE (field
) != FIELD_DECL
732 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
733 || DECL_ARTIFICIAL (field
))
735 ftype
= strip_array_types (TREE_TYPE (field
));
736 if (type_has_constexpr_default_constructor (ftype
))
738 /* It's OK to skip a member with a trivial constexpr ctor.
739 A constexpr ctor that isn't trivial should have been
741 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
747 error ("member %qD must be initialized by mem-initializer "
748 "in %<constexpr%> constructor", field
);
749 inform (DECL_SOURCE_LOCATION (field
), "declared here");
752 if (field
== NULL_TREE
)
754 field
= DECL_CHAIN (field
);
760 /* We are processing the definition of the constexpr function FUN.
761 Check that its BODY fulfills the propriate requirements and
762 enter it in the constexpr function definition table.
763 For constructor BODY is actually the TREE_LIST of the
764 member-initializer list. */
767 register_constexpr_fundef (tree fun
, tree body
)
769 constexpr_fundef entry
;
770 constexpr_fundef
**slot
;
772 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
775 body
= massage_constexpr_body (fun
, body
);
776 if (body
== NULL_TREE
|| body
== error_mark_node
)
778 if (!DECL_CONSTRUCTOR_P (fun
))
779 error ("body of constexpr function %qD not a return-statement", fun
);
783 if (!potential_rvalue_constant_expression (body
))
785 if (!DECL_GENERATED_P (fun
))
786 require_potential_rvalue_constant_expression (body
);
790 if (DECL_CONSTRUCTOR_P (fun
)
791 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
794 /* Create the constexpr function table if necessary. */
795 if (constexpr_fundef_table
== NULL
)
796 constexpr_fundef_table
797 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
801 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
803 gcc_assert (*slot
== NULL
);
804 *slot
= ggc_alloc
<constexpr_fundef
> ();
810 /* FUN is a non-constexpr function called in a context that requires a
811 constant expression. If it comes from a constexpr template, explain why
812 the instantiation isn't constexpr. */
815 explain_invalid_constexpr_fn (tree fun
)
817 static hash_set
<tree
> *diagnosed
;
820 /* Only diagnose defaulted functions or instantiations. */
821 if (!DECL_DEFAULTED_FN (fun
)
822 && !is_instantiation_of_constexpr (fun
))
824 if (diagnosed
== NULL
)
825 diagnosed
= new hash_set
<tree
>;
826 if (diagnosed
->add (fun
))
827 /* Already explained. */
830 save_loc
= input_location
;
831 input_location
= DECL_SOURCE_LOCATION (fun
);
832 inform (input_location
,
833 "%qD is not usable as a constexpr function because:", fun
);
834 /* First check the declaration. */
835 if (is_valid_constexpr_fn (fun
, true))
837 /* Then if it's OK, the body. */
838 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
839 explain_implicit_non_constexpr (fun
);
842 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
843 require_potential_rvalue_constant_expression (body
);
844 if (DECL_CONSTRUCTOR_P (fun
))
845 cx_check_missing_mem_inits (fun
, body
, true);
848 input_location
= save_loc
;
851 /* Objects of this type represent calls to constexpr functions
852 along with the bindings of parameters to their arguments, for
853 the purpose of compile time evaluation. */
855 struct GTY((for_user
)) constexpr_call
{
856 /* Description of the constexpr function definition. */
857 constexpr_fundef
*fundef
;
858 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
859 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
860 Note: This arrangement is made to accommodate the use of
861 iterative_hash_template_arg (see pt.c). If you change this
862 representation, also change the hash calculation in
863 cxx_eval_call_expression. */
865 /* Result of the call.
866 NULL means the call is being evaluated.
867 error_mark_node means that the evaluation was erroneous;
868 otherwise, the actuall value of the call. */
870 /* The hash of this call; we remember it here to avoid having to
871 recalculate it when expanding the hash table. */
875 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
877 static hashval_t
hash (constexpr_call
*);
878 static bool equal (constexpr_call
*, constexpr_call
*);
881 /* The constexpr expansion context. CALL is the current function
882 expansion, CTOR is the current aggregate initializer, OBJECT is the
883 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
884 is a map of values of variables initialized within the expression. */
886 struct constexpr_ctx
{
887 /* The innermost call we're evaluating. */
888 constexpr_call
*call
;
889 /* Values for any temporaries or local variables within the
890 constant-expression. */
891 hash_map
<tree
,tree
> *values
;
892 /* The CONSTRUCTOR we're currently building up for an aggregate
895 /* The object we're building the CONSTRUCTOR for. */
897 /* Whether we should error on a non-constant expression or fail quietly. */
899 /* Whether we are strictly conforming to constant expression rules or
900 trying harder to get a constant value. */
904 /* A table of all constexpr calls that have been evaluated by the
905 compiler in this translation unit. */
907 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
909 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
910 bool, bool *, bool *, tree
* = NULL
);
912 /* Compute a hash value for a constexpr call representation. */
915 constexpr_call_hasher::hash (constexpr_call
*info
)
920 /* Return true if the objects pointed to by P and Q represent calls
921 to the same constexpr function with the same arguments.
922 Otherwise, return false. */
925 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
931 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
933 lhs_bindings
= lhs
->bindings
;
934 rhs_bindings
= rhs
->bindings
;
935 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
937 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
938 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
939 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
940 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
942 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
943 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
945 return lhs_bindings
== rhs_bindings
;
948 /* Initialize the constexpr call table, if needed. */
951 maybe_initialize_constexpr_call_table (void)
953 if (constexpr_call_table
== NULL
)
954 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
957 /* We have an expression tree T that represents a call, either CALL_EXPR
958 or AGGR_INIT_EXPR. If the call is lexically to a named function,
959 retrun the _DECL for that function. */
962 get_function_named_in_call (tree t
)
965 switch (TREE_CODE (t
))
968 fun
= CALL_EXPR_FN (t
);
972 fun
= AGGR_INIT_EXPR_FN (t
);
979 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
980 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
981 fun
= TREE_OPERAND (fun
, 0);
985 /* We have an expression tree T that represents a call, either CALL_EXPR
986 or AGGR_INIT_EXPR. Return the Nth argument. */
989 get_nth_callarg (tree t
, int n
)
991 switch (TREE_CODE (t
))
994 return CALL_EXPR_ARG (t
, n
);
997 return AGGR_INIT_EXPR_ARG (t
, n
);
1005 /* Attempt to evaluate T which represents a call to a builtin function.
1006 We assume here that all builtin functions evaluate to scalar types
1007 represented by _CST nodes. */
1010 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1012 bool *non_constant_p
, bool *overflow_p
)
1014 const int nargs
= call_expr_nargs (t
);
1015 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1019 /* Don't fold __builtin_constant_p within a constexpr function. */
1020 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
1021 && current_function_decl
1022 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1024 *non_constant_p
= true;
1028 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1029 return constant false for a non-constant argument. */
1030 constexpr_ctx new_ctx
= *ctx
;
1031 new_ctx
.quiet
= true;
1032 bool dummy1
= false, dummy2
= false;
1033 for (i
= 0; i
< nargs
; ++i
)
1034 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1035 lval
, &dummy1
, &dummy2
);
1037 bool save_ffbcp
= force_folding_builtin_constant_p
;
1038 force_folding_builtin_constant_p
= true;
1039 new_call
= fold_build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1040 CALL_EXPR_FN (t
), nargs
, args
);
1041 force_folding_builtin_constant_p
= save_ffbcp
;
1042 VERIFY_CONSTANT (new_call
);
1046 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1047 the type of the value to match. */
1050 adjust_temp_type (tree type
, tree temp
)
1052 if (TREE_TYPE (temp
) == type
)
1054 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1055 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1056 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1057 gcc_assert (scalarish_type_p (type
));
1058 return cp_fold_convert (type
, temp
);
1061 /* Subroutine of cxx_eval_call_expression.
1062 We are processing a call expression (either CALL_EXPR or
1063 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1064 all arguments and bind their values to correspondings
1065 parameters, making up the NEW_CALL context. */
1068 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1069 constexpr_call
*new_call
,
1070 bool *non_constant_p
, bool *overflow_p
,
1071 bool *non_constant_args
)
1073 const int nargs
= call_expr_nargs (t
);
1074 tree fun
= new_call
->fundef
->decl
;
1075 tree parms
= DECL_ARGUMENTS (fun
);
1077 tree
*p
= &new_call
->bindings
;
1078 for (i
= 0; i
< nargs
; ++i
)
1081 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1082 x
= get_nth_callarg (t
, i
);
1083 /* For member function, the first argument is a pointer to the implied
1084 object. For a constructor, it might still be a dummy object, in
1085 which case we get the real argument from ctx. */
1086 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1087 && is_dummy_object (x
))
1090 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1093 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1094 non_constant_p
, overflow_p
);
1095 /* Don't VERIFY_CONSTANT here. */
1096 if (*non_constant_p
&& ctx
->quiet
)
1098 /* Just discard ellipsis args after checking their constantitude. */
1101 if (*non_constant_p
)
1102 /* Don't try to adjust the type of non-constant args. */
1105 /* Make sure the binding has the same type as the parm. */
1106 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1107 arg
= adjust_temp_type (type
, arg
);
1108 if (!TREE_CONSTANT (arg
))
1109 *non_constant_args
= true;
1110 *p
= build_tree_list (parms
, arg
);
1111 p
= &TREE_CHAIN (*p
);
1113 parms
= TREE_CHAIN (parms
);
1117 /* Variables and functions to manage constexpr call expansion context.
1118 These do not need to be marked for PCH or GC. */
1120 /* FIXME remember and print actual constant arguments. */
1121 static vec
<tree
> call_stack
= vNULL
;
1122 static int call_stack_tick
;
1123 static int last_cx_error_tick
;
1126 push_cx_call_context (tree call
)
1129 if (!EXPR_HAS_LOCATION (call
))
1130 SET_EXPR_LOCATION (call
, input_location
);
1131 call_stack
.safe_push (call
);
1132 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1138 pop_cx_call_context (void)
1145 cx_error_context (void)
1147 vec
<tree
> r
= vNULL
;
1148 if (call_stack_tick
!= last_cx_error_tick
1149 && !call_stack
.is_empty ())
1151 last_cx_error_tick
= call_stack_tick
;
1155 /* Subroutine of cxx_eval_constant_expression.
1156 Evaluate the call expression tree T in the context of OLD_CALL expression
1160 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1162 bool *non_constant_p
, bool *overflow_p
)
1164 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1165 tree fun
= get_function_named_in_call (t
);
1166 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1169 if (fun
== NULL_TREE
)
1170 switch (CALL_EXPR_IFN (t
))
1172 case IFN_UBSAN_NULL
:
1173 case IFN_UBSAN_BOUNDS
:
1174 case IFN_UBSAN_VPTR
:
1178 error_at (loc
, "call to internal function");
1179 *non_constant_p
= true;
1183 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1185 /* Might be a constexpr function pointer. */
1186 fun
= cxx_eval_constant_expression (ctx
, fun
,
1187 /*lval*/false, non_constant_p
,
1190 if (TREE_CODE (fun
) == ADDR_EXPR
)
1191 fun
= TREE_OPERAND (fun
, 0);
1193 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1195 if (!ctx
->quiet
&& !*non_constant_p
)
1196 error_at (loc
, "expression %qE does not designate a constexpr "
1198 *non_constant_p
= true;
1201 if (DECL_CLONED_FUNCTION_P (fun
))
1202 fun
= DECL_CLONED_FUNCTION (fun
);
1204 if (is_ubsan_builtin_p (fun
))
1207 if (is_builtin_fn (fun
))
1208 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1209 lval
, non_constant_p
, overflow_p
);
1210 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1214 error_at (loc
, "call to non-constexpr function %qD", fun
);
1215 explain_invalid_constexpr_fn (fun
);
1217 *non_constant_p
= true;
1221 /* Shortcut trivial constructor/op=. */
1222 if (trivial_fn_p (fun
))
1224 if (call_expr_nargs (t
) == 2)
1226 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
1227 return cxx_eval_constant_expression (ctx
, arg
,
1228 lval
, non_constant_p
,
1231 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1232 && AGGR_INIT_ZERO_FIRST (t
))
1233 return build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1236 /* We can't defer instantiating the function any longer. */
1237 if (!DECL_INITIAL (fun
)
1238 && DECL_TEMPLOID_INSTANTIATION (fun
))
1241 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1245 /* If in direct recursive call, optimize definition search. */
1246 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1247 new_call
.fundef
= ctx
->call
->fundef
;
1250 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1251 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
1255 if (DECL_INITIAL (fun
))
1257 /* The definition of fun was somehow unsuitable. */
1258 error_at (loc
, "%qD called in a constant expression", fun
);
1259 explain_invalid_constexpr_fn (fun
);
1262 error_at (loc
, "%qD used before its definition", fun
);
1264 *non_constant_p
= true;
1269 constexpr_ctx new_ctx
= *ctx
;
1270 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1271 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1273 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1274 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1275 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1276 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1277 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1278 ctx
->values
->put (new_ctx
.object
, ctor
);
1282 bool non_constant_args
= false;
1283 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1284 non_constant_p
, overflow_p
, &non_constant_args
);
1285 if (*non_constant_p
)
1288 depth_ok
= push_cx_call_context (t
);
1290 tree result
= NULL_TREE
;
1292 constexpr_call
*entry
= NULL
;
1293 if (depth_ok
&& !non_constant_args
)
1295 new_call
.hash
= iterative_hash_template_arg
1296 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1298 /* If we have seen this call before, we are done. */
1299 maybe_initialize_constexpr_call_table ();
1300 constexpr_call
**slot
1301 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1305 /* We need to keep a pointer to the entry, not just the slot, as the
1306 slot can move in the call to cxx_eval_builtin_function_call. */
1307 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1310 /* Calls which are in progress have their result set to NULL
1311 so that we can detect circular dependencies. */
1312 else if (entry
->result
== NULL
)
1315 error ("call has circular dependency");
1316 *non_constant_p
= true;
1317 entry
->result
= result
= error_mark_node
;
1320 result
= entry
->result
;
1326 error ("constexpr evaluation depth exceeds maximum of %d (use "
1327 "-fconstexpr-depth= to increase the maximum)",
1328 max_constexpr_depth
);
1329 *non_constant_p
= true;
1330 result
= error_mark_node
;
1334 if (!result
|| result
== error_mark_node
)
1336 if (DECL_SAVED_TREE (fun
) == NULL_TREE
1337 && (DECL_CONSTRUCTOR_P (fun
) || DECL_DESTRUCTOR_P (fun
)))
1338 /* The maybe-in-charge 'tor had its DECL_SAVED_TREE
1339 cleared, try a clone. */
1340 for (fun
= DECL_CHAIN (fun
);
1341 fun
&& DECL_CLONED_FUNCTION_P (fun
);
1342 fun
= DECL_CHAIN (fun
))
1343 if (DECL_SAVED_TREE (fun
))
1345 gcc_assert (DECL_SAVED_TREE (fun
));
1348 /* Unshare the whole function body. */
1349 tree body
= copy_fn (fun
, parms
, res
);
1351 /* Associate the bindings with the remapped parms. */
1352 tree bound
= new_call
.bindings
;
1353 tree remapped
= parms
;
1356 tree oparm
= TREE_PURPOSE (bound
);
1357 tree arg
= TREE_VALUE (bound
);
1358 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1359 ctx
->values
->put (remapped
, arg
);
1360 bound
= TREE_CHAIN (bound
);
1361 remapped
= DECL_CHAIN (remapped
);
1363 /* Add the RESULT_DECL to the values map, too. */
1364 tree slot
= NULL_TREE
;
1365 if (DECL_BY_REFERENCE (res
))
1367 slot
= AGGR_INIT_EXPR_SLOT (t
);
1368 tree addr
= build_address (slot
);
1369 addr
= build_nop (TREE_TYPE (res
), addr
);
1370 ctx
->values
->put (res
, addr
);
1371 ctx
->values
->put (slot
, NULL_TREE
);
1374 ctx
->values
->put (res
, NULL_TREE
);
1376 tree jump_target
= NULL_TREE
;
1377 cxx_eval_constant_expression (ctx
, body
,
1378 lval
, non_constant_p
, overflow_p
,
1381 if (DECL_CONSTRUCTOR_P (fun
))
1382 /* This can be null for a subobject constructor call, in
1383 which case what we care about is the initialization
1384 side-effects rather than the value. We could get at the
1385 value by evaluating *this, but we don't bother; there's
1386 no need to put such a call in the hash table. */
1387 result
= lval
? ctx
->object
: ctx
->ctor
;
1388 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1392 result
= *ctx
->values
->get (slot
? slot
: res
);
1393 if (result
== NULL_TREE
&& !*non_constant_p
)
1396 error ("constexpr call flows off the end "
1398 *non_constant_p
= true;
1402 /* Remove the parms/result from the values map. Is it worth
1403 bothering to do this when the map itself is only live for
1404 one constexpr evaluation? If so, maybe also clear out
1405 other vars from call, maybe in BIND_EXPR handling? */
1406 ctx
->values
->remove (res
);
1408 ctx
->values
->remove (slot
);
1409 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1410 ctx
->values
->remove (parm
);
1413 if (result
== error_mark_node
)
1414 *non_constant_p
= true;
1415 if (*non_constant_p
)
1416 result
= error_mark_node
;
1420 entry
->result
= result
;
1423 pop_cx_call_context ();
1424 return unshare_expr (result
);
1427 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1430 reduced_constant_expression_p (tree t
)
1432 switch (TREE_CODE (t
))
1435 /* Even if we can't lower this yet, it's constant. */
1439 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1440 tree elt
; unsigned HOST_WIDE_INT idx
;
1441 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1442 if (!reduced_constant_expression_p (elt
))
1447 /* FIXME are we calling this too much? */
1448 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1452 /* Some expressions may have constant operands but are not constant
1453 themselves, such as 1/0. Call this function (or rather, the macro
1454 following it) to check for that condition.
1456 We only call this in places that require an arithmetic constant, not in
1457 places where we might have a non-constant expression that can be a
1458 component of a constant expression, such as the address of a constexpr
1459 variable that might be dereferenced later. */
1462 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1465 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1467 if (!allow_non_constant
)
1468 error ("%q+E is not a constant expression", t
);
1469 *non_constant_p
= true;
1471 if (TREE_OVERFLOW_P (t
))
1473 if (!allow_non_constant
)
1475 permerror (input_location
, "overflow in constant expression");
1476 /* If we're being permissive (and are in an enforcing
1477 context), ignore the overflow. */
1478 if (flag_permissive
)
1479 return *non_constant_p
;
1483 return *non_constant_p
;
1486 /* Check whether the shift operation with code CODE and type TYPE on LHS
1487 and RHS is undefined. If it is, give an error with an explanation,
1488 and return true; return false otherwise. */
1491 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1492 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1494 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1495 || TREE_CODE (lhs
) != INTEGER_CST
1496 || TREE_CODE (rhs
) != INTEGER_CST
)
1499 tree lhstype
= TREE_TYPE (lhs
);
1500 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1502 /* [expr.shift] The behavior is undefined if the right operand
1503 is negative, or greater than or equal to the length in bits
1504 of the promoted left operand. */
1505 if (tree_int_cst_sgn (rhs
) == -1)
1508 error_at (loc
, "right operand of shift expression %q+E is negative",
1509 build2_loc (loc
, code
, type
, lhs
, rhs
));
1512 if (compare_tree_int (rhs
, uprec
) >= 0)
1515 error_at (loc
, "right operand of shift expression %q+E is >= than "
1516 "the precision of the left operand",
1517 build2_loc (loc
, code
, type
, lhs
, rhs
));
1521 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1522 if E1 has a signed type and non-negative value, and E1x2^E2 is
1523 representable in the corresponding unsigned type of the result type,
1524 then that value, converted to the result type, is the resulting value;
1525 otherwise, the behavior is undefined. */
1526 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1527 && (cxx_dialect
>= cxx11
))
1529 if (tree_int_cst_sgn (lhs
) == -1)
1532 error_at (loc
, "left operand of shift expression %q+E is negative",
1533 build2_loc (loc
, code
, type
, lhs
, rhs
));
1536 /* For signed x << y the following:
1537 (unsigned) x >> ((prec (lhs) - 1) - y)
1538 if > 1, is undefined. The right-hand side of this formula
1539 is the highest bit of the LHS that can be set (starting from 0),
1540 so that the shift doesn't overflow. We then right-shift the LHS
1541 to see whether any other bit is set making the original shift
1542 undefined -- the result is not representable in the corresponding
1544 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1545 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1546 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1547 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1548 if (tree_int_cst_lt (integer_one_node
, t
))
1551 error_at (loc
, "shift expression %q+E overflows",
1552 build2_loc (loc
, code
, type
, lhs
, rhs
));
1559 /* Subroutine of cxx_eval_constant_expression.
1560 Attempt to reduce the unary expression tree T to a compile time value.
1561 If successful, return the value. Otherwise issue a diagnostic
1562 and return error_mark_node. */
1565 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1567 bool *non_constant_p
, bool *overflow_p
)
1570 tree orig_arg
= TREE_OPERAND (t
, 0);
1571 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1572 non_constant_p
, overflow_p
);
1573 VERIFY_CONSTANT (arg
);
1574 location_t loc
= EXPR_LOCATION (t
);
1575 enum tree_code code
= TREE_CODE (t
);
1576 tree type
= TREE_TYPE (t
);
1577 r
= fold_unary_loc (loc
, code
, type
, arg
);
1580 if (arg
== orig_arg
)
1583 r
= build1_loc (loc
, code
, type
, arg
);
1585 VERIFY_CONSTANT (r
);
1589 /* Subroutine of cxx_eval_constant_expression.
1590 Like cxx_eval_unary_expression, except for binary expressions. */
1593 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1595 bool *non_constant_p
, bool *overflow_p
)
1598 tree orig_lhs
= TREE_OPERAND (t
, 0);
1599 tree orig_rhs
= TREE_OPERAND (t
, 1);
1601 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1602 non_constant_p
, overflow_p
);
1603 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1604 a local array in a constexpr function. */
1605 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1607 VERIFY_CONSTANT (lhs
);
1608 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1609 non_constant_p
, overflow_p
);
1611 VERIFY_CONSTANT (rhs
);
1613 location_t loc
= EXPR_LOCATION (t
);
1614 enum tree_code code
= TREE_CODE (t
);
1615 tree type
= TREE_TYPE (t
);
1616 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1619 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1622 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1624 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1625 *non_constant_p
= true;
1627 VERIFY_CONSTANT (r
);
1631 /* Subroutine of cxx_eval_constant_expression.
1632 Attempt to evaluate condition expressions. Dead branches are not
1636 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1638 bool *non_constant_p
, bool *overflow_p
,
1641 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1643 non_constant_p
, overflow_p
);
1644 VERIFY_CONSTANT (val
);
1645 /* Don't VERIFY_CONSTANT the other operands. */
1646 if (integer_zerop (val
))
1647 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1649 non_constant_p
, overflow_p
,
1651 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1653 non_constant_p
, overflow_p
,
1657 /* Returns less than, equal to, or greater than zero if KEY is found to be
1658 less than, to match, or to be greater than the constructor_elt's INDEX. */
1661 array_index_cmp (tree key
, tree index
)
1663 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
1665 switch (TREE_CODE (index
))
1668 return tree_int_cst_compare (key
, index
);
1671 tree lo
= TREE_OPERAND (index
, 0);
1672 tree hi
= TREE_OPERAND (index
, 1);
1673 if (tree_int_cst_lt (key
, lo
))
1675 else if (tree_int_cst_lt (hi
, key
))
1685 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
1686 if none. If INSERT is true, insert a matching element rather than fail. */
1688 static HOST_WIDE_INT
1689 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
1691 if (tree_int_cst_sgn (dindex
) < 0)
1694 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
1695 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
1696 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
1698 unsigned HOST_WIDE_INT end
= len
;
1699 unsigned HOST_WIDE_INT begin
= 0;
1701 /* If the last element of the CONSTRUCTOR has its own index, we can assume
1702 that the same is true of the other elements and index directly. */
1705 tree cindex
= (*elts
)[end
-1].index
;
1706 if (TREE_CODE (cindex
) == INTEGER_CST
1707 && compare_tree_int (cindex
, end
-1) == 0)
1716 /* Otherwise, find a matching index by means of a binary search. */
1717 while (begin
!= end
)
1719 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
1721 int cmp
= array_index_cmp (dindex
, (*elts
)[middle
].index
);
1732 constructor_elt e
= { dindex
, NULL_TREE
};
1733 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
1741 /* Subroutine of cxx_eval_constant_expression.
1742 Attempt to reduce a reference to an array slot. */
1745 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
1747 bool *non_constant_p
, bool *overflow_p
)
1749 tree oldary
= TREE_OPERAND (t
, 0);
1750 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
1752 non_constant_p
, overflow_p
);
1756 unsigned len
, elem_nchars
= 1;
1757 if (*non_constant_p
)
1759 oldidx
= TREE_OPERAND (t
, 1);
1760 index
= cxx_eval_constant_expression (ctx
, oldidx
,
1762 non_constant_p
, overflow_p
);
1763 VERIFY_CONSTANT (index
);
1764 if (lval
&& ary
== oldary
&& index
== oldidx
)
1767 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
1768 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
1769 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1770 len
= CONSTRUCTOR_NELTS (ary
);
1771 else if (TREE_CODE (ary
) == STRING_CST
)
1773 elem_nchars
= (TYPE_PRECISION (elem_type
)
1774 / TYPE_PRECISION (char_type_node
));
1775 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
1779 /* We can't do anything with other tree codes, so use
1780 VERIFY_CONSTANT to complain and fail. */
1781 VERIFY_CONSTANT (ary
);
1785 i
= tree_to_shwi (index
);
1789 error ("negative array subscript");
1790 *non_constant_p
= true;
1795 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1797 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
1807 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
1809 if (TREE_CODE (ary
) == CONSTRUCTOR
1810 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
1812 /* 'ary' is part of the aggregate initializer we're currently
1813 building; if there's no initializer for this element yet,
1816 error ("accessing uninitialized array element");
1817 *non_constant_p
= true;
1821 /* If it's within the array bounds but doesn't have an explicit
1822 initializer, it's value-initialized. */
1823 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
1824 return cxx_eval_constant_expression (ctx
, val
,
1826 non_constant_p
, overflow_p
);
1830 error ("array subscript out of bound");
1831 *non_constant_p
= true;
1835 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1836 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
1837 else if (elem_nchars
== 1)
1838 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
1839 TREE_STRING_POINTER (ary
)[i
]);
1842 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
1843 return native_interpret_expr (type
, (const unsigned char *)
1844 TREE_STRING_POINTER (ary
)
1845 + i
* elem_nchars
, elem_nchars
);
1847 /* Don't VERIFY_CONSTANT here. */
1850 /* Subroutine of cxx_eval_constant_expression.
1851 Attempt to reduce a field access of a value of class type. */
1854 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
1856 bool *non_constant_p
, bool *overflow_p
)
1858 unsigned HOST_WIDE_INT i
;
1861 tree part
= TREE_OPERAND (t
, 1);
1862 tree orig_whole
= TREE_OPERAND (t
, 0);
1863 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1865 non_constant_p
, overflow_p
);
1866 if (whole
== orig_whole
)
1869 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
1870 whole
, part
, NULL_TREE
);
1871 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1873 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
1876 error ("%qE is not a constant expression", orig_whole
);
1877 *non_constant_p
= true;
1879 if (DECL_MUTABLE_P (part
))
1882 error ("mutable %qD is not usable in a constant expression", part
);
1883 *non_constant_p
= true;
1885 if (*non_constant_p
)
1887 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1894 /* We're in the middle of initializing it. */
1898 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
1899 && CONSTRUCTOR_NELTS (whole
) > 0)
1901 /* DR 1188 says we don't have to deal with this. */
1903 error ("accessing %qD member instead of initialized %qD member in "
1904 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
1905 *non_constant_p
= true;
1909 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
1911 /* 'whole' is part of the aggregate initializer we're currently
1912 building; if there's no initializer for this member yet, that's an
1915 error ("accessing uninitialized member %qD", part
);
1916 *non_constant_p
= true;
1920 /* If there's no explicit init for this field, it's value-initialized. */
1921 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
1922 return cxx_eval_constant_expression (ctx
, value
,
1924 non_constant_p
, overflow_p
);
1927 /* Subroutine of cxx_eval_constant_expression.
1928 Attempt to reduce a field access of a value of class type that is
1929 expressed as a BIT_FIELD_REF. */
1932 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
1934 bool *non_constant_p
, bool *overflow_p
)
1936 tree orig_whole
= TREE_OPERAND (t
, 0);
1937 tree retval
, fldval
, utype
, mask
;
1938 bool fld_seen
= false;
1939 HOST_WIDE_INT istart
, isize
;
1940 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1942 non_constant_p
, overflow_p
);
1943 tree start
, field
, value
;
1944 unsigned HOST_WIDE_INT i
;
1946 if (whole
== orig_whole
)
1948 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1950 if (!*non_constant_p
1951 && TREE_CODE (whole
) != VECTOR_CST
1952 && TREE_CODE (whole
) != CONSTRUCTOR
)
1955 error ("%qE is not a constant expression", orig_whole
);
1956 *non_constant_p
= true;
1958 if (*non_constant_p
)
1961 if (TREE_CODE (whole
) == VECTOR_CST
)
1962 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
1963 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
1965 start
= TREE_OPERAND (t
, 2);
1966 istart
= tree_to_shwi (start
);
1967 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
1968 utype
= TREE_TYPE (t
);
1969 if (!TYPE_UNSIGNED (utype
))
1970 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
1971 retval
= build_int_cst (utype
, 0);
1972 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1974 tree bitpos
= bit_position (field
);
1975 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
1977 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
1978 && TREE_CODE (value
) == INTEGER_CST
1979 && tree_fits_shwi_p (bitpos
)
1980 && tree_fits_shwi_p (DECL_SIZE (field
)))
1982 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
1983 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
1984 HOST_WIDE_INT shift
;
1985 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
1987 fldval
= fold_convert (utype
, value
);
1988 mask
= build_int_cst_type (utype
, -1);
1989 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
1990 size_int (TYPE_PRECISION (utype
) - sz
));
1991 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
1992 size_int (TYPE_PRECISION (utype
) - sz
));
1993 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
1994 shift
= bit
- istart
;
1995 if (BYTES_BIG_ENDIAN
)
1996 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
1997 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
1999 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2005 return fold_convert (TREE_TYPE (t
), retval
);
2007 return error_mark_node
;
2010 /* Subroutine of cxx_eval_constant_expression.
2011 Evaluate a short-circuited logical expression T in the context
2012 of a given constexpr CALL. BAILOUT_VALUE is the value for
2013 early return. CONTINUE_VALUE is used here purely for
2014 sanity check purposes. */
2017 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2018 tree bailout_value
, tree continue_value
,
2020 bool *non_constant_p
, bool *overflow_p
)
2023 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2025 non_constant_p
, overflow_p
);
2026 VERIFY_CONSTANT (lhs
);
2027 if (tree_int_cst_equal (lhs
, bailout_value
))
2029 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2030 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2031 lval
, non_constant_p
,
2033 VERIFY_CONSTANT (r
);
2037 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2038 CONSTRUCTOR elements to initialize (part of) an object containing that
2039 field. Return a pointer to the constructor_elt corresponding to the
2040 initialization of the field. */
2042 static constructor_elt
*
2043 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2045 tree aggr
= TREE_OPERAND (ref
, 0);
2046 tree field
= TREE_OPERAND (ref
, 1);
2048 constructor_elt
*ce
;
2050 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2052 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2054 constructor_elt
*base_ce
2055 = base_field_constructor_elt (v
, aggr
);
2056 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2059 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2060 if (ce
->index
== field
)
2067 /* Some of the expressions fed to the constexpr mechanism are calls to
2068 constructors, which have type void. In that case, return the type being
2069 initialized by the constructor. */
2072 initialized_type (tree t
)
2076 tree type
= cv_unqualified (TREE_TYPE (t
));
2077 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2079 /* A constructor call has void type, so we need to look deeper. */
2080 tree fn
= get_function_named_in_call (t
);
2081 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2082 && DECL_CXX_CONSTRUCTOR_P (fn
))
2083 type
= DECL_CONTEXT (fn
);
2088 /* We're about to initialize element INDEX of an array or class from VALUE.
2089 Set up NEW_CTX appropriately by adjusting .object to refer to the
2090 subobject and creating a new CONSTRUCTOR if the element is itself
2091 a class or array. */
2094 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2095 tree index
, tree
&value
)
2099 if (index
&& TREE_CODE (index
) != INTEGER_CST
2100 && TREE_CODE (index
) != FIELD_DECL
)
2101 /* This won't have an element in the new CONSTRUCTOR. */
2104 tree type
= initialized_type (value
);
2105 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2106 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2109 /* The sub-aggregate initializer might contain a placeholder;
2110 update object to refer to the subobject and ctor to refer to
2111 the (newly created) sub-initializer. */
2113 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2114 tree elt
= build_constructor (type
, NULL
);
2115 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2118 if (TREE_CODE (value
) == TARGET_EXPR
)
2119 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2120 value
= TARGET_EXPR_INITIAL (value
);
2123 /* We're about to process an initializer for a class or array TYPE. Make
2124 sure that CTX is set up appropriately. */
2127 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2129 /* We don't bother building a ctor for an empty base subobject. */
2130 if (is_empty_class (type
))
2133 /* We're in the middle of an initializer that might involve placeholders;
2134 our caller should have created a CONSTRUCTOR for us to put the
2135 initializer into. We will either return that constructor or T. */
2136 gcc_assert (ctx
->ctor
);
2137 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2138 (type
, TREE_TYPE (ctx
->ctor
)));
2139 gcc_assert (CONSTRUCTOR_NELTS (ctx
->ctor
) == 0);
2141 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2142 (type
, TREE_TYPE (ctx
->object
)));
2143 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2144 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2147 /* Subroutine of cxx_eval_constant_expression.
2148 The expression tree T denotes a C-style array or a C-style
2149 aggregate. Reduce it to a constant expression. */
2152 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2154 bool *non_constant_p
, bool *overflow_p
)
2156 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2157 bool changed
= false;
2158 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2160 verify_ctor_sanity (ctx
, TREE_TYPE (t
));
2161 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2162 vec_alloc (*p
, vec_safe_length (v
));
2164 unsigned i
; tree index
, value
;
2165 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2167 constexpr_ctx new_ctx
;
2168 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2169 if (new_ctx
.ctor
!= ctx
->ctor
)
2170 /* If we built a new CONSTRUCTOR, attach it now so that other
2171 initializers can refer to it. */
2172 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2173 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2175 non_constant_p
, overflow_p
);
2176 /* Don't VERIFY_CONSTANT here. */
2177 if (ctx
->quiet
&& *non_constant_p
)
2181 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2183 /* This is an initialization of a vfield inside a base
2184 subaggregate that we already initialized; push this
2185 initialization into the previous initialization. */
2186 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2191 && (TREE_CODE (index
) == NOP_EXPR
2192 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2194 /* This is an initializer for an empty base; now that we've
2195 checked that it's constant, we can ignore it. */
2196 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2199 else if (new_ctx
.ctor
!= ctx
->ctor
)
2201 /* We appended this element above; update the value. */
2202 gcc_assert ((*p
)->last().index
== index
);
2203 (*p
)->last().value
= elt
;
2206 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2208 if (*non_constant_p
|| !changed
)
2211 /* We're done building this CONSTRUCTOR, so now we can interpret an
2212 element without an explicit initializer as value-initialized. */
2213 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2214 if (VECTOR_TYPE_P (TREE_TYPE (t
)))
2219 /* Subroutine of cxx_eval_constant_expression.
2220 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2221 initialization of a non-static data member of array type. Reduce it to a
2224 Note that apart from value-initialization (when VALUE_INIT is true),
2225 this is only intended to support value-initialization and the
2226 initializations done by defaulted constructors for classes with
2227 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2228 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2229 for the copy/move constructor. */
2232 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2233 bool value_init
, bool lval
,
2234 bool *non_constant_p
, bool *overflow_p
)
2236 tree elttype
= TREE_TYPE (atype
);
2237 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2238 verify_ctor_sanity (ctx
, atype
);
2239 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2240 vec_alloc (*p
, max
+ 1);
2241 bool pre_init
= false;
2242 unsigned HOST_WIDE_INT i
;
2244 /* For the default constructor, build up a call to the default
2245 constructor of the element type. We only need to handle class types
2246 here, as for a constructor to be constexpr, all members must be
2247 initialized, which for a defaulted default constructor means they must
2248 be of a class type with a constexpr default constructor. */
2249 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2250 /* We only do this at the lowest level. */;
2251 else if (value_init
)
2253 init
= build_value_init (elttype
, tf_warning_or_error
);
2258 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2259 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2260 &argvec
, elttype
, LOOKUP_NORMAL
,
2261 tf_warning_or_error
);
2262 release_tree_vector (argvec
);
2263 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2267 for (i
= 0; i
< max
; ++i
)
2269 tree idx
= build_int_cst (size_type_node
, i
);
2271 constexpr_ctx new_ctx
;
2272 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2273 if (new_ctx
.ctor
!= ctx
->ctor
)
2274 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2275 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2277 /* A multidimensional array; recurse. */
2278 if (value_init
|| init
== NULL_TREE
)
2279 eltinit
= NULL_TREE
;
2281 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2282 tf_warning_or_error
);
2283 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2285 non_constant_p
, overflow_p
);
2289 /* Initializing an element using value or default initialization
2290 we just pre-built above. */
2291 eltinit
= (cxx_eval_constant_expression
2293 lval
, non_constant_p
, overflow_p
));
2297 /* Copying an element. */
2298 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2299 (atype
, TREE_TYPE (init
)));
2300 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2301 tf_warning_or_error
);
2302 if (!real_lvalue_p (init
))
2303 eltinit
= move (eltinit
);
2304 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2305 eltinit
= (cxx_eval_constant_expression
2306 (&new_ctx
, eltinit
, lval
,
2307 non_constant_p
, overflow_p
));
2309 if (*non_constant_p
&& !ctx
->quiet
)
2311 if (new_ctx
.ctor
!= ctx
->ctor
)
2313 /* We appended this element above; update the value. */
2314 gcc_assert ((*p
)->last().index
== idx
);
2315 (*p
)->last().value
= eltinit
;
2318 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2321 if (!*non_constant_p
)
2324 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2330 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2332 bool *non_constant_p
, bool *overflow_p
)
2334 tree atype
= TREE_TYPE (t
);
2335 tree init
= VEC_INIT_EXPR_INIT (t
);
2336 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2337 VEC_INIT_EXPR_VALUE_INIT (t
),
2338 lval
, non_constant_p
, overflow_p
);
2339 if (*non_constant_p
)
2345 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2346 match. We want to be less strict for simple *& folding; if we have a
2347 non-const temporary that we access through a const pointer, that should
2348 work. We handle this here rather than change fold_indirect_ref_1
2349 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2350 don't really make sense outside of constant expression evaluation. Also
2351 we want to allow folding to COMPONENT_REF, which could cause trouble
2352 with TBAA in fold_indirect_ref_1.
2354 Try to keep this function synced with fold_indirect_ref_1. */
2357 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2363 subtype
= TREE_TYPE (sub
);
2364 if (!POINTER_TYPE_P (subtype
))
2367 if (TREE_CODE (sub
) == ADDR_EXPR
)
2369 tree op
= TREE_OPERAND (sub
, 0);
2370 tree optype
= TREE_TYPE (op
);
2372 /* *&CONST_DECL -> to the value of the const decl. */
2373 if (TREE_CODE (op
) == CONST_DECL
)
2374 return DECL_INITIAL (op
);
2375 /* *&p => p; make sure to handle *&"str"[cst] here. */
2376 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
2378 tree fop
= fold_read_from_constant_string (op
);
2384 /* *(foo *)&fooarray => fooarray[0] */
2385 else if (TREE_CODE (optype
) == ARRAY_TYPE
2386 && (same_type_ignoring_top_level_qualifiers_p
2387 (type
, TREE_TYPE (optype
))))
2389 tree type_domain
= TYPE_DOMAIN (optype
);
2390 tree min_val
= size_zero_node
;
2391 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2392 min_val
= TYPE_MIN_VALUE (type_domain
);
2393 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2394 NULL_TREE
, NULL_TREE
);
2396 /* *(foo *)&complexfoo => __real__ complexfoo */
2397 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2398 && (same_type_ignoring_top_level_qualifiers_p
2399 (type
, TREE_TYPE (optype
))))
2400 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2401 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2402 else if (VECTOR_TYPE_P (optype
)
2403 && (same_type_ignoring_top_level_qualifiers_p
2404 (type
, TREE_TYPE (optype
))))
2406 tree part_width
= TYPE_SIZE (type
);
2407 tree index
= bitsize_int (0);
2408 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2410 /* Also handle conversion to an empty base class, which
2411 is represented with a NOP_EXPR. */
2412 else if (is_empty_class (type
)
2413 && CLASS_TYPE_P (optype
)
2414 && DERIVED_FROM_P (type
, optype
))
2419 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2420 else if (RECORD_OR_UNION_TYPE_P (optype
))
2422 tree field
= TYPE_FIELDS (optype
);
2423 for (; field
; field
= DECL_CHAIN (field
))
2424 if (TREE_CODE (field
) == FIELD_DECL
2425 && integer_zerop (byte_position (field
))
2426 && (same_type_ignoring_top_level_qualifiers_p
2427 (TREE_TYPE (field
), type
)))
2429 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2434 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2435 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2437 tree op00
= TREE_OPERAND (sub
, 0);
2438 tree op01
= TREE_OPERAND (sub
, 1);
2441 if (TREE_CODE (op00
) == ADDR_EXPR
)
2444 op00
= TREE_OPERAND (op00
, 0);
2445 op00type
= TREE_TYPE (op00
);
2447 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2448 if (VECTOR_TYPE_P (op00type
)
2449 && (same_type_ignoring_top_level_qualifiers_p
2450 (type
, TREE_TYPE (op00type
))))
2452 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2453 tree part_width
= TYPE_SIZE (type
);
2454 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2455 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2456 tree index
= bitsize_int (indexi
);
2458 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2459 return fold_build3_loc (loc
,
2460 BIT_FIELD_REF
, type
, op00
,
2464 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2465 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2466 && (same_type_ignoring_top_level_qualifiers_p
2467 (type
, TREE_TYPE (op00type
))))
2469 tree size
= TYPE_SIZE_UNIT (type
);
2470 if (tree_int_cst_equal (size
, op01
))
2471 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2473 /* ((foo *)&fooarray)[1] => fooarray[1] */
2474 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2475 && (same_type_ignoring_top_level_qualifiers_p
2476 (type
, TREE_TYPE (op00type
))))
2478 tree type_domain
= TYPE_DOMAIN (op00type
);
2479 tree min_val
= size_zero_node
;
2480 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2481 min_val
= TYPE_MIN_VALUE (type_domain
);
2482 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2483 TYPE_SIZE_UNIT (type
));
2484 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2485 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2486 NULL_TREE
, NULL_TREE
);
2488 /* Also handle conversion to an empty base class, which
2489 is represented with a NOP_EXPR. */
2490 else if (is_empty_class (type
)
2491 && CLASS_TYPE_P (op00type
)
2492 && DERIVED_FROM_P (type
, op00type
))
2497 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2498 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2500 tree field
= TYPE_FIELDS (op00type
);
2501 for (; field
; field
= DECL_CHAIN (field
))
2502 if (TREE_CODE (field
) == FIELD_DECL
2503 && tree_int_cst_equal (byte_position (field
), op01
)
2504 && (same_type_ignoring_top_level_qualifiers_p
2505 (TREE_TYPE (field
), type
)))
2507 return fold_build3 (COMPONENT_REF
, type
, op00
,
2514 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2515 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2516 && (same_type_ignoring_top_level_qualifiers_p
2517 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2520 tree min_val
= size_zero_node
;
2521 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2525 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2526 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2527 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2528 min_val
= TYPE_MIN_VALUE (type_domain
);
2529 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2537 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2539 bool *non_constant_p
, bool *overflow_p
)
2541 tree orig_op0
= TREE_OPERAND (t
, 0);
2542 bool empty_base
= false;
2544 /* First try to simplify it directly. */
2545 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
2549 /* If that didn't work, evaluate the operand first. */
2550 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2551 /*lval*/false, non_constant_p
,
2553 /* Don't VERIFY_CONSTANT here. */
2554 if (*non_constant_p
)
2557 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2561 /* We couldn't fold to a constant value. Make sure it's not
2562 something we should have been able to fold. */
2565 if (TREE_CODE (sub
) == ADDR_EXPR
)
2567 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2568 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
2569 /* DR 1188 says we don't have to deal with this. */
2571 error ("accessing value of %qE through a %qT glvalue in a "
2572 "constant expression", build_fold_indirect_ref (sub
),
2574 *non_constant_p
= true;
2578 if (lval
&& op0
!= orig_op0
)
2579 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
2581 VERIFY_CONSTANT (t
);
2586 r
= cxx_eval_constant_expression (ctx
, r
,
2587 lval
, non_constant_p
, overflow_p
);
2588 if (*non_constant_p
)
2591 /* If we're pulling out the value of an empty base, make sure
2592 that the whole object is constant and then return an empty
2594 if (empty_base
&& !lval
)
2596 VERIFY_CONSTANT (r
);
2597 r
= build_constructor (TREE_TYPE (t
), NULL
);
2598 TREE_CONSTANT (r
) = true;
2604 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2605 Shared between potential_constant_expression and
2606 cxx_eval_constant_expression. */
2609 non_const_var_error (tree r
)
2611 tree type
= TREE_TYPE (r
);
2612 error ("the value of %qD is not usable in a constant "
2614 /* Avoid error cascade. */
2615 if (DECL_INITIAL (r
) == error_mark_node
)
2617 if (DECL_DECLARED_CONSTEXPR_P (r
))
2618 inform (DECL_SOURCE_LOCATION (r
),
2619 "%qD used in its own initializer", r
);
2620 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
2622 if (!CP_TYPE_CONST_P (type
))
2623 inform (DECL_SOURCE_LOCATION (r
),
2624 "%q#D is not const", r
);
2625 else if (CP_TYPE_VOLATILE_P (type
))
2626 inform (DECL_SOURCE_LOCATION (r
),
2627 "%q#D is volatile", r
);
2628 else if (!DECL_INITIAL (r
)
2629 || !TREE_CONSTANT (DECL_INITIAL (r
)))
2630 inform (DECL_SOURCE_LOCATION (r
),
2631 "%qD was not initialized with a constant "
2638 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
2639 inform (DECL_SOURCE_LOCATION (r
),
2640 "%qD was not declared %<constexpr%>", r
);
2642 inform (DECL_SOURCE_LOCATION (r
),
2643 "%qD does not have integral or enumeration type",
2648 /* Subroutine of cxx_eval_constant_expression.
2649 Like cxx_eval_unary_expression, except for trinary expressions. */
2652 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
2654 bool *non_constant_p
, bool *overflow_p
)
2660 for (i
= 0; i
< 3; i
++)
2662 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
2664 non_constant_p
, overflow_p
);
2665 VERIFY_CONSTANT (args
[i
]);
2668 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
2669 args
[0], args
[1], args
[2]);
2670 if (val
== NULL_TREE
)
2672 VERIFY_CONSTANT (val
);
2677 var_in_constexpr_fn (tree t
)
2679 tree ctx
= DECL_CONTEXT (t
);
2680 return (cxx_dialect
>= cxx14
&& ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
2681 && DECL_DECLARED_CONSTEXPR_P (ctx
));
2684 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
2687 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
2689 bool *non_constant_p
, bool *overflow_p
)
2691 constexpr_ctx new_ctx
= *ctx
;
2693 tree init
= TREE_OPERAND (t
, 1);
2694 if (TREE_CLOBBER_P (init
))
2695 /* Just ignore clobbers. */
2698 /* First we figure out where we're storing to. */
2699 tree target
= TREE_OPERAND (t
, 0);
2700 tree type
= TREE_TYPE (target
);
2701 target
= cxx_eval_constant_expression (ctx
, target
,
2703 non_constant_p
, overflow_p
);
2704 if (*non_constant_p
)
2707 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
2709 /* For initialization of an empty base, the original target will be
2710 *(base*)this, which the above evaluation resolves to the object
2711 argument, which has the derived type rather than the base type. In
2712 this situation, just evaluate the initializer and return, since
2713 there's no actual data to store. */
2714 gcc_assert (is_empty_class (type
));
2715 return cxx_eval_constant_expression (ctx
, init
, false,
2716 non_constant_p
, overflow_p
);
2719 /* And then find the underlying variable. */
2720 vec
<tree
,va_gc
> *refs
= make_tree_vector();
2721 tree object
= NULL_TREE
;
2722 for (tree probe
= target
; object
== NULL_TREE
; )
2724 switch (TREE_CODE (probe
))
2729 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
2730 vec_safe_push (refs
, TREE_TYPE (probe
));
2731 probe
= TREE_OPERAND (probe
, 0);
2739 /* And then find/build up our initializer for the path to the subobject
2740 we're initializing. */
2742 if (DECL_P (object
))
2743 valp
= ctx
->values
->get (object
);
2748 /* A constant-expression cannot modify objects from outside the
2749 constant-expression. */
2751 error ("modification of %qE is not a constant-expression", object
);
2752 *non_constant_p
= true;
2755 type
= TREE_TYPE (object
);
2756 bool no_zero_init
= true;
2757 while (!refs
->is_empty())
2759 if (*valp
== NULL_TREE
)
2761 *valp
= build_constructor (type
, NULL
);
2762 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
2764 /* If the value of object is already zero-initialized, any new ctors for
2765 subobjects will also be zero-initialized. */
2766 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
2768 enum tree_code code
= TREE_CODE (type
);
2770 tree index
= refs
->pop();
2772 constructor_elt
*cep
= NULL
;
2773 if (code
== ARRAY_TYPE
)
2776 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
2777 gcc_assert (i
>= 0);
2778 cep
= CONSTRUCTOR_ELT (*valp
, i
);
2779 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
2783 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
2784 for (unsigned HOST_WIDE_INT idx
= 0;
2785 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
2787 if (index
== cep
->index
)
2791 constructor_elt ce
= { index
, NULL_TREE
};
2792 cep
= vec_safe_push (CONSTRUCTOR_ELTS (*valp
), ce
);
2797 release_tree_vector (refs
);
2799 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
2801 /* Create a new CONSTRUCTOR in case evaluation of the initializer
2802 wants to modify it. */
2803 new_ctx
.ctor
= build_constructor (type
, NULL
);
2804 if (*valp
== NULL_TREE
)
2805 *valp
= new_ctx
.ctor
;
2806 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = no_zero_init
;
2807 new_ctx
.object
= target
;
2810 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
2811 non_constant_p
, overflow_p
);
2812 if (target
== object
)
2814 /* The hash table might have moved since the get earlier. */
2815 valp
= ctx
->values
->get (object
);
2816 if (TREE_CODE (init
) == CONSTRUCTOR
)
2817 /* An outer ctx->ctor might be pointing to *valp, so just replace
2819 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
2826 if (*non_constant_p
)
2834 /* Evaluate a ++ or -- expression. */
2837 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
2839 bool *non_constant_p
, bool *overflow_p
)
2841 enum tree_code code
= TREE_CODE (t
);
2842 tree type
= TREE_TYPE (t
);
2843 tree op
= TREE_OPERAND (t
, 0);
2844 tree offset
= TREE_OPERAND (t
, 1);
2845 gcc_assert (TREE_CONSTANT (offset
));
2847 /* The operand as an lvalue. */
2848 op
= cxx_eval_constant_expression (ctx
, op
, true,
2849 non_constant_p
, overflow_p
);
2851 /* The operand as an rvalue. */
2852 tree val
= rvalue (op
);
2853 val
= cxx_eval_constant_expression (ctx
, val
, false,
2854 non_constant_p
, overflow_p
);
2855 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2856 a local array in a constexpr function. */
2857 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
2859 VERIFY_CONSTANT (val
);
2861 /* The modified value. */
2862 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
2864 if (POINTER_TYPE_P (type
))
2866 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
2867 offset
= convert_to_ptrofftype (offset
);
2869 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
2870 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
2873 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
2875 VERIFY_CONSTANT (mod
);
2877 /* Storing the modified value. */
2878 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
2879 cxx_eval_constant_expression (ctx
, store
,
2880 true, non_constant_p
, overflow_p
);
2882 /* And the value of the expression. */
2883 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
2885 /* Prefix ops are lvalues. */
2889 /* But we optimize when the caller wants an rvalue. */
2893 /* Postfix ops are rvalues. */
2897 /* Predicates for the meaning of *jump_target. */
2900 returns (tree
*jump_target
)
2903 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
2907 breaks (tree
*jump_target
)
2910 && TREE_CODE (*jump_target
) == LABEL_DECL
2911 && LABEL_DECL_BREAK (*jump_target
);
2915 continues (tree
*jump_target
)
2918 && TREE_CODE (*jump_target
) == LABEL_DECL
2919 && LABEL_DECL_CONTINUE (*jump_target
);
2923 switches (tree
*jump_target
)
2926 && TREE_CODE (*jump_target
) == INTEGER_CST
;
2929 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
2930 at I matches *jump_target. If we're looking for a case label and we see
2931 the default label, copy I into DEFAULT_LABEL. */
2934 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
2935 tree_stmt_iterator
& default_label
)
2937 tree stmt
= tsi_stmt (i
);
2938 switch (TREE_CODE (*jump_target
))
2941 if (TREE_CODE (stmt
) == LABEL_EXPR
2942 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
2947 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
2949 if (!CASE_LOW (stmt
))
2951 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
2962 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
2963 semantics, for switch, break, continue, and return. */
2966 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
2967 bool *non_constant_p
, bool *overflow_p
,
2970 tree_stmt_iterator i
;
2971 tree_stmt_iterator default_label
= tree_stmt_iterator();
2973 /* In a statement-expression we want to return the last value. */
2977 local_target
= NULL_TREE
;
2978 jump_target
= &local_target
;
2980 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
2983 tree stmt
= tsi_stmt (i
);
2986 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
2987 /* The label we want might be inside. */;
2988 else if (label_matches (jump_target
, i
, default_label
))
2990 *jump_target
= NULL_TREE
;
2994 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
2995 non_constant_p
, overflow_p
,
2997 if (*non_constant_p
)
2999 if (returns (jump_target
) || breaks (jump_target
))
3002 if (switches (jump_target
) && !tsi_end_p (default_label
))
3005 *jump_target
= NULL_TREE
;
3011 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3012 semantics; continue semantics are covered by cxx_eval_statement_list. */
3015 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3016 bool *non_constant_p
, bool *overflow_p
,
3019 tree body
= TREE_OPERAND (t
, 0);
3022 cxx_eval_statement_list (ctx
, body
,
3023 non_constant_p
, overflow_p
, jump_target
);
3024 if (returns (jump_target
) || breaks (jump_target
) || *non_constant_p
)
3027 if (breaks (jump_target
))
3028 *jump_target
= NULL_TREE
;
3032 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3036 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3037 bool *non_constant_p
, bool *overflow_p
,
3040 tree cond
= TREE_OPERAND (t
, 0);
3041 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3042 non_constant_p
, overflow_p
);
3043 VERIFY_CONSTANT (cond
);
3044 *jump_target
= cond
;
3046 tree body
= TREE_OPERAND (t
, 1);
3047 cxx_eval_statement_list (ctx
, body
,
3048 non_constant_p
, overflow_p
, jump_target
);
3049 if (breaks (jump_target
) || switches (jump_target
))
3050 *jump_target
= NULL_TREE
;
3054 /* Subroutine of cxx_eval_constant_expression.
3055 Attempt to reduce a POINTER_PLUS_EXPR expression T. */
3058 cxx_eval_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
3059 bool lval
, bool *non_constant_p
,
3062 tree orig_type
= TREE_TYPE (t
);
3063 tree op00
= TREE_OPERAND (t
, 0);
3064 tree op01
= TREE_OPERAND (t
, 1);
3065 location_t loc
= EXPR_LOCATION (t
);
3067 op00
= cxx_eval_constant_expression (ctx
, op00
, lval
,
3068 non_constant_p
, overflow_p
);
3071 if (TREE_CODE (op00
) != ADDR_EXPR
)
3074 op00
= TREE_OPERAND (op00
, 0);
3076 /* &A[i] p+ j => &A[i + j] */
3077 if (TREE_CODE (op00
) == ARRAY_REF
3078 && TREE_CODE (TREE_OPERAND (op00
, 1)) == INTEGER_CST
3079 && TREE_CODE (op01
) == INTEGER_CST
3080 && TYPE_SIZE_UNIT (TREE_TYPE (op00
))
3081 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (op00
))) == INTEGER_CST
)
3083 tree type
= TREE_TYPE (op00
);
3084 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (op00
, 1));
3085 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (op00
, 0)));
3086 /* Don't fold an out-of-bound access. */
3087 if (!tree_int_cst_le (t
, nelts
))
3089 op01
= cp_fold_convert (ssizetype
, op01
);
3090 /* Don't fold if op01 can't be divided exactly by TYPE_SIZE_UNIT.
3091 constexpr int A[1]; ... (char *)&A[0] + 1 */
3092 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
3093 op01
, TYPE_SIZE_UNIT (type
))))
3095 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
3097 op01
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, op01
,
3098 TYPE_SIZE_UNIT (type
));
3099 t
= size_binop_loc (loc
, PLUS_EXPR
, op01
, t
);
3100 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (op00
, 0),
3101 t
, NULL_TREE
, NULL_TREE
);
3102 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
3103 t
= cp_fold_convert (orig_type
, t
);
3104 return cxx_eval_constant_expression (ctx
, t
, lval
, non_constant_p
,
3111 /* Attempt to reduce the expression T to a constant value.
3112 On failure, issue diagnostic and return error_mark_node. */
3113 /* FIXME unify with c_fully_fold */
3114 /* FIXME overflow_p is too global */
3117 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3119 bool *non_constant_p
, bool *overflow_p
,
3122 constexpr_ctx new_ctx
;
3125 if (t
== error_mark_node
)
3127 *non_constant_p
= true;
3130 if (CONSTANT_CLASS_P (t
))
3132 if (TREE_CODE (t
) == PTRMEM_CST
)
3133 t
= cplus_expand_constant (t
);
3134 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| ctx
->quiet
))
3139 switch (TREE_CODE (t
))
3144 /* We ask for an rvalue for the RESULT_DECL when indirecting
3145 through an invisible reference, or in named return value
3147 return (*ctx
->values
->get (t
));
3151 /* We used to not check lval for CONST_DECL, but darwin.c uses
3152 CONST_DECL for aggregate constants. */
3156 r
= decl_really_constant_value (t
);
3158 r
= decl_constant_value (t
);
3159 if (TREE_CODE (r
) == TARGET_EXPR
3160 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3161 r
= TARGET_EXPR_INITIAL (r
);
3163 if (tree
*p
= ctx
->values
->get (r
))
3168 non_const_var_error (r
);
3169 *non_constant_p
= true;
3177 case CASE_LABEL_EXPR
:
3181 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
3183 else if (tree
*p
= ctx
->values
->get (r
))
3186 /* Defer in case this is only used for its type. */;
3187 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3188 /* Defer, there's no lvalue->rvalue conversion. */;
3189 else if (is_empty_class (TREE_TYPE (t
)))
3191 /* If the class is empty, we aren't actually loading anything. */
3192 r
= build_constructor (TREE_TYPE (t
), NULL
);
3193 TREE_CONSTANT (r
) = true;
3198 error ("%qE is not a constant expression", t
);
3199 *non_constant_p
= true;
3204 case AGGR_INIT_EXPR
:
3205 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3206 non_constant_p
, overflow_p
);
3211 r
= DECL_EXPR_DECL (t
);
3212 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3213 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3217 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3218 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3219 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3223 if (tree init
= DECL_INITIAL (r
))
3225 init
= cxx_eval_constant_expression (ctx
, init
,
3227 non_constant_p
, overflow_p
);
3228 ctx
->values
->put (r
, init
);
3230 else if (ctx
== &new_ctx
)
3231 /* We gave it a CONSTRUCTOR above. */;
3233 ctx
->values
->put (r
, NULL_TREE
);
3238 if (!literal_type_p (TREE_TYPE (t
)))
3242 error ("temporary of non-literal type %qT in a "
3243 "constant expression", TREE_TYPE (t
));
3244 explain_non_literal_class (TREE_TYPE (t
));
3246 *non_constant_p
= true;
3249 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3251 /* We're being expanded without an explicit target, so start
3252 initializing a new object; expansion with an explicit target
3253 strips the TARGET_EXPR before we get here. */
3255 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3256 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3257 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3258 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3261 /* Pass false for 'lval' because this indicates
3262 initialization of a temporary. */
3263 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3265 non_constant_p
, overflow_p
);
3266 if (!*non_constant_p
)
3267 /* Adjust the type of the result to the type of the temporary. */
3268 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3271 tree slot
= TARGET_EXPR_SLOT (t
);
3272 ctx
->values
->put (slot
, r
);
3279 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3280 non_constant_p
, overflow_p
);
3284 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3286 non_constant_p
, overflow_p
);
3290 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
3291 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3293 non_constant_p
, overflow_p
);
3298 /* Avoid evaluating a SAVE_EXPR more than once. */
3299 if (tree
*p
= ctx
->values
->get (t
))
3303 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3304 non_constant_p
, overflow_p
);
3305 ctx
->values
->put (t
, r
);
3309 case NON_LVALUE_EXPR
:
3310 case TRY_CATCH_EXPR
:
3312 case CLEANUP_POINT_EXPR
:
3313 case MUST_NOT_THROW_EXPR
:
3316 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3318 non_constant_p
, overflow_p
,
3322 case TRY_FINALLY_EXPR
:
3323 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
3324 non_constant_p
, overflow_p
,
3326 if (!*non_constant_p
)
3327 /* Also evaluate the cleanup. */
3328 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
3329 non_constant_p
, overflow_p
,
3333 /* These differ from cxx_eval_unary_expression in that this doesn't
3334 check for a constant operand or result; an address can be
3335 constant without its operand being, and vice versa. */
3337 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3338 non_constant_p
, overflow_p
);
3343 tree oldop
= TREE_OPERAND (t
, 0);
3344 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3346 non_constant_p
, overflow_p
);
3347 /* Don't VERIFY_CONSTANT here. */
3348 if (*non_constant_p
)
3350 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3351 /* This function does more aggressive folding than fold itself. */
3352 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3353 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3361 case FIX_TRUNC_EXPR
:
3366 case TRUTH_NOT_EXPR
:
3367 case FIXED_CONVERT_EXPR
:
3368 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3369 non_constant_p
, overflow_p
);
3373 if (SIZEOF_EXPR_TYPE_P (t
))
3374 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
3375 SIZEOF_EXPR
, false);
3376 else if (TYPE_P (TREE_OPERAND (t
, 0)))
3377 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3380 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3382 if (r
== error_mark_node
)
3384 VERIFY_CONSTANT (r
);
3389 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3390 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3391 introduced by build_call_a. */
3392 tree op0
= TREE_OPERAND (t
, 0);
3393 tree op1
= TREE_OPERAND (t
, 1);
3395 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3396 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3397 r
= cxx_eval_constant_expression (ctx
, op0
,
3398 lval
, non_constant_p
, overflow_p
,
3402 /* Check that the LHS is constant and then discard it. */
3403 cxx_eval_constant_expression (ctx
, op0
,
3404 true, non_constant_p
, overflow_p
,
3406 op1
= TREE_OPERAND (t
, 1);
3407 r
= cxx_eval_constant_expression (ctx
, op1
,
3408 lval
, non_constant_p
, overflow_p
,
3414 case POINTER_PLUS_EXPR
:
3415 r
= cxx_eval_pointer_plus_expression (ctx
, t
, lval
, non_constant_p
,
3419 /* else fall through */
3424 case TRUNC_DIV_EXPR
:
3426 case FLOOR_DIV_EXPR
:
3427 case ROUND_DIV_EXPR
:
3428 case TRUNC_MOD_EXPR
:
3430 case ROUND_MOD_EXPR
:
3432 case EXACT_DIV_EXPR
:
3442 case TRUTH_XOR_EXPR
:
3449 case UNORDERED_EXPR
:
3459 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3460 non_constant_p
, overflow_p
);
3463 /* fold can introduce non-IF versions of these; still treat them as
3464 short-circuiting. */
3465 case TRUTH_AND_EXPR
:
3466 case TRUTH_ANDIF_EXPR
:
3467 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
3470 non_constant_p
, overflow_p
);
3474 case TRUTH_ORIF_EXPR
:
3475 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
3478 non_constant_p
, overflow_p
);
3482 r
= cxx_eval_array_reference (ctx
, t
, lval
,
3483 non_constant_p
, overflow_p
);
3487 if (is_overloaded_fn (t
))
3489 /* We can only get here in checking mode via
3490 build_non_dependent_expr, because any expression that
3491 calls or takes the address of the function will have
3492 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3493 gcc_checking_assert (ctx
->quiet
|| errorcount
);
3494 *non_constant_p
= true;
3497 r
= cxx_eval_component_reference (ctx
, t
, lval
,
3498 non_constant_p
, overflow_p
);
3502 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
3503 non_constant_p
, overflow_p
);
3508 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
3509 non_constant_p
, overflow_p
,
3514 if (TREE_CONSTANT (t
))
3515 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3516 VECTOR_CST if applicable. */
3518 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
3519 non_constant_p
, overflow_p
);
3523 /* We can get this in a defaulted constructor for a class with a
3524 non-static data member of array type. Either the initializer will
3525 be NULL, meaning default-initialization, or it will be an lvalue
3526 or xvalue of the same type, meaning direct-initialization from the
3527 corresponding member. */
3528 r
= cxx_eval_vec_init (ctx
, t
, lval
,
3529 non_constant_p
, overflow_p
);
3534 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
3535 non_constant_p
, overflow_p
);
3539 case VIEW_CONVERT_EXPR
:
3542 tree oldop
= TREE_OPERAND (t
, 0);
3543 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3545 non_constant_p
, overflow_p
);
3546 if (*non_constant_p
)
3548 if (POINTER_TYPE_P (TREE_TYPE (t
))
3549 && TREE_CODE (op
) == INTEGER_CST
3550 && !integer_zerop (op
))
3553 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3554 "reinterpret_cast from integer to pointer");
3555 *non_constant_p
= true;
3559 /* We didn't fold at the top so we could check for ptr-int
3562 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
3563 /* Conversion of an out-of-range value has implementation-defined
3564 behavior; the language considers it different from arithmetic
3565 overflow, which is undefined. */
3566 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
3567 TREE_OVERFLOW (r
) = false;
3571 case EMPTY_CLASS_EXPR
:
3572 /* This is good enough for a function argument that might not get
3573 used, and they can't do anything with it, so just return it. */
3576 case STATEMENT_LIST
:
3578 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3579 return cxx_eval_statement_list (&new_ctx
, t
,
3580 non_constant_p
, overflow_p
, jump_target
);
3583 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
3585 non_constant_p
, overflow_p
,
3588 case PREINCREMENT_EXPR
:
3589 case POSTINCREMENT_EXPR
:
3590 case PREDECREMENT_EXPR
:
3591 case POSTDECREMENT_EXPR
:
3592 return cxx_eval_increment_expression (ctx
, t
,
3593 lval
, non_constant_p
, overflow_p
);
3599 case VEC_DELETE_EXPR
:
3602 /* GCC internal stuff. */
3605 case WITH_CLEANUP_EXPR
:
3606 case NON_DEPENDENT_EXPR
:
3610 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3611 "expression %qE is not a constant-expression", t
);
3612 *non_constant_p
= true;
3615 case PLACEHOLDER_EXPR
:
3616 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
)
3617 || !(same_type_ignoring_top_level_qualifiers_p
3618 (TREE_TYPE (t
), TREE_TYPE (ctx
->ctor
))))
3620 /* A placeholder without a referent. We can get here when
3621 checking whether NSDMIs are noexcept, or in massage_init_elt;
3622 just say it's non-constant for now. */
3623 gcc_assert (ctx
->quiet
);
3624 *non_constant_p
= true;
3629 /* Use of the value or address of the current object. We could
3630 use ctx->object unconditionally, but using ctx->ctor when we
3631 can is a minor optimization. */
3632 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
3633 return cxx_eval_constant_expression
3635 non_constant_p
, overflow_p
);
3640 *jump_target
= TREE_OPERAND (t
, 0);
3641 gcc_assert (breaks (jump_target
) || continues (jump_target
));
3645 cxx_eval_loop_expr (ctx
, t
,
3646 non_constant_p
, overflow_p
, jump_target
);
3650 cxx_eval_switch_expr (ctx
, t
,
3651 non_constant_p
, overflow_p
, jump_target
);
3655 /* It's possible to get a requires-expression in a constant
3656 expression. For example:
3658 template<typename T> concept bool C() {
3659 return requires (T t) { t; };
3662 template<typename T> requires !C<T>() void f(T);
3664 Normalization leaves f with the associated constraint
3665 '!requires (T t) { ... }' which is not transformed into
3667 if (!processing_template_decl
)
3668 return evaluate_constraint_expression (t
, NULL_TREE
);
3670 *non_constant_p
= true;
3674 if (STATEMENT_CODE_P (TREE_CODE (t
)))
3676 /* This function doesn't know how to deal with pre-genericize
3677 statements; this can only happen with statement-expressions,
3678 so for now just fail. */
3680 error_at (EXPR_LOCATION (t
),
3681 "statement is not a constant-expression");
3684 internal_error ("unexpected expression %qE of kind %s", t
,
3685 get_tree_code_name (TREE_CODE (t
)));
3686 *non_constant_p
= true;
3690 if (r
== error_mark_node
)
3691 *non_constant_p
= true;
3693 if (*non_constant_p
)
3700 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
3701 bool strict
= true, tree object
= NULL_TREE
)
3703 bool non_constant_p
= false;
3704 bool overflow_p
= false;
3705 hash_map
<tree
,tree
> map
;
3706 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, allow_non_constant
, strict
};
3707 tree type
= initialized_type (t
);
3709 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3711 /* In C++14 an NSDMI can participate in aggregate initialization,
3712 and can refer to the address of the object being initialized, so
3713 we need to pass in the relevant VAR_DECL if we want to do the
3714 evaluation in a single pass. The evaluation will dynamically
3715 update ctx.values for the VAR_DECL. We use the same strategy
3716 for C++11 constexpr constructors that refer to the object being
3718 ctx
.ctor
= build_constructor (type
, NULL
);
3719 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
3722 if (TREE_CODE (t
) == TARGET_EXPR
)
3723 object
= TARGET_EXPR_SLOT (t
);
3724 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3725 object
= AGGR_INIT_EXPR_SLOT (t
);
3727 ctx
.object
= object
;
3729 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3730 (type
, TREE_TYPE (object
)));
3731 if (object
&& DECL_P (object
))
3732 map
.put (object
, ctx
.ctor
);
3733 if (TREE_CODE (r
) == TARGET_EXPR
)
3734 /* Avoid creating another CONSTRUCTOR when we expand the
3736 r
= TARGET_EXPR_INITIAL (r
);
3739 r
= cxx_eval_constant_expression (&ctx
, r
,
3740 false, &non_constant_p
, &overflow_p
);
3742 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
3744 /* Mutable logic is a bit tricky: we want to allow initialization of
3745 constexpr variables with mutable members, but we can't copy those
3746 members to another constexpr variable. */
3747 if (TREE_CODE (r
) == CONSTRUCTOR
3748 && CONSTRUCTOR_MUTABLE_POISON (r
))
3750 if (!allow_non_constant
)
3751 error ("%qE is not a constant expression because it refers to "
3752 "mutable subobjects of %qT", t
, type
);
3753 non_constant_p
= true;
3756 /* Technically we should check this for all subexpressions, but that
3757 runs into problems with our internal representation of pointer
3758 subtraction and the 5.19 rules are still in flux. */
3759 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
3760 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
3761 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
3763 if (!allow_non_constant
)
3764 error ("conversion from pointer type %qT "
3765 "to arithmetic type %qT in a constant-expression",
3766 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
3767 non_constant_p
= true;
3770 if (!non_constant_p
&& overflow_p
)
3771 non_constant_p
= true;
3773 if (non_constant_p
&& !allow_non_constant
)
3774 return error_mark_node
;
3775 else if (non_constant_p
&& TREE_CONSTANT (r
))
3777 /* This isn't actually constant, so unset TREE_CONSTANT. */
3780 else if (TREE_CODE (r
) == CONSTRUCTOR
)
3781 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
3783 r
= build_nop (TREE_TYPE (r
), r
);
3784 TREE_CONSTANT (r
) = false;
3786 else if (non_constant_p
|| r
== t
)
3789 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
3791 if (TREE_CODE (t
) == TARGET_EXPR
3792 && TARGET_EXPR_INITIAL (t
) == r
)
3796 r
= get_target_expr (r
);
3797 TREE_CONSTANT (r
) = true;
3805 /* Returns true if T is a valid subexpression of a constant expression,
3806 even if it isn't itself a constant expression. */
3809 is_sub_constant_expr (tree t
)
3811 bool non_constant_p
= false;
3812 bool overflow_p
= false;
3813 hash_map
<tree
, tree
> map
;
3814 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, true, true };
3815 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
3817 return !non_constant_p
&& !overflow_p
;
3820 /* If T represents a constant expression returns its reduced value.
3821 Otherwise return error_mark_node. If T is dependent, then
3825 cxx_constant_value (tree t
, tree decl
)
3827 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
3830 /* If T is a constant expression, returns its reduced value.
3831 Otherwise, if T does not have TREE_CONSTANT set, returns T.
3832 Otherwise, returns a version of T without TREE_CONSTANT. */
3835 maybe_constant_value (tree t
, tree decl
)
3839 if (instantiation_dependent_expression_p (t
)
3840 || type_unknown_p (t
)
3841 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3842 || !potential_constant_expression (t
))
3844 if (TREE_OVERFLOW_P (t
))
3846 t
= build_nop (TREE_TYPE (t
), t
);
3847 TREE_CONSTANT (t
) = false;
3852 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
3853 #ifdef ENABLE_CHECKING
3855 || CONVERT_EXPR_P (t
)
3856 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3857 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3858 || !cp_tree_equal (r
, t
));
3863 /* Like maybe_constant_value but first fully instantiate the argument.
3865 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3866 (t, tf_none) followed by maybe_constant_value but is more efficient,
3867 because calls instantiation_dependent_expression_p and
3868 potential_constant_expression at most once. */
3871 fold_non_dependent_expr (tree t
)
3876 /* If we're in a template, but T isn't value dependent, simplify
3877 it. We're supposed to treat:
3879 template <typename T> void f(T[1 + 1]);
3880 template <typename T> void f(T[2]);
3882 as two declarations of the same function, for example. */
3883 if (processing_template_decl
)
3885 if (!instantiation_dependent_expression_p (t
)
3886 && potential_constant_expression (t
))
3888 processing_template_decl_sentinel s
;
3889 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
3891 if (type_unknown_p (t
)
3892 || BRACE_ENCLOSED_INITIALIZER_P (t
))
3894 if (TREE_OVERFLOW_P (t
))
3896 t
= build_nop (TREE_TYPE (t
), t
);
3897 TREE_CONSTANT (t
) = false;
3902 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
3903 #ifdef ENABLE_CHECKING
3904 /* cp_tree_equal looks through NOPs, so allow them. */
3906 || CONVERT_EXPR_P (t
)
3907 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3908 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3909 || !cp_tree_equal (r
, t
));
3913 else if (TREE_OVERFLOW_P (t
))
3915 t
= build_nop (TREE_TYPE (t
), t
);
3916 TREE_CONSTANT (t
) = false;
3921 return maybe_constant_value (t
);
3924 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3925 than wrapped in a TARGET_EXPR. */
3928 maybe_constant_init (tree t
, tree decl
)
3930 if (TREE_CODE (t
) == EXPR_STMT
)
3931 t
= TREE_OPERAND (t
, 0);
3932 if (TREE_CODE (t
) == CONVERT_EXPR
3933 && VOID_TYPE_P (TREE_TYPE (t
)))
3934 t
= TREE_OPERAND (t
, 0);
3935 if (TREE_CODE (t
) == INIT_EXPR
)
3936 t
= TREE_OPERAND (t
, 1);
3937 if (instantiation_dependent_expression_p (t
)
3938 || type_unknown_p (t
)
3939 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3940 || !potential_static_init_expression (t
))
3941 /* Don't try to evaluate it. */;
3943 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
3944 if (TREE_CODE (t
) == TARGET_EXPR
)
3946 tree init
= TARGET_EXPR_INITIAL (t
);
3947 if (TREE_CODE (init
) == CONSTRUCTOR
)
3954 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
3955 /* Return true if the object referred to by REF has automatic or thread
3958 enum { ck_ok
, ck_bad
, ck_unknown
};
3960 check_automatic_or_tls (tree ref
)
3963 HOST_WIDE_INT bitsize
, bitpos
;
3965 int volatilep
= 0, unsignedp
= 0;
3966 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
3967 &mode
, &unsignedp
, &volatilep
, false);
3970 /* If there isn't a decl in the middle, we don't know the linkage here,
3971 and this isn't a constant expression anyway. */
3974 dk
= decl_storage_duration (decl
);
3975 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
3979 /* Return true if T denotes a potentially constant expression. Issue
3980 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
3981 an lvalue-rvalue conversion is implied.
3983 C++0x [expr.const] used to say
3985 6 An expression is a potential constant expression if it is
3986 a constant expression where all occurrences of function
3987 parameters are replaced by arbitrary constant expressions
3988 of the appropriate type.
3990 2 A conditional expression is a constant expression unless it
3991 involves one of the following as a potentially evaluated
3992 subexpression (3.2), but subexpressions of logical AND (5.14),
3993 logical OR (5.15), and conditional (5.16) operations that are
3994 not evaluated are not considered. */
3997 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
3998 tsubst_flags_t flags
)
4000 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
4001 enum { any
= false, rval
= true };
4005 if (t
== error_mark_node
)
4009 if (TREE_THIS_VOLATILE (t
))
4011 if (flags
& tf_error
)
4012 error ("expression %qE has side-effects", t
);
4015 if (CONSTANT_CLASS_P (t
))
4018 switch (TREE_CODE (t
))
4024 case TEMPLATE_ID_EXPR
:
4027 case CASE_LABEL_EXPR
:
4033 case TEMPLATE_PARM_INDEX
:
4035 case IDENTIFIER_NODE
:
4036 case USERDEF_LITERAL
:
4037 /* We can see a FIELD_DECL in a pointer-to-member expression. */
4042 case PLACEHOLDER_EXPR
:
4048 case AGGR_INIT_EXPR
:
4050 /* -- an invocation of a function other than a constexpr function
4051 or a constexpr constructor. */
4053 tree fun
= get_function_named_in_call (t
);
4054 const int nargs
= call_expr_nargs (t
);
4057 if (fun
== NULL_TREE
)
4059 if (TREE_CODE (t
) == CALL_EXPR
4060 && CALL_EXPR_FN (t
) == NULL_TREE
)
4061 switch (CALL_EXPR_IFN (t
))
4063 /* These should be ignored, they are optimized away from
4064 constexpr functions. */
4065 case IFN_UBSAN_NULL
:
4066 case IFN_UBSAN_BOUNDS
:
4067 case IFN_UBSAN_VPTR
:
4072 /* fold_call_expr can't do anything with IFN calls. */
4073 if (flags
& tf_error
)
4074 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4075 "call to internal function");
4078 if (is_overloaded_fn (fun
))
4080 if (TREE_CODE (fun
) == FUNCTION_DECL
)
4082 if (builtin_valid_in_constant_expr_p (fun
))
4084 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
4085 /* Allow any built-in function; if the expansion
4086 isn't constant, we'll deal with that then. */
4087 && !is_builtin_fn (fun
))
4089 if (flags
& tf_error
)
4091 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4092 "call to non-constexpr function %qD", fun
);
4093 explain_invalid_constexpr_fn (fun
);
4097 /* A call to a non-static member function takes the address
4098 of the object as the first argument. But in a constant
4099 expression the address will be folded away, so look
4101 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
4102 && !DECL_CONSTRUCTOR_P (fun
))
4104 tree x
= get_nth_callarg (t
, 0);
4105 if (is_this_parameter (x
))
4107 else if (!RECUR (x
, rval
))
4114 if (!RECUR (fun
, true))
4116 fun
= get_first_fn (fun
);
4118 /* Skip initial arguments to base constructors. */
4119 if (DECL_BASE_CONSTRUCTOR_P (fun
))
4120 i
= num_artificial_parms_for (fun
);
4121 fun
= DECL_ORIGIN (fun
);
4125 if (RECUR (fun
, rval
))
4126 /* Might end up being a constant function pointer. */;
4130 for (; i
< nargs
; ++i
)
4132 tree x
= get_nth_callarg (t
, i
);
4133 /* In a template, reference arguments haven't been converted to
4134 REFERENCE_TYPE and we might not even know if the parameter
4135 is a reference, so accept lvalue constants too. */
4136 bool rv
= processing_template_decl
? any
: rval
;
4143 case NON_LVALUE_EXPR
:
4144 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
4145 -- an lvalue of integral type that refers to a non-volatile
4146 const variable or static data member initialized with
4147 constant expressions, or
4149 -- an lvalue of literal type that refers to non-volatile
4150 object defined with constexpr, or that refers to a
4151 sub-object of such an object; */
4152 return RECUR (TREE_OPERAND (t
, 0), rval
);
4156 && !decl_constant_var_p (t
)
4158 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
4159 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
4160 && !var_in_constexpr_fn (t
)
4161 && !type_dependent_expression_p (t
))
4163 if (flags
& tf_error
)
4164 non_const_var_error (t
);
4171 case VIEW_CONVERT_EXPR
:
4172 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4173 may change to something more specific to type-punning (DR 1312). */
4175 tree from
= TREE_OPERAND (t
, 0);
4176 if (POINTER_TYPE_P (TREE_TYPE (t
))
4177 && TREE_CODE (from
) == INTEGER_CST
4178 && !integer_zerop (from
))
4180 if (flags
& tf_error
)
4181 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4182 "reinterpret_cast from integer to pointer");
4185 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
4189 /* -- a unary operator & that is applied to an lvalue that
4190 designates an object with thread or automatic storage
4192 t
= TREE_OPERAND (t
, 0);
4194 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
4195 /* A pointer-to-member constant. */
4199 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4200 any checking here, as we might dereference the pointer later. If
4201 we remove this code, also remove check_automatic_or_tls. */
4202 i
= check_automatic_or_tls (t
);
4207 if (flags
& tf_error
)
4208 error ("address-of an object %qE with thread local or "
4209 "automatic storage is not a constant expression", t
);
4213 return RECUR (t
, any
);
4219 /* -- a class member access unless its postfix-expression is
4220 of literal type or of pointer to literal type. */
4221 /* This test would be redundant, as it follows from the
4222 postfix-expression being a potential constant expression. */
4223 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4225 case EXPR_PACK_EXPANSION
:
4226 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
4230 tree x
= TREE_OPERAND (t
, 0);
4232 if (is_this_parameter (x
))
4234 if (DECL_CONTEXT (x
)
4235 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4237 if (flags
& tf_error
)
4238 error ("use of %<this%> in a constant expression");
4243 return RECUR (x
, rval
);
4246 case STATEMENT_LIST
:
4248 tree_stmt_iterator i
;
4249 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4251 if (!RECUR (tsi_stmt (i
), any
))
4259 if (cxx_dialect
< cxx14
)
4261 if (!RECUR (TREE_OPERAND (t
, 0), any
))
4263 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
4268 if (cxx_dialect
< cxx14
)
4270 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
4272 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
4277 if (!RECUR (DO_COND (t
), rval
))
4279 if (!RECUR (DO_BODY (t
), any
))
4284 if (!RECUR (FOR_INIT_STMT (t
), any
))
4286 if (!RECUR (FOR_COND (t
), rval
))
4288 if (!RECUR (FOR_EXPR (t
), any
))
4290 if (!RECUR (FOR_BODY (t
), any
))
4295 if (!RECUR (WHILE_COND (t
), rval
))
4297 if (!RECUR (WHILE_BODY (t
), any
))
4302 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
4304 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
4305 unreachable labels would be checked. */
4309 return RECUR (STMT_EXPR_STMT (t
), rval
);
4312 case DYNAMIC_CAST_EXPR
:
4313 case PSEUDO_DTOR_EXPR
:
4317 case VEC_DELETE_EXPR
:
4320 case OMP_ATOMIC_READ
:
4321 case OMP_ATOMIC_CAPTURE_OLD
:
4322 case OMP_ATOMIC_CAPTURE_NEW
:
4323 /* GCC internal stuff. */
4326 case TRANSACTION_EXPR
:
4328 case AT_ENCODE_EXPR
:
4330 if (flags
& tf_error
)
4331 error ("expression %qE is not a constant-expression", t
);
4335 /* -- a typeid expression whose operand is of polymorphic
4338 tree e
= TREE_OPERAND (t
, 0);
4339 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
4340 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
4342 if (flags
& tf_error
)
4343 error ("typeid-expression is not a constant expression "
4344 "because %qE is of polymorphic type", e
);
4363 case PREINCREMENT_EXPR
:
4364 case POSTINCREMENT_EXPR
:
4365 case PREDECREMENT_EXPR
:
4366 case POSTDECREMENT_EXPR
:
4367 if (cxx_dialect
< cxx14
)
4373 if (TYPE_P (TREE_OPERAND (t
, 0)))
4375 /* else fall through. */
4381 case FIX_TRUNC_EXPR
:
4385 case TRUTH_NOT_EXPR
:
4386 case FIXED_CONVERT_EXPR
:
4387 case UNARY_PLUS_EXPR
:
4389 return RECUR (TREE_OPERAND (t
, 0), rval
);
4392 case CONST_CAST_EXPR
:
4393 case STATIC_CAST_EXPR
:
4394 case REINTERPRET_CAST_EXPR
:
4395 case IMPLICIT_CONV_EXPR
:
4396 if (cxx_dialect
< cxx11
4397 && !dependent_type_p (TREE_TYPE (t
))
4398 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
4399 /* In C++98, a conversion to non-integral type can't be part of a
4400 constant expression. */
4402 if (flags
& tf_error
)
4403 error ("cast to non-integral type %qT in a constant expression",
4408 return (RECUR (TREE_OPERAND (t
, 0),
4409 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
4412 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
4414 case WITH_CLEANUP_EXPR
:
4415 case CLEANUP_POINT_EXPR
:
4416 case MUST_NOT_THROW_EXPR
:
4417 case TRY_CATCH_EXPR
:
4423 case NON_DEPENDENT_EXPR
:
4424 /* For convenience. */
4426 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4428 case TRY_FINALLY_EXPR
:
4429 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
4430 && RECUR (TREE_OPERAND (t
, 1), any
));
4433 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4436 if (!literal_type_p (TREE_TYPE (t
)))
4438 if (flags
& tf_error
)
4440 error ("temporary of non-literal type %qT in a "
4441 "constant expression", TREE_TYPE (t
));
4442 explain_non_literal_class (TREE_TYPE (t
));
4447 return RECUR (TREE_OPERAND (t
, 1), rval
);
4451 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4452 constructor_elt
*ce
;
4453 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4454 if (!RECUR (ce
->value
, want_rval
))
4461 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
4462 || DECL_P (TREE_PURPOSE (t
)));
4463 if (!RECUR (TREE_VALUE (t
), want_rval
))
4465 if (TREE_CHAIN (t
) == NULL_TREE
)
4467 return RECUR (TREE_CHAIN (t
), want_rval
);
4470 case TRUNC_DIV_EXPR
:
4472 case FLOOR_DIV_EXPR
:
4473 case ROUND_DIV_EXPR
:
4474 case TRUNC_MOD_EXPR
:
4476 case ROUND_MOD_EXPR
:
4478 tree denom
= TREE_OPERAND (t
, 1);
4479 if (!RECUR (denom
, rval
))
4481 /* We can't call cxx_eval_outermost_constant_expr on an expression
4482 that hasn't been through instantiate_non_dependent_expr yet. */
4483 if (!processing_template_decl
)
4484 denom
= cxx_eval_outermost_constant_expr (denom
, true);
4485 if (integer_zerop (denom
))
4487 if (flags
& tf_error
)
4488 error ("division by zero is not a constant-expression");
4494 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4500 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4501 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4502 introduced by build_call_a. */
4503 tree op0
= TREE_OPERAND (t
, 0);
4504 tree op1
= TREE_OPERAND (t
, 1);
4506 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4507 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4508 return RECUR (op0
, want_rval
);
4513 /* If the first operand is the non-short-circuit constant, look at
4514 the second operand; otherwise we only care about the first one for
4516 case TRUTH_AND_EXPR
:
4517 case TRUTH_ANDIF_EXPR
:
4518 tmp
= boolean_true_node
;
4521 case TRUTH_ORIF_EXPR
:
4522 tmp
= boolean_false_node
;
4525 tree op
= TREE_OPERAND (t
, 0);
4526 if (!RECUR (op
, rval
))
4528 if (!processing_template_decl
)
4529 op
= cxx_eval_outermost_constant_expr (op
, true);
4530 if (tree_int_cst_equal (op
, tmp
))
4531 return RECUR (TREE_OPERAND (t
, 1), rval
);
4538 case POINTER_PLUS_EXPR
:
4540 case EXACT_DIV_EXPR
:
4550 case TRUTH_XOR_EXPR
:
4551 case UNORDERED_EXPR
:
4564 case ARRAY_RANGE_REF
:
4569 for (i
= 0; i
< 2; ++i
)
4570 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
4574 case CILK_SYNC_STMT
:
4575 case CILK_SPAWN_STMT
:
4576 case ARRAY_NOTATION_REF
:
4581 for (i
= 0; i
< 3; ++i
)
4582 if (!RECUR (TREE_OPERAND (t
, i
), true))
4589 /* If the condition is a known constant, we know which of the legs we
4590 care about; otherwise we only require that the condition and
4591 either of the legs be potentially constant. */
4592 tmp
= TREE_OPERAND (t
, 0);
4593 if (!RECUR (tmp
, rval
))
4595 if (!processing_template_decl
)
4596 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
4597 if (integer_zerop (tmp
))
4598 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
4599 else if (TREE_CODE (tmp
) == INTEGER_CST
)
4600 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4601 for (i
= 1; i
< 3; ++i
)
4602 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
4603 want_rval
, strict
, tf_none
))
4605 if (flags
& tf_error
)
4606 error ("expression %qE is not a constant-expression", t
);
4610 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
4612 if (flags
& tf_error
)
4614 error ("non-constant array initialization");
4615 diagnose_non_constexpr_vec_init (t
);
4621 /* We can see these in statement-expressions. */
4625 if (objc_is_property_ref (t
))
4628 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
4635 /* The main entry point to the above. */
4638 potential_constant_expression (tree t
)
4640 return potential_constant_expression_1 (t
, false, true, tf_none
);
4644 potential_static_init_expression (tree t
)
4646 return potential_constant_expression_1 (t
, false, false, tf_none
);
4649 /* As above, but require a constant rvalue. */
4652 potential_rvalue_constant_expression (tree t
)
4654 return potential_constant_expression_1 (t
, true, true, tf_none
);
4657 /* Like above, but complain about non-constant expressions. */
4660 require_potential_constant_expression (tree t
)
4662 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
4665 /* Cross product of the above. */
4668 require_potential_rvalue_constant_expression (tree t
)
4670 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
4673 #include "gt-cp-constexpr.h"