1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2017 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
34 #include "gimple-fold.h"
37 static bool verify_constant (tree
, bool, bool *, bool *);
38 #define VERIFY_CONSTANT(X) \
40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
44 /* Returns true iff FUN is an instantiation of a constexpr function
45 template or a defaulted constexpr function. */
48 is_instantiation_of_constexpr (tree fun
)
50 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
52 || (DECL_DEFAULTED_FN (fun
)
53 && DECL_DECLARED_CONSTEXPR_P (fun
)));
56 /* Return true if T is a literal type. */
59 literal_type_p (tree t
)
63 || TREE_CODE (t
) == REFERENCE_TYPE
64 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
68 t
= complete_type (t
);
69 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
70 return CLASSTYPE_LITERAL_P (t
);
72 if (TREE_CODE (t
) == ARRAY_TYPE
)
73 return literal_type_p (strip_array_types (t
));
77 /* If DECL is a variable declared `constexpr', require its type
78 be literal. Return the DECL if OK, otherwise NULL. */
81 ensure_literal_type_for_constexpr_object (tree decl
)
83 tree type
= TREE_TYPE (decl
);
85 && (DECL_DECLARED_CONSTEXPR_P (decl
)
86 || var_in_constexpr_fn (decl
))
87 && !processing_template_decl
)
89 tree stype
= strip_array_types (type
);
90 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
91 /* Don't complain here, we'll complain about incompleteness
92 when we try to initialize the variable. */;
93 else if (!literal_type_p (type
))
95 if (DECL_DECLARED_CONSTEXPR_P (decl
))
97 error ("the type %qT of constexpr variable %qD is not literal",
99 explain_non_literal_class (type
);
103 if (!is_instantiation_of_constexpr (current_function_decl
))
105 error ("variable %qD of non-literal type %qT in %<constexpr%> "
106 "function", decl
, type
);
107 explain_non_literal_class (type
);
109 cp_function_chain
->invalid_constexpr
= true;
117 /* Representation of entries in the constexpr function definition table. */
119 struct GTY((for_user
)) constexpr_fundef
{
124 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
126 static hashval_t
hash (constexpr_fundef
*);
127 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
130 /* This table holds all constexpr function definitions seen in
131 the current translation unit. */
133 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
135 /* Utility function used for managing the constexpr function table.
136 Return true if the entries pointed to by P and Q are for the
137 same constexpr function. */
140 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
142 return lhs
->decl
== rhs
->decl
;
145 /* Utility function used for managing the constexpr function table.
146 Return a hash value for the entry pointed to by Q. */
149 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
151 return DECL_UID (fundef
->decl
);
154 /* Return a previously saved definition of function FUN. */
156 static constexpr_fundef
*
157 retrieve_constexpr_fundef (tree fun
)
159 constexpr_fundef fundef
= { NULL
, NULL
};
160 if (constexpr_fundef_table
== NULL
)
164 return constexpr_fundef_table
->find (&fundef
);
167 /* Check whether the parameter and return types of FUN are valid for a
168 constexpr function, and complain if COMPLAIN. */
171 is_valid_constexpr_fn (tree fun
, bool complain
)
175 if (DECL_INHERITED_CTOR (fun
)
176 && TREE_CODE (fun
) == TEMPLATE_DECL
)
180 error ("inherited constructor %qD is not constexpr",
181 DECL_INHERITED_CTOR (fun
));
185 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
186 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
187 if (!literal_type_p (TREE_TYPE (parm
)))
192 error ("invalid type for parameter %d of constexpr "
193 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
194 explain_non_literal_class (TREE_TYPE (parm
));
199 if (!DECL_CONSTRUCTOR_P (fun
))
201 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
202 if (!literal_type_p (rettype
))
207 error ("invalid return type %qT of constexpr function %q+D",
209 explain_non_literal_class (rettype
);
213 /* C++14 DR 1684 removed this restriction. */
214 if (cxx_dialect
< cxx14
215 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
216 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
220 && pedwarn (DECL_SOURCE_LOCATION (fun
), OPT_Wpedantic
,
221 "enclosing class of constexpr non-static member "
222 "function %q+#D is not a literal type", fun
))
223 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
) == VAR_DECL
)
385 /* Initializing a local variable, don't add anything. */
387 if (TREE_CODE (aggr
) != COMPONENT_REF
)
388 /* Normal member initialization. */
389 member
= TREE_OPERAND (member
, 1);
390 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
391 /* Initializing a member of an anonymous union. */
392 return build_anon_member_initialization (member
, init
, vec
);
394 /* We're initializing a vtable pointer in a base. Leave it as
395 COMPONENT_REF so we remember the path to get to the vfield. */
396 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
399 /* Value-initialization can produce multiple initializers for the
400 same field; use the last one. */
401 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
402 (*vec
)->last().value
= init
;
404 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
408 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
409 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
410 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
413 check_constexpr_bind_expr_vars (tree t
)
415 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
417 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
418 if (TREE_CODE (var
) == TYPE_DECL
419 && DECL_IMPLICIT_TYPEDEF_P (var
)
420 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
425 /* Subroutine of check_constexpr_ctor_body. */
428 check_constexpr_ctor_body_1 (tree last
, tree list
)
430 switch (TREE_CODE (list
))
433 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
434 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
438 case CLEANUP_POINT_EXPR
:
439 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
443 if (!check_constexpr_bind_expr_vars (list
)
444 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
458 /* Make sure that there are no statements after LAST in the constructor
459 body represented by LIST. */
462 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
464 /* C++14 doesn't require a constexpr ctor to have an empty body. */
465 if (cxx_dialect
>= cxx14
)
469 if (TREE_CODE (list
) == STATEMENT_LIST
)
471 tree_stmt_iterator i
= tsi_last (list
);
472 for (; !tsi_end_p (i
); tsi_prev (&i
))
474 tree t
= tsi_stmt (i
);
477 if (!check_constexpr_ctor_body_1 (last
, t
))
484 else if (list
!= last
485 && !check_constexpr_ctor_body_1 (last
, list
))
490 error ("constexpr constructor does not have empty body");
491 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
496 /* V is a vector of constructor elements built up for the base and member
497 initializers of a constructor for TYPE. They need to be in increasing
498 offset order, which they might not be yet if TYPE has a primary base
499 which is not first in the base-clause or a vptr and at least one base
500 all of which are non-primary. */
502 static vec
<constructor_elt
, va_gc
> *
503 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
505 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
511 field_type
= BINFO_TYPE (pri
);
512 else if (TYPE_CONTAINS_VPTR_P (type
))
513 field_type
= vtbl_ptr_type_node
;
517 /* Find the element for the primary base or vptr and move it to the
518 beginning of the vec. */
519 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
520 if (TREE_TYPE (ce
->index
) == field_type
)
523 if (i
> 0 && i
< vec_safe_length (v
))
525 vec
<constructor_elt
, va_gc
> &vref
= *v
;
526 constructor_elt elt
= vref
[i
];
535 /* Build compile-time evalable representations of member-initializer list
536 for a constexpr constructor. */
539 build_constexpr_constructor_member_initializers (tree type
, tree body
)
541 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
544 switch (TREE_CODE (body
))
546 case MUST_NOT_THROW_EXPR
:
548 body
= TREE_OPERAND (body
, 0);
552 for (tree_stmt_iterator i
= tsi_start (body
);
553 !tsi_end_p (i
); tsi_next (&i
))
556 if (TREE_CODE (body
) == BIND_EXPR
)
562 body
= BIND_EXPR_BODY (body
);
569 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
571 body
= TREE_OPERAND (body
, 0);
572 if (TREE_CODE (body
) == EXPR_STMT
)
573 body
= TREE_OPERAND (body
, 0);
574 if (TREE_CODE (body
) == INIT_EXPR
575 && (same_type_ignoring_top_level_qualifiers_p
576 (TREE_TYPE (TREE_OPERAND (body
, 0)),
577 current_class_type
)))
580 return TREE_OPERAND (body
, 1);
582 ok
= build_data_member_initialization (body
, &vec
);
584 else if (TREE_CODE (body
) == STATEMENT_LIST
)
586 tree_stmt_iterator i
;
587 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
589 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
594 else if (TREE_CODE (body
) == TRY_BLOCK
)
596 error ("body of %<constexpr%> constructor cannot be "
597 "a function-try-block");
598 return error_mark_node
;
600 else if (EXPR_P (body
))
601 ok
= build_data_member_initialization (body
, &vec
);
603 gcc_assert (errorcount
> 0);
606 if (vec_safe_length (vec
) > 0)
608 /* In a delegating constructor, return the target. */
609 constructor_elt
*ce
= &(*vec
)[0];
610 if (ce
->index
== current_class_ptr
)
617 vec
= sort_constexpr_mem_initializers (type
, vec
);
618 return build_constructor (type
, vec
);
621 return error_mark_node
;
624 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
625 declared to be constexpr, or a sub-statement thereof. Returns the
626 return value if suitable, error_mark_node for a statement not allowed in
627 a constexpr function, or NULL_TREE if no return value was found. */
630 constexpr_fn_retval (tree body
)
632 switch (TREE_CODE (body
))
636 tree_stmt_iterator i
;
637 tree expr
= NULL_TREE
;
638 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
640 tree s
= constexpr_fn_retval (tsi_stmt (i
));
641 if (s
== error_mark_node
)
642 return error_mark_node
;
643 else if (s
== NULL_TREE
)
644 /* Keep iterating. */;
646 /* Multiple return statements. */
647 return error_mark_node
;
655 return break_out_target_exprs (TREE_OPERAND (body
, 0));
659 tree decl
= DECL_EXPR_DECL (body
);
660 if (TREE_CODE (decl
) == USING_DECL
661 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
662 || DECL_ARTIFICIAL (decl
))
664 return error_mark_node
;
667 case CLEANUP_POINT_EXPR
:
668 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
671 if (!check_constexpr_bind_expr_vars (body
))
672 return error_mark_node
;
673 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
679 return error_mark_node
;
683 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
684 FUN; do the necessary transformations to turn it into a single expression
685 that we can store in the hash table. */
688 massage_constexpr_body (tree fun
, tree body
)
690 if (DECL_CONSTRUCTOR_P (fun
))
691 body
= build_constexpr_constructor_member_initializers
692 (DECL_CONTEXT (fun
), body
);
693 else if (cxx_dialect
< cxx14
)
695 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
696 body
= EH_SPEC_STMTS (body
);
697 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
698 body
= TREE_OPERAND (body
, 0);
699 body
= constexpr_fn_retval (body
);
704 /* CTYPE is a type constructed from BODY. Return true if some
705 bases/fields are uninitialized, and complain if COMPLAIN. */
708 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
714 if (TREE_CODE (body
) != CONSTRUCTOR
)
716 nelts
= CONSTRUCTOR_NELTS (body
);
718 tree field
= TYPE_FIELDS (ctype
);
720 if (TREE_CODE (ctype
) == UNION_TYPE
)
722 if (nelts
== 0 && next_initializable_field (field
))
725 error ("%<constexpr%> constructor for union %qT must "
726 "initialize exactly one non-static data member", ctype
);
732 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
733 need an explicit initialization. */
735 for (unsigned i
= 0; i
<= nelts
; ++i
)
737 tree index
= NULL_TREE
;
740 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
741 /* Skip base and vtable inits. */
742 if (TREE_CODE (index
) != FIELD_DECL
743 || DECL_ARTIFICIAL (index
))
747 for (; field
!= index
; field
= DECL_CHAIN (field
))
750 if (TREE_CODE (field
) != FIELD_DECL
)
752 if (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
754 if (DECL_ARTIFICIAL (field
))
756 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
758 /* Recurse to check the anonummous aggregate member. */
759 bad
|= cx_check_missing_mem_inits
760 (TREE_TYPE (field
), NULL_TREE
, complain
);
761 if (bad
&& !complain
)
765 ftype
= strip_array_types (TREE_TYPE (field
));
766 if (type_has_constexpr_default_constructor (ftype
))
768 /* It's OK to skip a member with a trivial constexpr ctor.
769 A constexpr ctor that isn't trivial should have been
771 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
777 error ("member %qD must be initialized by mem-initializer "
778 "in %<constexpr%> constructor", field
);
779 inform (DECL_SOURCE_LOCATION (field
), "declared here");
782 if (field
== NULL_TREE
)
785 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
787 /* Check the anonymous aggregate initializer is valid. */
788 bad
|= cx_check_missing_mem_inits
789 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
790 if (bad
&& !complain
)
793 field
= DECL_CHAIN (field
);
799 /* We are processing the definition of the constexpr function FUN.
800 Check that its BODY fulfills the propriate requirements and
801 enter it in the constexpr function definition table.
802 For constructor BODY is actually the TREE_LIST of the
803 member-initializer list. */
806 register_constexpr_fundef (tree fun
, tree body
)
808 constexpr_fundef entry
;
809 constexpr_fundef
**slot
;
811 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
814 tree massaged
= massage_constexpr_body (fun
, body
);
815 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
817 if (!DECL_CONSTRUCTOR_P (fun
))
818 error ("body of constexpr function %qD not a return-statement", fun
);
822 if (!potential_rvalue_constant_expression (massaged
))
824 if (!DECL_GENERATED_P (fun
))
825 require_potential_rvalue_constant_expression (massaged
);
829 if (DECL_CONSTRUCTOR_P (fun
)
830 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
831 massaged
, !DECL_GENERATED_P (fun
)))
834 /* Create the constexpr function table if necessary. */
835 if (constexpr_fundef_table
== NULL
)
836 constexpr_fundef_table
837 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
841 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
843 gcc_assert (*slot
== NULL
);
844 *slot
= ggc_alloc
<constexpr_fundef
> ();
850 /* FUN is a non-constexpr function called in a context that requires a
851 constant expression. If it comes from a constexpr template, explain why
852 the instantiation isn't constexpr. */
855 explain_invalid_constexpr_fn (tree fun
)
857 static hash_set
<tree
> *diagnosed
;
860 /* Only diagnose defaulted functions, lambdas, or instantiations. */
861 if (!DECL_DEFAULTED_FN (fun
)
862 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
863 && !is_instantiation_of_constexpr (fun
))
865 if (diagnosed
== NULL
)
866 diagnosed
= new hash_set
<tree
>;
867 if (diagnosed
->add (fun
))
868 /* Already explained. */
871 save_loc
= input_location
;
872 if (!lambda_static_thunk_p (fun
))
874 /* Diagnostics should completely ignore the static thunk, so leave
875 input_location set to our caller's location. */
876 input_location
= DECL_SOURCE_LOCATION (fun
);
877 inform (input_location
,
878 "%qD is not usable as a constexpr function because:", fun
);
880 /* First check the declaration. */
881 if (is_valid_constexpr_fn (fun
, true))
883 /* Then if it's OK, the body. */
884 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
885 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
886 explain_implicit_non_constexpr (fun
);
889 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
890 require_potential_rvalue_constant_expression (body
);
891 if (DECL_CONSTRUCTOR_P (fun
))
892 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
895 input_location
= save_loc
;
898 /* Objects of this type represent calls to constexpr functions
899 along with the bindings of parameters to their arguments, for
900 the purpose of compile time evaluation. */
902 struct GTY((for_user
)) constexpr_call
{
903 /* Description of the constexpr function definition. */
904 constexpr_fundef
*fundef
;
905 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
906 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
907 Note: This arrangement is made to accommodate the use of
908 iterative_hash_template_arg (see pt.c). If you change this
909 representation, also change the hash calculation in
910 cxx_eval_call_expression. */
912 /* Result of the call.
913 NULL means the call is being evaluated.
914 error_mark_node means that the evaluation was erroneous;
915 otherwise, the actuall value of the call. */
917 /* The hash of this call; we remember it here to avoid having to
918 recalculate it when expanding the hash table. */
922 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
924 static hashval_t
hash (constexpr_call
*);
925 static bool equal (constexpr_call
*, constexpr_call
*);
928 enum constexpr_switch_state
{
929 /* Used when processing a switch for the first time by cxx_eval_switch_expr
930 and default: label for that switch has not been seen yet. */
931 css_default_not_seen
,
932 /* Used when processing a switch for the first time by cxx_eval_switch_expr
933 and default: label for that switch has been seen already. */
935 /* Used when processing a switch for the second time by
936 cxx_eval_switch_expr, where default: label should match. */
937 css_default_processing
940 /* The constexpr expansion context. CALL is the current function
941 expansion, CTOR is the current aggregate initializer, OBJECT is the
942 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
943 is a map of values of variables initialized within the expression. */
945 struct constexpr_ctx
{
946 /* The innermost call we're evaluating. */
947 constexpr_call
*call
;
948 /* Values for any temporaries or local variables within the
949 constant-expression. */
950 hash_map
<tree
,tree
> *values
;
951 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
952 aren't inside a loop. */
953 hash_set
<tree
> *save_exprs
;
954 /* The CONSTRUCTOR we're currently building up for an aggregate
957 /* The object we're building the CONSTRUCTOR for. */
959 /* If inside SWITCH_EXPR. */
960 constexpr_switch_state
*css_state
;
961 /* Whether we should error on a non-constant expression or fail quietly. */
963 /* Whether we are strictly conforming to constant expression rules or
964 trying harder to get a constant value. */
968 /* A table of all constexpr calls that have been evaluated by the
969 compiler in this translation unit. */
971 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
973 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
974 bool, bool *, bool *, tree
* = NULL
);
976 /* Compute a hash value for a constexpr call representation. */
979 constexpr_call_hasher::hash (constexpr_call
*info
)
984 /* Return true if the objects pointed to by P and Q represent calls
985 to the same constexpr function with the same arguments.
986 Otherwise, return false. */
989 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
995 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
997 lhs_bindings
= lhs
->bindings
;
998 rhs_bindings
= rhs
->bindings
;
999 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
1001 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1002 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1003 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1004 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1006 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1007 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1009 return lhs_bindings
== rhs_bindings
;
1012 /* Initialize the constexpr call table, if needed. */
1015 maybe_initialize_constexpr_call_table (void)
1017 if (constexpr_call_table
== NULL
)
1018 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1021 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1022 a function happens to get called recursively, we unshare the callee
1023 function's body and evaluate this unshared copy instead of evaluating the
1026 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1027 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1028 that's keyed off of the original FUNCTION_DECL and whose value is a
1029 TREE_LIST of this function's unused copies awaiting reuse.
1031 This is not GC-deletable to avoid GC affecting UID generation. */
1033 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1035 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1038 maybe_initialize_fundef_copies_table ()
1040 if (fundef_copies_table
== NULL
)
1041 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1044 /* Reuse a copy or create a new unshared copy of the function FUN.
1045 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1046 is parms, TYPE is result. */
1049 get_fundef_copy (tree fun
)
1051 maybe_initialize_fundef_copies_table ();
1055 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1059 /* There is no cached function available, or in use. We can use
1060 the function directly. That the slot is now created records
1061 that this function is now in use. */
1062 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1063 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1065 else if (*slot
== NULL_TREE
)
1067 /* We've already used the function itself, so make a copy. */
1068 copy
= build_tree_list (NULL
, NULL
);
1069 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1073 /* We have a cached function available. */
1075 *slot
= TREE_CHAIN (copy
);
1081 /* Save the copy COPY of function FUN for later reuse by
1082 get_fundef_copy(). By construction, there will always be an entry
1086 save_fundef_copy (tree fun
, tree copy
)
1088 tree
*slot
= fundef_copies_table
->get (fun
);
1089 TREE_CHAIN (copy
) = *slot
;
1093 /* We have an expression tree T that represents a call, either CALL_EXPR
1094 or AGGR_INIT_EXPR. If the call is lexically to a named function,
1095 retrun the _DECL for that function. */
1098 get_function_named_in_call (tree t
)
1100 tree fun
= cp_get_callee (t
);
1101 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
1102 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
1103 fun
= TREE_OPERAND (fun
, 0);
1107 /* We have an expression tree T that represents a call, either CALL_EXPR
1108 or AGGR_INIT_EXPR. Return the Nth argument. */
1111 get_nth_callarg (tree t
, int n
)
1113 switch (TREE_CODE (t
))
1116 return CALL_EXPR_ARG (t
, n
);
1118 case AGGR_INIT_EXPR
:
1119 return AGGR_INIT_EXPR_ARG (t
, n
);
1127 /* Attempt to evaluate T which represents a call to a builtin function.
1128 We assume here that all builtin functions evaluate to scalar types
1129 represented by _CST nodes. */
1132 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1134 bool *non_constant_p
, bool *overflow_p
)
1136 const int nargs
= call_expr_nargs (t
);
1137 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1141 /* Don't fold __builtin_constant_p within a constexpr function. */
1142 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1145 && current_function_decl
1146 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1148 *non_constant_p
= true;
1152 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1153 return constant false for a non-constant argument. */
1154 constexpr_ctx new_ctx
= *ctx
;
1155 new_ctx
.quiet
= true;
1156 bool dummy1
= false, dummy2
= false;
1157 for (i
= 0; i
< nargs
; ++i
)
1159 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1160 false, &dummy1
, &dummy2
);
1162 /* For __built_in_constant_p, fold all expressions with constant values
1163 even if they aren't C++ constant-expressions. */
1164 args
[i
] = cp_fully_fold (args
[i
]);
1167 bool save_ffbcp
= force_folding_builtin_constant_p
;
1168 force_folding_builtin_constant_p
= true;
1169 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1170 CALL_EXPR_FN (t
), nargs
, args
);
1171 force_folding_builtin_constant_p
= save_ffbcp
;
1172 if (new_call
== NULL
)
1174 if (!*non_constant_p
&& !ctx
->quiet
)
1176 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1177 CALL_EXPR_FN (t
), nargs
, args
);
1178 error ("%q+E is not a constant expression", new_call
);
1180 *non_constant_p
= true;
1184 if (!is_constant_expression (new_call
))
1186 if (!*non_constant_p
&& !ctx
->quiet
)
1187 error ("%q+E is not a constant expression", new_call
);
1188 *non_constant_p
= true;
1192 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1193 non_constant_p
, overflow_p
);
1196 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1197 the type of the value to match. */
1200 adjust_temp_type (tree type
, tree temp
)
1202 if (TREE_TYPE (temp
) == type
)
1204 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1205 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1206 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1207 gcc_assert (scalarish_type_p (type
));
1208 return cp_fold_convert (type
, temp
);
1211 /* Callback for walk_tree used by unshare_constructor. */
1214 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1218 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1223 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1224 subexpression, return an unshared copy of T. Otherwise return T. */
1227 unshare_constructor (tree t
)
1229 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1230 if (ctor
!= NULL_TREE
)
1231 return unshare_expr (t
);
1235 /* Subroutine of cxx_eval_call_expression.
1236 We are processing a call expression (either CALL_EXPR or
1237 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1238 all arguments and bind their values to correspondings
1239 parameters, making up the NEW_CALL context. */
1242 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1243 constexpr_call
*new_call
,
1244 bool *non_constant_p
, bool *overflow_p
,
1245 bool *non_constant_args
)
1247 const int nargs
= call_expr_nargs (t
);
1248 tree fun
= new_call
->fundef
->decl
;
1249 tree parms
= DECL_ARGUMENTS (fun
);
1251 tree
*p
= &new_call
->bindings
;
1252 for (i
= 0; i
< nargs
; ++i
)
1255 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1256 x
= get_nth_callarg (t
, i
);
1257 /* For member function, the first argument is a pointer to the implied
1258 object. For a constructor, it might still be a dummy object, in
1259 which case we get the real argument from ctx. */
1260 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1261 && is_dummy_object (x
))
1264 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1267 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1268 non_constant_p
, overflow_p
);
1269 /* Don't VERIFY_CONSTANT here. */
1270 if (*non_constant_p
&& ctx
->quiet
)
1272 /* Just discard ellipsis args after checking their constantitude. */
1276 if (!*non_constant_p
)
1278 /* Make sure the binding has the same type as the parm. But
1279 only for constant args. */
1280 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1281 arg
= adjust_temp_type (type
, arg
);
1282 if (!TREE_CONSTANT (arg
))
1283 *non_constant_args
= true;
1284 *p
= build_tree_list (parms
, arg
);
1285 p
= &TREE_CHAIN (*p
);
1287 parms
= TREE_CHAIN (parms
);
1291 /* Variables and functions to manage constexpr call expansion context.
1292 These do not need to be marked for PCH or GC. */
1294 /* FIXME remember and print actual constant arguments. */
1295 static vec
<tree
> call_stack
;
1296 static int call_stack_tick
;
1297 static int last_cx_error_tick
;
1300 push_cx_call_context (tree call
)
1303 if (!EXPR_HAS_LOCATION (call
))
1304 SET_EXPR_LOCATION (call
, input_location
);
1305 call_stack
.safe_push (call
);
1306 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1312 pop_cx_call_context (void)
1319 cx_error_context (void)
1321 vec
<tree
> r
= vNULL
;
1322 if (call_stack_tick
!= last_cx_error_tick
1323 && !call_stack
.is_empty ())
1325 last_cx_error_tick
= call_stack_tick
;
1329 /* Evaluate a call T to a GCC internal function when possible and return
1330 the evaluated result or, under the control of CTX, give an error, set
1331 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1334 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1336 bool *non_constant_p
, bool *overflow_p
)
1338 enum tree_code opcode
= ERROR_MARK
;
1340 switch (CALL_EXPR_IFN (t
))
1342 case IFN_UBSAN_NULL
:
1343 case IFN_UBSAN_BOUNDS
:
1344 case IFN_UBSAN_VPTR
:
1345 case IFN_FALLTHROUGH
:
1348 case IFN_ADD_OVERFLOW
:
1351 case IFN_SUB_OVERFLOW
:
1352 opcode
= MINUS_EXPR
;
1354 case IFN_MUL_OVERFLOW
:
1359 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1360 false, non_constant_p
, overflow_p
);
1364 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1365 "call to internal function %qE", t
);
1366 *non_constant_p
= true;
1370 /* Evaluate constant arguments using OPCODE and return a complex
1371 number containing the result and the overflow bit. */
1372 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1373 non_constant_p
, overflow_p
);
1374 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1375 non_constant_p
, overflow_p
);
1377 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1379 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1380 tree type
= TREE_TYPE (TREE_TYPE (t
));
1381 tree result
= fold_binary_loc (loc
, opcode
, type
,
1382 fold_convert_loc (loc
, type
, arg0
),
1383 fold_convert_loc (loc
, type
, arg1
));
1385 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1386 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1387 if (TREE_OVERFLOW (result
))
1388 TREE_OVERFLOW (result
) = 0;
1390 return build_complex (TREE_TYPE (t
), result
, ovf
);
1393 *non_constant_p
= true;
1397 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1400 clear_no_implicit_zero (tree ctor
)
1402 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
))
1404 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = false;
1405 tree elt
; unsigned HOST_WIDE_INT idx
;
1406 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, elt
)
1407 if (TREE_CODE (elt
) == CONSTRUCTOR
)
1408 clear_no_implicit_zero (elt
);
1412 /* Subroutine of cxx_eval_constant_expression.
1413 Evaluate the call expression tree T in the context of OLD_CALL expression
1417 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1419 bool *non_constant_p
, bool *overflow_p
)
1421 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1422 tree fun
= get_function_named_in_call (t
);
1423 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1426 if (fun
== NULL_TREE
)
1427 return cxx_eval_internal_function (ctx
, t
, lval
,
1428 non_constant_p
, overflow_p
);
1430 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1432 /* Might be a constexpr function pointer. */
1433 fun
= cxx_eval_constant_expression (ctx
, fun
,
1434 /*lval*/false, non_constant_p
,
1437 if (TREE_CODE (fun
) == ADDR_EXPR
)
1438 fun
= TREE_OPERAND (fun
, 0);
1440 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1442 if (!ctx
->quiet
&& !*non_constant_p
)
1443 error_at (loc
, "expression %qE does not designate a constexpr "
1445 *non_constant_p
= true;
1448 if (DECL_CLONED_FUNCTION_P (fun
))
1449 fun
= DECL_CLONED_FUNCTION (fun
);
1451 if (is_ubsan_builtin_p (fun
))
1454 if (is_builtin_fn (fun
))
1455 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1456 lval
, non_constant_p
, overflow_p
);
1457 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1461 if (!lambda_static_thunk_p (fun
))
1462 error_at (loc
, "call to non-constexpr function %qD", fun
);
1463 explain_invalid_constexpr_fn (fun
);
1465 *non_constant_p
= true;
1469 constexpr_ctx new_ctx
= *ctx
;
1470 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1471 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1473 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1474 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1475 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1476 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1477 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1478 ctx
->values
->put (new_ctx
.object
, ctor
);
1482 /* Shortcut trivial constructor/op=. */
1483 if (trivial_fn_p (fun
))
1485 tree init
= NULL_TREE
;
1486 if (call_expr_nargs (t
) == 2)
1487 init
= convert_from_reference (get_nth_callarg (t
, 1));
1488 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1489 && AGGR_INIT_ZERO_FIRST (t
))
1490 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1493 tree op
= get_nth_callarg (t
, 0);
1494 if (is_dummy_object (op
))
1497 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1498 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1499 new_ctx
.call
= &new_call
;
1500 return cxx_eval_constant_expression (&new_ctx
, set
, lval
,
1501 non_constant_p
, overflow_p
);
1505 /* We can't defer instantiating the function any longer. */
1506 if (!DECL_INITIAL (fun
)
1507 && DECL_TEMPLOID_INSTANTIATION (fun
))
1509 location_t save_loc
= input_location
;
1510 input_location
= loc
;
1512 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1514 input_location
= save_loc
;
1517 /* If in direct recursive call, optimize definition search. */
1518 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
&& ctx
->call
->fundef
->decl
== fun
)
1519 new_call
.fundef
= ctx
->call
->fundef
;
1522 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1523 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1524 || fun
== current_function_decl
)
1528 /* We need to check for current_function_decl here in case we're
1529 being called during cp_fold_function, because at that point
1530 DECL_INITIAL is set properly and we have a fundef but we
1531 haven't lowered invisirefs yet (c++/70344). */
1532 if (DECL_INITIAL (fun
) == error_mark_node
1533 || fun
== current_function_decl
)
1534 error_at (loc
, "%qD called in a constant expression before its "
1535 "definition is complete", fun
);
1536 else if (DECL_INITIAL (fun
))
1538 /* The definition of fun was somehow unsuitable. But pretend
1539 that lambda static thunks don't exist. */
1540 if (!lambda_static_thunk_p (fun
))
1541 error_at (loc
, "%qD called in a constant expression", fun
);
1542 explain_invalid_constexpr_fn (fun
);
1545 error_at (loc
, "%qD used before its definition", fun
);
1547 *non_constant_p
= true;
1552 bool non_constant_args
= false;
1553 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1554 non_constant_p
, overflow_p
, &non_constant_args
);
1555 if (*non_constant_p
)
1558 depth_ok
= push_cx_call_context (t
);
1560 tree result
= NULL_TREE
;
1562 constexpr_call
*entry
= NULL
;
1563 if (depth_ok
&& !non_constant_args
)
1565 new_call
.hash
= iterative_hash_template_arg
1566 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1568 /* If we have seen this call before, we are done. */
1569 maybe_initialize_constexpr_call_table ();
1570 constexpr_call
**slot
1571 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1575 /* We need to keep a pointer to the entry, not just the slot, as the
1576 slot can move in the call to cxx_eval_builtin_function_call. */
1577 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1580 /* Calls that are in progress have their result set to NULL,
1581 so that we can detect circular dependencies. */
1582 else if (entry
->result
== NULL
)
1585 error ("call has circular dependency");
1586 *non_constant_p
= true;
1587 entry
->result
= result
= error_mark_node
;
1590 result
= entry
->result
;
1596 error ("constexpr evaluation depth exceeds maximum of %d (use "
1597 "-fconstexpr-depth= to increase the maximum)",
1598 max_constexpr_depth
);
1599 *non_constant_p
= true;
1600 result
= error_mark_node
;
1604 if (result
&& result
!= error_mark_node
)
1606 else if (!DECL_SAVED_TREE (fun
))
1608 /* When at_eof >= 2, cgraph has started throwing away
1609 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1610 late code generation for VEC_INIT_EXPR, which needs to be
1611 completely reconsidered. */
1612 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1613 *non_constant_p
= true;
1617 tree body
, parms
, res
;
1619 /* Reuse or create a new unshared copy of this function's body. */
1620 tree copy
= get_fundef_copy (fun
);
1621 body
= TREE_PURPOSE (copy
);
1622 parms
= TREE_VALUE (copy
);
1623 res
= TREE_TYPE (copy
);
1625 /* Associate the bindings with the remapped parms. */
1626 tree bound
= new_call
.bindings
;
1627 tree remapped
= parms
;
1630 tree oparm
= TREE_PURPOSE (bound
);
1631 tree arg
= TREE_VALUE (bound
);
1632 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1633 /* Don't share a CONSTRUCTOR that might be changed. */
1634 arg
= unshare_constructor (arg
);
1635 ctx
->values
->put (remapped
, arg
);
1636 bound
= TREE_CHAIN (bound
);
1637 remapped
= DECL_CHAIN (remapped
);
1639 /* Add the RESULT_DECL to the values map, too. */
1640 tree slot
= NULL_TREE
;
1641 if (DECL_BY_REFERENCE (res
))
1643 slot
= AGGR_INIT_EXPR_SLOT (t
);
1644 tree addr
= build_address (slot
);
1645 addr
= build_nop (TREE_TYPE (res
), addr
);
1646 ctx
->values
->put (res
, addr
);
1647 ctx
->values
->put (slot
, NULL_TREE
);
1650 ctx
->values
->put (res
, NULL_TREE
);
1652 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1653 their values after the call. */
1654 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1655 hash_set
<tree
> save_exprs
;
1656 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1657 ctx_with_save_exprs
.call
= &new_call
;
1659 tree jump_target
= NULL_TREE
;
1660 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1661 lval
, non_constant_p
, overflow_p
,
1664 if (DECL_CONSTRUCTOR_P (fun
))
1665 /* This can be null for a subobject constructor call, in
1666 which case what we care about is the initialization
1667 side-effects rather than the value. We could get at the
1668 value by evaluating *this, but we don't bother; there's
1669 no need to put such a call in the hash table. */
1670 result
= lval
? ctx
->object
: ctx
->ctor
;
1671 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1675 result
= *ctx
->values
->get (slot
? slot
: res
);
1676 if (result
== NULL_TREE
&& !*non_constant_p
)
1679 error ("constexpr call flows off the end "
1681 *non_constant_p
= true;
1685 /* Forget the saved values of the callee's SAVE_EXPRs. */
1686 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1687 iter
!= save_exprs
.end(); ++iter
)
1688 ctx_with_save_exprs
.values
->remove (*iter
);
1690 /* Remove the parms/result from the values map. Is it worth
1691 bothering to do this when the map itself is only live for
1692 one constexpr evaluation? If so, maybe also clear out
1693 other vars from call, maybe in BIND_EXPR handling? */
1694 ctx
->values
->remove (res
);
1696 ctx
->values
->remove (slot
);
1697 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1698 ctx
->values
->remove (parm
);
1700 /* Make the unshared function copy we used available for re-use. */
1701 save_fundef_copy (fun
, copy
);
1704 if (result
== error_mark_node
)
1705 *non_constant_p
= true;
1706 if (*non_constant_p
|| *overflow_p
)
1707 result
= error_mark_node
;
1711 entry
->result
= result
;
1714 /* The result of a constexpr function must be completely initialized. */
1715 if (TREE_CODE (result
) == CONSTRUCTOR
)
1716 clear_no_implicit_zero (result
);
1718 pop_cx_call_context ();
1719 return unshare_constructor (result
);
1722 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1725 reduced_constant_expression_p (tree t
)
1727 switch (TREE_CODE (t
))
1730 /* Even if we can't lower this yet, it's constant. */
1734 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1735 tree idx
, val
, field
; unsigned HOST_WIDE_INT i
;
1736 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1737 field
= next_initializable_field (TYPE_FIELDS (TREE_TYPE (t
)));
1740 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, idx
, val
)
1743 /* We're in the middle of initializing this element. */
1745 if (!reduced_constant_expression_p (val
))
1751 field
= next_initializable_field (DECL_CHAIN (field
));
1756 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t
))
1757 /* All the fields are initialized. */
1758 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
1762 /* FIXME are we calling this too much? */
1763 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1767 /* Some expressions may have constant operands but are not constant
1768 themselves, such as 1/0. Call this function (or rather, the macro
1769 following it) to check for that condition.
1771 We only call this in places that require an arithmetic constant, not in
1772 places where we might have a non-constant expression that can be a
1773 component of a constant expression, such as the address of a constexpr
1774 variable that might be dereferenced later. */
1777 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1780 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1782 if (!allow_non_constant
)
1783 error ("%q+E is not a constant expression", t
);
1784 *non_constant_p
= true;
1786 if (TREE_OVERFLOW_P (t
))
1788 if (!allow_non_constant
)
1790 permerror (input_location
, "overflow in constant expression");
1791 /* If we're being permissive (and are in an enforcing
1792 context), ignore the overflow. */
1793 if (flag_permissive
)
1794 return *non_constant_p
;
1798 return *non_constant_p
;
1801 /* Check whether the shift operation with code CODE and type TYPE on LHS
1802 and RHS is undefined. If it is, give an error with an explanation,
1803 and return true; return false otherwise. */
1806 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1807 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1809 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1810 || TREE_CODE (lhs
) != INTEGER_CST
1811 || TREE_CODE (rhs
) != INTEGER_CST
)
1814 tree lhstype
= TREE_TYPE (lhs
);
1815 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1817 /* [expr.shift] The behavior is undefined if the right operand
1818 is negative, or greater than or equal to the length in bits
1819 of the promoted left operand. */
1820 if (tree_int_cst_sgn (rhs
) == -1)
1823 permerror (loc
, "right operand of shift expression %q+E is negative",
1824 build2_loc (loc
, code
, type
, lhs
, rhs
));
1825 return (!flag_permissive
|| ctx
->quiet
);
1827 if (compare_tree_int (rhs
, uprec
) >= 0)
1830 permerror (loc
, "right operand of shift expression %q+E is >= than "
1831 "the precision of the left operand",
1832 build2_loc (loc
, code
, type
, lhs
, rhs
));
1833 return (!flag_permissive
|| ctx
->quiet
);
1836 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1837 if E1 has a signed type and non-negative value, and E1x2^E2 is
1838 representable in the corresponding unsigned type of the result type,
1839 then that value, converted to the result type, is the resulting value;
1840 otherwise, the behavior is undefined. */
1841 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1842 && (cxx_dialect
>= cxx11
))
1844 if (tree_int_cst_sgn (lhs
) == -1)
1848 "left operand of shift expression %q+E is negative",
1849 build2_loc (loc
, code
, type
, lhs
, rhs
));
1850 return (!flag_permissive
|| ctx
->quiet
);
1852 /* For signed x << y the following:
1853 (unsigned) x >> ((prec (lhs) - 1) - y)
1854 if > 1, is undefined. The right-hand side of this formula
1855 is the highest bit of the LHS that can be set (starting from 0),
1856 so that the shift doesn't overflow. We then right-shift the LHS
1857 to see whether any other bit is set making the original shift
1858 undefined -- the result is not representable in the corresponding
1860 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1861 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1862 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1863 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1864 if (tree_int_cst_lt (integer_one_node
, t
))
1867 permerror (loc
, "shift expression %q+E overflows",
1868 build2_loc (loc
, code
, type
, lhs
, rhs
));
1869 return (!flag_permissive
|| ctx
->quiet
);
1875 /* Subroutine of cxx_eval_constant_expression.
1876 Attempt to reduce the unary expression tree T to a compile time value.
1877 If successful, return the value. Otherwise issue a diagnostic
1878 and return error_mark_node. */
1881 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1883 bool *non_constant_p
, bool *overflow_p
)
1886 tree orig_arg
= TREE_OPERAND (t
, 0);
1887 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1888 non_constant_p
, overflow_p
);
1889 VERIFY_CONSTANT (arg
);
1890 location_t loc
= EXPR_LOCATION (t
);
1891 enum tree_code code
= TREE_CODE (t
);
1892 tree type
= TREE_TYPE (t
);
1893 r
= fold_unary_loc (loc
, code
, type
, arg
);
1896 if (arg
== orig_arg
)
1899 r
= build1_loc (loc
, code
, type
, arg
);
1901 VERIFY_CONSTANT (r
);
1905 /* Helper function for cxx_eval_binary_expression. Try to optimize
1906 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1907 generic folding should be used. */
1910 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1911 tree lhs
, tree rhs
, bool *non_constant_p
,
1915 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1918 lhs
= TREE_OPERAND (lhs
, 0);
1920 /* &A[i] p+ j => &A[i + j] */
1921 if (TREE_CODE (lhs
) == ARRAY_REF
1922 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1923 && TREE_CODE (rhs
) == INTEGER_CST
1924 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1925 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1927 tree orig_type
= TREE_TYPE (t
);
1928 location_t loc
= EXPR_LOCATION (t
);
1929 tree type
= TREE_TYPE (lhs
);
1931 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1932 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1933 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1935 if (*non_constant_p
)
1937 /* Don't fold an out-of-bound access. */
1938 if (!tree_int_cst_le (t
, nelts
))
1940 rhs
= cp_fold_convert (ssizetype
, rhs
);
1941 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1942 constexpr int A[1]; ... (char *)&A[0] + 1 */
1943 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1944 rhs
, TYPE_SIZE_UNIT (type
))))
1946 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1948 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1949 TYPE_SIZE_UNIT (type
));
1950 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1951 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1952 t
, NULL_TREE
, NULL_TREE
);
1953 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1954 t
= cp_fold_convert (orig_type
, t
);
1955 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1956 non_constant_p
, overflow_p
);
1962 /* Subroutine of cxx_eval_constant_expression.
1963 Like cxx_eval_unary_expression, except for binary expressions. */
1966 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1968 bool *non_constant_p
, bool *overflow_p
)
1971 tree orig_lhs
= TREE_OPERAND (t
, 0);
1972 tree orig_rhs
= TREE_OPERAND (t
, 1);
1974 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1975 non_constant_p
, overflow_p
);
1976 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
1978 if (*non_constant_p
)
1980 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1981 non_constant_p
, overflow_p
);
1982 if (*non_constant_p
)
1985 location_t loc
= EXPR_LOCATION (t
);
1986 enum tree_code code
= TREE_CODE (t
);
1987 tree type
= TREE_TYPE (t
);
1989 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
1991 bool is_code_eq
= (code
== EQ_EXPR
);
1993 if (TREE_CODE (lhs
) == PTRMEM_CST
1994 && TREE_CODE (rhs
) == PTRMEM_CST
)
1995 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
1997 else if ((TREE_CODE (lhs
) == PTRMEM_CST
1998 || TREE_CODE (rhs
) == PTRMEM_CST
)
1999 && (null_member_pointer_value_p (lhs
)
2000 || null_member_pointer_value_p (rhs
)))
2001 r
= constant_boolean_node (!is_code_eq
, type
);
2002 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
2003 lhs
= cplus_expand_constant (lhs
);
2004 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
2005 rhs
= cplus_expand_constant (rhs
);
2007 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
2008 && integer_zerop (lhs
) && !integer_zerop (rhs
))
2011 error ("arithmetic involving a null pointer in %qE", lhs
);
2014 else if (code
== POINTER_PLUS_EXPR
)
2015 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2019 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2023 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2026 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2028 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2029 *non_constant_p
= true;
2030 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2031 a local array in a constexpr function. */
2032 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2034 VERIFY_CONSTANT (r
);
2038 /* Subroutine of cxx_eval_constant_expression.
2039 Attempt to evaluate condition expressions. Dead branches are not
2043 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2045 bool *non_constant_p
, bool *overflow_p
,
2048 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2050 non_constant_p
, overflow_p
);
2051 VERIFY_CONSTANT (val
);
2052 /* Don't VERIFY_CONSTANT the other operands. */
2053 if (integer_zerop (val
))
2054 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2056 non_constant_p
, overflow_p
,
2058 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2060 non_constant_p
, overflow_p
,
2064 /* Returns less than, equal to, or greater than zero if KEY is found to be
2065 less than, to match, or to be greater than the constructor_elt's INDEX. */
2068 array_index_cmp (tree key
, tree index
)
2070 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2072 switch (TREE_CODE (index
))
2075 return tree_int_cst_compare (key
, index
);
2078 tree lo
= TREE_OPERAND (index
, 0);
2079 tree hi
= TREE_OPERAND (index
, 1);
2080 if (tree_int_cst_lt (key
, lo
))
2082 else if (tree_int_cst_lt (hi
, key
))
2092 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2093 if none. If INSERT is true, insert a matching element rather than fail. */
2095 static HOST_WIDE_INT
2096 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2098 if (tree_int_cst_sgn (dindex
) < 0)
2101 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2102 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2103 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2105 unsigned HOST_WIDE_INT end
= len
;
2106 unsigned HOST_WIDE_INT begin
= 0;
2108 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2109 that the same is true of the other elements and index directly. */
2112 tree cindex
= (*elts
)[end
-1].index
;
2113 if (TREE_CODE (cindex
) == INTEGER_CST
2114 && compare_tree_int (cindex
, end
-1) == 0)
2123 /* Otherwise, find a matching index by means of a binary search. */
2124 while (begin
!= end
)
2126 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2127 constructor_elt
&elt
= (*elts
)[middle
];
2128 tree idx
= elt
.index
;
2130 int cmp
= array_index_cmp (dindex
, idx
);
2137 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2139 /* We need to split the range. */
2141 tree lo
= TREE_OPERAND (idx
, 0);
2142 tree hi
= TREE_OPERAND (idx
, 1);
2143 if (tree_int_cst_lt (lo
, dindex
))
2145 /* There are still some lower elts; shorten the range. */
2146 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2148 if (tree_int_cst_equal (lo
, new_hi
))
2149 /* Only one element left, no longer a range. */
2152 TREE_OPERAND (idx
, 1) = new_hi
;
2153 /* Append the element we want to insert. */
2156 e
.value
= unshare_constructor (elt
.value
);
2157 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2160 /* No lower elts, the range elt is now ours. */
2163 if (tree_int_cst_lt (dindex
, hi
))
2165 /* There are still some higher elts; append a range. */
2166 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2168 if (tree_int_cst_equal (new_lo
, hi
))
2171 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2172 e
.value
= unshare_constructor (elt
.value
);
2173 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2182 constructor_elt e
= { dindex
, NULL_TREE
};
2183 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2190 /* Under the control of CTX, issue a detailed diagnostic for
2191 an out-of-bounds subscript INDEX into the expression ARRAY. */
2194 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2198 tree arraytype
= TREE_TYPE (array
);
2200 /* Convert the unsigned array subscript to a signed integer to avoid
2201 printing huge numbers for small negative values. */
2202 tree sidx
= fold_convert (ssizetype
, index
);
2205 error ("array subscript value %qE is outside the bounds "
2206 "of array %qD of type %qT", sidx
, array
, arraytype
);
2207 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2210 error ("array subscript value %qE is outside the bounds "
2211 "of array type %qT", sidx
, arraytype
);
2215 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2216 STRING_CST STRING. */
2219 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2221 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2224 if (chars_per_elt
== 1)
2225 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2228 const unsigned char *ptr
2229 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2230 + index
* chars_per_elt
);
2231 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2236 /* Subroutine of cxx_eval_constant_expression.
2237 Attempt to reduce a reference to an array slot. */
2240 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2242 bool *non_constant_p
, bool *overflow_p
)
2244 tree oldary
= TREE_OPERAND (t
, 0);
2245 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2247 non_constant_p
, overflow_p
);
2249 HOST_WIDE_INT i
= 0;
2250 tree elem_type
= NULL_TREE
;
2251 unsigned len
= 0, elem_nchars
= 1;
2252 if (*non_constant_p
)
2254 oldidx
= TREE_OPERAND (t
, 1);
2255 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2257 non_constant_p
, overflow_p
);
2258 VERIFY_CONSTANT (index
);
2261 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2262 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2263 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2264 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2265 ary
= TREE_OPERAND (ary
, 0);
2266 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2267 len
= CONSTRUCTOR_NELTS (ary
);
2268 else if (TREE_CODE (ary
) == STRING_CST
)
2270 elem_nchars
= (TYPE_PRECISION (elem_type
)
2271 / TYPE_PRECISION (char_type_node
));
2272 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2274 else if (TREE_CODE (ary
) == VECTOR_CST
)
2275 len
= VECTOR_CST_NELTS (ary
);
2278 /* We can't do anything with other tree codes, so use
2279 VERIFY_CONSTANT to complain and fail. */
2280 VERIFY_CONSTANT (ary
);
2284 if (!tree_fits_shwi_p (index
)
2285 || (i
= tree_to_shwi (index
)) < 0)
2287 diag_array_subscript (ctx
, ary
, index
);
2288 *non_constant_p
= true;
2294 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2295 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2296 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2297 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2301 /* For VLAs, the number of elements won't be an integer constant. */
2302 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2304 VERIFY_CONSTANT (nelts
);
2306 ? !tree_int_cst_le (index
, nelts
)
2307 : !tree_int_cst_lt (index
, nelts
))
2308 || tree_int_cst_sgn (index
) < 0)
2310 diag_array_subscript (ctx
, ary
, index
);
2311 *non_constant_p
= true;
2315 if (lval
&& ary
== oldary
&& index
== oldidx
)
2318 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2321 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2323 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2334 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2335 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2336 else if (TREE_CODE (ary
) == VECTOR_CST
)
2337 r
= VECTOR_CST_ELT (ary
, i
);
2339 r
= extract_string_elt (ary
, elem_nchars
, i
);
2342 /* Don't VERIFY_CONSTANT here. */
2345 /* Otherwise the element doesn't have a value yet. */
2350 if (TREE_CODE (ary
) == CONSTRUCTOR
2351 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2353 /* 'ary' is part of the aggregate initializer we're currently
2354 building; if there's no initializer for this element yet,
2357 error ("accessing uninitialized array element");
2358 *non_constant_p
= true;
2362 /* If it's within the array bounds but doesn't have an explicit
2363 initializer, it's value-initialized. */
2364 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2365 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2369 /* Subroutine of cxx_eval_constant_expression.
2370 Attempt to reduce a field access of a value of class type. */
2373 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2375 bool *non_constant_p
, bool *overflow_p
)
2377 unsigned HOST_WIDE_INT i
;
2380 tree part
= TREE_OPERAND (t
, 1);
2381 tree orig_whole
= TREE_OPERAND (t
, 0);
2382 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2384 non_constant_p
, overflow_p
);
2385 if (TREE_CODE (whole
) == INDIRECT_REF
2386 && integer_zerop (TREE_OPERAND (whole
, 0))
2388 error ("dereferencing a null pointer in %qE", orig_whole
);
2390 if (TREE_CODE (whole
) == PTRMEM_CST
)
2391 whole
= cplus_expand_constant (whole
);
2392 if (whole
== orig_whole
)
2395 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2396 whole
, part
, NULL_TREE
);
2397 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2399 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2402 error ("%qE is not a constant expression", orig_whole
);
2403 *non_constant_p
= true;
2405 if (DECL_MUTABLE_P (part
))
2408 error ("mutable %qD is not usable in a constant expression", part
);
2409 *non_constant_p
= true;
2411 if (*non_constant_p
)
2413 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2414 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2416 /* Use name match for PMF fields, as a variant will have a
2417 different FIELD_DECL with a different type. */
2418 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2424 /* We're in the middle of initializing it. */
2428 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2429 && CONSTRUCTOR_NELTS (whole
) > 0)
2431 /* DR 1188 says we don't have to deal with this. */
2433 error ("accessing %qD member instead of initialized %qD member in "
2434 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2435 *non_constant_p
= true;
2439 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2440 classes never get represented; throw together a value now. */
2441 if (is_really_empty_class (TREE_TYPE (t
)))
2442 return build_constructor (TREE_TYPE (t
), NULL
);
2444 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2446 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2448 /* 'whole' is part of the aggregate initializer we're currently
2449 building; if there's no initializer for this member yet, that's an
2452 error ("accessing uninitialized member %qD", part
);
2453 *non_constant_p
= true;
2457 /* If there's no explicit init for this field, it's value-initialized. */
2458 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2459 return cxx_eval_constant_expression (ctx
, value
,
2461 non_constant_p
, overflow_p
);
2464 /* Subroutine of cxx_eval_constant_expression.
2465 Attempt to reduce a field access of a value of class type that is
2466 expressed as a BIT_FIELD_REF. */
2469 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2471 bool *non_constant_p
, bool *overflow_p
)
2473 tree orig_whole
= TREE_OPERAND (t
, 0);
2474 tree retval
, fldval
, utype
, mask
;
2475 bool fld_seen
= false;
2476 HOST_WIDE_INT istart
, isize
;
2477 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2479 non_constant_p
, overflow_p
);
2480 tree start
, field
, value
;
2481 unsigned HOST_WIDE_INT i
;
2483 if (whole
== orig_whole
)
2485 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2487 if (!*non_constant_p
2488 && TREE_CODE (whole
) != VECTOR_CST
2489 && TREE_CODE (whole
) != CONSTRUCTOR
)
2492 error ("%qE is not a constant expression", orig_whole
);
2493 *non_constant_p
= true;
2495 if (*non_constant_p
)
2498 if (TREE_CODE (whole
) == VECTOR_CST
)
2499 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2500 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2502 start
= TREE_OPERAND (t
, 2);
2503 istart
= tree_to_shwi (start
);
2504 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2505 utype
= TREE_TYPE (t
);
2506 if (!TYPE_UNSIGNED (utype
))
2507 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2508 retval
= build_int_cst (utype
, 0);
2509 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2511 tree bitpos
= bit_position (field
);
2512 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2514 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2515 && TREE_CODE (value
) == INTEGER_CST
2516 && tree_fits_shwi_p (bitpos
)
2517 && tree_fits_shwi_p (DECL_SIZE (field
)))
2519 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2520 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2521 HOST_WIDE_INT shift
;
2522 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2524 fldval
= fold_convert (utype
, value
);
2525 mask
= build_int_cst_type (utype
, -1);
2526 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2527 size_int (TYPE_PRECISION (utype
) - sz
));
2528 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2529 size_int (TYPE_PRECISION (utype
) - sz
));
2530 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2531 shift
= bit
- istart
;
2532 if (BYTES_BIG_ENDIAN
)
2533 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2534 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2536 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2542 return fold_convert (TREE_TYPE (t
), retval
);
2544 return error_mark_node
;
2547 /* Subroutine of cxx_eval_constant_expression.
2548 Evaluate a short-circuited logical expression T in the context
2549 of a given constexpr CALL. BAILOUT_VALUE is the value for
2550 early return. CONTINUE_VALUE is used here purely for
2551 sanity check purposes. */
2554 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2555 tree bailout_value
, tree continue_value
,
2557 bool *non_constant_p
, bool *overflow_p
)
2560 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2562 non_constant_p
, overflow_p
);
2563 VERIFY_CONSTANT (lhs
);
2564 if (tree_int_cst_equal (lhs
, bailout_value
))
2566 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2567 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2568 lval
, non_constant_p
,
2570 VERIFY_CONSTANT (r
);
2574 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2575 CONSTRUCTOR elements to initialize (part of) an object containing that
2576 field. Return a pointer to the constructor_elt corresponding to the
2577 initialization of the field. */
2579 static constructor_elt
*
2580 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2582 tree aggr
= TREE_OPERAND (ref
, 0);
2583 tree field
= TREE_OPERAND (ref
, 1);
2585 constructor_elt
*ce
;
2587 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2589 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2591 constructor_elt
*base_ce
2592 = base_field_constructor_elt (v
, aggr
);
2593 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2596 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2597 if (ce
->index
== field
)
2604 /* Some of the expressions fed to the constexpr mechanism are calls to
2605 constructors, which have type void. In that case, return the type being
2606 initialized by the constructor. */
2609 initialized_type (tree t
)
2613 tree type
= cv_unqualified (TREE_TYPE (t
));
2614 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2616 /* A constructor call has void type, so we need to look deeper. */
2617 tree fn
= get_function_named_in_call (t
);
2618 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2619 && DECL_CXX_CONSTRUCTOR_P (fn
))
2620 type
= DECL_CONTEXT (fn
);
2625 /* We're about to initialize element INDEX of an array or class from VALUE.
2626 Set up NEW_CTX appropriately by adjusting .object to refer to the
2627 subobject and creating a new CONSTRUCTOR if the element is itself
2628 a class or array. */
2631 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2632 tree index
, tree
&value
)
2636 if (index
&& TREE_CODE (index
) != INTEGER_CST
2637 && TREE_CODE (index
) != FIELD_DECL
)
2638 /* This won't have an element in the new CONSTRUCTOR. */
2641 tree type
= initialized_type (value
);
2642 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2643 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2646 /* The sub-aggregate initializer might contain a placeholder;
2647 update object to refer to the subobject and ctor to refer to
2648 the (newly created) sub-initializer. */
2650 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2651 tree elt
= build_constructor (type
, NULL
);
2652 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2655 if (TREE_CODE (value
) == TARGET_EXPR
)
2656 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2657 value
= TARGET_EXPR_INITIAL (value
);
2660 /* We're about to process an initializer for a class or array TYPE. Make
2661 sure that CTX is set up appropriately. */
2664 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2666 /* We don't bother building a ctor for an empty base subobject. */
2667 if (is_empty_class (type
))
2670 /* We're in the middle of an initializer that might involve placeholders;
2671 our caller should have created a CONSTRUCTOR for us to put the
2672 initializer into. We will either return that constructor or T. */
2673 gcc_assert (ctx
->ctor
);
2674 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2675 (type
, TREE_TYPE (ctx
->ctor
)));
2676 /* We used to check that ctx->ctor was empty, but that isn't the case when
2677 the object is zero-initialized before calling the constructor. */
2680 tree otype
= TREE_TYPE (ctx
->object
);
2681 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2682 /* Handle flexible array members. */
2683 || (TREE_CODE (otype
) == ARRAY_TYPE
2684 && TYPE_DOMAIN (otype
) == NULL_TREE
2685 && TREE_CODE (type
) == ARRAY_TYPE
2686 && (same_type_ignoring_top_level_qualifiers_p
2687 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2689 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2690 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2693 /* Subroutine of cxx_eval_constant_expression.
2694 The expression tree T denotes a C-style array or a C-style
2695 aggregate. Reduce it to a constant expression. */
2698 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2700 bool *non_constant_p
, bool *overflow_p
)
2702 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2703 bool changed
= false;
2704 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2705 tree type
= TREE_TYPE (t
);
2707 constexpr_ctx new_ctx
;
2708 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2710 /* We don't really need the ctx->ctor business for a PMF or
2711 vector, but it's simpler to use the same code. */
2713 new_ctx
.ctor
= build_constructor (type
, NULL
);
2714 new_ctx
.object
= NULL_TREE
;
2717 verify_ctor_sanity (ctx
, type
);
2718 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2719 vec_alloc (*p
, vec_safe_length (v
));
2723 bool constant_p
= true;
2724 bool side_effects_p
= false;
2725 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2727 tree orig_value
= value
;
2728 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2729 if (new_ctx
.ctor
!= ctx
->ctor
)
2730 /* If we built a new CONSTRUCTOR, attach it now so that other
2731 initializers can refer to it. */
2732 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2733 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2735 non_constant_p
, overflow_p
);
2736 /* Don't VERIFY_CONSTANT here. */
2737 if (ctx
->quiet
&& *non_constant_p
)
2739 if (elt
!= orig_value
)
2742 if (!TREE_CONSTANT (elt
))
2744 if (TREE_SIDE_EFFECTS (elt
))
2745 side_effects_p
= true;
2746 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2748 /* This is an initialization of a vfield inside a base
2749 subaggregate that we already initialized; push this
2750 initialization into the previous initialization. */
2751 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2756 && (TREE_CODE (index
) == NOP_EXPR
2757 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2759 /* This is an initializer for an empty base; now that we've
2760 checked that it's constant, we can ignore it. */
2761 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2764 else if (new_ctx
.ctor
!= ctx
->ctor
)
2766 /* We appended this element above; update the value. */
2767 gcc_assert ((*p
)->last().index
== index
);
2768 (*p
)->last().value
= elt
;
2771 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2773 if (*non_constant_p
|| !changed
)
2776 /* We're done building this CONSTRUCTOR, so now we can interpret an
2777 element without an explicit initializer as value-initialized. */
2778 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2779 TREE_CONSTANT (t
) = constant_p
;
2780 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2781 if (VECTOR_TYPE_P (type
))
2786 /* Subroutine of cxx_eval_constant_expression.
2787 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2788 initialization of a non-static data member of array type. Reduce it to a
2791 Note that apart from value-initialization (when VALUE_INIT is true),
2792 this is only intended to support value-initialization and the
2793 initializations done by defaulted constructors for classes with
2794 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2795 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2796 for the copy/move constructor. */
2799 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2800 bool value_init
, bool lval
,
2801 bool *non_constant_p
, bool *overflow_p
)
2803 tree elttype
= TREE_TYPE (atype
);
2804 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2805 verify_ctor_sanity (ctx
, atype
);
2806 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2807 vec_alloc (*p
, max
+ 1);
2808 bool pre_init
= false;
2809 unsigned HOST_WIDE_INT i
;
2811 /* For the default constructor, build up a call to the default
2812 constructor of the element type. We only need to handle class types
2813 here, as for a constructor to be constexpr, all members must be
2814 initialized, which for a defaulted default constructor means they must
2815 be of a class type with a constexpr default constructor. */
2816 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2817 /* We only do this at the lowest level. */;
2818 else if (value_init
)
2820 init
= build_value_init (elttype
, tf_warning_or_error
);
2825 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2826 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2827 &argvec
, elttype
, LOOKUP_NORMAL
,
2828 tf_warning_or_error
);
2829 release_tree_vector (argvec
);
2830 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2834 for (i
= 0; i
< max
; ++i
)
2836 tree idx
= build_int_cst (size_type_node
, i
);
2839 constexpr_ctx new_ctx
;
2840 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2841 if (new_ctx
.ctor
!= ctx
->ctor
)
2842 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2843 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2845 /* A multidimensional array; recurse. */
2846 if (value_init
|| init
== NULL_TREE
)
2848 eltinit
= NULL_TREE
;
2852 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2853 tf_warning_or_error
);
2854 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2856 non_constant_p
, overflow_p
);
2860 /* Initializing an element using value or default initialization
2861 we just pre-built above. */
2862 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2863 non_constant_p
, overflow_p
);
2868 /* Copying an element. */
2869 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2870 (atype
, TREE_TYPE (init
)));
2871 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2872 tf_warning_or_error
);
2873 if (!lvalue_p (init
))
2874 eltinit
= move (eltinit
);
2875 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2876 eltinit
= (cxx_eval_constant_expression
2877 (&new_ctx
, eltinit
, lval
,
2878 non_constant_p
, overflow_p
));
2880 if (*non_constant_p
&& !ctx
->quiet
)
2882 if (new_ctx
.ctor
!= ctx
->ctor
)
2884 /* We appended this element above; update the value. */
2885 gcc_assert ((*p
)->last().index
== idx
);
2886 (*p
)->last().value
= eltinit
;
2889 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2890 /* Reuse the result of cxx_eval_constant_expression call
2891 from the first iteration to all others if it is a constant
2892 initializer that doesn't require relocations. */
2895 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2896 == null_pointer_node
))
2898 if (new_ctx
.ctor
!= ctx
->ctor
)
2899 eltinit
= new_ctx
.ctor
;
2900 for (i
= 1; i
< max
; ++i
)
2902 idx
= build_int_cst (size_type_node
, i
);
2903 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2909 if (!*non_constant_p
)
2912 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2918 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2920 bool *non_constant_p
, bool *overflow_p
)
2922 tree atype
= TREE_TYPE (t
);
2923 tree init
= VEC_INIT_EXPR_INIT (t
);
2924 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2925 VEC_INIT_EXPR_VALUE_INIT (t
),
2926 lval
, non_constant_p
, overflow_p
);
2927 if (*non_constant_p
)
2933 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2934 match. We want to be less strict for simple *& folding; if we have a
2935 non-const temporary that we access through a const pointer, that should
2936 work. We handle this here rather than change fold_indirect_ref_1
2937 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2938 don't really make sense outside of constant expression evaluation. Also
2939 we want to allow folding to COMPONENT_REF, which could cause trouble
2940 with TBAA in fold_indirect_ref_1.
2942 Try to keep this function synced with fold_indirect_ref_1. */
2945 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2951 subtype
= TREE_TYPE (sub
);
2952 if (!POINTER_TYPE_P (subtype
))
2955 if (TREE_CODE (sub
) == ADDR_EXPR
)
2957 tree op
= TREE_OPERAND (sub
, 0);
2958 tree optype
= TREE_TYPE (op
);
2960 /* *&CONST_DECL -> to the value of the const decl. */
2961 if (TREE_CODE (op
) == CONST_DECL
)
2962 return DECL_INITIAL (op
);
2963 /* *&p => p; make sure to handle *&"str"[cst] here. */
2964 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2965 /* Also handle the case where the desired type is an array of unknown
2966 bounds because the variable has had its bounds deduced since the
2967 ADDR_EXPR was created. */
2968 || (TREE_CODE (type
) == ARRAY_TYPE
2969 && TREE_CODE (optype
) == ARRAY_TYPE
2970 && TYPE_DOMAIN (type
) == NULL_TREE
2971 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
2974 tree fop
= fold_read_from_constant_string (op
);
2980 /* *(foo *)&fooarray => fooarray[0] */
2981 else if (TREE_CODE (optype
) == ARRAY_TYPE
2982 && (same_type_ignoring_top_level_qualifiers_p
2983 (type
, TREE_TYPE (optype
))))
2985 tree type_domain
= TYPE_DOMAIN (optype
);
2986 tree min_val
= size_zero_node
;
2987 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2988 min_val
= TYPE_MIN_VALUE (type_domain
);
2989 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2990 NULL_TREE
, NULL_TREE
);
2992 /* *(foo *)&complexfoo => __real__ complexfoo */
2993 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2994 && (same_type_ignoring_top_level_qualifiers_p
2995 (type
, TREE_TYPE (optype
))))
2996 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2997 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2998 else if (VECTOR_TYPE_P (optype
)
2999 && (same_type_ignoring_top_level_qualifiers_p
3000 (type
, TREE_TYPE (optype
))))
3002 tree part_width
= TYPE_SIZE (type
);
3003 tree index
= bitsize_int (0);
3004 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
3006 /* Also handle conversion to an empty base class, which
3007 is represented with a NOP_EXPR. */
3008 else if (is_empty_class (type
)
3009 && CLASS_TYPE_P (optype
)
3010 && DERIVED_FROM_P (type
, optype
))
3015 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3016 else if (RECORD_OR_UNION_TYPE_P (optype
))
3018 tree field
= TYPE_FIELDS (optype
);
3019 for (; field
; field
= DECL_CHAIN (field
))
3020 if (TREE_CODE (field
) == FIELD_DECL
3021 && TREE_TYPE (field
) != error_mark_node
3022 && integer_zerop (byte_position (field
))
3023 && (same_type_ignoring_top_level_qualifiers_p
3024 (TREE_TYPE (field
), type
)))
3025 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3028 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3029 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
3031 tree op00
= TREE_OPERAND (sub
, 0);
3032 tree op01
= TREE_OPERAND (sub
, 1);
3035 if (TREE_CODE (op00
) == ADDR_EXPR
)
3038 op00
= TREE_OPERAND (op00
, 0);
3039 op00type
= TREE_TYPE (op00
);
3041 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3042 if (VECTOR_TYPE_P (op00type
)
3043 && (same_type_ignoring_top_level_qualifiers_p
3044 (type
, TREE_TYPE (op00type
))))
3046 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
3047 tree part_width
= TYPE_SIZE (type
);
3048 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
3049 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
3050 tree index
= bitsize_int (indexi
);
3052 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
3053 return fold_build3_loc (loc
,
3054 BIT_FIELD_REF
, type
, op00
,
3058 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3059 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3060 && (same_type_ignoring_top_level_qualifiers_p
3061 (type
, TREE_TYPE (op00type
))))
3063 tree size
= TYPE_SIZE_UNIT (type
);
3064 if (tree_int_cst_equal (size
, op01
))
3065 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3067 /* ((foo *)&fooarray)[1] => fooarray[1] */
3068 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3069 && (same_type_ignoring_top_level_qualifiers_p
3070 (type
, TREE_TYPE (op00type
))))
3072 tree type_domain
= TYPE_DOMAIN (op00type
);
3073 tree min_val
= size_zero_node
;
3074 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3075 min_val
= TYPE_MIN_VALUE (type_domain
);
3076 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
3077 TYPE_SIZE_UNIT (type
));
3078 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
3079 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3080 NULL_TREE
, NULL_TREE
);
3082 /* Also handle conversion to an empty base class, which
3083 is represented with a NOP_EXPR. */
3084 else if (is_empty_class (type
)
3085 && CLASS_TYPE_P (op00type
)
3086 && DERIVED_FROM_P (type
, op00type
))
3091 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3092 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3094 tree field
= TYPE_FIELDS (op00type
);
3095 for (; field
; field
= DECL_CHAIN (field
))
3096 if (TREE_CODE (field
) == FIELD_DECL
3097 && TREE_TYPE (field
) != error_mark_node
3098 && tree_int_cst_equal (byte_position (field
), op01
)
3099 && (same_type_ignoring_top_level_qualifiers_p
3100 (TREE_TYPE (field
), type
)))
3101 return fold_build3 (COMPONENT_REF
, type
, op00
,
3106 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3107 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3108 && (same_type_ignoring_top_level_qualifiers_p
3109 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3112 tree min_val
= size_zero_node
;
3113 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3117 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3118 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3119 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3120 min_val
= TYPE_MIN_VALUE (type_domain
);
3121 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3129 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3131 bool *non_constant_p
, bool *overflow_p
)
3133 tree orig_op0
= TREE_OPERAND (t
, 0);
3134 bool empty_base
= false;
3136 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3137 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3139 if (TREE_CODE (t
) == MEM_REF
3140 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3142 gcc_assert (ctx
->quiet
);
3143 *non_constant_p
= true;
3147 /* First try to simplify it directly. */
3148 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3152 /* If that didn't work, evaluate the operand first. */
3153 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3154 /*lval*/false, non_constant_p
,
3156 /* Don't VERIFY_CONSTANT here. */
3157 if (*non_constant_p
)
3160 if (!lval
&& integer_zerop (op0
))
3163 error ("dereferencing a null pointer");
3164 *non_constant_p
= true;
3168 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3172 /* We couldn't fold to a constant value. Make sure it's not
3173 something we should have been able to fold. */
3176 if (TREE_CODE (sub
) == ADDR_EXPR
)
3178 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3179 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3180 /* DR 1188 says we don't have to deal with this. */
3182 error ("accessing value of %qE through a %qT glvalue in a "
3183 "constant expression", build_fold_indirect_ref (sub
),
3185 *non_constant_p
= true;
3189 if (lval
&& op0
!= orig_op0
)
3190 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3192 VERIFY_CONSTANT (t
);
3197 r
= cxx_eval_constant_expression (ctx
, r
,
3198 lval
, non_constant_p
, overflow_p
);
3199 if (*non_constant_p
)
3202 /* If we're pulling out the value of an empty base, just return an empty
3204 if (empty_base
&& !lval
)
3206 r
= build_constructor (TREE_TYPE (t
), NULL
);
3207 TREE_CONSTANT (r
) = true;
3213 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3214 Shared between potential_constant_expression and
3215 cxx_eval_constant_expression. */
3218 non_const_var_error (tree r
)
3220 tree type
= TREE_TYPE (r
);
3221 error ("the value of %qD is not usable in a constant "
3223 /* Avoid error cascade. */
3224 if (DECL_INITIAL (r
) == error_mark_node
)
3226 if (DECL_DECLARED_CONSTEXPR_P (r
))
3227 inform (DECL_SOURCE_LOCATION (r
),
3228 "%qD used in its own initializer", r
);
3229 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3231 if (!CP_TYPE_CONST_P (type
))
3232 inform (DECL_SOURCE_LOCATION (r
),
3233 "%q#D is not const", r
);
3234 else if (CP_TYPE_VOLATILE_P (type
))
3235 inform (DECL_SOURCE_LOCATION (r
),
3236 "%q#D is volatile", r
);
3237 else if (!DECL_INITIAL (r
)
3238 || !TREE_CONSTANT (DECL_INITIAL (r
))
3239 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3240 inform (DECL_SOURCE_LOCATION (r
),
3241 "%qD was not initialized with a constant "
3246 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3247 inform (DECL_SOURCE_LOCATION (r
),
3248 "%qD was not initialized with a constant "
3252 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3253 inform (DECL_SOURCE_LOCATION (r
),
3254 "%qD was not declared %<constexpr%>", r
);
3256 inform (DECL_SOURCE_LOCATION (r
),
3257 "%qD does not have integral or enumeration type",
3262 /* Subroutine of cxx_eval_constant_expression.
3263 Like cxx_eval_unary_expression, except for trinary expressions. */
3266 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3268 bool *non_constant_p
, bool *overflow_p
)
3274 for (i
= 0; i
< 3; i
++)
3276 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3278 non_constant_p
, overflow_p
);
3279 VERIFY_CONSTANT (args
[i
]);
3282 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3283 args
[0], args
[1], args
[2]);
3284 if (val
== NULL_TREE
)
3286 VERIFY_CONSTANT (val
);
3290 /* True if T was declared in a function declared to be constexpr, and
3291 therefore potentially constant in C++14. */
3294 var_in_constexpr_fn (tree t
)
3296 tree ctx
= DECL_CONTEXT (t
);
3297 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3298 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3301 /* True if T was declared in a function that might be constexpr: either a
3302 function that was declared constexpr, or a C++17 lambda op(). */
3305 var_in_maybe_constexpr_fn (tree t
)
3307 if (cxx_dialect
>= cxx1z
3308 && DECL_FUNCTION_SCOPE_P (t
)
3309 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3311 return var_in_constexpr_fn (t
);
3314 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3315 build_over_call we implement trivial copy of a class with tail padding using
3316 assignment of character arrays, which is valid in normal code, but not in
3317 constexpr evaluation. We don't need to worry about clobbering tail padding
3318 in constexpr evaluation, so strip the type punning. */
3321 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3323 if (TREE_CODE (target
) == MEM_REF
3324 && TREE_CODE (init
) == MEM_REF
3325 && TREE_TYPE (target
) == TREE_TYPE (init
)
3326 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3327 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3329 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3330 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3334 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3337 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3339 bool *non_constant_p
, bool *overflow_p
)
3341 constexpr_ctx new_ctx
= *ctx
;
3343 tree init
= TREE_OPERAND (t
, 1);
3344 if (TREE_CLOBBER_P (init
))
3345 /* Just ignore clobbers. */
3348 /* First we figure out where we're storing to. */
3349 tree target
= TREE_OPERAND (t
, 0);
3351 maybe_simplify_trivial_copy (target
, init
);
3353 tree type
= TREE_TYPE (target
);
3354 target
= cxx_eval_constant_expression (ctx
, target
,
3356 non_constant_p
, overflow_p
);
3357 if (*non_constant_p
)
3360 /* cxx_eval_array_reference for lval = true allows references one past
3361 end of array, because it does not know if it is just taking address
3362 (which is valid), or actual dereference. Here we know it is
3363 a dereference, so diagnose it here. */
3364 for (tree probe
= target
; probe
; )
3366 switch (TREE_CODE (probe
))
3370 ary
= TREE_OPERAND (probe
, 0);
3371 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3372 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3373 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3374 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3377 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3378 non_constant_p
, overflow_p
);
3379 VERIFY_CONSTANT (nelts
);
3380 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3381 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3382 if (wi::eq_p (TREE_OPERAND (probe
, 1), nelts
))
3384 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3385 *non_constant_p
= true;
3392 probe
= TREE_OPERAND (probe
, 0);
3401 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3403 /* For initialization of an empty base, the original target will be
3404 *(base*)this, which the above evaluation resolves to the object
3405 argument, which has the derived type rather than the base type. In
3406 this situation, just evaluate the initializer and return, since
3407 there's no actual data to store. */
3408 gcc_assert (is_empty_class (type
));
3409 return cxx_eval_constant_expression (ctx
, init
, false,
3410 non_constant_p
, overflow_p
);
3413 /* And then find the underlying variable. */
3414 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3415 tree object
= NULL_TREE
;
3416 for (tree probe
= target
; object
== NULL_TREE
; )
3418 switch (TREE_CODE (probe
))
3423 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3424 vec_safe_push (refs
, TREE_TYPE (probe
));
3425 probe
= TREE_OPERAND (probe
, 0);
3433 /* And then find/build up our initializer for the path to the subobject
3434 we're initializing. */
3436 if (object
== ctx
->object
&& VAR_P (object
)
3437 && DECL_NAME (object
) && ctx
->call
== NULL
)
3438 /* The variable we're building up an aggregate initializer for is outside
3439 the constant-expression, so don't evaluate the store. We check
3440 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3442 else if (DECL_P (object
))
3443 valp
= ctx
->values
->get (object
);
3448 /* A constant-expression cannot modify objects from outside the
3449 constant-expression. */
3451 error ("modification of %qE is not a constant expression", object
);
3452 *non_constant_p
= true;
3455 type
= TREE_TYPE (object
);
3456 bool no_zero_init
= true;
3458 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3459 while (!refs
->is_empty())
3461 if (*valp
== NULL_TREE
)
3463 *valp
= build_constructor (type
, NULL
);
3464 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3466 else if (TREE_CODE (*valp
) == STRING_CST
)
3468 /* An array was initialized with a string constant, and now
3469 we're writing into one of its elements. Explode the
3470 single initialization into a set of element
3472 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3474 tree string
= *valp
;
3475 tree elt_type
= TREE_TYPE (type
);
3476 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3477 / TYPE_PRECISION (char_type_node
));
3478 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3479 tree ary_ctor
= build_constructor (type
, NULL
);
3481 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3482 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3484 constructor_elt elt
=
3486 build_int_cst (size_type_node
, ix
),
3487 extract_string_elt (string
, chars_per_elt
, ix
)
3489 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3495 /* If the value of object is already zero-initialized, any new ctors for
3496 subobjects will also be zero-initialized. */
3497 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3499 vec_safe_push (ctors
, *valp
);
3501 enum tree_code code
= TREE_CODE (type
);
3503 tree index
= refs
->pop();
3505 constructor_elt
*cep
= NULL
;
3506 if (code
== ARRAY_TYPE
)
3509 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3510 gcc_assert (i
>= 0);
3511 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3512 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3516 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3518 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3519 Usually we meet initializers in that order, but it is
3520 possible for base types to be placed not in program
3522 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3523 unsigned HOST_WIDE_INT idx
;
3525 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3526 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3527 /* Changing active member. */
3528 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3531 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3532 idx
++, fields
= DECL_CHAIN (fields
))
3534 if (index
== cep
->index
)
3537 /* The field we're initializing must be on the field
3538 list. Look to see if it is present before the
3539 field the current ELT initializes. */
3540 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3541 if (index
== fields
)
3545 /* We fell off the end of the CONSTRUCTOR, so insert a new
3546 entry at the end. */
3549 constructor_elt ce
= { index
, NULL_TREE
};
3551 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3552 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3558 release_tree_vector (refs
);
3560 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3562 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3563 wants to modify it. */
3564 if (*valp
== NULL_TREE
)
3566 *valp
= build_constructor (type
, NULL
);
3567 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3569 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3570 *valp
= cplus_expand_constant (*valp
);
3571 new_ctx
.ctor
= *valp
;
3572 new_ctx
.object
= target
;
3575 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3576 non_constant_p
, overflow_p
);
3577 /* Don't share a CONSTRUCTOR that might be changed later. */
3578 init
= unshare_constructor (init
);
3579 if (target
== object
)
3580 /* The hash table might have moved since the get earlier. */
3581 valp
= ctx
->values
->get (object
);
3583 if (TREE_CODE (init
) == CONSTRUCTOR
)
3585 /* An outer ctx->ctor might be pointing to *valp, so replace
3587 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3588 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3589 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3590 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3591 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3596 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3597 CONSTRUCTORs, if any. */
3600 bool c
= TREE_CONSTANT (init
);
3601 bool s
= TREE_SIDE_EFFECTS (init
);
3603 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3606 TREE_CONSTANT (elt
) = false;
3608 TREE_SIDE_EFFECTS (elt
) = true;
3610 release_tree_vector (ctors
);
3612 if (*non_constant_p
)
3620 /* Evaluate a ++ or -- expression. */
3623 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3625 bool *non_constant_p
, bool *overflow_p
)
3627 enum tree_code code
= TREE_CODE (t
);
3628 tree type
= TREE_TYPE (t
);
3629 tree op
= TREE_OPERAND (t
, 0);
3630 tree offset
= TREE_OPERAND (t
, 1);
3631 gcc_assert (TREE_CONSTANT (offset
));
3633 /* The operand as an lvalue. */
3634 op
= cxx_eval_constant_expression (ctx
, op
, true,
3635 non_constant_p
, overflow_p
);
3637 /* The operand as an rvalue. */
3638 tree val
= rvalue (op
);
3639 val
= cxx_eval_constant_expression (ctx
, val
, false,
3640 non_constant_p
, overflow_p
);
3641 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3642 a local array in a constexpr function. */
3643 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3645 VERIFY_CONSTANT (val
);
3647 /* The modified value. */
3648 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3650 if (POINTER_TYPE_P (type
))
3652 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3653 offset
= convert_to_ptrofftype (offset
);
3655 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3656 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3659 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3661 VERIFY_CONSTANT (mod
);
3663 /* Storing the modified value. */
3664 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3665 cxx_eval_constant_expression (ctx
, store
,
3666 true, non_constant_p
, overflow_p
);
3668 /* And the value of the expression. */
3669 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3671 /* Prefix ops are lvalues. */
3675 /* But we optimize when the caller wants an rvalue. */
3679 /* Postfix ops are rvalues. */
3683 /* Predicates for the meaning of *jump_target. */
3686 returns (tree
*jump_target
)
3689 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3690 || (TREE_CODE (*jump_target
) == LABEL_DECL
3691 && LABEL_DECL_CDTOR (*jump_target
)));
3695 breaks (tree
*jump_target
)
3698 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3699 && LABEL_DECL_BREAK (*jump_target
))
3700 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3704 continues (tree
*jump_target
)
3707 && TREE_CODE (*jump_target
) == LABEL_DECL
3708 && LABEL_DECL_CONTINUE (*jump_target
);
3712 switches (tree
*jump_target
)
3715 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3718 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3719 STMT matches *jump_target. If we're looking for a case label and we see
3720 the default label, note it in ctx->css_state. */
3723 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3725 switch (TREE_CODE (*jump_target
))
3728 if (TREE_CODE (stmt
) == LABEL_EXPR
3729 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3734 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3736 gcc_assert (ctx
->css_state
!= NULL
);
3737 if (!CASE_LOW (stmt
))
3739 /* default: should appear just once in a SWITCH_EXPR
3740 body (excluding nested SWITCH_EXPR). */
3741 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3742 /* When evaluating SWITCH_EXPR body for the second time,
3743 return true for the default: label. */
3744 if (*ctx
->css_state
== css_default_processing
)
3746 *ctx
->css_state
= css_default_seen
;
3748 else if (CASE_HIGH (stmt
))
3750 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3751 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3754 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3765 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3766 semantics, for switch, break, continue, and return. */
3769 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3770 bool *non_constant_p
, bool *overflow_p
,
3773 tree_stmt_iterator i
;
3775 /* In a statement-expression we want to return the last value.
3776 For empty statement expression return void_node. */
3780 local_target
= NULL_TREE
;
3781 jump_target
= &local_target
;
3783 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3785 tree stmt
= tsi_stmt (i
);
3786 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3787 non_constant_p
, overflow_p
,
3789 if (*non_constant_p
)
3791 if (returns (jump_target
) || breaks (jump_target
))
3797 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3798 semantics; continue semantics are covered by cxx_eval_statement_list. */
3801 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3802 bool *non_constant_p
, bool *overflow_p
,
3805 constexpr_ctx new_ctx
= *ctx
;
3807 tree body
= TREE_OPERAND (t
, 0);
3811 hash_set
<tree
> save_exprs
;
3812 new_ctx
.save_exprs
= &save_exprs
;
3814 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3815 non_constant_p
, overflow_p
, jump_target
);
3817 /* Forget saved values of SAVE_EXPRs. */
3818 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3819 iter
!= save_exprs
.end(); ++iter
)
3820 new_ctx
.values
->remove (*iter
);
3821 if (++count
>= constexpr_loop_limit
)
3824 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3825 "constexpr loop iteration count exceeds limit of %d "
3826 "(use -fconstexpr-loop-limit= to increase the limit)",
3827 constexpr_loop_limit
);
3828 *non_constant_p
= true;
3832 while (!returns (jump_target
)
3833 && !breaks (jump_target
)
3834 && !switches (jump_target
)
3835 && !*non_constant_p
);
3837 if (breaks (jump_target
))
3838 *jump_target
= NULL_TREE
;
3843 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3847 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3848 bool *non_constant_p
, bool *overflow_p
,
3851 tree cond
= TREE_OPERAND (t
, 0);
3852 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3853 non_constant_p
, overflow_p
);
3854 VERIFY_CONSTANT (cond
);
3855 *jump_target
= cond
;
3857 tree body
= TREE_OPERAND (t
, 1);
3858 constexpr_ctx new_ctx
= *ctx
;
3859 constexpr_switch_state css
= css_default_not_seen
;
3860 new_ctx
.css_state
= &css
;
3861 cxx_eval_constant_expression (&new_ctx
, body
, false,
3862 non_constant_p
, overflow_p
, jump_target
);
3863 if (switches (jump_target
) && css
== css_default_seen
)
3865 /* If the SWITCH_EXPR body has default: label, process it once again,
3866 this time instructing label_matches to return true for default:
3867 label on switches (jump_target). */
3868 css
= css_default_processing
;
3869 cxx_eval_constant_expression (&new_ctx
, body
, false,
3870 non_constant_p
, overflow_p
, jump_target
);
3872 if (breaks (jump_target
) || switches (jump_target
))
3873 *jump_target
= NULL_TREE
;
3877 /* Find the object of TYPE under initialization in CTX. */
3880 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3885 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3886 can is a minor optimization. */
3887 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
3893 /* Since an object cannot have a field of its own type, we can search outward
3894 from ctx->object to find the unique containing object of TYPE. */
3895 tree ob
= ctx
->object
;
3898 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
3900 if (handled_component_p (ob
))
3901 ob
= TREE_OPERAND (ob
, 0);
3909 /* Attempt to reduce the expression T to a constant value.
3910 On failure, issue diagnostic and return error_mark_node. */
3911 /* FIXME unify with c_fully_fold */
3912 /* FIXME overflow_p is too global */
3915 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3917 bool *non_constant_p
, bool *overflow_p
,
3920 constexpr_ctx new_ctx
;
3923 if (jump_target
&& *jump_target
)
3925 /* If we are jumping, ignore all statements/expressions except those
3926 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
3927 switch (TREE_CODE (t
))
3930 case STATEMENT_LIST
:
3935 case CASE_LABEL_EXPR
:
3936 if (label_matches (ctx
, jump_target
, t
))
3938 *jump_target
= NULL_TREE
;
3944 if (t
== error_mark_node
)
3946 *non_constant_p
= true;
3949 if (CONSTANT_CLASS_P (t
))
3951 if (TREE_OVERFLOW (t
))
3954 permerror (input_location
, "overflow in constant expression");
3955 if (!flag_permissive
|| ctx
->quiet
)
3959 if (TREE_CODE (t
) == INTEGER_CST
3960 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
3961 && !integer_zerop (t
))
3964 error ("value %qE of type %qT is not a constant expression",
3966 *non_constant_p
= true;
3972 tree_code tcode
= TREE_CODE (t
);
3978 /* We ask for an rvalue for the RESULT_DECL when indirecting
3979 through an invisible reference, or in named return value
3981 return (*ctx
->values
->get (t
));
3984 if (DECL_HAS_VALUE_EXPR_P (t
))
3985 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
3986 lval
, non_constant_p
, overflow_p
);
3989 /* We used to not check lval for CONST_DECL, but darwin.c uses
3990 CONST_DECL for aggregate constants. */
3993 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
3994 && is_really_empty_class (TREE_TYPE (t
)))
3996 /* If the class is empty, we aren't actually loading anything. */
3997 r
= build_constructor (TREE_TYPE (t
), NULL
);
3998 TREE_CONSTANT (r
) = true;
4000 else if (ctx
->strict
)
4001 r
= decl_really_constant_value (t
);
4003 r
= decl_constant_value (t
);
4004 if (TREE_CODE (r
) == TARGET_EXPR
4005 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
4006 r
= TARGET_EXPR_INITIAL (r
);
4008 if (tree
*p
= ctx
->values
->get (r
))
4009 if (*p
!= NULL_TREE
)
4014 non_const_var_error (r
);
4015 *non_constant_p
= true;
4023 case CASE_LABEL_EXPR
:
4028 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4030 else if (tree
*p
= ctx
->values
->get (r
))
4033 /* Defer in case this is only used for its type. */;
4034 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4035 /* Defer, there's no lvalue->rvalue conversion. */;
4036 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4037 && is_really_empty_class (TREE_TYPE (t
)))
4039 /* If the class is empty, we aren't actually loading anything. */
4040 r
= build_constructor (TREE_TYPE (t
), NULL
);
4041 TREE_CONSTANT (r
) = true;
4046 error ("%qE is not a constant expression", t
);
4047 *non_constant_p
= true;
4052 case AGGR_INIT_EXPR
:
4053 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4054 non_constant_p
, overflow_p
);
4059 r
= DECL_EXPR_DECL (t
);
4060 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4061 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4065 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4066 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4067 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4071 if (tree init
= DECL_INITIAL (r
))
4073 init
= cxx_eval_constant_expression (ctx
, init
,
4075 non_constant_p
, overflow_p
);
4076 /* Don't share a CONSTRUCTOR that might be changed. */
4077 init
= unshare_constructor (init
);
4078 ctx
->values
->put (r
, init
);
4080 else if (ctx
== &new_ctx
)
4081 /* We gave it a CONSTRUCTOR above. */;
4083 ctx
->values
->put (r
, NULL_TREE
);
4088 if (!literal_type_p (TREE_TYPE (t
)))
4092 error ("temporary of non-literal type %qT in a "
4093 "constant expression", TREE_TYPE (t
));
4094 explain_non_literal_class (TREE_TYPE (t
));
4096 *non_constant_p
= true;
4099 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4101 /* We're being expanded without an explicit target, so start
4102 initializing a new object; expansion with an explicit target
4103 strips the TARGET_EXPR before we get here. */
4105 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4106 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4107 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4108 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4111 /* Pass false for 'lval' because this indicates
4112 initialization of a temporary. */
4113 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4115 non_constant_p
, overflow_p
);
4116 if (!*non_constant_p
)
4117 /* Adjust the type of the result to the type of the temporary. */
4118 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4121 tree slot
= TARGET_EXPR_SLOT (t
);
4122 r
= unshare_constructor (r
);
4123 ctx
->values
->put (slot
, r
);
4130 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4131 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4132 non_constant_p
, overflow_p
);
4136 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4138 non_constant_p
, overflow_p
);
4142 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4143 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4145 non_constant_p
, overflow_p
);
4150 /* Avoid evaluating a SAVE_EXPR more than once. */
4151 if (tree
*p
= ctx
->values
->get (t
))
4155 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4156 non_constant_p
, overflow_p
);
4157 ctx
->values
->put (t
, r
);
4158 if (ctx
->save_exprs
)
4159 ctx
->save_exprs
->add (t
);
4163 case NON_LVALUE_EXPR
:
4164 case TRY_CATCH_EXPR
:
4166 case CLEANUP_POINT_EXPR
:
4167 case MUST_NOT_THROW_EXPR
:
4170 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4172 non_constant_p
, overflow_p
,
4176 case TRY_FINALLY_EXPR
:
4177 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4178 non_constant_p
, overflow_p
,
4180 if (!*non_constant_p
)
4181 /* Also evaluate the cleanup. */
4182 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4183 non_constant_p
, overflow_p
,
4187 /* These differ from cxx_eval_unary_expression in that this doesn't
4188 check for a constant operand or result; an address can be
4189 constant without its operand being, and vice versa. */
4192 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4193 non_constant_p
, overflow_p
);
4198 tree oldop
= TREE_OPERAND (t
, 0);
4199 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4201 non_constant_p
, overflow_p
);
4202 /* Don't VERIFY_CONSTANT here. */
4203 if (*non_constant_p
)
4205 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4206 /* This function does more aggressive folding than fold itself. */
4207 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4208 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4217 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4218 non_constant_p
, overflow_p
);
4219 if (r
== error_mark_node
)
4221 else if (r
== TREE_OPERAND (t
, 0))
4224 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4229 case FIX_TRUNC_EXPR
:
4234 case TRUTH_NOT_EXPR
:
4235 case FIXED_CONVERT_EXPR
:
4236 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4237 non_constant_p
, overflow_p
);
4241 r
= fold_sizeof_expr (t
);
4242 VERIFY_CONSTANT (r
);
4247 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4248 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4249 introduced by build_call_a. */
4250 tree op0
= TREE_OPERAND (t
, 0);
4251 tree op1
= TREE_OPERAND (t
, 1);
4253 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4254 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4255 r
= cxx_eval_constant_expression (ctx
, op0
,
4256 lval
, non_constant_p
, overflow_p
,
4260 /* Check that the LHS is constant and then discard it. */
4261 cxx_eval_constant_expression (ctx
, op0
,
4262 true, non_constant_p
, overflow_p
,
4264 if (*non_constant_p
)
4266 op1
= TREE_OPERAND (t
, 1);
4267 r
= cxx_eval_constant_expression (ctx
, op1
,
4268 lval
, non_constant_p
, overflow_p
,
4274 case POINTER_PLUS_EXPR
:
4278 case TRUNC_DIV_EXPR
:
4280 case FLOOR_DIV_EXPR
:
4281 case ROUND_DIV_EXPR
:
4282 case TRUNC_MOD_EXPR
:
4284 case ROUND_MOD_EXPR
:
4286 case EXACT_DIV_EXPR
:
4296 case TRUTH_XOR_EXPR
:
4303 case UNORDERED_EXPR
:
4313 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4314 non_constant_p
, overflow_p
);
4317 /* fold can introduce non-IF versions of these; still treat them as
4318 short-circuiting. */
4319 case TRUTH_AND_EXPR
:
4320 case TRUTH_ANDIF_EXPR
:
4321 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4324 non_constant_p
, overflow_p
);
4328 case TRUTH_ORIF_EXPR
:
4329 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4332 non_constant_p
, overflow_p
);
4336 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4337 non_constant_p
, overflow_p
);
4341 if (is_overloaded_fn (t
))
4343 /* We can only get here in checking mode via
4344 build_non_dependent_expr, because any expression that
4345 calls or takes the address of the function will have
4346 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4347 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4348 *non_constant_p
= true;
4351 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4352 non_constant_p
, overflow_p
);
4356 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4357 non_constant_p
, overflow_p
);
4361 if (jump_target
&& *jump_target
)
4363 /* When jumping to a label, the label might be either in the
4364 then or else blocks, so process then block first in skipping
4365 mode first, and if we are still in the skipping mode at its end,
4366 process the else block too. */
4367 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4368 lval
, non_constant_p
, overflow_p
,
4371 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4372 lval
, non_constant_p
, overflow_p
,
4378 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4379 non_constant_p
, overflow_p
,
4384 if (TREE_CONSTANT (t
))
4386 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4387 VECTOR_CST if applicable. */
4388 /* FIXME after GCC 6 branches, make the verify unconditional. */
4390 verify_constructor_flags (t
);
4392 recompute_constructor_flags (t
);
4393 if (TREE_CONSTANT (t
))
4396 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4397 non_constant_p
, overflow_p
);
4401 /* We can get this in a defaulted constructor for a class with a
4402 non-static data member of array type. Either the initializer will
4403 be NULL, meaning default-initialization, or it will be an lvalue
4404 or xvalue of the same type, meaning direct-initialization from the
4405 corresponding member. */
4406 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4407 non_constant_p
, overflow_p
);
4412 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4413 non_constant_p
, overflow_p
);
4417 case VIEW_CONVERT_EXPR
:
4419 case UNARY_PLUS_EXPR
:
4421 tree oldop
= TREE_OPERAND (t
, 0);
4423 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4425 non_constant_p
, overflow_p
);
4426 if (*non_constant_p
)
4428 tree type
= TREE_TYPE (t
);
4429 if (TREE_CODE (op
) == PTRMEM_CST
4430 && !TYPE_PTRMEM_P (type
))
4431 op
= cplus_expand_constant (op
);
4432 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4434 if (same_type_ignoring_top_level_qualifiers_p (type
,
4436 || can_convert_qual (type
, op
))
4437 return cp_fold_convert (type
, op
);
4441 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4442 "a reinterpret_cast is not a constant expression");
4443 *non_constant_p
= true;
4448 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4450 if (integer_zerop (op
))
4452 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4455 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4456 "dereferencing a null pointer");
4457 *non_constant_p
= true;
4460 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4462 tree from
= TREE_TYPE (op
);
4464 if (!can_convert (type
, from
, tf_none
))
4467 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4468 "conversion of %qT null pointer to %qT "
4469 "is not a constant expression",
4471 *non_constant_p
= true;
4478 /* This detects for example:
4479 reinterpret_cast<void*>(sizeof 0)
4482 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4483 "%<reinterpret_cast<%T>(%E)%> is not "
4484 "a constant expression",
4486 *non_constant_p
= true;
4490 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4491 /* We didn't fold at the top so we could check for ptr-int
4494 if (tcode
== UNARY_PLUS_EXPR
)
4495 r
= fold_convert (TREE_TYPE (t
), op
);
4497 r
= fold_build1 (tcode
, type
, op
);
4498 /* Conversion of an out-of-range value has implementation-defined
4499 behavior; the language considers it different from arithmetic
4500 overflow, which is undefined. */
4501 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4502 TREE_OVERFLOW (r
) = false;
4506 case EMPTY_CLASS_EXPR
:
4507 /* This is good enough for a function argument that might not get
4508 used, and they can't do anything with it, so just return it. */
4511 case STATEMENT_LIST
:
4513 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4514 return cxx_eval_statement_list (&new_ctx
, t
,
4515 non_constant_p
, overflow_p
, jump_target
);
4518 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4520 non_constant_p
, overflow_p
,
4523 case PREINCREMENT_EXPR
:
4524 case POSTINCREMENT_EXPR
:
4525 case PREDECREMENT_EXPR
:
4526 case POSTDECREMENT_EXPR
:
4527 return cxx_eval_increment_expression (ctx
, t
,
4528 lval
, non_constant_p
, overflow_p
);
4534 case VEC_DELETE_EXPR
:
4537 /* GCC internal stuff. */
4540 case NON_DEPENDENT_EXPR
:
4544 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4545 "expression %qE is not a constant expression", t
);
4546 *non_constant_p
= true;
4549 case PLACEHOLDER_EXPR
:
4550 /* Use of the value or address of the current object. */
4551 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4552 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4553 non_constant_p
, overflow_p
);
4554 /* A placeholder without a referent. We can get here when
4555 checking whether NSDMIs are noexcept, or in massage_init_elt;
4556 just say it's non-constant for now. */
4557 gcc_assert (ctx
->quiet
);
4558 *non_constant_p
= true;
4563 tree cond
= TREE_OPERAND (t
, 0);
4564 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4565 non_constant_p
, overflow_p
);
4566 VERIFY_CONSTANT (cond
);
4567 if (integer_nonzerop (cond
))
4573 *jump_target
= TREE_OPERAND (t
, 0);
4574 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4575 /* Allow for jumping to a cdtor_label. */
4576 || returns (jump_target
));
4580 cxx_eval_loop_expr (ctx
, t
,
4581 non_constant_p
, overflow_p
, jump_target
);
4585 cxx_eval_switch_expr (ctx
, t
,
4586 non_constant_p
, overflow_p
, jump_target
);
4590 /* It's possible to get a requires-expression in a constant
4591 expression. For example:
4593 template<typename T> concept bool C() {
4594 return requires (T t) { t; };
4597 template<typename T> requires !C<T>() void f(T);
4599 Normalization leaves f with the associated constraint
4600 '!requires (T t) { ... }' which is not transformed into
4602 if (!processing_template_decl
)
4603 return evaluate_constraint_expression (t
, NULL_TREE
);
4605 *non_constant_p
= true;
4609 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
4610 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4612 non_constant_p
, overflow_p
,
4617 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4619 /* This function doesn't know how to deal with pre-genericize
4620 statements; this can only happen with statement-expressions,
4621 so for now just fail. */
4623 error_at (EXPR_LOCATION (t
),
4624 "statement is not a constant expression");
4627 internal_error ("unexpected expression %qE of kind %s", t
,
4628 get_tree_code_name (TREE_CODE (t
)));
4629 *non_constant_p
= true;
4633 if (r
== error_mark_node
)
4634 *non_constant_p
= true;
4636 if (*non_constant_p
)
4643 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4644 bool strict
= true, tree object
= NULL_TREE
)
4646 auto_timevar
time (TV_CONSTEXPR
);
4648 bool non_constant_p
= false;
4649 bool overflow_p
= false;
4650 hash_map
<tree
,tree
> map
;
4652 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4653 allow_non_constant
, strict
};
4655 tree type
= initialized_type (t
);
4657 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4659 /* In C++14 an NSDMI can participate in aggregate initialization,
4660 and can refer to the address of the object being initialized, so
4661 we need to pass in the relevant VAR_DECL if we want to do the
4662 evaluation in a single pass. The evaluation will dynamically
4663 update ctx.values for the VAR_DECL. We use the same strategy
4664 for C++11 constexpr constructors that refer to the object being
4666 ctx
.ctor
= build_constructor (type
, NULL
);
4667 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4670 if (TREE_CODE (t
) == TARGET_EXPR
)
4671 object
= TARGET_EXPR_SLOT (t
);
4672 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4673 object
= AGGR_INIT_EXPR_SLOT (t
);
4675 ctx
.object
= object
;
4677 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4678 (type
, TREE_TYPE (object
)));
4679 if (object
&& DECL_P (object
))
4680 map
.put (object
, ctx
.ctor
);
4681 if (TREE_CODE (r
) == TARGET_EXPR
)
4682 /* Avoid creating another CONSTRUCTOR when we expand the
4684 r
= TARGET_EXPR_INITIAL (r
);
4687 r
= cxx_eval_constant_expression (&ctx
, r
,
4688 false, &non_constant_p
, &overflow_p
);
4690 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4692 /* Mutable logic is a bit tricky: we want to allow initialization of
4693 constexpr variables with mutable members, but we can't copy those
4694 members to another constexpr variable. */
4695 if (TREE_CODE (r
) == CONSTRUCTOR
4696 && CONSTRUCTOR_MUTABLE_POISON (r
))
4698 if (!allow_non_constant
)
4699 error ("%qE is not a constant expression because it refers to "
4700 "mutable subobjects of %qT", t
, type
);
4701 non_constant_p
= true;
4704 if (TREE_CODE (r
) == CONSTRUCTOR
4705 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4707 if (!allow_non_constant
)
4708 error ("%qE is not a constant expression because it refers to "
4709 "an incompletely initialized variable", t
);
4710 TREE_CONSTANT (r
) = false;
4711 non_constant_p
= true;
4714 /* Technically we should check this for all subexpressions, but that
4715 runs into problems with our internal representation of pointer
4716 subtraction and the 5.19 rules are still in flux. */
4717 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4718 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4719 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4721 if (!allow_non_constant
)
4722 error ("conversion from pointer type %qT "
4723 "to arithmetic type %qT in a constant expression",
4724 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4725 non_constant_p
= true;
4728 if (!non_constant_p
&& overflow_p
)
4729 non_constant_p
= true;
4731 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4733 bool should_unshare
= true;
4734 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4735 should_unshare
= false;
4737 if (non_constant_p
&& !allow_non_constant
)
4738 return error_mark_node
;
4739 else if (non_constant_p
&& TREE_CONSTANT (r
))
4741 /* This isn't actually constant, so unset TREE_CONSTANT. */
4744 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4745 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4747 r
= build_nop (TREE_TYPE (r
), r
);
4748 TREE_CONSTANT (r
) = false;
4750 else if (non_constant_p
|| r
== t
)
4754 r
= unshare_expr (r
);
4756 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4758 if (TREE_CODE (t
) == TARGET_EXPR
4759 && TARGET_EXPR_INITIAL (t
) == r
)
4763 r
= get_target_expr (r
);
4764 TREE_CONSTANT (r
) = true;
4772 /* Returns true if T is a valid subexpression of a constant expression,
4773 even if it isn't itself a constant expression. */
4776 is_sub_constant_expr (tree t
)
4778 bool non_constant_p
= false;
4779 bool overflow_p
= false;
4780 hash_map
<tree
, tree
> map
;
4782 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4784 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4786 return !non_constant_p
&& !overflow_p
;
4789 /* If T represents a constant expression returns its reduced value.
4790 Otherwise return error_mark_node. If T is dependent, then
4794 cxx_constant_value (tree t
, tree decl
)
4796 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4799 /* Helper routine for fold_simple function. Either return simplified
4800 expression T, otherwise NULL_TREE.
4801 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4802 even if we are within template-declaration. So be careful on call, as in
4803 such case types can be undefined. */
4806 fold_simple_1 (tree t
)
4809 enum tree_code code
= TREE_CODE (t
);
4821 return fold_sizeof_expr (t
);
4829 case TRUTH_NOT_EXPR
:
4831 case VIEW_CONVERT_EXPR
:
4834 case FIX_TRUNC_EXPR
:
4835 case FIXED_CONVERT_EXPR
:
4836 case ADDR_SPACE_CONVERT_EXPR
:
4838 op1
= TREE_OPERAND (t
, 0);
4840 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4844 if (CONVERT_EXPR_CODE_P (code
)
4845 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4846 TREE_OVERFLOW (t
) = false;
4854 /* If T is a simple constant expression, returns its simplified value.
4855 Otherwise returns T. In contrast to maybe_constant_value do we
4856 simplify only few operations on constant-expressions, and we don't
4857 try to simplify constexpressions. */
4860 fold_simple (tree t
)
4863 if (processing_template_decl
)
4866 r
= fold_simple_1 (t
);
4873 /* If T is a constant expression, returns its reduced value.
4874 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4875 Otherwise, returns a version of T without TREE_CONSTANT. */
4877 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4880 maybe_constant_value (tree t
, tree decl
)
4884 if (!is_nondependent_constant_expression (t
))
4886 if (TREE_OVERFLOW_P (t
))
4888 t
= build_nop (TREE_TYPE (t
), t
);
4889 TREE_CONSTANT (t
) = false;
4893 else if (CONSTANT_CLASS_P (t
))
4894 /* No caching or evaluation needed. */
4897 if (cv_cache
== NULL
)
4898 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4899 if (tree
*cached
= cv_cache
->get (t
))
4902 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4903 gcc_checking_assert (r
== t
4904 || CONVERT_EXPR_P (t
)
4905 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4906 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4907 || !cp_tree_equal (r
, t
));
4908 cv_cache
->put (t
, r
);
4912 /* Dispose of the whole CV_CACHE. */
4915 clear_cv_cache (void)
4917 if (cv_cache
!= NULL
)
4921 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4924 clear_cv_and_fold_caches (void)
4927 clear_fold_cache ();
4930 /* Like maybe_constant_value but first fully instantiate the argument.
4932 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4933 (t, tf_none) followed by maybe_constant_value but is more efficient,
4934 because calls instantiation_dependent_expression_p and
4935 potential_constant_expression at most once. */
4938 fold_non_dependent_expr (tree t
)
4943 /* If we're in a template, but T isn't value dependent, simplify
4944 it. We're supposed to treat:
4946 template <typename T> void f(T[1 + 1]);
4947 template <typename T> void f(T[2]);
4949 as two declarations of the same function, for example. */
4950 if (processing_template_decl
)
4952 if (is_nondependent_constant_expression (t
))
4954 processing_template_decl_sentinel s
;
4955 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4957 if (type_unknown_p (t
)
4958 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4960 if (TREE_OVERFLOW_P (t
))
4962 t
= build_nop (TREE_TYPE (t
), t
);
4963 TREE_CONSTANT (t
) = false;
4968 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4969 /* cp_tree_equal looks through NOPs, so allow them. */
4970 gcc_checking_assert (r
== t
4971 || CONVERT_EXPR_P (t
)
4972 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4973 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4974 || !cp_tree_equal (r
, t
));
4977 else if (TREE_OVERFLOW_P (t
))
4979 t
= build_nop (TREE_TYPE (t
), t
);
4980 TREE_CONSTANT (t
) = false;
4985 return maybe_constant_value (t
);
4988 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4989 than wrapped in a TARGET_EXPR. */
4992 maybe_constant_init (tree t
, tree decl
)
4996 if (TREE_CODE (t
) == EXPR_STMT
)
4997 t
= TREE_OPERAND (t
, 0);
4998 if (TREE_CODE (t
) == CONVERT_EXPR
4999 && VOID_TYPE_P (TREE_TYPE (t
)))
5000 t
= TREE_OPERAND (t
, 0);
5001 if (TREE_CODE (t
) == INIT_EXPR
)
5002 t
= TREE_OPERAND (t
, 1);
5003 if (TREE_CODE (t
) == TARGET_EXPR
)
5004 t
= TARGET_EXPR_INITIAL (t
);
5005 if (!is_nondependent_static_init_expression (t
))
5006 /* Don't try to evaluate it. */;
5007 else if (CONSTANT_CLASS_P (t
))
5008 /* No evaluation needed. */;
5010 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
5011 if (TREE_CODE (t
) == TARGET_EXPR
)
5013 tree init
= TARGET_EXPR_INITIAL (t
);
5014 if (TREE_CODE (init
) == CONSTRUCTOR
)
5021 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5022 /* Return true if the object referred to by REF has automatic or thread
5025 enum { ck_ok
, ck_bad
, ck_unknown
};
5027 check_automatic_or_tls (tree ref
)
5030 HOST_WIDE_INT bitsize
, bitpos
;
5032 int volatilep
= 0, unsignedp
= 0;
5033 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5034 &mode
, &unsignedp
, &volatilep
, false);
5037 /* If there isn't a decl in the middle, we don't know the linkage here,
5038 and this isn't a constant expression anyway. */
5041 dk
= decl_storage_duration (decl
);
5042 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5046 /* Return true if T denotes a potentially constant expression. Issue
5047 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5048 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5049 consider the expression in the current context, independent of constexpr
5052 C++0x [expr.const] used to say
5054 6 An expression is a potential constant expression if it is
5055 a constant expression where all occurrences of function
5056 parameters are replaced by arbitrary constant expressions
5057 of the appropriate type.
5059 2 A conditional expression is a constant expression unless it
5060 involves one of the following as a potentially evaluated
5061 subexpression (3.2), but subexpressions of logical AND (5.14),
5062 logical OR (5.15), and conditional (5.16) operations that are
5063 not evaluated are not considered. */
5066 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5067 tsubst_flags_t flags
)
5069 #define RECUR(T,RV) \
5070 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5072 enum { any
= false, rval
= true };
5076 if (t
== error_mark_node
)
5080 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5081 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5083 if (flags
& tf_error
)
5084 error_at (loc
, "expression %qE has side-effects", t
);
5087 if (CONSTANT_CLASS_P (t
))
5089 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5090 && TREE_TYPE (t
) == error_mark_node
)
5093 switch (TREE_CODE (t
))
5099 case TEMPLATE_ID_EXPR
:
5102 case CASE_LABEL_EXPR
:
5108 case TEMPLATE_PARM_INDEX
:
5110 case IDENTIFIER_NODE
:
5111 case USERDEF_LITERAL
:
5112 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5117 case PLACEHOLDER_EXPR
:
5127 if (flags
& tf_error
)
5128 error ("%qE is not a constant expression", t
);
5133 case AGGR_INIT_EXPR
:
5135 /* -- an invocation of a function other than a constexpr function
5136 or a constexpr constructor. */
5138 tree fun
= get_function_named_in_call (t
);
5139 const int nargs
= call_expr_nargs (t
);
5142 if (fun
== NULL_TREE
)
5144 /* Reset to allow the function to continue past the end
5145 of the block below. Otherwise return early. */
5148 if (TREE_CODE (t
) == CALL_EXPR
5149 && CALL_EXPR_FN (t
) == NULL_TREE
)
5150 switch (CALL_EXPR_IFN (t
))
5152 /* These should be ignored, they are optimized away from
5153 constexpr functions. */
5154 case IFN_UBSAN_NULL
:
5155 case IFN_UBSAN_BOUNDS
:
5156 case IFN_UBSAN_VPTR
:
5157 case IFN_FALLTHROUGH
:
5160 case IFN_ADD_OVERFLOW
:
5161 case IFN_SUB_OVERFLOW
:
5162 case IFN_MUL_OVERFLOW
:
5172 /* fold_call_expr can't do anything with IFN calls. */
5173 if (flags
& tf_error
)
5174 error_at (loc
, "call to internal function %qE", t
);
5179 if (fun
&& is_overloaded_fn (fun
))
5181 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5183 if (builtin_valid_in_constant_expr_p (fun
))
5185 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5186 /* Allow any built-in function; if the expansion
5187 isn't constant, we'll deal with that then. */
5188 && !is_builtin_fn (fun
))
5190 if (flags
& tf_error
)
5192 error_at (loc
, "call to non-constexpr function %qD",
5194 explain_invalid_constexpr_fn (fun
);
5198 /* A call to a non-static member function takes the address
5199 of the object as the first argument. But in a constant
5200 expression the address will be folded away, so look
5202 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5203 && !DECL_CONSTRUCTOR_P (fun
))
5205 tree x
= get_nth_callarg (t
, 0);
5206 if (is_this_parameter (x
))
5208 /* Don't require an immediately constant value, as
5209 constexpr substitution might not use the value. */
5210 bool sub_now
= false;
5211 if (!potential_constant_expression_1 (x
, rval
, strict
,
5219 if (!RECUR (fun
, true))
5221 fun
= get_first_fn (fun
);
5223 /* Skip initial arguments to base constructors. */
5224 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5225 i
= num_artificial_parms_for (fun
);
5226 fun
= DECL_ORIGIN (fun
);
5230 if (RECUR (fun
, rval
))
5231 /* Might end up being a constant function pointer. */;
5235 for (; i
< nargs
; ++i
)
5237 tree x
= get_nth_callarg (t
, i
);
5238 /* In a template, reference arguments haven't been converted to
5239 REFERENCE_TYPE and we might not even know if the parameter
5240 is a reference, so accept lvalue constants too. */
5241 bool rv
= processing_template_decl
? any
: rval
;
5242 /* Don't require an immediately constant value, as constexpr
5243 substitution might not use the value of the argument. */
5244 bool sub_now
= false;
5245 if (!potential_constant_expression_1 (x
, rv
, strict
,
5252 case NON_LVALUE_EXPR
:
5253 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5254 -- an lvalue of integral type that refers to a non-volatile
5255 const variable or static data member initialized with
5256 constant expressions, or
5258 -- an lvalue of literal type that refers to non-volatile
5259 object defined with constexpr, or that refers to a
5260 sub-object of such an object; */
5261 return RECUR (TREE_OPERAND (t
, 0), rval
);
5264 if (DECL_HAS_VALUE_EXPR_P (t
))
5265 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5267 && !var_in_maybe_constexpr_fn (t
)
5268 && !type_dependent_expression_p (t
)
5269 && !decl_maybe_constant_var_p (t
)
5271 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5272 || (DECL_INITIAL (t
)
5273 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5274 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5275 && !is_really_empty_class (TREE_TYPE (t
)))
5277 if (flags
& tf_error
)
5278 non_const_var_error (t
);
5285 case VIEW_CONVERT_EXPR
:
5286 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5287 may change to something more specific to type-punning (DR 1312). */
5289 tree from
= TREE_OPERAND (t
, 0);
5290 if (POINTER_TYPE_P (TREE_TYPE (t
))
5291 && TREE_CODE (from
) == INTEGER_CST
5292 && !integer_zerop (from
))
5294 if (flags
& tf_error
)
5295 error_at (loc
, "reinterpret_cast from integer to pointer");
5298 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5301 case ADDRESSOF_EXPR
:
5302 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5303 t
= TREE_OPERAND (t
, 0);
5304 goto handle_addr_expr
;
5307 /* -- a unary operator & that is applied to an lvalue that
5308 designates an object with thread or automatic storage
5310 t
= TREE_OPERAND (t
, 0);
5312 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5313 /* A pointer-to-member constant. */
5318 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5319 any checking here, as we might dereference the pointer later. If
5320 we remove this code, also remove check_automatic_or_tls. */
5321 i
= check_automatic_or_tls (t
);
5326 if (flags
& tf_error
)
5327 error ("address-of an object %qE with thread local or "
5328 "automatic storage is not a constant expression", t
);
5332 return RECUR (t
, any
);
5340 /* -- a class member access unless its postfix-expression is
5341 of literal type or of pointer to literal type. */
5342 /* This test would be redundant, as it follows from the
5343 postfix-expression being a potential constant expression. */
5344 if (type_unknown_p (t
))
5346 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5348 case EXPR_PACK_EXPANSION
:
5349 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5353 tree x
= TREE_OPERAND (t
, 0);
5355 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5357 if (!var_in_maybe_constexpr_fn (x
))
5359 if (flags
& tf_error
)
5360 error_at (loc
, "use of %<this%> in a constant expression");
5365 return RECUR (x
, rval
);
5368 case STATEMENT_LIST
:
5370 tree_stmt_iterator i
;
5371 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5373 if (!RECUR (tsi_stmt (i
), any
))
5381 if (cxx_dialect
< cxx14
)
5383 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5385 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5390 if (cxx_dialect
< cxx14
)
5392 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5394 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5399 if (!RECUR (DO_COND (t
), rval
))
5401 if (!RECUR (DO_BODY (t
), any
))
5406 if (!RECUR (FOR_INIT_STMT (t
), any
))
5408 if (!RECUR (FOR_COND (t
), rval
))
5410 if (!RECUR (FOR_EXPR (t
), any
))
5412 if (!RECUR (FOR_BODY (t
), any
))
5416 case RANGE_FOR_STMT
:
5417 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5419 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5424 if (!RECUR (WHILE_COND (t
), rval
))
5426 if (!RECUR (WHILE_BODY (t
), any
))
5431 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5433 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5434 unreachable labels would be checked. */
5438 return RECUR (STMT_EXPR_STMT (t
), rval
);
5441 case DYNAMIC_CAST_EXPR
:
5442 case PSEUDO_DTOR_EXPR
:
5446 case VEC_DELETE_EXPR
:
5451 case OMP_DISTRIBUTE
:
5454 case OMP_TARGET_DATA
:
5463 case OMP_TARGET_UPDATE
:
5464 case OMP_TARGET_ENTER_DATA
:
5465 case OMP_TARGET_EXIT_DATA
:
5467 case OMP_ATOMIC_READ
:
5468 case OMP_ATOMIC_CAPTURE_OLD
:
5469 case OMP_ATOMIC_CAPTURE_NEW
:
5473 case OACC_HOST_DATA
:
5477 case OACC_ENTER_DATA
:
5478 case OACC_EXIT_DATA
:
5482 /* GCC internal stuff. */
5485 case TRANSACTION_EXPR
:
5487 case AT_ENCODE_EXPR
:
5489 if (flags
& tf_error
)
5490 error_at (loc
, "expression %qE is not a constant expression", t
);
5494 /* -- a typeid expression whose operand is of polymorphic
5497 tree e
= TREE_OPERAND (t
, 0);
5498 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5499 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5501 if (flags
& tf_error
)
5502 error_at (loc
, "typeid-expression is not a constant expression "
5503 "because %qE is of polymorphic type", e
);
5522 case PREINCREMENT_EXPR
:
5523 case POSTINCREMENT_EXPR
:
5524 case PREDECREMENT_EXPR
:
5525 case POSTDECREMENT_EXPR
:
5526 if (cxx_dialect
< cxx14
)
5532 if (TYPE_P (TREE_OPERAND (t
, 0)))
5538 case FIX_TRUNC_EXPR
:
5542 case TRUTH_NOT_EXPR
:
5543 case FIXED_CONVERT_EXPR
:
5544 case UNARY_PLUS_EXPR
:
5545 case UNARY_LEFT_FOLD_EXPR
:
5546 case UNARY_RIGHT_FOLD_EXPR
:
5548 return RECUR (TREE_OPERAND (t
, 0), rval
);
5551 case CONST_CAST_EXPR
:
5552 case STATIC_CAST_EXPR
:
5553 case REINTERPRET_CAST_EXPR
:
5554 case IMPLICIT_CONV_EXPR
:
5555 if (cxx_dialect
< cxx11
5556 && !dependent_type_p (TREE_TYPE (t
))
5557 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5558 /* In C++98, a conversion to non-integral type can't be part of a
5559 constant expression. */
5561 if (flags
& tf_error
)
5563 "cast to non-integral type %qT in a constant expression",
5568 return (RECUR (TREE_OPERAND (t
, 0),
5569 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5572 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5574 case CLEANUP_POINT_EXPR
:
5575 case MUST_NOT_THROW_EXPR
:
5576 case TRY_CATCH_EXPR
:
5581 case NON_DEPENDENT_EXPR
:
5582 /* For convenience. */
5586 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5589 tmp
= DECL_EXPR_DECL (t
);
5590 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5592 if (TREE_STATIC (tmp
))
5594 if (flags
& tf_error
)
5595 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5596 "%<static%> in %<constexpr%> context", tmp
);
5599 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5601 if (flags
& tf_error
)
5602 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5603 "%<thread_local%> in %<constexpr%> context", tmp
);
5606 else if (!DECL_NONTRIVIALLY_INITIALIZED_P (tmp
))
5608 if (flags
& tf_error
)
5609 error_at (DECL_SOURCE_LOCATION (tmp
), "uninitialized "
5610 "variable %qD in %<constexpr%> context", tmp
);
5614 return RECUR (tmp
, want_rval
);
5616 case TRY_FINALLY_EXPR
:
5617 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5618 && RECUR (TREE_OPERAND (t
, 1), any
));
5621 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5624 if (!literal_type_p (TREE_TYPE (t
)))
5626 if (flags
& tf_error
)
5628 error_at (loc
, "temporary of non-literal type %qT in a "
5629 "constant expression", TREE_TYPE (t
));
5630 explain_non_literal_class (TREE_TYPE (t
));
5636 return RECUR (TREE_OPERAND (t
, 1), rval
);
5640 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5641 constructor_elt
*ce
;
5642 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5643 if (!RECUR (ce
->value
, want_rval
))
5650 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5651 || DECL_P (TREE_PURPOSE (t
)));
5652 if (!RECUR (TREE_VALUE (t
), want_rval
))
5654 if (TREE_CHAIN (t
) == NULL_TREE
)
5656 return RECUR (TREE_CHAIN (t
), want_rval
);
5659 case TRUNC_DIV_EXPR
:
5661 case FLOOR_DIV_EXPR
:
5662 case ROUND_DIV_EXPR
:
5663 case TRUNC_MOD_EXPR
:
5665 case ROUND_MOD_EXPR
:
5667 tree denom
= TREE_OPERAND (t
, 1);
5668 if (!RECUR (denom
, rval
))
5670 /* We can't call cxx_eval_outermost_constant_expr on an expression
5671 that hasn't been through instantiate_non_dependent_expr yet. */
5672 if (!processing_template_decl
)
5673 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5674 if (integer_zerop (denom
))
5676 if (flags
& tf_error
)
5677 error ("division by zero is not a constant expression");
5683 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5689 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5690 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5691 introduced by build_call_a. */
5692 tree op0
= TREE_OPERAND (t
, 0);
5693 tree op1
= TREE_OPERAND (t
, 1);
5695 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5696 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5697 return RECUR (op0
, want_rval
);
5702 /* If the first operand is the non-short-circuit constant, look at
5703 the second operand; otherwise we only care about the first one for
5705 case TRUTH_AND_EXPR
:
5706 case TRUTH_ANDIF_EXPR
:
5707 tmp
= boolean_true_node
;
5710 case TRUTH_ORIF_EXPR
:
5711 tmp
= boolean_false_node
;
5714 tree op
= TREE_OPERAND (t
, 0);
5715 if (!RECUR (op
, rval
))
5717 if (!processing_template_decl
)
5718 op
= cxx_eval_outermost_constant_expr (op
, true);
5719 if (tree_int_cst_equal (op
, tmp
))
5720 return RECUR (TREE_OPERAND (t
, 1), rval
);
5727 case POINTER_PLUS_EXPR
:
5729 case EXACT_DIV_EXPR
:
5739 case TRUTH_XOR_EXPR
:
5740 case UNORDERED_EXPR
:
5753 case ARRAY_RANGE_REF
:
5757 case BINARY_LEFT_FOLD_EXPR
:
5758 case BINARY_RIGHT_FOLD_EXPR
:
5760 for (i
= 0; i
< 2; ++i
)
5761 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5765 case CILK_SYNC_STMT
:
5766 case CILK_SPAWN_STMT
:
5767 case ARRAY_NOTATION_REF
:
5772 for (i
= 0; i
< 3; ++i
)
5773 if (!RECUR (TREE_OPERAND (t
, i
), true))
5778 if (COND_EXPR_IS_VEC_DELETE (t
))
5780 if (flags
& tf_error
)
5781 error_at (loc
, "%<delete[]%> is not a constant expression");
5787 /* If the condition is a known constant, we know which of the legs we
5788 care about; otherwise we only require that the condition and
5789 either of the legs be potentially constant. */
5790 tmp
= TREE_OPERAND (t
, 0);
5791 if (!RECUR (tmp
, rval
))
5793 if (!processing_template_decl
)
5794 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5795 if (integer_zerop (tmp
))
5796 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5797 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5798 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5799 for (i
= 1; i
< 3; ++i
)
5800 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5801 want_rval
, strict
, now
, tf_none
))
5803 if (flags
& tf_error
)
5804 error_at (loc
, "expression %qE is not a constant expression", t
);
5808 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5810 if (flags
& tf_error
)
5812 error_at (loc
, "non-constant array initialization");
5813 diagnose_non_constexpr_vec_init (t
);
5819 /* We can see these in statement-expressions. */
5823 case EMPTY_CLASS_EXPR
:
5829 tree
*target
= &TREE_OPERAND (t
, 0);
5830 /* Gotos representing break and continue are OK. */
5831 if (breaks (target
) || continues (target
))
5833 if (flags
& tf_error
)
5834 error_at (loc
, "%<goto%> is not a constant expression");
5839 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
5840 return RECUR (TREE_OPERAND (t
, 0), rval
);
5843 if (objc_is_property_ref (t
))
5846 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5853 /* The main entry point to the above. */
5856 potential_constant_expression (tree t
)
5858 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
5861 /* As above, but require a constant rvalue. */
5864 potential_rvalue_constant_expression (tree t
)
5866 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
5869 /* Like above, but complain about non-constant expressions. */
5872 require_potential_constant_expression (tree t
)
5874 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
5877 /* Cross product of the above. */
5880 require_potential_rvalue_constant_expression (tree t
)
5882 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
5885 /* Like potential_constant_expression, but don't consider possible constexpr
5886 substitution of the current function. That is, PARM_DECL qualifies under
5887 potential_constant_expression, but not here.
5889 This is basically what you can check when any actual constant values might
5890 be value-dependent. */
5893 is_constant_expression (tree t
)
5895 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
5898 /* Like above, but complain about non-constant expressions. */
5901 require_constant_expression (tree t
)
5903 return potential_constant_expression_1 (t
, false, true, true,
5904 tf_warning_or_error
);
5907 /* Like is_constant_expression, but allow const variables that are not allowed
5908 under constexpr rules. */
5911 is_static_init_expression (tree t
)
5913 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
5916 /* Returns true if T is a potential constant expression that is not
5917 instantiation-dependent, and therefore a candidate for constant folding even
5921 is_nondependent_constant_expression (tree t
)
5923 return (!type_unknown_p (t
)
5924 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5925 && is_constant_expression (t
)
5926 && !instantiation_dependent_expression_p (t
));
5929 /* Returns true if T is a potential static initializer expression that is not
5930 instantiation-dependent. */
5933 is_nondependent_static_init_expression (tree t
)
5935 return (!type_unknown_p (t
)
5936 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5937 && is_static_init_expression (t
)
5938 && !instantiation_dependent_expression_p (t
));
5941 /* Finalize constexpr processing after parsing. */
5944 fini_constexpr (void)
5946 /* The contexpr call and fundef copies tables are no longer needed. */
5947 constexpr_call_table
= NULL
;
5948 fundef_copies_table
= NULL
;
5951 #include "gt-cp-constexpr.h"