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 elt
; unsigned HOST_WIDE_INT idx
;
1736 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1739 /* We're in the middle of initializing this element. */
1741 if (!reduced_constant_expression_p (elt
))
1747 /* FIXME are we calling this too much? */
1748 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1752 /* Some expressions may have constant operands but are not constant
1753 themselves, such as 1/0. Call this function (or rather, the macro
1754 following it) to check for that condition.
1756 We only call this in places that require an arithmetic constant, not in
1757 places where we might have a non-constant expression that can be a
1758 component of a constant expression, such as the address of a constexpr
1759 variable that might be dereferenced later. */
1762 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1765 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1767 if (!allow_non_constant
)
1768 error ("%q+E is not a constant expression", t
);
1769 *non_constant_p
= true;
1771 if (TREE_OVERFLOW_P (t
))
1773 if (!allow_non_constant
)
1775 permerror (input_location
, "overflow in constant expression");
1776 /* If we're being permissive (and are in an enforcing
1777 context), ignore the overflow. */
1778 if (flag_permissive
)
1779 return *non_constant_p
;
1783 return *non_constant_p
;
1786 /* Check whether the shift operation with code CODE and type TYPE on LHS
1787 and RHS is undefined. If it is, give an error with an explanation,
1788 and return true; return false otherwise. */
1791 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1792 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1794 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1795 || TREE_CODE (lhs
) != INTEGER_CST
1796 || TREE_CODE (rhs
) != INTEGER_CST
)
1799 tree lhstype
= TREE_TYPE (lhs
);
1800 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1802 /* [expr.shift] The behavior is undefined if the right operand
1803 is negative, or greater than or equal to the length in bits
1804 of the promoted left operand. */
1805 if (tree_int_cst_sgn (rhs
) == -1)
1808 permerror (loc
, "right operand of shift expression %q+E is negative",
1809 build2_loc (loc
, code
, type
, lhs
, rhs
));
1810 return (!flag_permissive
|| ctx
->quiet
);
1812 if (compare_tree_int (rhs
, uprec
) >= 0)
1815 permerror (loc
, "right operand of shift expression %q+E is >= than "
1816 "the precision of the left operand",
1817 build2_loc (loc
, code
, type
, lhs
, rhs
));
1818 return (!flag_permissive
|| ctx
->quiet
);
1821 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1822 if E1 has a signed type and non-negative value, and E1x2^E2 is
1823 representable in the corresponding unsigned type of the result type,
1824 then that value, converted to the result type, is the resulting value;
1825 otherwise, the behavior is undefined. */
1826 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1827 && (cxx_dialect
>= cxx11
))
1829 if (tree_int_cst_sgn (lhs
) == -1)
1833 "left operand of shift expression %q+E is negative",
1834 build2_loc (loc
, code
, type
, lhs
, rhs
));
1835 return (!flag_permissive
|| ctx
->quiet
);
1837 /* For signed x << y the following:
1838 (unsigned) x >> ((prec (lhs) - 1) - y)
1839 if > 1, is undefined. The right-hand side of this formula
1840 is the highest bit of the LHS that can be set (starting from 0),
1841 so that the shift doesn't overflow. We then right-shift the LHS
1842 to see whether any other bit is set making the original shift
1843 undefined -- the result is not representable in the corresponding
1845 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1846 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1847 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1848 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1849 if (tree_int_cst_lt (integer_one_node
, t
))
1852 permerror (loc
, "shift expression %q+E overflows",
1853 build2_loc (loc
, code
, type
, lhs
, rhs
));
1854 return (!flag_permissive
|| ctx
->quiet
);
1860 /* Subroutine of cxx_eval_constant_expression.
1861 Attempt to reduce the unary expression tree T to a compile time value.
1862 If successful, return the value. Otherwise issue a diagnostic
1863 and return error_mark_node. */
1866 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1868 bool *non_constant_p
, bool *overflow_p
)
1871 tree orig_arg
= TREE_OPERAND (t
, 0);
1872 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1873 non_constant_p
, overflow_p
);
1874 VERIFY_CONSTANT (arg
);
1875 location_t loc
= EXPR_LOCATION (t
);
1876 enum tree_code code
= TREE_CODE (t
);
1877 tree type
= TREE_TYPE (t
);
1878 r
= fold_unary_loc (loc
, code
, type
, arg
);
1881 if (arg
== orig_arg
)
1884 r
= build1_loc (loc
, code
, type
, arg
);
1886 VERIFY_CONSTANT (r
);
1890 /* Helper function for cxx_eval_binary_expression. Try to optimize
1891 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1892 generic folding should be used. */
1895 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1896 tree lhs
, tree rhs
, bool *non_constant_p
,
1900 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1903 lhs
= TREE_OPERAND (lhs
, 0);
1905 /* &A[i] p+ j => &A[i + j] */
1906 if (TREE_CODE (lhs
) == ARRAY_REF
1907 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1908 && TREE_CODE (rhs
) == INTEGER_CST
1909 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1910 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1912 tree orig_type
= TREE_TYPE (t
);
1913 location_t loc
= EXPR_LOCATION (t
);
1914 tree type
= TREE_TYPE (lhs
);
1916 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1917 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1918 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1920 if (*non_constant_p
)
1922 /* Don't fold an out-of-bound access. */
1923 if (!tree_int_cst_le (t
, nelts
))
1925 rhs
= cp_fold_convert (ssizetype
, rhs
);
1926 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1927 constexpr int A[1]; ... (char *)&A[0] + 1 */
1928 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1929 rhs
, TYPE_SIZE_UNIT (type
))))
1931 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1933 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1934 TYPE_SIZE_UNIT (type
));
1935 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1936 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1937 t
, NULL_TREE
, NULL_TREE
);
1938 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1939 t
= cp_fold_convert (orig_type
, t
);
1940 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1941 non_constant_p
, overflow_p
);
1947 /* Subroutine of cxx_eval_constant_expression.
1948 Like cxx_eval_unary_expression, except for binary expressions. */
1951 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1953 bool *non_constant_p
, bool *overflow_p
)
1956 tree orig_lhs
= TREE_OPERAND (t
, 0);
1957 tree orig_rhs
= TREE_OPERAND (t
, 1);
1959 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1960 non_constant_p
, overflow_p
);
1961 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
1963 if (*non_constant_p
)
1965 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1966 non_constant_p
, overflow_p
);
1967 if (*non_constant_p
)
1970 location_t loc
= EXPR_LOCATION (t
);
1971 enum tree_code code
= TREE_CODE (t
);
1972 tree type
= TREE_TYPE (t
);
1974 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
1976 bool is_code_eq
= (code
== EQ_EXPR
);
1978 if (TREE_CODE (lhs
) == PTRMEM_CST
1979 && TREE_CODE (rhs
) == PTRMEM_CST
)
1980 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
1982 else if ((TREE_CODE (lhs
) == PTRMEM_CST
1983 || TREE_CODE (rhs
) == PTRMEM_CST
)
1984 && (null_member_pointer_value_p (lhs
)
1985 || null_member_pointer_value_p (rhs
)))
1986 r
= constant_boolean_node (!is_code_eq
, type
);
1987 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
1988 lhs
= cplus_expand_constant (lhs
);
1989 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
1990 rhs
= cplus_expand_constant (rhs
);
1992 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
1993 && integer_zerop (lhs
) && !integer_zerop (rhs
))
1996 error ("arithmetic involving a null pointer in %qE", lhs
);
1999 else if (code
== POINTER_PLUS_EXPR
)
2000 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
2004 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
2008 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
2011 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
2013 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
2014 *non_constant_p
= true;
2015 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2016 a local array in a constexpr function. */
2017 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
2019 VERIFY_CONSTANT (r
);
2023 /* Subroutine of cxx_eval_constant_expression.
2024 Attempt to evaluate condition expressions. Dead branches are not
2028 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2030 bool *non_constant_p
, bool *overflow_p
,
2033 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2035 non_constant_p
, overflow_p
);
2036 VERIFY_CONSTANT (val
);
2037 /* Don't VERIFY_CONSTANT the other operands. */
2038 if (integer_zerop (val
))
2039 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2041 non_constant_p
, overflow_p
,
2043 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2045 non_constant_p
, overflow_p
,
2049 /* Returns less than, equal to, or greater than zero if KEY is found to be
2050 less than, to match, or to be greater than the constructor_elt's INDEX. */
2053 array_index_cmp (tree key
, tree index
)
2055 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2057 switch (TREE_CODE (index
))
2060 return tree_int_cst_compare (key
, index
);
2063 tree lo
= TREE_OPERAND (index
, 0);
2064 tree hi
= TREE_OPERAND (index
, 1);
2065 if (tree_int_cst_lt (key
, lo
))
2067 else if (tree_int_cst_lt (hi
, key
))
2077 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2078 if none. If INSERT is true, insert a matching element rather than fail. */
2080 static HOST_WIDE_INT
2081 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2083 if (tree_int_cst_sgn (dindex
) < 0)
2086 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2087 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2088 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2090 unsigned HOST_WIDE_INT end
= len
;
2091 unsigned HOST_WIDE_INT begin
= 0;
2093 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2094 that the same is true of the other elements and index directly. */
2097 tree cindex
= (*elts
)[end
-1].index
;
2098 if (TREE_CODE (cindex
) == INTEGER_CST
2099 && compare_tree_int (cindex
, end
-1) == 0)
2108 /* Otherwise, find a matching index by means of a binary search. */
2109 while (begin
!= end
)
2111 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2112 constructor_elt
&elt
= (*elts
)[middle
];
2113 tree idx
= elt
.index
;
2115 int cmp
= array_index_cmp (dindex
, idx
);
2122 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2124 /* We need to split the range. */
2126 tree lo
= TREE_OPERAND (idx
, 0);
2127 tree hi
= TREE_OPERAND (idx
, 1);
2128 if (tree_int_cst_lt (lo
, dindex
))
2130 /* There are still some lower elts; shorten the range. */
2131 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2133 if (tree_int_cst_equal (lo
, new_hi
))
2134 /* Only one element left, no longer a range. */
2137 TREE_OPERAND (idx
, 1) = new_hi
;
2138 /* Append the element we want to insert. */
2141 e
.value
= unshare_constructor (elt
.value
);
2142 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2145 /* No lower elts, the range elt is now ours. */
2148 if (tree_int_cst_lt (dindex
, hi
))
2150 /* There are still some higher elts; append a range. */
2151 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2153 if (tree_int_cst_equal (new_lo
, hi
))
2156 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2157 e
.value
= unshare_constructor (elt
.value
);
2158 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2167 constructor_elt e
= { dindex
, NULL_TREE
};
2168 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2175 /* Under the control of CTX, issue a detailed diagnostic for
2176 an out-of-bounds subscript INDEX into the expression ARRAY. */
2179 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2183 tree arraytype
= TREE_TYPE (array
);
2185 /* Convert the unsigned array subscript to a signed integer to avoid
2186 printing huge numbers for small negative values. */
2187 tree sidx
= fold_convert (ssizetype
, index
);
2190 error ("array subscript value %qE is outside the bounds "
2191 "of array %qD of type %qT", sidx
, array
, arraytype
);
2192 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2195 error ("array subscript value %qE is outside the bounds "
2196 "of array type %qT", sidx
, arraytype
);
2200 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2201 STRING_CST STRING. */
2204 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2206 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2209 if (chars_per_elt
== 1)
2210 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2213 const unsigned char *ptr
2214 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2215 + index
* chars_per_elt
);
2216 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2221 /* Subroutine of cxx_eval_constant_expression.
2222 Attempt to reduce a reference to an array slot. */
2225 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2227 bool *non_constant_p
, bool *overflow_p
)
2229 tree oldary
= TREE_OPERAND (t
, 0);
2230 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2232 non_constant_p
, overflow_p
);
2234 HOST_WIDE_INT i
= 0;
2235 tree elem_type
= NULL_TREE
;
2236 unsigned len
= 0, elem_nchars
= 1;
2237 if (*non_constant_p
)
2239 oldidx
= TREE_OPERAND (t
, 1);
2240 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2242 non_constant_p
, overflow_p
);
2243 VERIFY_CONSTANT (index
);
2246 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2247 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2248 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2249 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2250 ary
= TREE_OPERAND (ary
, 0);
2251 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2252 len
= CONSTRUCTOR_NELTS (ary
);
2253 else if (TREE_CODE (ary
) == STRING_CST
)
2255 elem_nchars
= (TYPE_PRECISION (elem_type
)
2256 / TYPE_PRECISION (char_type_node
));
2257 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2259 else if (TREE_CODE (ary
) == VECTOR_CST
)
2260 len
= VECTOR_CST_NELTS (ary
);
2263 /* We can't do anything with other tree codes, so use
2264 VERIFY_CONSTANT to complain and fail. */
2265 VERIFY_CONSTANT (ary
);
2269 if (!tree_fits_shwi_p (index
)
2270 || (i
= tree_to_shwi (index
)) < 0)
2272 diag_array_subscript (ctx
, ary
, index
);
2273 *non_constant_p
= true;
2279 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2280 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2281 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2282 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2286 /* For VLAs, the number of elements won't be an integer constant. */
2287 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2289 VERIFY_CONSTANT (nelts
);
2291 ? !tree_int_cst_le (index
, nelts
)
2292 : !tree_int_cst_lt (index
, nelts
))
2293 || tree_int_cst_sgn (index
) < 0)
2295 diag_array_subscript (ctx
, ary
, index
);
2296 *non_constant_p
= true;
2300 if (lval
&& ary
== oldary
&& index
== oldidx
)
2303 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2306 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2308 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2319 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2320 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2321 else if (TREE_CODE (ary
) == VECTOR_CST
)
2322 r
= VECTOR_CST_ELT (ary
, i
);
2324 r
= extract_string_elt (ary
, elem_nchars
, i
);
2327 /* Don't VERIFY_CONSTANT here. */
2330 /* Otherwise the element doesn't have a value yet. */
2335 if (TREE_CODE (ary
) == CONSTRUCTOR
2336 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2338 /* 'ary' is part of the aggregate initializer we're currently
2339 building; if there's no initializer for this element yet,
2342 error ("accessing uninitialized array element");
2343 *non_constant_p
= true;
2347 /* If it's within the array bounds but doesn't have an explicit
2348 initializer, it's value-initialized. */
2349 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2350 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2354 /* Subroutine of cxx_eval_constant_expression.
2355 Attempt to reduce a field access of a value of class type. */
2358 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2360 bool *non_constant_p
, bool *overflow_p
)
2362 unsigned HOST_WIDE_INT i
;
2365 tree part
= TREE_OPERAND (t
, 1);
2366 tree orig_whole
= TREE_OPERAND (t
, 0);
2367 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2369 non_constant_p
, overflow_p
);
2370 if (TREE_CODE (whole
) == INDIRECT_REF
2371 && integer_zerop (TREE_OPERAND (whole
, 0))
2373 error ("dereferencing a null pointer in %qE", orig_whole
);
2375 if (TREE_CODE (whole
) == PTRMEM_CST
)
2376 whole
= cplus_expand_constant (whole
);
2377 if (whole
== orig_whole
)
2380 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2381 whole
, part
, NULL_TREE
);
2382 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2384 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2387 error ("%qE is not a constant expression", orig_whole
);
2388 *non_constant_p
= true;
2390 if (DECL_MUTABLE_P (part
))
2393 error ("mutable %qD is not usable in a constant expression", part
);
2394 *non_constant_p
= true;
2396 if (*non_constant_p
)
2398 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2399 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2401 /* Use name match for PMF fields, as a variant will have a
2402 different FIELD_DECL with a different type. */
2403 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2409 /* We're in the middle of initializing it. */
2413 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2414 && CONSTRUCTOR_NELTS (whole
) > 0)
2416 /* DR 1188 says we don't have to deal with this. */
2418 error ("accessing %qD member instead of initialized %qD member in "
2419 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2420 *non_constant_p
= true;
2424 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2425 classes never get represented; throw together a value now. */
2426 if (is_really_empty_class (TREE_TYPE (t
)))
2427 return build_constructor (TREE_TYPE (t
), NULL
);
2429 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2431 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2433 /* 'whole' is part of the aggregate initializer we're currently
2434 building; if there's no initializer for this member yet, that's an
2437 error ("accessing uninitialized member %qD", part
);
2438 *non_constant_p
= true;
2442 /* If there's no explicit init for this field, it's value-initialized. */
2443 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2444 return cxx_eval_constant_expression (ctx
, value
,
2446 non_constant_p
, overflow_p
);
2449 /* Subroutine of cxx_eval_constant_expression.
2450 Attempt to reduce a field access of a value of class type that is
2451 expressed as a BIT_FIELD_REF. */
2454 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2456 bool *non_constant_p
, bool *overflow_p
)
2458 tree orig_whole
= TREE_OPERAND (t
, 0);
2459 tree retval
, fldval
, utype
, mask
;
2460 bool fld_seen
= false;
2461 HOST_WIDE_INT istart
, isize
;
2462 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2464 non_constant_p
, overflow_p
);
2465 tree start
, field
, value
;
2466 unsigned HOST_WIDE_INT i
;
2468 if (whole
== orig_whole
)
2470 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2472 if (!*non_constant_p
2473 && TREE_CODE (whole
) != VECTOR_CST
2474 && TREE_CODE (whole
) != CONSTRUCTOR
)
2477 error ("%qE is not a constant expression", orig_whole
);
2478 *non_constant_p
= true;
2480 if (*non_constant_p
)
2483 if (TREE_CODE (whole
) == VECTOR_CST
)
2484 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2485 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2487 start
= TREE_OPERAND (t
, 2);
2488 istart
= tree_to_shwi (start
);
2489 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2490 utype
= TREE_TYPE (t
);
2491 if (!TYPE_UNSIGNED (utype
))
2492 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2493 retval
= build_int_cst (utype
, 0);
2494 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2496 tree bitpos
= bit_position (field
);
2497 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2499 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2500 && TREE_CODE (value
) == INTEGER_CST
2501 && tree_fits_shwi_p (bitpos
)
2502 && tree_fits_shwi_p (DECL_SIZE (field
)))
2504 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2505 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2506 HOST_WIDE_INT shift
;
2507 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2509 fldval
= fold_convert (utype
, value
);
2510 mask
= build_int_cst_type (utype
, -1);
2511 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2512 size_int (TYPE_PRECISION (utype
) - sz
));
2513 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2514 size_int (TYPE_PRECISION (utype
) - sz
));
2515 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2516 shift
= bit
- istart
;
2517 if (BYTES_BIG_ENDIAN
)
2518 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2519 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2521 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2527 return fold_convert (TREE_TYPE (t
), retval
);
2529 return error_mark_node
;
2532 /* Subroutine of cxx_eval_constant_expression.
2533 Evaluate a short-circuited logical expression T in the context
2534 of a given constexpr CALL. BAILOUT_VALUE is the value for
2535 early return. CONTINUE_VALUE is used here purely for
2536 sanity check purposes. */
2539 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2540 tree bailout_value
, tree continue_value
,
2542 bool *non_constant_p
, bool *overflow_p
)
2545 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2547 non_constant_p
, overflow_p
);
2548 VERIFY_CONSTANT (lhs
);
2549 if (tree_int_cst_equal (lhs
, bailout_value
))
2551 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2552 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2553 lval
, non_constant_p
,
2555 VERIFY_CONSTANT (r
);
2559 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2560 CONSTRUCTOR elements to initialize (part of) an object containing that
2561 field. Return a pointer to the constructor_elt corresponding to the
2562 initialization of the field. */
2564 static constructor_elt
*
2565 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2567 tree aggr
= TREE_OPERAND (ref
, 0);
2568 tree field
= TREE_OPERAND (ref
, 1);
2570 constructor_elt
*ce
;
2572 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2574 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2576 constructor_elt
*base_ce
2577 = base_field_constructor_elt (v
, aggr
);
2578 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2581 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2582 if (ce
->index
== field
)
2589 /* Some of the expressions fed to the constexpr mechanism are calls to
2590 constructors, which have type void. In that case, return the type being
2591 initialized by the constructor. */
2594 initialized_type (tree t
)
2598 tree type
= cv_unqualified (TREE_TYPE (t
));
2599 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2601 /* A constructor call has void type, so we need to look deeper. */
2602 tree fn
= get_function_named_in_call (t
);
2603 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2604 && DECL_CXX_CONSTRUCTOR_P (fn
))
2605 type
= DECL_CONTEXT (fn
);
2610 /* We're about to initialize element INDEX of an array or class from VALUE.
2611 Set up NEW_CTX appropriately by adjusting .object to refer to the
2612 subobject and creating a new CONSTRUCTOR if the element is itself
2613 a class or array. */
2616 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2617 tree index
, tree
&value
)
2621 if (index
&& TREE_CODE (index
) != INTEGER_CST
2622 && TREE_CODE (index
) != FIELD_DECL
)
2623 /* This won't have an element in the new CONSTRUCTOR. */
2626 tree type
= initialized_type (value
);
2627 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2628 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2631 /* The sub-aggregate initializer might contain a placeholder;
2632 update object to refer to the subobject and ctor to refer to
2633 the (newly created) sub-initializer. */
2635 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2636 tree elt
= build_constructor (type
, NULL
);
2637 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2640 if (TREE_CODE (value
) == TARGET_EXPR
)
2641 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2642 value
= TARGET_EXPR_INITIAL (value
);
2645 /* We're about to process an initializer for a class or array TYPE. Make
2646 sure that CTX is set up appropriately. */
2649 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2651 /* We don't bother building a ctor for an empty base subobject. */
2652 if (is_empty_class (type
))
2655 /* We're in the middle of an initializer that might involve placeholders;
2656 our caller should have created a CONSTRUCTOR for us to put the
2657 initializer into. We will either return that constructor or T. */
2658 gcc_assert (ctx
->ctor
);
2659 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2660 (type
, TREE_TYPE (ctx
->ctor
)));
2661 /* We used to check that ctx->ctor was empty, but that isn't the case when
2662 the object is zero-initialized before calling the constructor. */
2665 tree otype
= TREE_TYPE (ctx
->object
);
2666 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, otype
)
2667 /* Handle flexible array members. */
2668 || (TREE_CODE (otype
) == ARRAY_TYPE
2669 && TYPE_DOMAIN (otype
) == NULL_TREE
2670 && TREE_CODE (type
) == ARRAY_TYPE
2671 && (same_type_ignoring_top_level_qualifiers_p
2672 (TREE_TYPE (type
), TREE_TYPE (otype
)))));
2674 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2675 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2678 /* Subroutine of cxx_eval_constant_expression.
2679 The expression tree T denotes a C-style array or a C-style
2680 aggregate. Reduce it to a constant expression. */
2683 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2685 bool *non_constant_p
, bool *overflow_p
)
2687 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2688 bool changed
= false;
2689 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2690 tree type
= TREE_TYPE (t
);
2692 constexpr_ctx new_ctx
;
2693 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2695 /* We don't really need the ctx->ctor business for a PMF or
2696 vector, but it's simpler to use the same code. */
2698 new_ctx
.ctor
= build_constructor (type
, NULL
);
2699 new_ctx
.object
= NULL_TREE
;
2702 verify_ctor_sanity (ctx
, type
);
2703 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2704 vec_alloc (*p
, vec_safe_length (v
));
2708 bool constant_p
= true;
2709 bool side_effects_p
= false;
2710 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2712 tree orig_value
= value
;
2713 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2714 if (new_ctx
.ctor
!= ctx
->ctor
)
2715 /* If we built a new CONSTRUCTOR, attach it now so that other
2716 initializers can refer to it. */
2717 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2718 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2720 non_constant_p
, overflow_p
);
2721 /* Don't VERIFY_CONSTANT here. */
2722 if (ctx
->quiet
&& *non_constant_p
)
2724 if (elt
!= orig_value
)
2727 if (!TREE_CONSTANT (elt
))
2729 if (TREE_SIDE_EFFECTS (elt
))
2730 side_effects_p
= true;
2731 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2733 /* This is an initialization of a vfield inside a base
2734 subaggregate that we already initialized; push this
2735 initialization into the previous initialization. */
2736 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2741 && (TREE_CODE (index
) == NOP_EXPR
2742 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2744 /* This is an initializer for an empty base; now that we've
2745 checked that it's constant, we can ignore it. */
2746 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2749 else if (new_ctx
.ctor
!= ctx
->ctor
)
2751 /* We appended this element above; update the value. */
2752 gcc_assert ((*p
)->last().index
== index
);
2753 (*p
)->last().value
= elt
;
2756 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2758 if (*non_constant_p
|| !changed
)
2761 /* We're done building this CONSTRUCTOR, so now we can interpret an
2762 element without an explicit initializer as value-initialized. */
2763 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2764 TREE_CONSTANT (t
) = constant_p
;
2765 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2766 if (VECTOR_TYPE_P (type
))
2771 /* Subroutine of cxx_eval_constant_expression.
2772 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2773 initialization of a non-static data member of array type. Reduce it to a
2776 Note that apart from value-initialization (when VALUE_INIT is true),
2777 this is only intended to support value-initialization and the
2778 initializations done by defaulted constructors for classes with
2779 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2780 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2781 for the copy/move constructor. */
2784 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2785 bool value_init
, bool lval
,
2786 bool *non_constant_p
, bool *overflow_p
)
2788 tree elttype
= TREE_TYPE (atype
);
2789 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2790 verify_ctor_sanity (ctx
, atype
);
2791 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2792 vec_alloc (*p
, max
+ 1);
2793 bool pre_init
= false;
2794 unsigned HOST_WIDE_INT i
;
2796 /* For the default constructor, build up a call to the default
2797 constructor of the element type. We only need to handle class types
2798 here, as for a constructor to be constexpr, all members must be
2799 initialized, which for a defaulted default constructor means they must
2800 be of a class type with a constexpr default constructor. */
2801 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2802 /* We only do this at the lowest level. */;
2803 else if (value_init
)
2805 init
= build_value_init (elttype
, tf_warning_or_error
);
2810 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2811 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2812 &argvec
, elttype
, LOOKUP_NORMAL
,
2813 tf_warning_or_error
);
2814 release_tree_vector (argvec
);
2815 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2819 for (i
= 0; i
< max
; ++i
)
2821 tree idx
= build_int_cst (size_type_node
, i
);
2824 constexpr_ctx new_ctx
;
2825 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2826 if (new_ctx
.ctor
!= ctx
->ctor
)
2827 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2828 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2830 /* A multidimensional array; recurse. */
2831 if (value_init
|| init
== NULL_TREE
)
2833 eltinit
= NULL_TREE
;
2837 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2838 tf_warning_or_error
);
2839 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2841 non_constant_p
, overflow_p
);
2845 /* Initializing an element using value or default initialization
2846 we just pre-built above. */
2847 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2848 non_constant_p
, overflow_p
);
2853 /* Copying an element. */
2854 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2855 (atype
, TREE_TYPE (init
)));
2856 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2857 tf_warning_or_error
);
2858 if (!lvalue_p (init
))
2859 eltinit
= move (eltinit
);
2860 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2861 eltinit
= (cxx_eval_constant_expression
2862 (&new_ctx
, eltinit
, lval
,
2863 non_constant_p
, overflow_p
));
2865 if (*non_constant_p
&& !ctx
->quiet
)
2867 if (new_ctx
.ctor
!= ctx
->ctor
)
2869 /* We appended this element above; update the value. */
2870 gcc_assert ((*p
)->last().index
== idx
);
2871 (*p
)->last().value
= eltinit
;
2874 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2875 /* Reuse the result of cxx_eval_constant_expression call
2876 from the first iteration to all others if it is a constant
2877 initializer that doesn't require relocations. */
2880 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2881 == null_pointer_node
))
2883 if (new_ctx
.ctor
!= ctx
->ctor
)
2884 eltinit
= new_ctx
.ctor
;
2885 for (i
= 1; i
< max
; ++i
)
2887 idx
= build_int_cst (size_type_node
, i
);
2888 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2894 if (!*non_constant_p
)
2897 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2903 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2905 bool *non_constant_p
, bool *overflow_p
)
2907 tree atype
= TREE_TYPE (t
);
2908 tree init
= VEC_INIT_EXPR_INIT (t
);
2909 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2910 VEC_INIT_EXPR_VALUE_INIT (t
),
2911 lval
, non_constant_p
, overflow_p
);
2912 if (*non_constant_p
)
2918 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2919 match. We want to be less strict for simple *& folding; if we have a
2920 non-const temporary that we access through a const pointer, that should
2921 work. We handle this here rather than change fold_indirect_ref_1
2922 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2923 don't really make sense outside of constant expression evaluation. Also
2924 we want to allow folding to COMPONENT_REF, which could cause trouble
2925 with TBAA in fold_indirect_ref_1.
2927 Try to keep this function synced with fold_indirect_ref_1. */
2930 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2936 subtype
= TREE_TYPE (sub
);
2937 if (!POINTER_TYPE_P (subtype
))
2940 if (TREE_CODE (sub
) == ADDR_EXPR
)
2942 tree op
= TREE_OPERAND (sub
, 0);
2943 tree optype
= TREE_TYPE (op
);
2945 /* *&CONST_DECL -> to the value of the const decl. */
2946 if (TREE_CODE (op
) == CONST_DECL
)
2947 return DECL_INITIAL (op
);
2948 /* *&p => p; make sure to handle *&"str"[cst] here. */
2949 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2950 /* Also handle the case where the desired type is an array of unknown
2951 bounds because the variable has had its bounds deduced since the
2952 ADDR_EXPR was created. */
2953 || (TREE_CODE (type
) == ARRAY_TYPE
2954 && TREE_CODE (optype
) == ARRAY_TYPE
2955 && TYPE_DOMAIN (type
) == NULL_TREE
2956 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
2959 tree fop
= fold_read_from_constant_string (op
);
2965 /* *(foo *)&fooarray => fooarray[0] */
2966 else if (TREE_CODE (optype
) == ARRAY_TYPE
2967 && (same_type_ignoring_top_level_qualifiers_p
2968 (type
, TREE_TYPE (optype
))))
2970 tree type_domain
= TYPE_DOMAIN (optype
);
2971 tree min_val
= size_zero_node
;
2972 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2973 min_val
= TYPE_MIN_VALUE (type_domain
);
2974 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2975 NULL_TREE
, NULL_TREE
);
2977 /* *(foo *)&complexfoo => __real__ complexfoo */
2978 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2979 && (same_type_ignoring_top_level_qualifiers_p
2980 (type
, TREE_TYPE (optype
))))
2981 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2982 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2983 else if (VECTOR_TYPE_P (optype
)
2984 && (same_type_ignoring_top_level_qualifiers_p
2985 (type
, TREE_TYPE (optype
))))
2987 tree part_width
= TYPE_SIZE (type
);
2988 tree index
= bitsize_int (0);
2989 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2991 /* Also handle conversion to an empty base class, which
2992 is represented with a NOP_EXPR. */
2993 else if (is_empty_class (type
)
2994 && CLASS_TYPE_P (optype
)
2995 && DERIVED_FROM_P (type
, optype
))
3000 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3001 else if (RECORD_OR_UNION_TYPE_P (optype
))
3003 tree field
= TYPE_FIELDS (optype
);
3004 for (; field
; field
= DECL_CHAIN (field
))
3005 if (TREE_CODE (field
) == FIELD_DECL
3006 && TREE_TYPE (field
) != error_mark_node
3007 && integer_zerop (byte_position (field
))
3008 && (same_type_ignoring_top_level_qualifiers_p
3009 (TREE_TYPE (field
), type
)))
3010 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
3013 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
3014 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
3016 tree op00
= TREE_OPERAND (sub
, 0);
3017 tree op01
= TREE_OPERAND (sub
, 1);
3020 if (TREE_CODE (op00
) == ADDR_EXPR
)
3023 op00
= TREE_OPERAND (op00
, 0);
3024 op00type
= TREE_TYPE (op00
);
3026 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3027 if (VECTOR_TYPE_P (op00type
)
3028 && (same_type_ignoring_top_level_qualifiers_p
3029 (type
, TREE_TYPE (op00type
))))
3031 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
3032 tree part_width
= TYPE_SIZE (type
);
3033 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
3034 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
3035 tree index
= bitsize_int (indexi
);
3037 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
3038 return fold_build3_loc (loc
,
3039 BIT_FIELD_REF
, type
, op00
,
3043 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3044 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3045 && (same_type_ignoring_top_level_qualifiers_p
3046 (type
, TREE_TYPE (op00type
))))
3048 tree size
= TYPE_SIZE_UNIT (type
);
3049 if (tree_int_cst_equal (size
, op01
))
3050 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3052 /* ((foo *)&fooarray)[1] => fooarray[1] */
3053 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3054 && (same_type_ignoring_top_level_qualifiers_p
3055 (type
, TREE_TYPE (op00type
))))
3057 tree type_domain
= TYPE_DOMAIN (op00type
);
3058 tree min_val
= size_zero_node
;
3059 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3060 min_val
= TYPE_MIN_VALUE (type_domain
);
3061 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
3062 TYPE_SIZE_UNIT (type
));
3063 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
3064 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3065 NULL_TREE
, NULL_TREE
);
3067 /* Also handle conversion to an empty base class, which
3068 is represented with a NOP_EXPR. */
3069 else if (is_empty_class (type
)
3070 && CLASS_TYPE_P (op00type
)
3071 && DERIVED_FROM_P (type
, op00type
))
3076 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3077 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3079 tree field
= TYPE_FIELDS (op00type
);
3080 for (; field
; field
= DECL_CHAIN (field
))
3081 if (TREE_CODE (field
) == FIELD_DECL
3082 && TREE_TYPE (field
) != error_mark_node
3083 && tree_int_cst_equal (byte_position (field
), op01
)
3084 && (same_type_ignoring_top_level_qualifiers_p
3085 (TREE_TYPE (field
), type
)))
3086 return fold_build3 (COMPONENT_REF
, type
, op00
,
3091 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3092 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3093 && (same_type_ignoring_top_level_qualifiers_p
3094 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3097 tree min_val
= size_zero_node
;
3098 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3102 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3103 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3104 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3105 min_val
= TYPE_MIN_VALUE (type_domain
);
3106 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3114 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3116 bool *non_constant_p
, bool *overflow_p
)
3118 tree orig_op0
= TREE_OPERAND (t
, 0);
3119 bool empty_base
= false;
3121 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3122 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3124 if (TREE_CODE (t
) == MEM_REF
3125 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3127 gcc_assert (ctx
->quiet
);
3128 *non_constant_p
= true;
3132 /* First try to simplify it directly. */
3133 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3137 /* If that didn't work, evaluate the operand first. */
3138 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3139 /*lval*/false, non_constant_p
,
3141 /* Don't VERIFY_CONSTANT here. */
3142 if (*non_constant_p
)
3145 if (!lval
&& integer_zerop (op0
))
3148 error ("dereferencing a null pointer");
3149 *non_constant_p
= true;
3153 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3157 /* We couldn't fold to a constant value. Make sure it's not
3158 something we should have been able to fold. */
3161 if (TREE_CODE (sub
) == ADDR_EXPR
)
3163 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3164 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3165 /* DR 1188 says we don't have to deal with this. */
3167 error ("accessing value of %qE through a %qT glvalue in a "
3168 "constant expression", build_fold_indirect_ref (sub
),
3170 *non_constant_p
= true;
3174 if (lval
&& op0
!= orig_op0
)
3175 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3177 VERIFY_CONSTANT (t
);
3182 r
= cxx_eval_constant_expression (ctx
, r
,
3183 lval
, non_constant_p
, overflow_p
);
3184 if (*non_constant_p
)
3187 /* If we're pulling out the value of an empty base, just return an empty
3189 if (empty_base
&& !lval
)
3191 r
= build_constructor (TREE_TYPE (t
), NULL
);
3192 TREE_CONSTANT (r
) = true;
3198 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3199 Shared between potential_constant_expression and
3200 cxx_eval_constant_expression. */
3203 non_const_var_error (tree r
)
3205 tree type
= TREE_TYPE (r
);
3206 error ("the value of %qD is not usable in a constant "
3208 /* Avoid error cascade. */
3209 if (DECL_INITIAL (r
) == error_mark_node
)
3211 if (DECL_DECLARED_CONSTEXPR_P (r
))
3212 inform (DECL_SOURCE_LOCATION (r
),
3213 "%qD used in its own initializer", r
);
3214 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3216 if (!CP_TYPE_CONST_P (type
))
3217 inform (DECL_SOURCE_LOCATION (r
),
3218 "%q#D is not const", r
);
3219 else if (CP_TYPE_VOLATILE_P (type
))
3220 inform (DECL_SOURCE_LOCATION (r
),
3221 "%q#D is volatile", r
);
3222 else if (!DECL_INITIAL (r
)
3223 || !TREE_CONSTANT (DECL_INITIAL (r
))
3224 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3225 inform (DECL_SOURCE_LOCATION (r
),
3226 "%qD was not initialized with a constant "
3231 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3232 inform (DECL_SOURCE_LOCATION (r
),
3233 "%qD was not initialized with a constant "
3237 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3238 inform (DECL_SOURCE_LOCATION (r
),
3239 "%qD was not declared %<constexpr%>", r
);
3241 inform (DECL_SOURCE_LOCATION (r
),
3242 "%qD does not have integral or enumeration type",
3247 /* Subroutine of cxx_eval_constant_expression.
3248 Like cxx_eval_unary_expression, except for trinary expressions. */
3251 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3253 bool *non_constant_p
, bool *overflow_p
)
3259 for (i
= 0; i
< 3; i
++)
3261 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3263 non_constant_p
, overflow_p
);
3264 VERIFY_CONSTANT (args
[i
]);
3267 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3268 args
[0], args
[1], args
[2]);
3269 if (val
== NULL_TREE
)
3271 VERIFY_CONSTANT (val
);
3275 /* True if T was declared in a function declared to be constexpr, and
3276 therefore potentially constant in C++14. */
3279 var_in_constexpr_fn (tree t
)
3281 tree ctx
= DECL_CONTEXT (t
);
3282 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3283 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3286 /* True if T was declared in a function that might be constexpr: either a
3287 function that was declared constexpr, or a C++17 lambda op(). */
3290 var_in_maybe_constexpr_fn (tree t
)
3292 if (cxx_dialect
>= cxx1z
3293 && DECL_FUNCTION_SCOPE_P (t
)
3294 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3296 return var_in_constexpr_fn (t
);
3299 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3300 build_over_call we implement trivial copy of a class with tail padding using
3301 assignment of character arrays, which is valid in normal code, but not in
3302 constexpr evaluation. We don't need to worry about clobbering tail padding
3303 in constexpr evaluation, so strip the type punning. */
3306 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3308 if (TREE_CODE (target
) == MEM_REF
3309 && TREE_CODE (init
) == MEM_REF
3310 && TREE_TYPE (target
) == TREE_TYPE (init
)
3311 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3312 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3314 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3315 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3319 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3322 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3324 bool *non_constant_p
, bool *overflow_p
)
3326 constexpr_ctx new_ctx
= *ctx
;
3328 tree init
= TREE_OPERAND (t
, 1);
3329 if (TREE_CLOBBER_P (init
))
3330 /* Just ignore clobbers. */
3333 /* First we figure out where we're storing to. */
3334 tree target
= TREE_OPERAND (t
, 0);
3336 maybe_simplify_trivial_copy (target
, init
);
3338 tree type
= TREE_TYPE (target
);
3339 target
= cxx_eval_constant_expression (ctx
, target
,
3341 non_constant_p
, overflow_p
);
3342 if (*non_constant_p
)
3345 /* cxx_eval_array_reference for lval = true allows references one past
3346 end of array, because it does not know if it is just taking address
3347 (which is valid), or actual dereference. Here we know it is
3348 a dereference, so diagnose it here. */
3349 for (tree probe
= target
; probe
; )
3351 switch (TREE_CODE (probe
))
3355 ary
= TREE_OPERAND (probe
, 0);
3356 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3357 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3358 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3359 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3362 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3363 non_constant_p
, overflow_p
);
3364 VERIFY_CONSTANT (nelts
);
3365 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3366 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3367 if (wi::eq_p (TREE_OPERAND (probe
, 1), nelts
))
3369 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3370 *non_constant_p
= true;
3377 probe
= TREE_OPERAND (probe
, 0);
3386 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3388 /* For initialization of an empty base, the original target will be
3389 *(base*)this, which the above evaluation resolves to the object
3390 argument, which has the derived type rather than the base type. In
3391 this situation, just evaluate the initializer and return, since
3392 there's no actual data to store. */
3393 gcc_assert (is_empty_class (type
));
3394 return cxx_eval_constant_expression (ctx
, init
, false,
3395 non_constant_p
, overflow_p
);
3398 /* And then find the underlying variable. */
3399 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3400 tree object
= NULL_TREE
;
3401 for (tree probe
= target
; object
== NULL_TREE
; )
3403 switch (TREE_CODE (probe
))
3408 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3409 vec_safe_push (refs
, TREE_TYPE (probe
));
3410 probe
= TREE_OPERAND (probe
, 0);
3418 /* And then find/build up our initializer for the path to the subobject
3419 we're initializing. */
3421 if (object
== ctx
->object
&& VAR_P (object
)
3422 && DECL_NAME (object
) && ctx
->call
== NULL
)
3423 /* The variable we're building up an aggregate initializer for is outside
3424 the constant-expression, so don't evaluate the store. We check
3425 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3427 else if (DECL_P (object
))
3428 valp
= ctx
->values
->get (object
);
3433 /* A constant-expression cannot modify objects from outside the
3434 constant-expression. */
3436 error ("modification of %qE is not a constant expression", object
);
3437 *non_constant_p
= true;
3440 type
= TREE_TYPE (object
);
3441 bool no_zero_init
= true;
3443 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3444 while (!refs
->is_empty())
3446 if (*valp
== NULL_TREE
)
3448 *valp
= build_constructor (type
, NULL
);
3449 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3451 else if (TREE_CODE (*valp
) == STRING_CST
)
3453 /* An array was initialized with a string constant, and now
3454 we're writing into one of its elements. Explode the
3455 single initialization into a set of element
3457 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3459 tree string
= *valp
;
3460 tree elt_type
= TREE_TYPE (type
);
3461 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3462 / TYPE_PRECISION (char_type_node
));
3463 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3464 tree ary_ctor
= build_constructor (type
, NULL
);
3466 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3467 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3469 constructor_elt elt
=
3471 build_int_cst (size_type_node
, ix
),
3472 extract_string_elt (string
, chars_per_elt
, ix
)
3474 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3480 /* If the value of object is already zero-initialized, any new ctors for
3481 subobjects will also be zero-initialized. */
3482 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3484 vec_safe_push (ctors
, *valp
);
3486 enum tree_code code
= TREE_CODE (type
);
3488 tree index
= refs
->pop();
3490 constructor_elt
*cep
= NULL
;
3491 if (code
== ARRAY_TYPE
)
3494 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3495 gcc_assert (i
>= 0);
3496 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3497 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3501 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3503 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3504 Usually we meet initializers in that order, but it is
3505 possible for base types to be placed not in program
3507 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3508 unsigned HOST_WIDE_INT idx
;
3510 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3511 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3512 /* Changing active member. */
3513 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3516 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3517 idx
++, fields
= DECL_CHAIN (fields
))
3519 if (index
== cep
->index
)
3522 /* The field we're initializing must be on the field
3523 list. Look to see if it is present before the
3524 field the current ELT initializes. */
3525 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3526 if (index
== fields
)
3530 /* We fell off the end of the CONSTRUCTOR, so insert a new
3531 entry at the end. */
3534 constructor_elt ce
= { index
, NULL_TREE
};
3536 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3537 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3543 release_tree_vector (refs
);
3545 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3547 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3548 wants to modify it. */
3549 if (*valp
== NULL_TREE
)
3551 *valp
= build_constructor (type
, NULL
);
3552 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3554 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3555 *valp
= cplus_expand_constant (*valp
);
3556 new_ctx
.ctor
= *valp
;
3557 new_ctx
.object
= target
;
3560 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3561 non_constant_p
, overflow_p
);
3562 /* Don't share a CONSTRUCTOR that might be changed later. */
3563 init
= unshare_constructor (init
);
3564 if (target
== object
)
3565 /* The hash table might have moved since the get earlier. */
3566 valp
= ctx
->values
->get (object
);
3568 if (TREE_CODE (init
) == CONSTRUCTOR
)
3570 /* An outer ctx->ctor might be pointing to *valp, so replace
3572 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3573 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3574 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3575 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3576 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3581 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3582 CONSTRUCTORs, if any. */
3585 bool c
= TREE_CONSTANT (init
);
3586 bool s
= TREE_SIDE_EFFECTS (init
);
3588 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3591 TREE_CONSTANT (elt
) = false;
3593 TREE_SIDE_EFFECTS (elt
) = true;
3595 release_tree_vector (ctors
);
3597 if (*non_constant_p
)
3605 /* Evaluate a ++ or -- expression. */
3608 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3610 bool *non_constant_p
, bool *overflow_p
)
3612 enum tree_code code
= TREE_CODE (t
);
3613 tree type
= TREE_TYPE (t
);
3614 tree op
= TREE_OPERAND (t
, 0);
3615 tree offset
= TREE_OPERAND (t
, 1);
3616 gcc_assert (TREE_CONSTANT (offset
));
3618 /* The operand as an lvalue. */
3619 op
= cxx_eval_constant_expression (ctx
, op
, true,
3620 non_constant_p
, overflow_p
);
3622 /* The operand as an rvalue. */
3623 tree val
= rvalue (op
);
3624 val
= cxx_eval_constant_expression (ctx
, val
, false,
3625 non_constant_p
, overflow_p
);
3626 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3627 a local array in a constexpr function. */
3628 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3630 VERIFY_CONSTANT (val
);
3632 /* The modified value. */
3633 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3635 if (POINTER_TYPE_P (type
))
3637 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3638 offset
= convert_to_ptrofftype (offset
);
3640 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3641 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3644 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3646 VERIFY_CONSTANT (mod
);
3648 /* Storing the modified value. */
3649 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3650 cxx_eval_constant_expression (ctx
, store
,
3651 true, non_constant_p
, overflow_p
);
3653 /* And the value of the expression. */
3654 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3656 /* Prefix ops are lvalues. */
3660 /* But we optimize when the caller wants an rvalue. */
3664 /* Postfix ops are rvalues. */
3668 /* Predicates for the meaning of *jump_target. */
3671 returns (tree
*jump_target
)
3674 && (TREE_CODE (*jump_target
) == RETURN_EXPR
3675 || (TREE_CODE (*jump_target
) == LABEL_DECL
3676 && LABEL_DECL_CDTOR (*jump_target
)));
3680 breaks (tree
*jump_target
)
3683 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3684 && LABEL_DECL_BREAK (*jump_target
))
3685 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3689 continues (tree
*jump_target
)
3692 && TREE_CODE (*jump_target
) == LABEL_DECL
3693 && LABEL_DECL_CONTINUE (*jump_target
);
3697 switches (tree
*jump_target
)
3700 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3703 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3704 STMT matches *jump_target. If we're looking for a case label and we see
3705 the default label, note it in ctx->css_state. */
3708 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3710 switch (TREE_CODE (*jump_target
))
3713 if (TREE_CODE (stmt
) == LABEL_EXPR
3714 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3719 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3721 gcc_assert (ctx
->css_state
!= NULL
);
3722 if (!CASE_LOW (stmt
))
3724 /* default: should appear just once in a SWITCH_EXPR
3725 body (excluding nested SWITCH_EXPR). */
3726 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3727 /* When evaluating SWITCH_EXPR body for the second time,
3728 return true for the default: label. */
3729 if (*ctx
->css_state
== css_default_processing
)
3731 *ctx
->css_state
= css_default_seen
;
3733 else if (CASE_HIGH (stmt
))
3735 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3736 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3739 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3750 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3751 semantics, for switch, break, continue, and return. */
3754 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3755 bool *non_constant_p
, bool *overflow_p
,
3758 tree_stmt_iterator i
;
3760 /* In a statement-expression we want to return the last value.
3761 For empty statement expression return void_node. */
3765 local_target
= NULL_TREE
;
3766 jump_target
= &local_target
;
3768 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3770 tree stmt
= tsi_stmt (i
);
3771 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3772 non_constant_p
, overflow_p
,
3774 if (*non_constant_p
)
3776 if (returns (jump_target
) || breaks (jump_target
))
3782 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3783 semantics; continue semantics are covered by cxx_eval_statement_list. */
3786 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3787 bool *non_constant_p
, bool *overflow_p
,
3790 constexpr_ctx new_ctx
= *ctx
;
3792 tree body
= TREE_OPERAND (t
, 0);
3796 hash_set
<tree
> save_exprs
;
3797 new_ctx
.save_exprs
= &save_exprs
;
3799 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3800 non_constant_p
, overflow_p
, jump_target
);
3802 /* Forget saved values of SAVE_EXPRs. */
3803 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3804 iter
!= save_exprs
.end(); ++iter
)
3805 new_ctx
.values
->remove (*iter
);
3806 if (++count
>= constexpr_loop_limit
)
3809 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3810 "constexpr loop iteration count exceeds limit of %d "
3811 "(use -fconstexpr-loop-limit= to increase the limit)",
3812 constexpr_loop_limit
);
3813 *non_constant_p
= true;
3817 while (!returns (jump_target
)
3818 && !breaks (jump_target
)
3819 && !switches (jump_target
)
3820 && !*non_constant_p
);
3822 if (breaks (jump_target
))
3823 *jump_target
= NULL_TREE
;
3828 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3832 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3833 bool *non_constant_p
, bool *overflow_p
,
3836 tree cond
= TREE_OPERAND (t
, 0);
3837 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3838 non_constant_p
, overflow_p
);
3839 VERIFY_CONSTANT (cond
);
3840 *jump_target
= cond
;
3842 tree body
= TREE_OPERAND (t
, 1);
3843 constexpr_ctx new_ctx
= *ctx
;
3844 constexpr_switch_state css
= css_default_not_seen
;
3845 new_ctx
.css_state
= &css
;
3846 cxx_eval_constant_expression (&new_ctx
, body
, false,
3847 non_constant_p
, overflow_p
, jump_target
);
3848 if (switches (jump_target
) && css
== css_default_seen
)
3850 /* If the SWITCH_EXPR body has default: label, process it once again,
3851 this time instructing label_matches to return true for default:
3852 label on switches (jump_target). */
3853 css
= css_default_processing
;
3854 cxx_eval_constant_expression (&new_ctx
, body
, false,
3855 non_constant_p
, overflow_p
, jump_target
);
3857 if (breaks (jump_target
) || switches (jump_target
))
3858 *jump_target
= NULL_TREE
;
3862 /* Find the object of TYPE under initialization in CTX. */
3865 lookup_placeholder (const constexpr_ctx
*ctx
, bool lval
, tree type
)
3870 /* We could use ctx->object unconditionally, but using ctx->ctor when we
3871 can is a minor optimization. */
3872 if (!lval
&& ctx
->ctor
&& same_type_p (TREE_TYPE (ctx
->ctor
), type
))
3878 /* Since an object cannot have a field of its own type, we can search outward
3879 from ctx->object to find the unique containing object of TYPE. */
3880 tree ob
= ctx
->object
;
3883 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob
), type
))
3885 if (handled_component_p (ob
))
3886 ob
= TREE_OPERAND (ob
, 0);
3894 /* Attempt to reduce the expression T to a constant value.
3895 On failure, issue diagnostic and return error_mark_node. */
3896 /* FIXME unify with c_fully_fold */
3897 /* FIXME overflow_p is too global */
3900 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3902 bool *non_constant_p
, bool *overflow_p
,
3905 constexpr_ctx new_ctx
;
3908 if (jump_target
&& *jump_target
)
3910 /* If we are jumping, ignore all statements/expressions except those
3911 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
3912 switch (TREE_CODE (t
))
3915 case STATEMENT_LIST
:
3920 case CASE_LABEL_EXPR
:
3921 if (label_matches (ctx
, jump_target
, t
))
3923 *jump_target
= NULL_TREE
;
3929 if (t
== error_mark_node
)
3931 *non_constant_p
= true;
3934 if (CONSTANT_CLASS_P (t
))
3936 if (TREE_OVERFLOW (t
))
3939 permerror (input_location
, "overflow in constant expression");
3940 if (!flag_permissive
|| ctx
->quiet
)
3944 if (TREE_CODE (t
) == INTEGER_CST
3945 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
3946 && !integer_zerop (t
))
3949 error ("value %qE of type %qT is not a constant expression",
3951 *non_constant_p
= true;
3957 tree_code tcode
= TREE_CODE (t
);
3963 /* We ask for an rvalue for the RESULT_DECL when indirecting
3964 through an invisible reference, or in named return value
3966 return (*ctx
->values
->get (t
));
3969 if (DECL_HAS_VALUE_EXPR_P (t
))
3970 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
3971 lval
, non_constant_p
, overflow_p
);
3974 /* We used to not check lval for CONST_DECL, but darwin.c uses
3975 CONST_DECL for aggregate constants. */
3978 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
3979 && is_really_empty_class (TREE_TYPE (t
)))
3981 /* If the class is empty, we aren't actually loading anything. */
3982 r
= build_constructor (TREE_TYPE (t
), NULL
);
3983 TREE_CONSTANT (r
) = true;
3985 else if (ctx
->strict
)
3986 r
= decl_really_constant_value (t
);
3988 r
= decl_constant_value (t
);
3989 if (TREE_CODE (r
) == TARGET_EXPR
3990 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3991 r
= TARGET_EXPR_INITIAL (r
);
3993 if (tree
*p
= ctx
->values
->get (r
))
3994 if (*p
!= NULL_TREE
)
3999 non_const_var_error (r
);
4000 *non_constant_p
= true;
4008 case CASE_LABEL_EXPR
:
4013 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
4015 else if (tree
*p
= ctx
->values
->get (r
))
4018 /* Defer in case this is only used for its type. */;
4019 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4020 /* Defer, there's no lvalue->rvalue conversion. */;
4021 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
4022 && is_really_empty_class (TREE_TYPE (t
)))
4024 /* If the class is empty, we aren't actually loading anything. */
4025 r
= build_constructor (TREE_TYPE (t
), NULL
);
4026 TREE_CONSTANT (r
) = true;
4031 error ("%qE is not a constant expression", t
);
4032 *non_constant_p
= true;
4037 case AGGR_INIT_EXPR
:
4038 r
= cxx_eval_call_expression (ctx
, t
, lval
,
4039 non_constant_p
, overflow_p
);
4044 r
= DECL_EXPR_DECL (t
);
4045 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
4046 || VECTOR_TYPE_P (TREE_TYPE (r
)))
4050 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
4051 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4052 new_ctx
.values
->put (r
, new_ctx
.ctor
);
4056 if (tree init
= DECL_INITIAL (r
))
4058 init
= cxx_eval_constant_expression (ctx
, init
,
4060 non_constant_p
, overflow_p
);
4061 /* Don't share a CONSTRUCTOR that might be changed. */
4062 init
= unshare_constructor (init
);
4063 ctx
->values
->put (r
, init
);
4065 else if (ctx
== &new_ctx
)
4066 /* We gave it a CONSTRUCTOR above. */;
4068 ctx
->values
->put (r
, NULL_TREE
);
4073 if (!literal_type_p (TREE_TYPE (t
)))
4077 error ("temporary of non-literal type %qT in a "
4078 "constant expression", TREE_TYPE (t
));
4079 explain_non_literal_class (TREE_TYPE (t
));
4081 *non_constant_p
= true;
4084 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4086 /* We're being expanded without an explicit target, so start
4087 initializing a new object; expansion with an explicit target
4088 strips the TARGET_EXPR before we get here. */
4090 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4091 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4092 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4093 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4096 /* Pass false for 'lval' because this indicates
4097 initialization of a temporary. */
4098 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4100 non_constant_p
, overflow_p
);
4101 if (!*non_constant_p
)
4102 /* Adjust the type of the result to the type of the temporary. */
4103 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4106 tree slot
= TARGET_EXPR_SLOT (t
);
4107 r
= unshare_constructor (r
);
4108 ctx
->values
->put (slot
, r
);
4115 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4116 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4117 non_constant_p
, overflow_p
);
4121 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4123 non_constant_p
, overflow_p
);
4127 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4128 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4130 non_constant_p
, overflow_p
);
4135 /* Avoid evaluating a SAVE_EXPR more than once. */
4136 if (tree
*p
= ctx
->values
->get (t
))
4140 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4141 non_constant_p
, overflow_p
);
4142 ctx
->values
->put (t
, r
);
4143 if (ctx
->save_exprs
)
4144 ctx
->save_exprs
->add (t
);
4148 case NON_LVALUE_EXPR
:
4149 case TRY_CATCH_EXPR
:
4151 case CLEANUP_POINT_EXPR
:
4152 case MUST_NOT_THROW_EXPR
:
4155 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4157 non_constant_p
, overflow_p
,
4161 case TRY_FINALLY_EXPR
:
4162 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4163 non_constant_p
, overflow_p
,
4165 if (!*non_constant_p
)
4166 /* Also evaluate the cleanup. */
4167 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4168 non_constant_p
, overflow_p
,
4172 /* These differ from cxx_eval_unary_expression in that this doesn't
4173 check for a constant operand or result; an address can be
4174 constant without its operand being, and vice versa. */
4177 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4178 non_constant_p
, overflow_p
);
4183 tree oldop
= TREE_OPERAND (t
, 0);
4184 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4186 non_constant_p
, overflow_p
);
4187 /* Don't VERIFY_CONSTANT here. */
4188 if (*non_constant_p
)
4190 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4191 /* This function does more aggressive folding than fold itself. */
4192 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4193 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4202 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4203 non_constant_p
, overflow_p
);
4204 if (r
== error_mark_node
)
4206 else if (r
== TREE_OPERAND (t
, 0))
4209 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4214 case FIX_TRUNC_EXPR
:
4219 case TRUTH_NOT_EXPR
:
4220 case FIXED_CONVERT_EXPR
:
4221 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4222 non_constant_p
, overflow_p
);
4226 r
= fold_sizeof_expr (t
);
4227 VERIFY_CONSTANT (r
);
4232 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4233 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4234 introduced by build_call_a. */
4235 tree op0
= TREE_OPERAND (t
, 0);
4236 tree op1
= TREE_OPERAND (t
, 1);
4238 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4239 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4240 r
= cxx_eval_constant_expression (ctx
, op0
,
4241 lval
, non_constant_p
, overflow_p
,
4245 /* Check that the LHS is constant and then discard it. */
4246 cxx_eval_constant_expression (ctx
, op0
,
4247 true, non_constant_p
, overflow_p
,
4249 if (*non_constant_p
)
4251 op1
= TREE_OPERAND (t
, 1);
4252 r
= cxx_eval_constant_expression (ctx
, op1
,
4253 lval
, non_constant_p
, overflow_p
,
4259 case POINTER_PLUS_EXPR
:
4263 case TRUNC_DIV_EXPR
:
4265 case FLOOR_DIV_EXPR
:
4266 case ROUND_DIV_EXPR
:
4267 case TRUNC_MOD_EXPR
:
4269 case ROUND_MOD_EXPR
:
4271 case EXACT_DIV_EXPR
:
4281 case TRUTH_XOR_EXPR
:
4288 case UNORDERED_EXPR
:
4298 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4299 non_constant_p
, overflow_p
);
4302 /* fold can introduce non-IF versions of these; still treat them as
4303 short-circuiting. */
4304 case TRUTH_AND_EXPR
:
4305 case TRUTH_ANDIF_EXPR
:
4306 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4309 non_constant_p
, overflow_p
);
4313 case TRUTH_ORIF_EXPR
:
4314 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4317 non_constant_p
, overflow_p
);
4321 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4322 non_constant_p
, overflow_p
);
4326 if (is_overloaded_fn (t
))
4328 /* We can only get here in checking mode via
4329 build_non_dependent_expr, because any expression that
4330 calls or takes the address of the function will have
4331 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4332 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4333 *non_constant_p
= true;
4336 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4337 non_constant_p
, overflow_p
);
4341 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4342 non_constant_p
, overflow_p
);
4346 if (jump_target
&& *jump_target
)
4348 /* When jumping to a label, the label might be either in the
4349 then or else blocks, so process then block first in skipping
4350 mode first, and if we are still in the skipping mode at its end,
4351 process the else block too. */
4352 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4353 lval
, non_constant_p
, overflow_p
,
4356 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4357 lval
, non_constant_p
, overflow_p
,
4363 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4364 non_constant_p
, overflow_p
,
4369 if (TREE_CONSTANT (t
))
4371 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4372 VECTOR_CST if applicable. */
4373 /* FIXME after GCC 6 branches, make the verify unconditional. */
4375 verify_constructor_flags (t
);
4377 recompute_constructor_flags (t
);
4378 if (TREE_CONSTANT (t
))
4381 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4382 non_constant_p
, overflow_p
);
4386 /* We can get this in a defaulted constructor for a class with a
4387 non-static data member of array type. Either the initializer will
4388 be NULL, meaning default-initialization, or it will be an lvalue
4389 or xvalue of the same type, meaning direct-initialization from the
4390 corresponding member. */
4391 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4392 non_constant_p
, overflow_p
);
4397 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4398 non_constant_p
, overflow_p
);
4402 case VIEW_CONVERT_EXPR
:
4404 case UNARY_PLUS_EXPR
:
4406 tree oldop
= TREE_OPERAND (t
, 0);
4408 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4410 non_constant_p
, overflow_p
);
4411 if (*non_constant_p
)
4413 tree type
= TREE_TYPE (t
);
4414 if (TREE_CODE (op
) == PTRMEM_CST
4415 && !TYPE_PTRMEM_P (type
))
4416 op
= cplus_expand_constant (op
);
4417 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4419 if (same_type_ignoring_top_level_qualifiers_p (type
,
4421 || can_convert_qual (type
, op
))
4422 return cp_fold_convert (type
, op
);
4426 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4427 "a reinterpret_cast is not a constant expression");
4428 *non_constant_p
= true;
4433 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4435 if (integer_zerop (op
))
4437 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4440 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4441 "dereferencing a null pointer");
4442 *non_constant_p
= true;
4445 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4447 tree from
= TREE_TYPE (op
);
4449 if (!can_convert (type
, from
, tf_none
))
4452 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4453 "conversion of %qT null pointer to %qT "
4454 "is not a constant expression",
4456 *non_constant_p
= true;
4463 /* This detects for example:
4464 reinterpret_cast<void*>(sizeof 0)
4467 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4468 "%<reinterpret_cast<%T>(%E)%> is not "
4469 "a constant expression",
4471 *non_constant_p
= true;
4475 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4476 /* We didn't fold at the top so we could check for ptr-int
4479 if (tcode
== UNARY_PLUS_EXPR
)
4480 r
= fold_convert (TREE_TYPE (t
), op
);
4482 r
= fold_build1 (tcode
, type
, op
);
4483 /* Conversion of an out-of-range value has implementation-defined
4484 behavior; the language considers it different from arithmetic
4485 overflow, which is undefined. */
4486 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4487 TREE_OVERFLOW (r
) = false;
4491 case EMPTY_CLASS_EXPR
:
4492 /* This is good enough for a function argument that might not get
4493 used, and they can't do anything with it, so just return it. */
4496 case STATEMENT_LIST
:
4498 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4499 return cxx_eval_statement_list (&new_ctx
, t
,
4500 non_constant_p
, overflow_p
, jump_target
);
4503 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4505 non_constant_p
, overflow_p
,
4508 case PREINCREMENT_EXPR
:
4509 case POSTINCREMENT_EXPR
:
4510 case PREDECREMENT_EXPR
:
4511 case POSTDECREMENT_EXPR
:
4512 return cxx_eval_increment_expression (ctx
, t
,
4513 lval
, non_constant_p
, overflow_p
);
4519 case VEC_DELETE_EXPR
:
4522 /* GCC internal stuff. */
4525 case NON_DEPENDENT_EXPR
:
4529 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4530 "expression %qE is not a constant expression", t
);
4531 *non_constant_p
= true;
4534 case PLACEHOLDER_EXPR
:
4535 /* Use of the value or address of the current object. */
4536 if (tree ctor
= lookup_placeholder (ctx
, lval
, TREE_TYPE (t
)))
4537 return cxx_eval_constant_expression (ctx
, ctor
, lval
,
4538 non_constant_p
, overflow_p
);
4539 /* A placeholder without a referent. We can get here when
4540 checking whether NSDMIs are noexcept, or in massage_init_elt;
4541 just say it's non-constant for now. */
4542 gcc_assert (ctx
->quiet
);
4543 *non_constant_p
= true;
4548 tree cond
= TREE_OPERAND (t
, 0);
4549 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4550 non_constant_p
, overflow_p
);
4551 VERIFY_CONSTANT (cond
);
4552 if (integer_nonzerop (cond
))
4558 *jump_target
= TREE_OPERAND (t
, 0);
4559 gcc_assert (breaks (jump_target
) || continues (jump_target
)
4560 /* Allow for jumping to a cdtor_label. */
4561 || returns (jump_target
));
4565 cxx_eval_loop_expr (ctx
, t
,
4566 non_constant_p
, overflow_p
, jump_target
);
4570 cxx_eval_switch_expr (ctx
, t
,
4571 non_constant_p
, overflow_p
, jump_target
);
4575 /* It's possible to get a requires-expression in a constant
4576 expression. For example:
4578 template<typename T> concept bool C() {
4579 return requires (T t) { t; };
4582 template<typename T> requires !C<T>() void f(T);
4584 Normalization leaves f with the associated constraint
4585 '!requires (T t) { ... }' which is not transformed into
4587 if (!processing_template_decl
)
4588 return evaluate_constraint_expression (t
, NULL_TREE
);
4590 *non_constant_p
= true;
4594 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
4595 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4597 non_constant_p
, overflow_p
,
4602 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4604 /* This function doesn't know how to deal with pre-genericize
4605 statements; this can only happen with statement-expressions,
4606 so for now just fail. */
4608 error_at (EXPR_LOCATION (t
),
4609 "statement is not a constant expression");
4612 internal_error ("unexpected expression %qE of kind %s", t
,
4613 get_tree_code_name (TREE_CODE (t
)));
4614 *non_constant_p
= true;
4618 if (r
== error_mark_node
)
4619 *non_constant_p
= true;
4621 if (*non_constant_p
)
4628 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4629 bool strict
= true, tree object
= NULL_TREE
)
4631 auto_timevar
time (TV_CONSTEXPR
);
4633 bool non_constant_p
= false;
4634 bool overflow_p
= false;
4635 hash_map
<tree
,tree
> map
;
4637 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4638 allow_non_constant
, strict
};
4640 tree type
= initialized_type (t
);
4642 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4644 /* In C++14 an NSDMI can participate in aggregate initialization,
4645 and can refer to the address of the object being initialized, so
4646 we need to pass in the relevant VAR_DECL if we want to do the
4647 evaluation in a single pass. The evaluation will dynamically
4648 update ctx.values for the VAR_DECL. We use the same strategy
4649 for C++11 constexpr constructors that refer to the object being
4651 ctx
.ctor
= build_constructor (type
, NULL
);
4652 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4655 if (TREE_CODE (t
) == TARGET_EXPR
)
4656 object
= TARGET_EXPR_SLOT (t
);
4657 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4658 object
= AGGR_INIT_EXPR_SLOT (t
);
4660 ctx
.object
= object
;
4662 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4663 (type
, TREE_TYPE (object
)));
4664 if (object
&& DECL_P (object
))
4665 map
.put (object
, ctx
.ctor
);
4666 if (TREE_CODE (r
) == TARGET_EXPR
)
4667 /* Avoid creating another CONSTRUCTOR when we expand the
4669 r
= TARGET_EXPR_INITIAL (r
);
4672 r
= cxx_eval_constant_expression (&ctx
, r
,
4673 false, &non_constant_p
, &overflow_p
);
4675 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4677 /* Mutable logic is a bit tricky: we want to allow initialization of
4678 constexpr variables with mutable members, but we can't copy those
4679 members to another constexpr variable. */
4680 if (TREE_CODE (r
) == CONSTRUCTOR
4681 && CONSTRUCTOR_MUTABLE_POISON (r
))
4683 if (!allow_non_constant
)
4684 error ("%qE is not a constant expression because it refers to "
4685 "mutable subobjects of %qT", t
, type
);
4686 non_constant_p
= true;
4689 if (TREE_CODE (r
) == CONSTRUCTOR
4690 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4692 if (!allow_non_constant
)
4693 error ("%qE is not a constant expression because it refers to "
4694 "an incompletely initialized variable", t
);
4695 TREE_CONSTANT (r
) = false;
4696 non_constant_p
= true;
4699 /* Technically we should check this for all subexpressions, but that
4700 runs into problems with our internal representation of pointer
4701 subtraction and the 5.19 rules are still in flux. */
4702 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4703 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4704 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4706 if (!allow_non_constant
)
4707 error ("conversion from pointer type %qT "
4708 "to arithmetic type %qT in a constant expression",
4709 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4710 non_constant_p
= true;
4713 if (!non_constant_p
&& overflow_p
)
4714 non_constant_p
= true;
4716 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4718 bool should_unshare
= true;
4719 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4720 should_unshare
= false;
4722 if (non_constant_p
&& !allow_non_constant
)
4723 return error_mark_node
;
4724 else if (non_constant_p
&& TREE_CONSTANT (r
))
4726 /* This isn't actually constant, so unset TREE_CONSTANT. */
4729 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4730 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4732 r
= build_nop (TREE_TYPE (r
), r
);
4733 TREE_CONSTANT (r
) = false;
4735 else if (non_constant_p
|| r
== t
)
4739 r
= unshare_expr (r
);
4741 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4743 if (TREE_CODE (t
) == TARGET_EXPR
4744 && TARGET_EXPR_INITIAL (t
) == r
)
4748 r
= get_target_expr (r
);
4749 TREE_CONSTANT (r
) = true;
4757 /* Returns true if T is a valid subexpression of a constant expression,
4758 even if it isn't itself a constant expression. */
4761 is_sub_constant_expr (tree t
)
4763 bool non_constant_p
= false;
4764 bool overflow_p
= false;
4765 hash_map
<tree
, tree
> map
;
4767 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4769 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4771 return !non_constant_p
&& !overflow_p
;
4774 /* If T represents a constant expression returns its reduced value.
4775 Otherwise return error_mark_node. If T is dependent, then
4779 cxx_constant_value (tree t
, tree decl
)
4781 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4784 /* Helper routine for fold_simple function. Either return simplified
4785 expression T, otherwise NULL_TREE.
4786 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4787 even if we are within template-declaration. So be careful on call, as in
4788 such case types can be undefined. */
4791 fold_simple_1 (tree t
)
4794 enum tree_code code
= TREE_CODE (t
);
4806 return fold_sizeof_expr (t
);
4814 case TRUTH_NOT_EXPR
:
4816 case VIEW_CONVERT_EXPR
:
4819 case FIX_TRUNC_EXPR
:
4820 case FIXED_CONVERT_EXPR
:
4821 case ADDR_SPACE_CONVERT_EXPR
:
4823 op1
= TREE_OPERAND (t
, 0);
4825 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4829 if (CONVERT_EXPR_CODE_P (code
)
4830 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4831 TREE_OVERFLOW (t
) = false;
4839 /* If T is a simple constant expression, returns its simplified value.
4840 Otherwise returns T. In contrast to maybe_constant_value do we
4841 simplify only few operations on constant-expressions, and we don't
4842 try to simplify constexpressions. */
4845 fold_simple (tree t
)
4848 if (processing_template_decl
)
4851 r
= fold_simple_1 (t
);
4858 /* If T is a constant expression, returns its reduced value.
4859 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4860 Otherwise, returns a version of T without TREE_CONSTANT. */
4862 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4865 maybe_constant_value (tree t
, tree decl
)
4869 if (!is_nondependent_constant_expression (t
))
4871 if (TREE_OVERFLOW_P (t
))
4873 t
= build_nop (TREE_TYPE (t
), t
);
4874 TREE_CONSTANT (t
) = false;
4878 else if (CONSTANT_CLASS_P (t
))
4879 /* No caching or evaluation needed. */
4882 if (cv_cache
== NULL
)
4883 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4884 if (tree
*cached
= cv_cache
->get (t
))
4887 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4888 gcc_checking_assert (r
== t
4889 || CONVERT_EXPR_P (t
)
4890 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4891 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4892 || !cp_tree_equal (r
, t
));
4893 cv_cache
->put (t
, r
);
4897 /* Dispose of the whole CV_CACHE. */
4900 clear_cv_cache (void)
4902 if (cv_cache
!= NULL
)
4906 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4909 clear_cv_and_fold_caches (void)
4912 clear_fold_cache ();
4915 /* Like maybe_constant_value but first fully instantiate the argument.
4917 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4918 (t, tf_none) followed by maybe_constant_value but is more efficient,
4919 because calls instantiation_dependent_expression_p and
4920 potential_constant_expression at most once. */
4923 fold_non_dependent_expr (tree t
)
4928 /* If we're in a template, but T isn't value dependent, simplify
4929 it. We're supposed to treat:
4931 template <typename T> void f(T[1 + 1]);
4932 template <typename T> void f(T[2]);
4934 as two declarations of the same function, for example. */
4935 if (processing_template_decl
)
4937 if (is_nondependent_constant_expression (t
))
4939 processing_template_decl_sentinel s
;
4940 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4942 if (type_unknown_p (t
)
4943 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4945 if (TREE_OVERFLOW_P (t
))
4947 t
= build_nop (TREE_TYPE (t
), t
);
4948 TREE_CONSTANT (t
) = false;
4953 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4954 /* cp_tree_equal looks through NOPs, so allow them. */
4955 gcc_checking_assert (r
== t
4956 || CONVERT_EXPR_P (t
)
4957 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4958 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4959 || !cp_tree_equal (r
, t
));
4962 else if (TREE_OVERFLOW_P (t
))
4964 t
= build_nop (TREE_TYPE (t
), t
);
4965 TREE_CONSTANT (t
) = false;
4970 return maybe_constant_value (t
);
4973 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4974 than wrapped in a TARGET_EXPR. */
4977 maybe_constant_init (tree t
, tree decl
)
4981 if (TREE_CODE (t
) == EXPR_STMT
)
4982 t
= TREE_OPERAND (t
, 0);
4983 if (TREE_CODE (t
) == CONVERT_EXPR
4984 && VOID_TYPE_P (TREE_TYPE (t
)))
4985 t
= TREE_OPERAND (t
, 0);
4986 if (TREE_CODE (t
) == INIT_EXPR
)
4987 t
= TREE_OPERAND (t
, 1);
4988 if (TREE_CODE (t
) == TARGET_EXPR
)
4989 t
= TARGET_EXPR_INITIAL (t
);
4990 if (!is_nondependent_static_init_expression (t
))
4991 /* Don't try to evaluate it. */;
4992 else if (CONSTANT_CLASS_P (t
))
4993 /* No evaluation needed. */;
4995 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
4996 if (TREE_CODE (t
) == TARGET_EXPR
)
4998 tree init
= TARGET_EXPR_INITIAL (t
);
4999 if (TREE_CODE (init
) == CONSTRUCTOR
)
5006 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5007 /* Return true if the object referred to by REF has automatic or thread
5010 enum { ck_ok
, ck_bad
, ck_unknown
};
5012 check_automatic_or_tls (tree ref
)
5015 HOST_WIDE_INT bitsize
, bitpos
;
5017 int volatilep
= 0, unsignedp
= 0;
5018 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
5019 &mode
, &unsignedp
, &volatilep
, false);
5022 /* If there isn't a decl in the middle, we don't know the linkage here,
5023 and this isn't a constant expression anyway. */
5026 dk
= decl_storage_duration (decl
);
5027 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
5031 /* Return true if T denotes a potentially constant expression. Issue
5032 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5033 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5034 consider the expression in the current context, independent of constexpr
5037 C++0x [expr.const] used to say
5039 6 An expression is a potential constant expression if it is
5040 a constant expression where all occurrences of function
5041 parameters are replaced by arbitrary constant expressions
5042 of the appropriate type.
5044 2 A conditional expression is a constant expression unless it
5045 involves one of the following as a potentially evaluated
5046 subexpression (3.2), but subexpressions of logical AND (5.14),
5047 logical OR (5.15), and conditional (5.16) operations that are
5048 not evaluated are not considered. */
5051 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
, bool now
,
5052 tsubst_flags_t flags
)
5054 #define RECUR(T,RV) \
5055 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5057 enum { any
= false, rval
= true };
5061 if (t
== error_mark_node
)
5065 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5066 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5068 if (flags
& tf_error
)
5069 error_at (loc
, "expression %qE has side-effects", t
);
5072 if (CONSTANT_CLASS_P (t
))
5074 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5075 && TREE_TYPE (t
) == error_mark_node
)
5078 switch (TREE_CODE (t
))
5084 case TEMPLATE_ID_EXPR
:
5087 case CASE_LABEL_EXPR
:
5093 case TEMPLATE_PARM_INDEX
:
5095 case IDENTIFIER_NODE
:
5096 case USERDEF_LITERAL
:
5097 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5102 case PLACEHOLDER_EXPR
:
5112 if (flags
& tf_error
)
5113 error ("%qE is not a constant expression", t
);
5118 case AGGR_INIT_EXPR
:
5120 /* -- an invocation of a function other than a constexpr function
5121 or a constexpr constructor. */
5123 tree fun
= get_function_named_in_call (t
);
5124 const int nargs
= call_expr_nargs (t
);
5127 if (fun
== NULL_TREE
)
5129 /* Reset to allow the function to continue past the end
5130 of the block below. Otherwise return early. */
5133 if (TREE_CODE (t
) == CALL_EXPR
5134 && CALL_EXPR_FN (t
) == NULL_TREE
)
5135 switch (CALL_EXPR_IFN (t
))
5137 /* These should be ignored, they are optimized away from
5138 constexpr functions. */
5139 case IFN_UBSAN_NULL
:
5140 case IFN_UBSAN_BOUNDS
:
5141 case IFN_UBSAN_VPTR
:
5142 case IFN_FALLTHROUGH
:
5145 case IFN_ADD_OVERFLOW
:
5146 case IFN_SUB_OVERFLOW
:
5147 case IFN_MUL_OVERFLOW
:
5157 /* fold_call_expr can't do anything with IFN calls. */
5158 if (flags
& tf_error
)
5159 error_at (loc
, "call to internal function %qE", t
);
5164 if (fun
&& is_overloaded_fn (fun
))
5166 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5168 if (builtin_valid_in_constant_expr_p (fun
))
5170 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5171 /* Allow any built-in function; if the expansion
5172 isn't constant, we'll deal with that then. */
5173 && !is_builtin_fn (fun
))
5175 if (flags
& tf_error
)
5177 error_at (loc
, "call to non-constexpr function %qD",
5179 explain_invalid_constexpr_fn (fun
);
5183 /* A call to a non-static member function takes the address
5184 of the object as the first argument. But in a constant
5185 expression the address will be folded away, so look
5187 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5188 && !DECL_CONSTRUCTOR_P (fun
))
5190 tree x
= get_nth_callarg (t
, 0);
5191 if (is_this_parameter (x
))
5193 /* Don't require an immediately constant value, as
5194 constexpr substitution might not use the value. */
5195 bool sub_now
= false;
5196 if (!potential_constant_expression_1 (x
, rval
, strict
,
5204 if (!RECUR (fun
, true))
5206 fun
= get_first_fn (fun
);
5208 /* Skip initial arguments to base constructors. */
5209 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5210 i
= num_artificial_parms_for (fun
);
5211 fun
= DECL_ORIGIN (fun
);
5215 if (RECUR (fun
, rval
))
5216 /* Might end up being a constant function pointer. */;
5220 for (; i
< nargs
; ++i
)
5222 tree x
= get_nth_callarg (t
, i
);
5223 /* In a template, reference arguments haven't been converted to
5224 REFERENCE_TYPE and we might not even know if the parameter
5225 is a reference, so accept lvalue constants too. */
5226 bool rv
= processing_template_decl
? any
: rval
;
5227 /* Don't require an immediately constant value, as constexpr
5228 substitution might not use the value of the argument. */
5229 bool sub_now
= false;
5230 if (!potential_constant_expression_1 (x
, rv
, strict
,
5237 case NON_LVALUE_EXPR
:
5238 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5239 -- an lvalue of integral type that refers to a non-volatile
5240 const variable or static data member initialized with
5241 constant expressions, or
5243 -- an lvalue of literal type that refers to non-volatile
5244 object defined with constexpr, or that refers to a
5245 sub-object of such an object; */
5246 return RECUR (TREE_OPERAND (t
, 0), rval
);
5249 if (DECL_HAS_VALUE_EXPR_P (t
))
5250 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5252 && !var_in_maybe_constexpr_fn (t
)
5253 && !type_dependent_expression_p (t
)
5254 && !decl_maybe_constant_var_p (t
)
5256 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5257 || (DECL_INITIAL (t
)
5258 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
)))
5259 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5260 && !is_really_empty_class (TREE_TYPE (t
)))
5262 if (flags
& tf_error
)
5263 non_const_var_error (t
);
5270 case VIEW_CONVERT_EXPR
:
5271 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5272 may change to something more specific to type-punning (DR 1312). */
5274 tree from
= TREE_OPERAND (t
, 0);
5275 if (POINTER_TYPE_P (TREE_TYPE (t
))
5276 && TREE_CODE (from
) == INTEGER_CST
5277 && !integer_zerop (from
))
5279 if (flags
& tf_error
)
5280 error_at (loc
, "reinterpret_cast from integer to pointer");
5283 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5286 case ADDRESSOF_EXPR
:
5287 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5288 t
= TREE_OPERAND (t
, 0);
5289 goto handle_addr_expr
;
5292 /* -- a unary operator & that is applied to an lvalue that
5293 designates an object with thread or automatic storage
5295 t
= TREE_OPERAND (t
, 0);
5297 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5298 /* A pointer-to-member constant. */
5303 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5304 any checking here, as we might dereference the pointer later. If
5305 we remove this code, also remove check_automatic_or_tls. */
5306 i
= check_automatic_or_tls (t
);
5311 if (flags
& tf_error
)
5312 error ("address-of an object %qE with thread local or "
5313 "automatic storage is not a constant expression", t
);
5317 return RECUR (t
, any
);
5325 /* -- a class member access unless its postfix-expression is
5326 of literal type or of pointer to literal type. */
5327 /* This test would be redundant, as it follows from the
5328 postfix-expression being a potential constant expression. */
5329 if (type_unknown_p (t
))
5331 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5333 case EXPR_PACK_EXPANSION
:
5334 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5338 tree x
= TREE_OPERAND (t
, 0);
5340 if (is_this_parameter (x
) && !is_capture_proxy (x
))
5342 if (!var_in_maybe_constexpr_fn (x
))
5344 if (flags
& tf_error
)
5345 error_at (loc
, "use of %<this%> in a constant expression");
5350 return RECUR (x
, rval
);
5353 case STATEMENT_LIST
:
5355 tree_stmt_iterator i
;
5356 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5358 if (!RECUR (tsi_stmt (i
), any
))
5366 if (cxx_dialect
< cxx14
)
5368 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5370 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5375 if (cxx_dialect
< cxx14
)
5377 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5379 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5384 if (!RECUR (DO_COND (t
), rval
))
5386 if (!RECUR (DO_BODY (t
), any
))
5391 if (!RECUR (FOR_INIT_STMT (t
), any
))
5393 if (!RECUR (FOR_COND (t
), rval
))
5395 if (!RECUR (FOR_EXPR (t
), any
))
5397 if (!RECUR (FOR_BODY (t
), any
))
5401 case RANGE_FOR_STMT
:
5402 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5404 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5409 if (!RECUR (WHILE_COND (t
), rval
))
5411 if (!RECUR (WHILE_BODY (t
), any
))
5416 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5418 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5419 unreachable labels would be checked. */
5423 return RECUR (STMT_EXPR_STMT (t
), rval
);
5426 case DYNAMIC_CAST_EXPR
:
5427 case PSEUDO_DTOR_EXPR
:
5431 case VEC_DELETE_EXPR
:
5436 case OMP_DISTRIBUTE
:
5439 case OMP_TARGET_DATA
:
5448 case OMP_TARGET_UPDATE
:
5449 case OMP_TARGET_ENTER_DATA
:
5450 case OMP_TARGET_EXIT_DATA
:
5452 case OMP_ATOMIC_READ
:
5453 case OMP_ATOMIC_CAPTURE_OLD
:
5454 case OMP_ATOMIC_CAPTURE_NEW
:
5458 case OACC_HOST_DATA
:
5462 case OACC_ENTER_DATA
:
5463 case OACC_EXIT_DATA
:
5467 /* GCC internal stuff. */
5470 case TRANSACTION_EXPR
:
5472 case AT_ENCODE_EXPR
:
5474 if (flags
& tf_error
)
5475 error_at (loc
, "expression %qE is not a constant expression", t
);
5479 /* -- a typeid expression whose operand is of polymorphic
5482 tree e
= TREE_OPERAND (t
, 0);
5483 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5484 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5486 if (flags
& tf_error
)
5487 error_at (loc
, "typeid-expression is not a constant expression "
5488 "because %qE is of polymorphic type", e
);
5507 case PREINCREMENT_EXPR
:
5508 case POSTINCREMENT_EXPR
:
5509 case PREDECREMENT_EXPR
:
5510 case POSTDECREMENT_EXPR
:
5511 if (cxx_dialect
< cxx14
)
5517 if (TYPE_P (TREE_OPERAND (t
, 0)))
5523 case FIX_TRUNC_EXPR
:
5527 case TRUTH_NOT_EXPR
:
5528 case FIXED_CONVERT_EXPR
:
5529 case UNARY_PLUS_EXPR
:
5530 case UNARY_LEFT_FOLD_EXPR
:
5531 case UNARY_RIGHT_FOLD_EXPR
:
5533 return RECUR (TREE_OPERAND (t
, 0), rval
);
5536 case CONST_CAST_EXPR
:
5537 case STATIC_CAST_EXPR
:
5538 case REINTERPRET_CAST_EXPR
:
5539 case IMPLICIT_CONV_EXPR
:
5540 if (cxx_dialect
< cxx11
5541 && !dependent_type_p (TREE_TYPE (t
))
5542 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5543 /* In C++98, a conversion to non-integral type can't be part of a
5544 constant expression. */
5546 if (flags
& tf_error
)
5548 "cast to non-integral type %qT in a constant expression",
5553 return (RECUR (TREE_OPERAND (t
, 0),
5554 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5557 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5559 case CLEANUP_POINT_EXPR
:
5560 case MUST_NOT_THROW_EXPR
:
5561 case TRY_CATCH_EXPR
:
5566 case NON_DEPENDENT_EXPR
:
5567 /* For convenience. */
5571 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5574 tmp
= DECL_EXPR_DECL (t
);
5575 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5577 if (TREE_STATIC (tmp
))
5579 if (flags
& tf_error
)
5580 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5581 "%<static%> in %<constexpr%> context", tmp
);
5584 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5586 if (flags
& tf_error
)
5587 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5588 "%<thread_local%> in %<constexpr%> context", tmp
);
5591 else if (!DECL_NONTRIVIALLY_INITIALIZED_P (tmp
))
5593 if (flags
& tf_error
)
5594 error_at (DECL_SOURCE_LOCATION (tmp
), "uninitialized "
5595 "variable %qD in %<constexpr%> context", tmp
);
5599 return RECUR (tmp
, want_rval
);
5601 case TRY_FINALLY_EXPR
:
5602 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5603 && RECUR (TREE_OPERAND (t
, 1), any
));
5606 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5609 if (!literal_type_p (TREE_TYPE (t
)))
5611 if (flags
& tf_error
)
5613 error_at (loc
, "temporary of non-literal type %qT in a "
5614 "constant expression", TREE_TYPE (t
));
5615 explain_non_literal_class (TREE_TYPE (t
));
5621 return RECUR (TREE_OPERAND (t
, 1), rval
);
5625 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5626 constructor_elt
*ce
;
5627 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5628 if (!RECUR (ce
->value
, want_rval
))
5635 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5636 || DECL_P (TREE_PURPOSE (t
)));
5637 if (!RECUR (TREE_VALUE (t
), want_rval
))
5639 if (TREE_CHAIN (t
) == NULL_TREE
)
5641 return RECUR (TREE_CHAIN (t
), want_rval
);
5644 case TRUNC_DIV_EXPR
:
5646 case FLOOR_DIV_EXPR
:
5647 case ROUND_DIV_EXPR
:
5648 case TRUNC_MOD_EXPR
:
5650 case ROUND_MOD_EXPR
:
5652 tree denom
= TREE_OPERAND (t
, 1);
5653 if (!RECUR (denom
, rval
))
5655 /* We can't call cxx_eval_outermost_constant_expr on an expression
5656 that hasn't been through instantiate_non_dependent_expr yet. */
5657 if (!processing_template_decl
)
5658 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5659 if (integer_zerop (denom
))
5661 if (flags
& tf_error
)
5662 error ("division by zero is not a constant expression");
5668 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5674 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5675 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5676 introduced by build_call_a. */
5677 tree op0
= TREE_OPERAND (t
, 0);
5678 tree op1
= TREE_OPERAND (t
, 1);
5680 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5681 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5682 return RECUR (op0
, want_rval
);
5687 /* If the first operand is the non-short-circuit constant, look at
5688 the second operand; otherwise we only care about the first one for
5690 case TRUTH_AND_EXPR
:
5691 case TRUTH_ANDIF_EXPR
:
5692 tmp
= boolean_true_node
;
5695 case TRUTH_ORIF_EXPR
:
5696 tmp
= boolean_false_node
;
5699 tree op
= TREE_OPERAND (t
, 0);
5700 if (!RECUR (op
, rval
))
5702 if (!processing_template_decl
)
5703 op
= cxx_eval_outermost_constant_expr (op
, true);
5704 if (tree_int_cst_equal (op
, tmp
))
5705 return RECUR (TREE_OPERAND (t
, 1), rval
);
5712 case POINTER_PLUS_EXPR
:
5714 case EXACT_DIV_EXPR
:
5724 case TRUTH_XOR_EXPR
:
5725 case UNORDERED_EXPR
:
5738 case ARRAY_RANGE_REF
:
5742 case BINARY_LEFT_FOLD_EXPR
:
5743 case BINARY_RIGHT_FOLD_EXPR
:
5745 for (i
= 0; i
< 2; ++i
)
5746 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5750 case CILK_SYNC_STMT
:
5751 case CILK_SPAWN_STMT
:
5752 case ARRAY_NOTATION_REF
:
5757 for (i
= 0; i
< 3; ++i
)
5758 if (!RECUR (TREE_OPERAND (t
, i
), true))
5763 if (COND_EXPR_IS_VEC_DELETE (t
))
5765 if (flags
& tf_error
)
5766 error_at (loc
, "%<delete[]%> is not a constant expression");
5772 /* If the condition is a known constant, we know which of the legs we
5773 care about; otherwise we only require that the condition and
5774 either of the legs be potentially constant. */
5775 tmp
= TREE_OPERAND (t
, 0);
5776 if (!RECUR (tmp
, rval
))
5778 if (!processing_template_decl
)
5779 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5780 if (integer_zerop (tmp
))
5781 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5782 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5783 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5784 for (i
= 1; i
< 3; ++i
)
5785 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5786 want_rval
, strict
, now
, tf_none
))
5788 if (flags
& tf_error
)
5789 error_at (loc
, "expression %qE is not a constant expression", t
);
5793 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5795 if (flags
& tf_error
)
5797 error_at (loc
, "non-constant array initialization");
5798 diagnose_non_constexpr_vec_init (t
);
5804 /* We can see these in statement-expressions. */
5808 case EMPTY_CLASS_EXPR
:
5814 tree
*target
= &TREE_OPERAND (t
, 0);
5815 /* Gotos representing break and continue are OK. */
5816 if (breaks (target
) || continues (target
))
5818 if (flags
& tf_error
)
5819 error_at (loc
, "%<goto%> is not a constant expression");
5824 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
5825 return RECUR (TREE_OPERAND (t
, 0), rval
);
5828 if (objc_is_property_ref (t
))
5831 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5838 /* The main entry point to the above. */
5841 potential_constant_expression (tree t
)
5843 return potential_constant_expression_1 (t
, false, true, false, tf_none
);
5846 /* As above, but require a constant rvalue. */
5849 potential_rvalue_constant_expression (tree t
)
5851 return potential_constant_expression_1 (t
, true, true, false, tf_none
);
5854 /* Like above, but complain about non-constant expressions. */
5857 require_potential_constant_expression (tree t
)
5859 return potential_constant_expression_1 (t
, false, true, false, tf_warning_or_error
);
5862 /* Cross product of the above. */
5865 require_potential_rvalue_constant_expression (tree t
)
5867 return potential_constant_expression_1 (t
, true, true, false, tf_warning_or_error
);
5870 /* Like potential_constant_expression, but don't consider possible constexpr
5871 substitution of the current function. That is, PARM_DECL qualifies under
5872 potential_constant_expression, but not here.
5874 This is basically what you can check when any actual constant values might
5875 be value-dependent. */
5878 is_constant_expression (tree t
)
5880 return potential_constant_expression_1 (t
, false, true, true, tf_none
);
5883 /* Like above, but complain about non-constant expressions. */
5886 require_constant_expression (tree t
)
5888 return potential_constant_expression_1 (t
, false, true, true,
5889 tf_warning_or_error
);
5892 /* Like is_constant_expression, but allow const variables that are not allowed
5893 under constexpr rules. */
5896 is_static_init_expression (tree t
)
5898 return potential_constant_expression_1 (t
, false, false, true, tf_none
);
5901 /* Returns true if T is a potential constant expression that is not
5902 instantiation-dependent, and therefore a candidate for constant folding even
5906 is_nondependent_constant_expression (tree t
)
5908 return (!type_unknown_p (t
)
5909 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5910 && is_constant_expression (t
)
5911 && !instantiation_dependent_expression_p (t
));
5914 /* Returns true if T is a potential static initializer expression that is not
5915 instantiation-dependent. */
5918 is_nondependent_static_init_expression (tree t
)
5920 return (!type_unknown_p (t
)
5921 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5922 && is_static_init_expression (t
)
5923 && !instantiation_dependent_expression_p (t
));
5926 /* Finalize constexpr processing after parsing. */
5929 fini_constexpr (void)
5931 /* The contexpr call and fundef copies tables are no longer needed. */
5932 constexpr_call_table
= NULL
;
5933 fundef_copies_table
= NULL
;
5936 #include "gt-cp-constexpr.h"