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"
36 static bool verify_constant (tree
, bool, bool *, bool *);
37 #define VERIFY_CONSTANT(X) \
39 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
43 /* Returns true iff FUN is an instantiation of a constexpr function
44 template or a defaulted constexpr function. */
47 is_instantiation_of_constexpr (tree fun
)
49 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
50 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
51 || (DECL_DEFAULTED_FN (fun
)
52 && DECL_DECLARED_CONSTEXPR_P (fun
)));
55 /* Return true if T is a literal type. */
58 literal_type_p (tree t
)
62 || TREE_CODE (t
) == REFERENCE_TYPE
63 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
67 t
= complete_type (t
);
68 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
69 return CLASSTYPE_LITERAL_P (t
);
71 if (TREE_CODE (t
) == ARRAY_TYPE
)
72 return literal_type_p (strip_array_types (t
));
76 /* If DECL is a variable declared `constexpr', require its type
77 be literal. Return the DECL if OK, otherwise NULL. */
80 ensure_literal_type_for_constexpr_object (tree decl
)
82 tree type
= TREE_TYPE (decl
);
84 && (DECL_DECLARED_CONSTEXPR_P (decl
)
85 || var_in_constexpr_fn (decl
))
86 && !processing_template_decl
)
88 tree stype
= strip_array_types (type
);
89 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
90 /* Don't complain here, we'll complain about incompleteness
91 when we try to initialize the variable. */;
92 else if (!literal_type_p (type
))
94 if (DECL_DECLARED_CONSTEXPR_P (decl
))
96 error ("the type %qT of constexpr variable %qD is not literal",
98 explain_non_literal_class (type
);
102 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
104 error ("variable %qD of non-literal type %qT in %<constexpr%> "
105 "function", decl
, type
);
106 explain_non_literal_class (type
);
108 cp_function_chain
->invalid_constexpr
= true;
116 /* Representation of entries in the constexpr function definition table. */
118 struct GTY((for_user
)) constexpr_fundef
{
123 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
125 static hashval_t
hash (constexpr_fundef
*);
126 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
129 /* This table holds all constexpr function definitions seen in
130 the current translation unit. */
132 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
134 /* Utility function used for managing the constexpr function table.
135 Return true if the entries pointed to by P and Q are for the
136 same constexpr function. */
139 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
141 return lhs
->decl
== rhs
->decl
;
144 /* Utility function used for managing the constexpr function table.
145 Return a hash value for the entry pointed to by Q. */
148 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
150 return DECL_UID (fundef
->decl
);
153 /* Return a previously saved definition of function FUN. */
155 static constexpr_fundef
*
156 retrieve_constexpr_fundef (tree fun
)
158 constexpr_fundef fundef
= { NULL
, NULL
};
159 if (constexpr_fundef_table
== NULL
)
163 return constexpr_fundef_table
->find (&fundef
);
166 /* Check whether the parameter and return types of FUN are valid for a
167 constexpr function, and complain if COMPLAIN. */
170 is_valid_constexpr_fn (tree fun
, bool complain
)
174 if (DECL_INHERITED_CTOR (fun
)
175 && TREE_CODE (fun
) == TEMPLATE_DECL
)
179 error ("inherited constructor %qD is not constexpr",
180 DECL_INHERITED_CTOR (fun
));
184 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
185 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
186 if (!literal_type_p (TREE_TYPE (parm
)))
191 error ("invalid type for parameter %d of constexpr "
192 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
193 explain_non_literal_class (TREE_TYPE (parm
));
198 if (!DECL_CONSTRUCTOR_P (fun
))
200 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
201 if (!literal_type_p (rettype
))
206 error ("invalid return type %qT of constexpr function %q+D",
208 explain_non_literal_class (rettype
);
212 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
213 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
218 error ("enclosing class of constexpr non-static member "
219 "function %q+#D is not a literal type", fun
);
220 explain_non_literal_class (DECL_CONTEXT (fun
));
224 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
228 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
234 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
235 for a member of an anonymous aggregate, INIT is the initializer for that
236 member, and VEC_OUTER is the vector of constructor elements for the class
237 whose constructor we are processing. Add the initializer to the vector
238 and return true to indicate success. */
241 build_anon_member_initialization (tree member
, tree init
,
242 vec
<constructor_elt
, va_gc
> **vec_outer
)
244 /* MEMBER presents the relevant fields from the inside out, but we need
245 to build up the initializer from the outside in so that we can reuse
246 previously built CONSTRUCTORs if this is, say, the second field in an
247 anonymous struct. So we use a vec as a stack. */
248 auto_vec
<tree
, 2> fields
;
251 fields
.safe_push (TREE_OPERAND (member
, 1));
252 member
= TREE_OPERAND (member
, 0);
254 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
255 && TREE_CODE (member
) == COMPONENT_REF
);
257 /* VEC has the constructor elements vector for the context of FIELD.
258 If FIELD is an anonymous aggregate, we will push inside it. */
259 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
261 while (field
= fields
.pop(),
262 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
265 /* If there is already an outer constructor entry for the anonymous
266 aggregate FIELD, use it; otherwise, insert one. */
267 if (vec_safe_is_empty (*vec
)
268 || (*vec
)->last().index
!= field
)
270 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
271 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
274 ctor
= (*vec
)->last().value
;
275 vec
= &CONSTRUCTOR_ELTS (ctor
);
278 /* Now we're at the innermost field, the one that isn't an anonymous
279 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
280 gcc_assert (fields
.is_empty());
281 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
286 /* Subroutine of build_constexpr_constructor_member_initializers.
287 The expression tree T represents a data member initialization
288 in a (constexpr) constructor definition. Build a pairing of
289 the data member with its initializer, and prepend that pair
290 to the existing initialization pair INITS. */
293 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
296 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
297 t
= TREE_OPERAND (t
, 0);
298 if (TREE_CODE (t
) == EXPR_STMT
)
299 t
= TREE_OPERAND (t
, 0);
300 if (t
== error_mark_node
)
302 if (TREE_CODE (t
) == STATEMENT_LIST
)
304 tree_stmt_iterator i
;
305 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
307 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
312 if (TREE_CODE (t
) == CLEANUP_STMT
)
314 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
315 but we can in a constexpr constructor for a non-literal class. Just
316 ignore it; either all the initialization will be constant, in which
317 case the cleanup can't run, or it can't be constexpr.
318 Still recurse into CLEANUP_BODY. */
319 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
321 if (TREE_CODE (t
) == CONVERT_EXPR
)
322 t
= TREE_OPERAND (t
, 0);
323 if (TREE_CODE (t
) == INIT_EXPR
324 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
325 use what this function builds for cx_check_missing_mem_inits, and
326 assignment in the ctor body doesn't count. */
327 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
329 member
= TREE_OPERAND (t
, 0);
330 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
332 else if (TREE_CODE (t
) == CALL_EXPR
)
334 tree fn
= get_callee_fndecl (t
);
335 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
336 /* We're only interested in calls to subobject constructors. */
338 member
= CALL_EXPR_ARG (t
, 0);
339 /* We don't use build_cplus_new here because it complains about
340 abstract bases. Leaving the call unwrapped means that it has the
341 wrong type, but cxx_eval_constant_expression doesn't care. */
342 init
= break_out_target_exprs (t
);
344 else if (TREE_CODE (t
) == BIND_EXPR
)
345 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
347 /* Don't add anything else to the CONSTRUCTOR. */
349 if (INDIRECT_REF_P (member
))
350 member
= TREE_OPERAND (member
, 0);
351 if (TREE_CODE (member
) == NOP_EXPR
)
355 if (TREE_CODE (op
) == ADDR_EXPR
)
357 gcc_assert (same_type_ignoring_top_level_qualifiers_p
358 (TREE_TYPE (TREE_TYPE (op
)),
359 TREE_TYPE (TREE_TYPE (member
))));
360 /* Initializing a cv-qualified member; we need to look through
364 else if (op
== current_class_ptr
365 && (same_type_ignoring_top_level_qualifiers_p
366 (TREE_TYPE (TREE_TYPE (member
)),
367 current_class_type
)))
368 /* Delegating constructor. */
372 /* This is an initializer for an empty base; keep it for now so
373 we can check it in cxx_eval_bare_aggregate. */
374 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
377 if (TREE_CODE (member
) == ADDR_EXPR
)
378 member
= TREE_OPERAND (member
, 0);
379 if (TREE_CODE (member
) == COMPONENT_REF
)
381 tree aggr
= TREE_OPERAND (member
, 0);
382 if (TREE_CODE (aggr
) == VAR_DECL
)
383 /* Initializing a local variable, don't add anything. */
385 if (TREE_CODE (aggr
) != COMPONENT_REF
)
386 /* Normal member initialization. */
387 member
= TREE_OPERAND (member
, 1);
388 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
389 /* Initializing a member of an anonymous union. */
390 return build_anon_member_initialization (member
, init
, vec
);
392 /* We're initializing a vtable pointer in a base. Leave it as
393 COMPONENT_REF so we remember the path to get to the vfield. */
394 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
397 /* Value-initialization can produce multiple initializers for the
398 same field; use the last one. */
399 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
400 (*vec
)->last().value
= init
;
402 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
406 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
407 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
408 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
411 check_constexpr_bind_expr_vars (tree t
)
413 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
415 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
416 if (TREE_CODE (var
) == TYPE_DECL
417 && DECL_IMPLICIT_TYPEDEF_P (var
)
418 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
423 /* Subroutine of check_constexpr_ctor_body. */
426 check_constexpr_ctor_body_1 (tree last
, tree list
)
428 switch (TREE_CODE (list
))
431 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
432 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
436 case CLEANUP_POINT_EXPR
:
437 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
441 if (!check_constexpr_bind_expr_vars (list
)
442 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
456 /* Make sure that there are no statements after LAST in the constructor
457 body represented by LIST. */
460 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
462 /* C++14 doesn't require a constexpr ctor to have an empty body. */
463 if (cxx_dialect
>= cxx14
)
467 if (TREE_CODE (list
) == STATEMENT_LIST
)
469 tree_stmt_iterator i
= tsi_last (list
);
470 for (; !tsi_end_p (i
); tsi_prev (&i
))
472 tree t
= tsi_stmt (i
);
475 if (!check_constexpr_ctor_body_1 (last
, t
))
482 else if (list
!= last
483 && !check_constexpr_ctor_body_1 (last
, list
))
488 error ("constexpr constructor does not have empty body");
489 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
494 /* V is a vector of constructor elements built up for the base and member
495 initializers of a constructor for TYPE. They need to be in increasing
496 offset order, which they might not be yet if TYPE has a primary base
497 which is not first in the base-clause or a vptr and at least one base
498 all of which are non-primary. */
500 static vec
<constructor_elt
, va_gc
> *
501 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
503 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
509 field_type
= BINFO_TYPE (pri
);
510 else if (TYPE_CONTAINS_VPTR_P (type
))
511 field_type
= vtbl_ptr_type_node
;
515 /* Find the element for the primary base or vptr and move it to the
516 beginning of the vec. */
517 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
518 if (TREE_TYPE (ce
->index
) == field_type
)
521 if (i
> 0 && i
< vec_safe_length (v
))
523 vec
<constructor_elt
, va_gc
> &vref
= *v
;
524 constructor_elt elt
= vref
[i
];
533 /* Build compile-time evalable representations of member-initializer list
534 for a constexpr constructor. */
537 build_constexpr_constructor_member_initializers (tree type
, tree body
)
539 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
542 switch (TREE_CODE (body
))
544 case MUST_NOT_THROW_EXPR
:
546 body
= TREE_OPERAND (body
, 0);
550 for (tree_stmt_iterator i
= tsi_start (body
);
551 !tsi_end_p (i
); tsi_next (&i
))
554 if (TREE_CODE (body
) == BIND_EXPR
)
560 body
= BIND_EXPR_BODY (body
);
567 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
569 body
= TREE_OPERAND (body
, 0);
570 if (TREE_CODE (body
) == EXPR_STMT
)
571 body
= TREE_OPERAND (body
, 0);
572 if (TREE_CODE (body
) == INIT_EXPR
573 && (same_type_ignoring_top_level_qualifiers_p
574 (TREE_TYPE (TREE_OPERAND (body
, 0)),
575 current_class_type
)))
578 return TREE_OPERAND (body
, 1);
580 ok
= build_data_member_initialization (body
, &vec
);
582 else if (TREE_CODE (body
) == STATEMENT_LIST
)
584 tree_stmt_iterator i
;
585 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
587 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
592 else if (TREE_CODE (body
) == TRY_BLOCK
)
594 error ("body of %<constexpr%> constructor cannot be "
595 "a function-try-block");
596 return error_mark_node
;
598 else if (EXPR_P (body
))
599 ok
= build_data_member_initialization (body
, &vec
);
601 gcc_assert (errorcount
> 0);
604 if (vec_safe_length (vec
) > 0)
606 /* In a delegating constructor, return the target. */
607 constructor_elt
*ce
= &(*vec
)[0];
608 if (ce
->index
== current_class_ptr
)
615 vec
= sort_constexpr_mem_initializers (type
, vec
);
616 return build_constructor (type
, vec
);
619 return error_mark_node
;
622 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
623 declared to be constexpr, or a sub-statement thereof. Returns the
624 return value if suitable, error_mark_node for a statement not allowed in
625 a constexpr function, or NULL_TREE if no return value was found. */
628 constexpr_fn_retval (tree body
)
630 switch (TREE_CODE (body
))
634 tree_stmt_iterator i
;
635 tree expr
= NULL_TREE
;
636 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
638 tree s
= constexpr_fn_retval (tsi_stmt (i
));
639 if (s
== error_mark_node
)
640 return error_mark_node
;
641 else if (s
== NULL_TREE
)
642 /* Keep iterating. */;
644 /* Multiple return statements. */
645 return error_mark_node
;
653 return break_out_target_exprs (TREE_OPERAND (body
, 0));
657 tree decl
= DECL_EXPR_DECL (body
);
658 if (TREE_CODE (decl
) == USING_DECL
659 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
660 || DECL_ARTIFICIAL (decl
))
662 return error_mark_node
;
665 case CLEANUP_POINT_EXPR
:
666 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
669 if (!check_constexpr_bind_expr_vars (body
))
670 return error_mark_node
;
671 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
677 return error_mark_node
;
681 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
682 FUN; do the necessary transformations to turn it into a single expression
683 that we can store in the hash table. */
686 massage_constexpr_body (tree fun
, tree body
)
688 if (DECL_CONSTRUCTOR_P (fun
))
689 body
= build_constexpr_constructor_member_initializers
690 (DECL_CONTEXT (fun
), body
);
691 else if (cxx_dialect
< cxx14
)
693 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
694 body
= EH_SPEC_STMTS (body
);
695 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
696 body
= TREE_OPERAND (body
, 0);
697 body
= constexpr_fn_retval (body
);
702 /* CTYPE is a type constructed from BODY. Return true if some
703 bases/fields are uninitialized, and complain if COMPLAIN. */
706 cx_check_missing_mem_inits (tree ctype
, tree body
, bool complain
)
712 if (TREE_CODE (body
) != CONSTRUCTOR
)
714 nelts
= CONSTRUCTOR_NELTS (body
);
716 tree field
= TYPE_FIELDS (ctype
);
718 if (TREE_CODE (ctype
) == UNION_TYPE
)
720 if (nelts
== 0 && next_initializable_field (field
))
723 error ("%<constexpr%> constructor for union %qT must "
724 "initialize exactly one non-static data member", ctype
);
730 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
731 need an explicit initialization. */
733 for (unsigned i
= 0; i
<= nelts
; ++i
)
735 tree index
= NULL_TREE
;
738 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
739 /* Skip base and vtable inits. */
740 if (TREE_CODE (index
) != FIELD_DECL
741 || DECL_ARTIFICIAL (index
))
745 for (; field
!= index
; field
= DECL_CHAIN (field
))
748 if (TREE_CODE (field
) != FIELD_DECL
)
750 if (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
752 if (DECL_ARTIFICIAL (field
))
754 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
756 /* Recurse to check the anonummous aggregate member. */
757 bad
|= cx_check_missing_mem_inits
758 (TREE_TYPE (field
), NULL_TREE
, complain
);
759 if (bad
&& !complain
)
763 ftype
= strip_array_types (TREE_TYPE (field
));
764 if (type_has_constexpr_default_constructor (ftype
))
766 /* It's OK to skip a member with a trivial constexpr ctor.
767 A constexpr ctor that isn't trivial should have been
769 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
775 error ("member %qD must be initialized by mem-initializer "
776 "in %<constexpr%> constructor", field
);
777 inform (DECL_SOURCE_LOCATION (field
), "declared here");
780 if (field
== NULL_TREE
)
783 if (ANON_AGGR_TYPE_P (TREE_TYPE (index
)))
785 /* Check the anonymous aggregate initializer is valid. */
786 bad
|= cx_check_missing_mem_inits
787 (TREE_TYPE (index
), CONSTRUCTOR_ELT (body
, i
)->value
, complain
);
788 if (bad
&& !complain
)
791 field
= DECL_CHAIN (field
);
797 /* We are processing the definition of the constexpr function FUN.
798 Check that its BODY fulfills the propriate requirements and
799 enter it in the constexpr function definition table.
800 For constructor BODY is actually the TREE_LIST of the
801 member-initializer list. */
804 register_constexpr_fundef (tree fun
, tree body
)
806 constexpr_fundef entry
;
807 constexpr_fundef
**slot
;
809 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
812 tree massaged
= massage_constexpr_body (fun
, body
);
813 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
815 if (!DECL_CONSTRUCTOR_P (fun
))
816 error ("body of constexpr function %qD not a return-statement", fun
);
820 if (!potential_rvalue_constant_expression (massaged
))
822 if (!DECL_GENERATED_P (fun
))
823 require_potential_rvalue_constant_expression (massaged
);
827 if (DECL_CONSTRUCTOR_P (fun
)
828 && cx_check_missing_mem_inits (DECL_CONTEXT (fun
),
829 massaged
, !DECL_GENERATED_P (fun
)))
832 /* Create the constexpr function table if necessary. */
833 if (constexpr_fundef_table
== NULL
)
834 constexpr_fundef_table
835 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
839 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
841 gcc_assert (*slot
== NULL
);
842 *slot
= ggc_alloc
<constexpr_fundef
> ();
848 /* FUN is a non-constexpr function called in a context that requires a
849 constant expression. If it comes from a constexpr template, explain why
850 the instantiation isn't constexpr. */
853 explain_invalid_constexpr_fn (tree fun
)
855 static hash_set
<tree
> *diagnosed
;
858 /* Only diagnose defaulted functions, lambdas, or instantiations. */
859 if (!DECL_DEFAULTED_FN (fun
)
860 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
861 && !is_instantiation_of_constexpr (fun
))
863 if (diagnosed
== NULL
)
864 diagnosed
= new hash_set
<tree
>;
865 if (diagnosed
->add (fun
))
866 /* Already explained. */
869 save_loc
= input_location
;
870 if (!lambda_static_thunk_p (fun
))
872 /* Diagnostics should completely ignore the static thunk, so leave
873 input_location set to our caller's location. */
874 input_location
= DECL_SOURCE_LOCATION (fun
);
875 inform (input_location
,
876 "%qD is not usable as a constexpr function because:", fun
);
878 /* First check the declaration. */
879 if (is_valid_constexpr_fn (fun
, true))
881 /* Then if it's OK, the body. */
882 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
883 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
884 explain_implicit_non_constexpr (fun
);
887 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
888 require_potential_rvalue_constant_expression (body
);
889 if (DECL_CONSTRUCTOR_P (fun
))
890 cx_check_missing_mem_inits (DECL_CONTEXT (fun
), body
, true);
893 input_location
= save_loc
;
896 /* Objects of this type represent calls to constexpr functions
897 along with the bindings of parameters to their arguments, for
898 the purpose of compile time evaluation. */
900 struct GTY((for_user
)) constexpr_call
{
901 /* Description of the constexpr function definition. */
902 constexpr_fundef
*fundef
;
903 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
904 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
905 Note: This arrangement is made to accommodate the use of
906 iterative_hash_template_arg (see pt.c). If you change this
907 representation, also change the hash calculation in
908 cxx_eval_call_expression. */
910 /* Result of the call.
911 NULL means the call is being evaluated.
912 error_mark_node means that the evaluation was erroneous;
913 otherwise, the actuall value of the call. */
915 /* The hash of this call; we remember it here to avoid having to
916 recalculate it when expanding the hash table. */
920 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
922 static hashval_t
hash (constexpr_call
*);
923 static bool equal (constexpr_call
*, constexpr_call
*);
926 enum constexpr_switch_state
{
927 /* Used when processing a switch for the first time by cxx_eval_switch_expr
928 and default: label for that switch has not been seen yet. */
929 css_default_not_seen
,
930 /* Used when processing a switch for the first time by cxx_eval_switch_expr
931 and default: label for that switch has been seen already. */
933 /* Used when processing a switch for the second time by
934 cxx_eval_switch_expr, where default: label should match. */
935 css_default_processing
938 /* The constexpr expansion context. CALL is the current function
939 expansion, CTOR is the current aggregate initializer, OBJECT is the
940 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
941 is a map of values of variables initialized within the expression. */
943 struct constexpr_ctx
{
944 /* The innermost call we're evaluating. */
945 constexpr_call
*call
;
946 /* Values for any temporaries or local variables within the
947 constant-expression. */
948 hash_map
<tree
,tree
> *values
;
949 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
950 aren't inside a loop. */
951 hash_set
<tree
> *save_exprs
;
952 /* The CONSTRUCTOR we're currently building up for an aggregate
955 /* The object we're building the CONSTRUCTOR for. */
957 /* If inside SWITCH_EXPR. */
958 constexpr_switch_state
*css_state
;
959 /* Whether we should error on a non-constant expression or fail quietly. */
961 /* Whether we are strictly conforming to constant expression rules or
962 trying harder to get a constant value. */
966 /* A table of all constexpr calls that have been evaluated by the
967 compiler in this translation unit. */
969 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
971 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
972 bool, bool *, bool *, tree
* = NULL
);
974 /* Compute a hash value for a constexpr call representation. */
977 constexpr_call_hasher::hash (constexpr_call
*info
)
982 /* Return true if the objects pointed to by P and Q represent calls
983 to the same constexpr function with the same arguments.
984 Otherwise, return false. */
987 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
993 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
995 lhs_bindings
= lhs
->bindings
;
996 rhs_bindings
= rhs
->bindings
;
997 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
999 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
1000 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
1001 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
1002 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
1004 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
1005 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
1007 return lhs_bindings
== rhs_bindings
;
1010 /* Initialize the constexpr call table, if needed. */
1013 maybe_initialize_constexpr_call_table (void)
1015 if (constexpr_call_table
== NULL
)
1016 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
1019 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1020 a function happens to get called recursively, we unshare the callee
1021 function's body and evaluate this unshared copy instead of evaluating the
1024 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1025 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1026 that's keyed off of the original FUNCTION_DECL and whose value is a
1027 TREE_LIST of this function's unused copies awaiting reuse.
1029 This is not GC-deletable to avoid GC affecting UID generation. */
1031 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
1033 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1036 maybe_initialize_fundef_copies_table ()
1038 if (fundef_copies_table
== NULL
)
1039 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1042 /* Reuse a copy or create a new unshared copy of the function FUN.
1043 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1044 is parms, TYPE is result. */
1047 get_fundef_copy (tree fun
)
1049 maybe_initialize_fundef_copies_table ();
1053 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1057 /* There is no cached function available, or in use. We can use
1058 the function directly. That the slot is now created records
1059 that this function is now in use. */
1060 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1061 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1063 else if (*slot
== NULL_TREE
)
1065 /* We've already used the function itself, so make a copy. */
1066 copy
= build_tree_list (NULL
, NULL
);
1067 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1071 /* We have a cached function available. */
1073 *slot
= TREE_CHAIN (copy
);
1079 /* Save the copy COPY of function FUN for later reuse by
1080 get_fundef_copy(). By construction, there will always be an entry
1084 save_fundef_copy (tree fun
, tree copy
)
1086 tree
*slot
= fundef_copies_table
->get (fun
);
1087 TREE_CHAIN (copy
) = *slot
;
1091 /* We have an expression tree T that represents a call, either CALL_EXPR
1092 or AGGR_INIT_EXPR. If the call is lexically to a named function,
1093 retrun the _DECL for that function. */
1096 get_function_named_in_call (tree t
)
1098 tree fun
= cp_get_callee (t
);
1099 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
1100 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
1101 fun
= TREE_OPERAND (fun
, 0);
1105 /* We have an expression tree T that represents a call, either CALL_EXPR
1106 or AGGR_INIT_EXPR. Return the Nth argument. */
1109 get_nth_callarg (tree t
, int n
)
1111 switch (TREE_CODE (t
))
1114 return CALL_EXPR_ARG (t
, n
);
1116 case AGGR_INIT_EXPR
:
1117 return AGGR_INIT_EXPR_ARG (t
, n
);
1125 /* Attempt to evaluate T which represents a call to a builtin function.
1126 We assume here that all builtin functions evaluate to scalar types
1127 represented by _CST nodes. */
1130 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1132 bool *non_constant_p
, bool *overflow_p
)
1134 const int nargs
= call_expr_nargs (t
);
1135 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1139 /* Don't fold __builtin_constant_p within a constexpr function. */
1140 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1143 && current_function_decl
1144 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1146 *non_constant_p
= true;
1150 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1151 return constant false for a non-constant argument. */
1152 constexpr_ctx new_ctx
= *ctx
;
1153 new_ctx
.quiet
= true;
1154 bool dummy1
= false, dummy2
= false;
1155 for (i
= 0; i
< nargs
; ++i
)
1157 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1158 false, &dummy1
, &dummy2
);
1160 /* For __built_in_constant_p, fold all expressions with constant values
1161 even if they aren't C++ constant-expressions. */
1162 args
[i
] = cp_fully_fold (args
[i
]);
1165 bool save_ffbcp
= force_folding_builtin_constant_p
;
1166 force_folding_builtin_constant_p
= true;
1167 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1168 CALL_EXPR_FN (t
), nargs
, args
);
1169 force_folding_builtin_constant_p
= save_ffbcp
;
1170 if (new_call
== NULL
)
1172 if (!*non_constant_p
&& !ctx
->quiet
)
1174 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1175 CALL_EXPR_FN (t
), nargs
, args
);
1176 error ("%q+E is not a constant expression", new_call
);
1178 *non_constant_p
= true;
1182 if (!potential_constant_expression (new_call
))
1184 if (!*non_constant_p
&& !ctx
->quiet
)
1185 error ("%q+E is not a constant expression", new_call
);
1186 *non_constant_p
= true;
1190 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1191 non_constant_p
, overflow_p
);
1194 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1195 the type of the value to match. */
1198 adjust_temp_type (tree type
, tree temp
)
1200 if (TREE_TYPE (temp
) == type
)
1202 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1203 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1204 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1205 gcc_assert (scalarish_type_p (type
));
1206 return cp_fold_convert (type
, temp
);
1209 /* Callback for walk_tree used by unshare_constructor. */
1212 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1216 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1221 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1222 subexpression, return an unshared copy of T. Otherwise return T. */
1225 unshare_constructor (tree t
)
1227 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1228 if (ctor
!= NULL_TREE
)
1229 return unshare_expr (t
);
1233 /* Subroutine of cxx_eval_call_expression.
1234 We are processing a call expression (either CALL_EXPR or
1235 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1236 all arguments and bind their values to correspondings
1237 parameters, making up the NEW_CALL context. */
1240 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1241 constexpr_call
*new_call
,
1242 bool *non_constant_p
, bool *overflow_p
,
1243 bool *non_constant_args
)
1245 const int nargs
= call_expr_nargs (t
);
1246 tree fun
= new_call
->fundef
->decl
;
1247 tree parms
= DECL_ARGUMENTS (fun
);
1249 tree
*p
= &new_call
->bindings
;
1250 for (i
= 0; i
< nargs
; ++i
)
1253 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1254 x
= get_nth_callarg (t
, i
);
1255 /* For member function, the first argument is a pointer to the implied
1256 object. For a constructor, it might still be a dummy object, in
1257 which case we get the real argument from ctx. */
1258 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1259 && is_dummy_object (x
))
1262 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1265 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1266 non_constant_p
, overflow_p
);
1267 /* Don't VERIFY_CONSTANT here. */
1268 if (*non_constant_p
&& ctx
->quiet
)
1270 /* Just discard ellipsis args after checking their constantitude. */
1274 if (!*non_constant_p
)
1276 /* Make sure the binding has the same type as the parm. But
1277 only for constant args. */
1278 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1279 arg
= adjust_temp_type (type
, arg
);
1280 if (!TREE_CONSTANT (arg
))
1281 *non_constant_args
= true;
1282 *p
= build_tree_list (parms
, arg
);
1283 p
= &TREE_CHAIN (*p
);
1285 parms
= TREE_CHAIN (parms
);
1289 /* Variables and functions to manage constexpr call expansion context.
1290 These do not need to be marked for PCH or GC. */
1292 /* FIXME remember and print actual constant arguments. */
1293 static vec
<tree
> call_stack
;
1294 static int call_stack_tick
;
1295 static int last_cx_error_tick
;
1298 push_cx_call_context (tree call
)
1301 if (!EXPR_HAS_LOCATION (call
))
1302 SET_EXPR_LOCATION (call
, input_location
);
1303 call_stack
.safe_push (call
);
1304 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1310 pop_cx_call_context (void)
1317 cx_error_context (void)
1319 vec
<tree
> r
= vNULL
;
1320 if (call_stack_tick
!= last_cx_error_tick
1321 && !call_stack
.is_empty ())
1323 last_cx_error_tick
= call_stack_tick
;
1327 /* Evaluate a call T to a GCC internal function when possible and return
1328 the evaluated result or, under the control of CTX, give an error, set
1329 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1332 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1334 bool *non_constant_p
, bool *overflow_p
)
1336 enum tree_code opcode
= ERROR_MARK
;
1338 switch (CALL_EXPR_IFN (t
))
1340 case IFN_UBSAN_NULL
:
1341 case IFN_UBSAN_BOUNDS
:
1342 case IFN_UBSAN_VPTR
:
1343 case IFN_FALLTHROUGH
:
1346 case IFN_ADD_OVERFLOW
:
1349 case IFN_SUB_OVERFLOW
:
1350 opcode
= MINUS_EXPR
;
1352 case IFN_MUL_OVERFLOW
:
1357 return cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0),
1358 false, non_constant_p
, overflow_p
);
1362 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1363 "call to internal function %qE", t
);
1364 *non_constant_p
= true;
1368 /* Evaluate constant arguments using OPCODE and return a complex
1369 number containing the result and the overflow bit. */
1370 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1371 non_constant_p
, overflow_p
);
1372 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1373 non_constant_p
, overflow_p
);
1375 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1377 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1378 tree type
= TREE_TYPE (TREE_TYPE (t
));
1379 tree result
= fold_binary_loc (loc
, opcode
, type
,
1380 fold_convert_loc (loc
, type
, arg0
),
1381 fold_convert_loc (loc
, type
, arg1
));
1383 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1384 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1385 if (TREE_OVERFLOW (result
))
1386 TREE_OVERFLOW (result
) = 0;
1388 return build_complex (TREE_TYPE (t
), result
, ovf
);
1391 *non_constant_p
= true;
1395 /* Subroutine of cxx_eval_constant_expression.
1396 Evaluate the call expression tree T in the context of OLD_CALL expression
1400 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1402 bool *non_constant_p
, bool *overflow_p
)
1404 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1405 tree fun
= get_function_named_in_call (t
);
1406 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1409 if (fun
== NULL_TREE
)
1410 return cxx_eval_internal_function (ctx
, t
, lval
,
1411 non_constant_p
, overflow_p
);
1413 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1415 /* Might be a constexpr function pointer. */
1416 fun
= cxx_eval_constant_expression (ctx
, fun
,
1417 /*lval*/false, non_constant_p
,
1420 if (TREE_CODE (fun
) == ADDR_EXPR
)
1421 fun
= TREE_OPERAND (fun
, 0);
1423 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1425 if (!ctx
->quiet
&& !*non_constant_p
)
1426 error_at (loc
, "expression %qE does not designate a constexpr "
1428 *non_constant_p
= true;
1431 if (DECL_CLONED_FUNCTION_P (fun
))
1432 fun
= DECL_CLONED_FUNCTION (fun
);
1434 if (is_ubsan_builtin_p (fun
))
1437 if (is_builtin_fn (fun
))
1438 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1439 lval
, non_constant_p
, overflow_p
);
1440 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1444 error_at (loc
, "call to non-constexpr function %qD", fun
);
1445 explain_invalid_constexpr_fn (fun
);
1447 *non_constant_p
= true;
1451 constexpr_ctx new_ctx
= *ctx
;
1452 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1453 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1455 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1456 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1457 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1458 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1459 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1460 ctx
->values
->put (new_ctx
.object
, ctor
);
1464 /* Shortcut trivial constructor/op=. */
1465 if (trivial_fn_p (fun
))
1467 tree init
= NULL_TREE
;
1468 if (call_expr_nargs (t
) == 2)
1469 init
= convert_from_reference (get_nth_callarg (t
, 1));
1470 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1471 && AGGR_INIT_ZERO_FIRST (t
))
1472 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1475 tree op
= get_nth_callarg (t
, 0);
1476 if (is_dummy_object (op
))
1479 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1480 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1481 return cxx_eval_constant_expression (ctx
, set
, lval
,
1482 non_constant_p
, overflow_p
);
1486 /* We can't defer instantiating the function any longer. */
1487 if (!DECL_INITIAL (fun
)
1488 && DECL_TEMPLOID_INSTANTIATION (fun
))
1490 location_t save_loc
= input_location
;
1491 input_location
= loc
;
1493 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1495 input_location
= save_loc
;
1498 /* If in direct recursive call, optimize definition search. */
1499 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1500 new_call
.fundef
= ctx
->call
->fundef
;
1503 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1504 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1505 || fun
== current_function_decl
)
1509 /* We need to check for current_function_decl here in case we're
1510 being called during cp_fold_function, because at that point
1511 DECL_INITIAL is set properly and we have a fundef but we
1512 haven't lowered invisirefs yet (c++/70344). */
1513 if (DECL_INITIAL (fun
) == error_mark_node
1514 || fun
== current_function_decl
)
1515 error_at (loc
, "%qD called in a constant expression before its "
1516 "definition is complete", fun
);
1517 else if (DECL_INITIAL (fun
))
1519 /* The definition of fun was somehow unsuitable. But pretend
1520 that lambda static thunks don't exist. */
1521 if (!lambda_static_thunk_p (fun
))
1522 error_at (loc
, "%qD called in a constant expression", fun
);
1523 explain_invalid_constexpr_fn (fun
);
1526 error_at (loc
, "%qD used before its definition", fun
);
1528 *non_constant_p
= true;
1533 bool non_constant_args
= false;
1534 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1535 non_constant_p
, overflow_p
, &non_constant_args
);
1536 if (*non_constant_p
)
1539 depth_ok
= push_cx_call_context (t
);
1541 tree result
= NULL_TREE
;
1543 constexpr_call
*entry
= NULL
;
1544 if (depth_ok
&& !non_constant_args
)
1546 new_call
.hash
= iterative_hash_template_arg
1547 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1549 /* If we have seen this call before, we are done. */
1550 maybe_initialize_constexpr_call_table ();
1551 constexpr_call
**slot
1552 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1556 /* We need to keep a pointer to the entry, not just the slot, as the
1557 slot can move in the call to cxx_eval_builtin_function_call. */
1558 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1561 /* Calls that are in progress have their result set to NULL,
1562 so that we can detect circular dependencies. */
1563 else if (entry
->result
== NULL
)
1566 error ("call has circular dependency");
1567 *non_constant_p
= true;
1568 entry
->result
= result
= error_mark_node
;
1571 result
= entry
->result
;
1577 error ("constexpr evaluation depth exceeds maximum of %d (use "
1578 "-fconstexpr-depth= to increase the maximum)",
1579 max_constexpr_depth
);
1580 *non_constant_p
= true;
1581 result
= error_mark_node
;
1585 if (result
&& result
!= error_mark_node
)
1587 else if (!DECL_SAVED_TREE (fun
))
1589 /* When at_eof >= 2, cgraph has started throwing away
1590 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1591 late code generation for VEC_INIT_EXPR, which needs to be
1592 completely reconsidered. */
1593 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1594 *non_constant_p
= true;
1598 tree body
, parms
, res
;
1600 /* Reuse or create a new unshared copy of this function's body. */
1601 tree copy
= get_fundef_copy (fun
);
1602 body
= TREE_PURPOSE (copy
);
1603 parms
= TREE_VALUE (copy
);
1604 res
= TREE_TYPE (copy
);
1606 /* Associate the bindings with the remapped parms. */
1607 tree bound
= new_call
.bindings
;
1608 tree remapped
= parms
;
1611 tree oparm
= TREE_PURPOSE (bound
);
1612 tree arg
= TREE_VALUE (bound
);
1613 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1614 /* Don't share a CONSTRUCTOR that might be changed. */
1615 arg
= unshare_constructor (arg
);
1616 ctx
->values
->put (remapped
, arg
);
1617 bound
= TREE_CHAIN (bound
);
1618 remapped
= DECL_CHAIN (remapped
);
1620 /* Add the RESULT_DECL to the values map, too. */
1621 tree slot
= NULL_TREE
;
1622 if (DECL_BY_REFERENCE (res
))
1624 slot
= AGGR_INIT_EXPR_SLOT (t
);
1625 tree addr
= build_address (slot
);
1626 addr
= build_nop (TREE_TYPE (res
), addr
);
1627 ctx
->values
->put (res
, addr
);
1628 ctx
->values
->put (slot
, NULL_TREE
);
1631 ctx
->values
->put (res
, NULL_TREE
);
1633 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1634 their values after the call. */
1635 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1636 hash_set
<tree
> save_exprs
;
1637 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1638 ctx_with_save_exprs
.call
= &new_call
;
1640 tree jump_target
= NULL_TREE
;
1641 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1642 lval
, non_constant_p
, overflow_p
,
1645 if (DECL_CONSTRUCTOR_P (fun
))
1646 /* This can be null for a subobject constructor call, in
1647 which case what we care about is the initialization
1648 side-effects rather than the value. We could get at the
1649 value by evaluating *this, but we don't bother; there's
1650 no need to put such a call in the hash table. */
1651 result
= lval
? ctx
->object
: ctx
->ctor
;
1652 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1656 result
= *ctx
->values
->get (slot
? slot
: res
);
1657 if (result
== NULL_TREE
&& !*non_constant_p
)
1660 error ("constexpr call flows off the end "
1662 *non_constant_p
= true;
1666 /* Forget the saved values of the callee's SAVE_EXPRs. */
1667 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1668 iter
!= save_exprs
.end(); ++iter
)
1669 ctx_with_save_exprs
.values
->remove (*iter
);
1671 /* Remove the parms/result from the values map. Is it worth
1672 bothering to do this when the map itself is only live for
1673 one constexpr evaluation? If so, maybe also clear out
1674 other vars from call, maybe in BIND_EXPR handling? */
1675 ctx
->values
->remove (res
);
1677 ctx
->values
->remove (slot
);
1678 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1679 ctx
->values
->remove (parm
);
1681 /* Make the unshared function copy we used available for re-use. */
1682 save_fundef_copy (fun
, copy
);
1685 if (result
== error_mark_node
)
1686 *non_constant_p
= true;
1687 if (*non_constant_p
|| *overflow_p
)
1688 result
= error_mark_node
;
1692 entry
->result
= result
;
1695 /* The result of a constexpr function must be completely initialized. */
1696 if (TREE_CODE (result
) == CONSTRUCTOR
)
1697 CONSTRUCTOR_NO_IMPLICIT_ZERO (result
) = false;
1699 pop_cx_call_context ();
1700 return unshare_constructor (result
);
1703 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1706 reduced_constant_expression_p (tree t
)
1708 switch (TREE_CODE (t
))
1711 /* Even if we can't lower this yet, it's constant. */
1715 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1716 tree elt
; unsigned HOST_WIDE_INT idx
;
1717 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1718 if (!reduced_constant_expression_p (elt
))
1723 /* FIXME are we calling this too much? */
1724 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1728 /* Some expressions may have constant operands but are not constant
1729 themselves, such as 1/0. Call this function (or rather, the macro
1730 following it) to check for that condition.
1732 We only call this in places that require an arithmetic constant, not in
1733 places where we might have a non-constant expression that can be a
1734 component of a constant expression, such as the address of a constexpr
1735 variable that might be dereferenced later. */
1738 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1741 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1743 if (!allow_non_constant
)
1744 error ("%q+E is not a constant expression", t
);
1745 *non_constant_p
= true;
1747 if (TREE_OVERFLOW_P (t
))
1749 if (!allow_non_constant
)
1751 permerror (input_location
, "overflow in constant expression");
1752 /* If we're being permissive (and are in an enforcing
1753 context), ignore the overflow. */
1754 if (flag_permissive
)
1755 return *non_constant_p
;
1759 return *non_constant_p
;
1762 /* Check whether the shift operation with code CODE and type TYPE on LHS
1763 and RHS is undefined. If it is, give an error with an explanation,
1764 and return true; return false otherwise. */
1767 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1768 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1770 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1771 || TREE_CODE (lhs
) != INTEGER_CST
1772 || TREE_CODE (rhs
) != INTEGER_CST
)
1775 tree lhstype
= TREE_TYPE (lhs
);
1776 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1778 /* [expr.shift] The behavior is undefined if the right operand
1779 is negative, or greater than or equal to the length in bits
1780 of the promoted left operand. */
1781 if (tree_int_cst_sgn (rhs
) == -1)
1784 permerror (loc
, "right operand of shift expression %q+E is negative",
1785 build2_loc (loc
, code
, type
, lhs
, rhs
));
1786 return (!flag_permissive
|| ctx
->quiet
);
1788 if (compare_tree_int (rhs
, uprec
) >= 0)
1791 permerror (loc
, "right operand of shift expression %q+E is >= than "
1792 "the precision of the left operand",
1793 build2_loc (loc
, code
, type
, lhs
, rhs
));
1794 return (!flag_permissive
|| ctx
->quiet
);
1797 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1798 if E1 has a signed type and non-negative value, and E1x2^E2 is
1799 representable in the corresponding unsigned type of the result type,
1800 then that value, converted to the result type, is the resulting value;
1801 otherwise, the behavior is undefined. */
1802 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1803 && (cxx_dialect
>= cxx11
))
1805 if (tree_int_cst_sgn (lhs
) == -1)
1809 "left operand of shift expression %q+E is negative",
1810 build2_loc (loc
, code
, type
, lhs
, rhs
));
1811 return (!flag_permissive
|| ctx
->quiet
);
1813 /* For signed x << y the following:
1814 (unsigned) x >> ((prec (lhs) - 1) - y)
1815 if > 1, is undefined. The right-hand side of this formula
1816 is the highest bit of the LHS that can be set (starting from 0),
1817 so that the shift doesn't overflow. We then right-shift the LHS
1818 to see whether any other bit is set making the original shift
1819 undefined -- the result is not representable in the corresponding
1821 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1822 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1823 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1824 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1825 if (tree_int_cst_lt (integer_one_node
, t
))
1828 permerror (loc
, "shift expression %q+E overflows",
1829 build2_loc (loc
, code
, type
, lhs
, rhs
));
1830 return (!flag_permissive
|| ctx
->quiet
);
1836 /* Subroutine of cxx_eval_constant_expression.
1837 Attempt to reduce the unary expression tree T to a compile time value.
1838 If successful, return the value. Otherwise issue a diagnostic
1839 and return error_mark_node. */
1842 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1844 bool *non_constant_p
, bool *overflow_p
)
1847 tree orig_arg
= TREE_OPERAND (t
, 0);
1848 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1849 non_constant_p
, overflow_p
);
1850 VERIFY_CONSTANT (arg
);
1851 location_t loc
= EXPR_LOCATION (t
);
1852 enum tree_code code
= TREE_CODE (t
);
1853 tree type
= TREE_TYPE (t
);
1854 r
= fold_unary_loc (loc
, code
, type
, arg
);
1857 if (arg
== orig_arg
)
1860 r
= build1_loc (loc
, code
, type
, arg
);
1862 VERIFY_CONSTANT (r
);
1866 /* Helper function for cxx_eval_binary_expression. Try to optimize
1867 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1868 generic folding should be used. */
1871 cxx_fold_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
1872 tree lhs
, tree rhs
, bool *non_constant_p
,
1876 if (TREE_CODE (lhs
) != ADDR_EXPR
)
1879 lhs
= TREE_OPERAND (lhs
, 0);
1881 /* &A[i] p+ j => &A[i + j] */
1882 if (TREE_CODE (lhs
) == ARRAY_REF
1883 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
1884 && TREE_CODE (rhs
) == INTEGER_CST
1885 && TYPE_SIZE_UNIT (TREE_TYPE (lhs
))
1886 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1888 tree orig_type
= TREE_TYPE (t
);
1889 location_t loc
= EXPR_LOCATION (t
);
1890 tree type
= TREE_TYPE (lhs
);
1892 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (lhs
, 1));
1893 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs
, 0)));
1894 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
1896 if (*non_constant_p
)
1898 /* Don't fold an out-of-bound access. */
1899 if (!tree_int_cst_le (t
, nelts
))
1901 rhs
= cp_fold_convert (ssizetype
, rhs
);
1902 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1903 constexpr int A[1]; ... (char *)&A[0] + 1 */
1904 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
1905 rhs
, TYPE_SIZE_UNIT (type
))))
1907 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1909 rhs
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, rhs
,
1910 TYPE_SIZE_UNIT (type
));
1911 t
= size_binop_loc (loc
, PLUS_EXPR
, rhs
, t
);
1912 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (lhs
, 0),
1913 t
, NULL_TREE
, NULL_TREE
);
1914 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
1915 t
= cp_fold_convert (orig_type
, t
);
1916 return cxx_eval_constant_expression (ctx
, t
, /*lval*/false,
1917 non_constant_p
, overflow_p
);
1923 /* Subroutine of cxx_eval_constant_expression.
1924 Like cxx_eval_unary_expression, except for binary expressions. */
1927 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1929 bool *non_constant_p
, bool *overflow_p
)
1932 tree orig_lhs
= TREE_OPERAND (t
, 0);
1933 tree orig_rhs
= TREE_OPERAND (t
, 1);
1935 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1936 non_constant_p
, overflow_p
);
1937 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
1939 if (*non_constant_p
)
1941 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1942 non_constant_p
, overflow_p
);
1943 if (*non_constant_p
)
1946 location_t loc
= EXPR_LOCATION (t
);
1947 enum tree_code code
= TREE_CODE (t
);
1948 tree type
= TREE_TYPE (t
);
1950 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
1952 bool is_code_eq
= (code
== EQ_EXPR
);
1954 if (TREE_CODE (lhs
) == PTRMEM_CST
1955 && TREE_CODE (rhs
) == PTRMEM_CST
)
1956 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
1958 else if ((TREE_CODE (lhs
) == PTRMEM_CST
1959 || TREE_CODE (rhs
) == PTRMEM_CST
)
1960 && (null_member_pointer_value_p (lhs
)
1961 || null_member_pointer_value_p (rhs
)))
1962 r
= constant_boolean_node (!is_code_eq
, type
);
1963 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
1964 lhs
= cplus_expand_constant (lhs
);
1965 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
1966 rhs
= cplus_expand_constant (rhs
);
1968 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
1969 && integer_zerop (lhs
) && !integer_zerop (rhs
))
1972 error ("arithmetic involving a null pointer in %qE", lhs
);
1975 else if (code
== POINTER_PLUS_EXPR
)
1976 r
= cxx_fold_pointer_plus_expression (ctx
, t
, lhs
, rhs
, non_constant_p
,
1980 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1984 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1987 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1989 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1990 *non_constant_p
= true;
1991 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1992 a local array in a constexpr function. */
1993 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1995 VERIFY_CONSTANT (r
);
1999 /* Subroutine of cxx_eval_constant_expression.
2000 Attempt to evaluate condition expressions. Dead branches are not
2004 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
2006 bool *non_constant_p
, bool *overflow_p
,
2009 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2011 non_constant_p
, overflow_p
);
2012 VERIFY_CONSTANT (val
);
2013 /* Don't VERIFY_CONSTANT the other operands. */
2014 if (integer_zerop (val
))
2015 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
2017 non_constant_p
, overflow_p
,
2019 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2021 non_constant_p
, overflow_p
,
2025 /* Returns less than, equal to, or greater than zero if KEY is found to be
2026 less than, to match, or to be greater than the constructor_elt's INDEX. */
2029 array_index_cmp (tree key
, tree index
)
2031 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
2033 switch (TREE_CODE (index
))
2036 return tree_int_cst_compare (key
, index
);
2039 tree lo
= TREE_OPERAND (index
, 0);
2040 tree hi
= TREE_OPERAND (index
, 1);
2041 if (tree_int_cst_lt (key
, lo
))
2043 else if (tree_int_cst_lt (hi
, key
))
2053 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2054 if none. If INSERT is true, insert a matching element rather than fail. */
2056 static HOST_WIDE_INT
2057 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
2059 if (tree_int_cst_sgn (dindex
) < 0)
2062 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
2063 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
2064 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
2066 unsigned HOST_WIDE_INT end
= len
;
2067 unsigned HOST_WIDE_INT begin
= 0;
2069 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2070 that the same is true of the other elements and index directly. */
2073 tree cindex
= (*elts
)[end
-1].index
;
2074 if (TREE_CODE (cindex
) == INTEGER_CST
2075 && compare_tree_int (cindex
, end
-1) == 0)
2084 /* Otherwise, find a matching index by means of a binary search. */
2085 while (begin
!= end
)
2087 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
2088 constructor_elt
&elt
= (*elts
)[middle
];
2089 tree idx
= elt
.index
;
2091 int cmp
= array_index_cmp (dindex
, idx
);
2098 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
2100 /* We need to split the range. */
2102 tree lo
= TREE_OPERAND (idx
, 0);
2103 tree hi
= TREE_OPERAND (idx
, 1);
2104 if (tree_int_cst_lt (lo
, dindex
))
2106 /* There are still some lower elts; shorten the range. */
2107 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
2109 if (tree_int_cst_equal (lo
, new_hi
))
2110 /* Only one element left, no longer a range. */
2113 TREE_OPERAND (idx
, 1) = new_hi
;
2114 /* Append the element we want to insert. */
2117 e
.value
= unshare_constructor (elt
.value
);
2118 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2121 /* No lower elts, the range elt is now ours. */
2124 if (tree_int_cst_lt (dindex
, hi
))
2126 /* There are still some higher elts; append a range. */
2127 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2129 if (tree_int_cst_equal (new_lo
, hi
))
2132 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2133 e
.value
= unshare_constructor (elt
.value
);
2134 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2143 constructor_elt e
= { dindex
, NULL_TREE
};
2144 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2151 /* Under the control of CTX, issue a detailed diagnostic for
2152 an out-of-bounds subscript INDEX into the expression ARRAY. */
2155 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2159 tree arraytype
= TREE_TYPE (array
);
2161 /* Convert the unsigned array subscript to a signed integer to avoid
2162 printing huge numbers for small negative values. */
2163 tree sidx
= fold_convert (ssizetype
, index
);
2166 error ("array subscript value %qE is outside the bounds "
2167 "of array %qD of type %qT", sidx
, array
, arraytype
);
2168 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2171 error ("array subscript value %qE is outside the bounds "
2172 "of array type %qT", sidx
, arraytype
);
2176 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2177 STRING_CST STRING. */
2180 extract_string_elt (tree string
, unsigned chars_per_elt
, unsigned index
)
2182 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (string
)));
2185 if (chars_per_elt
== 1)
2186 r
= build_int_cst (type
, TREE_STRING_POINTER (string
)[index
]);
2189 const unsigned char *ptr
2190 = ((const unsigned char *)TREE_STRING_POINTER (string
)
2191 + index
* chars_per_elt
);
2192 r
= native_interpret_expr (type
, ptr
, chars_per_elt
);
2197 /* Subroutine of cxx_eval_constant_expression.
2198 Attempt to reduce a reference to an array slot. */
2201 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2203 bool *non_constant_p
, bool *overflow_p
)
2205 tree oldary
= TREE_OPERAND (t
, 0);
2206 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2208 non_constant_p
, overflow_p
);
2210 HOST_WIDE_INT i
= 0;
2211 tree elem_type
= NULL_TREE
;
2212 unsigned len
= 0, elem_nchars
= 1;
2213 if (*non_constant_p
)
2215 oldidx
= TREE_OPERAND (t
, 1);
2216 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2218 non_constant_p
, overflow_p
);
2219 VERIFY_CONSTANT (index
);
2222 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2223 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2224 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2225 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2226 ary
= TREE_OPERAND (ary
, 0);
2227 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2228 len
= CONSTRUCTOR_NELTS (ary
);
2229 else if (TREE_CODE (ary
) == STRING_CST
)
2231 elem_nchars
= (TYPE_PRECISION (elem_type
)
2232 / TYPE_PRECISION (char_type_node
));
2233 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2235 else if (TREE_CODE (ary
) == VECTOR_CST
)
2236 len
= VECTOR_CST_NELTS (ary
);
2239 /* We can't do anything with other tree codes, so use
2240 VERIFY_CONSTANT to complain and fail. */
2241 VERIFY_CONSTANT (ary
);
2245 if (!tree_fits_shwi_p (index
)
2246 || (i
= tree_to_shwi (index
)) < 0)
2248 diag_array_subscript (ctx
, ary
, index
);
2249 *non_constant_p
= true;
2255 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2256 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2257 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2258 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2262 /* For VLAs, the number of elements won't be an integer constant. */
2263 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2265 VERIFY_CONSTANT (nelts
);
2267 ? !tree_int_cst_le (index
, nelts
)
2268 : !tree_int_cst_lt (index
, nelts
))
2269 || tree_int_cst_sgn (index
) < 0)
2271 diag_array_subscript (ctx
, ary
, index
);
2272 *non_constant_p
= true;
2276 if (lval
&& ary
== oldary
&& index
== oldidx
)
2279 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2282 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2284 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2295 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2296 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2297 else if (TREE_CODE (ary
) == VECTOR_CST
)
2298 r
= VECTOR_CST_ELT (ary
, i
);
2300 r
= extract_string_elt (ary
, elem_nchars
, i
);
2303 /* Don't VERIFY_CONSTANT here. */
2306 /* Otherwise the element doesn't have a value yet. */
2311 if (TREE_CODE (ary
) == CONSTRUCTOR
2312 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2314 /* 'ary' is part of the aggregate initializer we're currently
2315 building; if there's no initializer for this element yet,
2318 error ("accessing uninitialized array element");
2319 *non_constant_p
= true;
2323 /* If it's within the array bounds but doesn't have an explicit
2324 initializer, it's value-initialized. */
2325 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2326 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2330 /* Subroutine of cxx_eval_constant_expression.
2331 Attempt to reduce a field access of a value of class type. */
2334 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2336 bool *non_constant_p
, bool *overflow_p
)
2338 unsigned HOST_WIDE_INT i
;
2341 tree part
= TREE_OPERAND (t
, 1);
2342 tree orig_whole
= TREE_OPERAND (t
, 0);
2343 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2345 non_constant_p
, overflow_p
);
2346 if (TREE_CODE (whole
) == INDIRECT_REF
2347 && integer_zerop (TREE_OPERAND (whole
, 0))
2349 error ("dereferencing a null pointer in %qE", orig_whole
);
2351 if (TREE_CODE (whole
) == PTRMEM_CST
)
2352 whole
= cplus_expand_constant (whole
);
2353 if (whole
== orig_whole
)
2356 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2357 whole
, part
, NULL_TREE
);
2358 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2360 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2363 error ("%qE is not a constant expression", orig_whole
);
2364 *non_constant_p
= true;
2366 if (DECL_MUTABLE_P (part
))
2369 error ("mutable %qD is not usable in a constant expression", part
);
2370 *non_constant_p
= true;
2372 if (*non_constant_p
)
2374 bool pmf
= TYPE_PTRMEMFUNC_P (TREE_TYPE (whole
));
2375 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2377 /* Use name match for PMF fields, as a variant will have a
2378 different FIELD_DECL with a different type. */
2379 if (pmf
? DECL_NAME (field
) == DECL_NAME (part
)
2385 /* We're in the middle of initializing it. */
2389 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2390 && CONSTRUCTOR_NELTS (whole
) > 0)
2392 /* DR 1188 says we don't have to deal with this. */
2394 error ("accessing %qD member instead of initialized %qD member in "
2395 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2396 *non_constant_p
= true;
2400 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2401 classes never get represented; throw together a value now. */
2402 if (is_really_empty_class (TREE_TYPE (t
)))
2403 return build_constructor (TREE_TYPE (t
), NULL
);
2405 gcc_assert (DECL_CONTEXT (part
) == TYPE_MAIN_VARIANT (TREE_TYPE (whole
)));
2407 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2409 /* 'whole' is part of the aggregate initializer we're currently
2410 building; if there's no initializer for this member yet, that's an
2413 error ("accessing uninitialized member %qD", part
);
2414 *non_constant_p
= true;
2418 /* If there's no explicit init for this field, it's value-initialized. */
2419 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2420 return cxx_eval_constant_expression (ctx
, value
,
2422 non_constant_p
, overflow_p
);
2425 /* Subroutine of cxx_eval_constant_expression.
2426 Attempt to reduce a field access of a value of class type that is
2427 expressed as a BIT_FIELD_REF. */
2430 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2432 bool *non_constant_p
, bool *overflow_p
)
2434 tree orig_whole
= TREE_OPERAND (t
, 0);
2435 tree retval
, fldval
, utype
, mask
;
2436 bool fld_seen
= false;
2437 HOST_WIDE_INT istart
, isize
;
2438 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2440 non_constant_p
, overflow_p
);
2441 tree start
, field
, value
;
2442 unsigned HOST_WIDE_INT i
;
2444 if (whole
== orig_whole
)
2446 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2448 if (!*non_constant_p
2449 && TREE_CODE (whole
) != VECTOR_CST
2450 && TREE_CODE (whole
) != CONSTRUCTOR
)
2453 error ("%qE is not a constant expression", orig_whole
);
2454 *non_constant_p
= true;
2456 if (*non_constant_p
)
2459 if (TREE_CODE (whole
) == VECTOR_CST
)
2460 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2461 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2463 start
= TREE_OPERAND (t
, 2);
2464 istart
= tree_to_shwi (start
);
2465 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2466 utype
= TREE_TYPE (t
);
2467 if (!TYPE_UNSIGNED (utype
))
2468 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2469 retval
= build_int_cst (utype
, 0);
2470 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2472 tree bitpos
= bit_position (field
);
2473 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2475 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2476 && TREE_CODE (value
) == INTEGER_CST
2477 && tree_fits_shwi_p (bitpos
)
2478 && tree_fits_shwi_p (DECL_SIZE (field
)))
2480 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2481 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2482 HOST_WIDE_INT shift
;
2483 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2485 fldval
= fold_convert (utype
, value
);
2486 mask
= build_int_cst_type (utype
, -1);
2487 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2488 size_int (TYPE_PRECISION (utype
) - sz
));
2489 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2490 size_int (TYPE_PRECISION (utype
) - sz
));
2491 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2492 shift
= bit
- istart
;
2493 if (BYTES_BIG_ENDIAN
)
2494 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2495 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2497 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2503 return fold_convert (TREE_TYPE (t
), retval
);
2505 return error_mark_node
;
2508 /* Subroutine of cxx_eval_constant_expression.
2509 Evaluate a short-circuited logical expression T in the context
2510 of a given constexpr CALL. BAILOUT_VALUE is the value for
2511 early return. CONTINUE_VALUE is used here purely for
2512 sanity check purposes. */
2515 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2516 tree bailout_value
, tree continue_value
,
2518 bool *non_constant_p
, bool *overflow_p
)
2521 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2523 non_constant_p
, overflow_p
);
2524 VERIFY_CONSTANT (lhs
);
2525 if (tree_int_cst_equal (lhs
, bailout_value
))
2527 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2528 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2529 lval
, non_constant_p
,
2531 VERIFY_CONSTANT (r
);
2535 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2536 CONSTRUCTOR elements to initialize (part of) an object containing that
2537 field. Return a pointer to the constructor_elt corresponding to the
2538 initialization of the field. */
2540 static constructor_elt
*
2541 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2543 tree aggr
= TREE_OPERAND (ref
, 0);
2544 tree field
= TREE_OPERAND (ref
, 1);
2546 constructor_elt
*ce
;
2548 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2550 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2552 constructor_elt
*base_ce
2553 = base_field_constructor_elt (v
, aggr
);
2554 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2557 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2558 if (ce
->index
== field
)
2565 /* Some of the expressions fed to the constexpr mechanism are calls to
2566 constructors, which have type void. In that case, return the type being
2567 initialized by the constructor. */
2570 initialized_type (tree t
)
2574 tree type
= cv_unqualified (TREE_TYPE (t
));
2575 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2577 /* A constructor call has void type, so we need to look deeper. */
2578 tree fn
= get_function_named_in_call (t
);
2579 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2580 && DECL_CXX_CONSTRUCTOR_P (fn
))
2581 type
= DECL_CONTEXT (fn
);
2586 /* We're about to initialize element INDEX of an array or class from VALUE.
2587 Set up NEW_CTX appropriately by adjusting .object to refer to the
2588 subobject and creating a new CONSTRUCTOR if the element is itself
2589 a class or array. */
2592 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2593 tree index
, tree
&value
)
2597 if (index
&& TREE_CODE (index
) != INTEGER_CST
2598 && TREE_CODE (index
) != FIELD_DECL
)
2599 /* This won't have an element in the new CONSTRUCTOR. */
2602 tree type
= initialized_type (value
);
2603 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2604 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2607 /* The sub-aggregate initializer might contain a placeholder;
2608 update object to refer to the subobject and ctor to refer to
2609 the (newly created) sub-initializer. */
2611 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2612 tree elt
= build_constructor (type
, NULL
);
2613 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2616 if (TREE_CODE (value
) == TARGET_EXPR
)
2617 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2618 value
= TARGET_EXPR_INITIAL (value
);
2621 /* We're about to process an initializer for a class or array TYPE. Make
2622 sure that CTX is set up appropriately. */
2625 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2627 /* We don't bother building a ctor for an empty base subobject. */
2628 if (is_empty_class (type
))
2631 /* We're in the middle of an initializer that might involve placeholders;
2632 our caller should have created a CONSTRUCTOR for us to put the
2633 initializer into. We will either return that constructor or T. */
2634 gcc_assert (ctx
->ctor
);
2635 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2636 (type
, TREE_TYPE (ctx
->ctor
)));
2637 /* We used to check that ctx->ctor was empty, but that isn't the case when
2638 the object is zero-initialized before calling the constructor. */
2640 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2641 (type
, TREE_TYPE (ctx
->object
)));
2642 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2643 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2646 /* Subroutine of cxx_eval_constant_expression.
2647 The expression tree T denotes a C-style array or a C-style
2648 aggregate. Reduce it to a constant expression. */
2651 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2653 bool *non_constant_p
, bool *overflow_p
)
2655 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2656 bool changed
= false;
2657 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2658 tree type
= TREE_TYPE (t
);
2660 constexpr_ctx new_ctx
;
2661 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2663 /* We don't really need the ctx->ctor business for a PMF or
2664 vector, but it's simpler to use the same code. */
2666 new_ctx
.ctor
= build_constructor (type
, NULL
);
2667 new_ctx
.object
= NULL_TREE
;
2670 verify_ctor_sanity (ctx
, type
);
2671 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2672 vec_alloc (*p
, vec_safe_length (v
));
2676 bool constant_p
= true;
2677 bool side_effects_p
= false;
2678 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2680 tree orig_value
= value
;
2681 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2682 if (new_ctx
.ctor
!= ctx
->ctor
)
2683 /* If we built a new CONSTRUCTOR, attach it now so that other
2684 initializers can refer to it. */
2685 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2686 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2688 non_constant_p
, overflow_p
);
2689 /* Don't VERIFY_CONSTANT here. */
2690 if (ctx
->quiet
&& *non_constant_p
)
2692 if (elt
!= orig_value
)
2695 if (!TREE_CONSTANT (elt
))
2697 if (TREE_SIDE_EFFECTS (elt
))
2698 side_effects_p
= true;
2699 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2701 /* This is an initialization of a vfield inside a base
2702 subaggregate that we already initialized; push this
2703 initialization into the previous initialization. */
2704 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2709 && (TREE_CODE (index
) == NOP_EXPR
2710 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2712 /* This is an initializer for an empty base; now that we've
2713 checked that it's constant, we can ignore it. */
2714 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2717 else if (new_ctx
.ctor
!= ctx
->ctor
)
2719 /* We appended this element above; update the value. */
2720 gcc_assert ((*p
)->last().index
== index
);
2721 (*p
)->last().value
= elt
;
2724 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2726 if (*non_constant_p
|| !changed
)
2729 /* We're done building this CONSTRUCTOR, so now we can interpret an
2730 element without an explicit initializer as value-initialized. */
2731 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2732 TREE_CONSTANT (t
) = constant_p
;
2733 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2734 if (VECTOR_TYPE_P (type
))
2739 /* Subroutine of cxx_eval_constant_expression.
2740 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2741 initialization of a non-static data member of array type. Reduce it to a
2744 Note that apart from value-initialization (when VALUE_INIT is true),
2745 this is only intended to support value-initialization and the
2746 initializations done by defaulted constructors for classes with
2747 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2748 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2749 for the copy/move constructor. */
2752 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2753 bool value_init
, bool lval
,
2754 bool *non_constant_p
, bool *overflow_p
)
2756 tree elttype
= TREE_TYPE (atype
);
2757 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2758 verify_ctor_sanity (ctx
, atype
);
2759 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2760 vec_alloc (*p
, max
+ 1);
2761 bool pre_init
= false;
2762 unsigned HOST_WIDE_INT i
;
2764 /* For the default constructor, build up a call to the default
2765 constructor of the element type. We only need to handle class types
2766 here, as for a constructor to be constexpr, all members must be
2767 initialized, which for a defaulted default constructor means they must
2768 be of a class type with a constexpr default constructor. */
2769 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2770 /* We only do this at the lowest level. */;
2771 else if (value_init
)
2773 init
= build_value_init (elttype
, tf_warning_or_error
);
2778 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2779 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2780 &argvec
, elttype
, LOOKUP_NORMAL
,
2781 tf_warning_or_error
);
2782 release_tree_vector (argvec
);
2783 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2787 for (i
= 0; i
< max
; ++i
)
2789 tree idx
= build_int_cst (size_type_node
, i
);
2792 constexpr_ctx new_ctx
;
2793 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2794 if (new_ctx
.ctor
!= ctx
->ctor
)
2795 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2796 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2798 /* A multidimensional array; recurse. */
2799 if (value_init
|| init
== NULL_TREE
)
2801 eltinit
= NULL_TREE
;
2805 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2806 tf_warning_or_error
);
2807 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2809 non_constant_p
, overflow_p
);
2813 /* Initializing an element using value or default initialization
2814 we just pre-built above. */
2815 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2816 non_constant_p
, overflow_p
);
2821 /* Copying an element. */
2822 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2823 (atype
, TREE_TYPE (init
)));
2824 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2825 tf_warning_or_error
);
2826 if (!lvalue_p (init
))
2827 eltinit
= move (eltinit
);
2828 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2829 eltinit
= (cxx_eval_constant_expression
2830 (&new_ctx
, eltinit
, lval
,
2831 non_constant_p
, overflow_p
));
2833 if (*non_constant_p
&& !ctx
->quiet
)
2835 if (new_ctx
.ctor
!= ctx
->ctor
)
2837 /* We appended this element above; update the value. */
2838 gcc_assert ((*p
)->last().index
== idx
);
2839 (*p
)->last().value
= eltinit
;
2842 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2843 /* Reuse the result of cxx_eval_constant_expression call
2844 from the first iteration to all others if it is a constant
2845 initializer that doesn't require relocations. */
2848 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2849 == null_pointer_node
))
2851 if (new_ctx
.ctor
!= ctx
->ctor
)
2852 eltinit
= new_ctx
.ctor
;
2853 for (i
= 1; i
< max
; ++i
)
2855 idx
= build_int_cst (size_type_node
, i
);
2856 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2862 if (!*non_constant_p
)
2865 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2871 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2873 bool *non_constant_p
, bool *overflow_p
)
2875 tree atype
= TREE_TYPE (t
);
2876 tree init
= VEC_INIT_EXPR_INIT (t
);
2877 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2878 VEC_INIT_EXPR_VALUE_INIT (t
),
2879 lval
, non_constant_p
, overflow_p
);
2880 if (*non_constant_p
)
2886 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2887 match. We want to be less strict for simple *& folding; if we have a
2888 non-const temporary that we access through a const pointer, that should
2889 work. We handle this here rather than change fold_indirect_ref_1
2890 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2891 don't really make sense outside of constant expression evaluation. Also
2892 we want to allow folding to COMPONENT_REF, which could cause trouble
2893 with TBAA in fold_indirect_ref_1.
2895 Try to keep this function synced with fold_indirect_ref_1. */
2898 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2904 subtype
= TREE_TYPE (sub
);
2905 if (!POINTER_TYPE_P (subtype
))
2908 if (TREE_CODE (sub
) == ADDR_EXPR
)
2910 tree op
= TREE_OPERAND (sub
, 0);
2911 tree optype
= TREE_TYPE (op
);
2913 /* *&CONST_DECL -> to the value of the const decl. */
2914 if (TREE_CODE (op
) == CONST_DECL
)
2915 return DECL_INITIAL (op
);
2916 /* *&p => p; make sure to handle *&"str"[cst] here. */
2917 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2918 /* Also handle the case where the desired type is an array of unknown
2919 bounds because the variable has had its bounds deduced since the
2920 ADDR_EXPR was created. */
2921 || (TREE_CODE (type
) == ARRAY_TYPE
2922 && TREE_CODE (optype
) == ARRAY_TYPE
2923 && TYPE_DOMAIN (type
) == NULL_TREE
2924 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
2927 tree fop
= fold_read_from_constant_string (op
);
2933 /* *(foo *)&fooarray => fooarray[0] */
2934 else if (TREE_CODE (optype
) == ARRAY_TYPE
2935 && (same_type_ignoring_top_level_qualifiers_p
2936 (type
, TREE_TYPE (optype
))))
2938 tree type_domain
= TYPE_DOMAIN (optype
);
2939 tree min_val
= size_zero_node
;
2940 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2941 min_val
= TYPE_MIN_VALUE (type_domain
);
2942 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2943 NULL_TREE
, NULL_TREE
);
2945 /* *(foo *)&complexfoo => __real__ complexfoo */
2946 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2947 && (same_type_ignoring_top_level_qualifiers_p
2948 (type
, TREE_TYPE (optype
))))
2949 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2950 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2951 else if (VECTOR_TYPE_P (optype
)
2952 && (same_type_ignoring_top_level_qualifiers_p
2953 (type
, TREE_TYPE (optype
))))
2955 tree part_width
= TYPE_SIZE (type
);
2956 tree index
= bitsize_int (0);
2957 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2959 /* Also handle conversion to an empty base class, which
2960 is represented with a NOP_EXPR. */
2961 else if (is_empty_class (type
)
2962 && CLASS_TYPE_P (optype
)
2963 && DERIVED_FROM_P (type
, optype
))
2968 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2969 else if (RECORD_OR_UNION_TYPE_P (optype
))
2971 tree field
= TYPE_FIELDS (optype
);
2972 for (; field
; field
= DECL_CHAIN (field
))
2973 if (TREE_CODE (field
) == FIELD_DECL
2974 && TREE_TYPE (field
) != error_mark_node
2975 && integer_zerop (byte_position (field
))
2976 && (same_type_ignoring_top_level_qualifiers_p
2977 (TREE_TYPE (field
), type
)))
2978 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2981 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2982 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2984 tree op00
= TREE_OPERAND (sub
, 0);
2985 tree op01
= TREE_OPERAND (sub
, 1);
2988 if (TREE_CODE (op00
) == ADDR_EXPR
)
2991 op00
= TREE_OPERAND (op00
, 0);
2992 op00type
= TREE_TYPE (op00
);
2994 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2995 if (VECTOR_TYPE_P (op00type
)
2996 && (same_type_ignoring_top_level_qualifiers_p
2997 (type
, TREE_TYPE (op00type
))))
2999 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
3000 tree part_width
= TYPE_SIZE (type
);
3001 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
3002 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
3003 tree index
= bitsize_int (indexi
);
3005 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
3006 return fold_build3_loc (loc
,
3007 BIT_FIELD_REF
, type
, op00
,
3011 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3012 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
3013 && (same_type_ignoring_top_level_qualifiers_p
3014 (type
, TREE_TYPE (op00type
))))
3016 tree size
= TYPE_SIZE_UNIT (type
);
3017 if (tree_int_cst_equal (size
, op01
))
3018 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
3020 /* ((foo *)&fooarray)[1] => fooarray[1] */
3021 else if (TREE_CODE (op00type
) == ARRAY_TYPE
3022 && (same_type_ignoring_top_level_qualifiers_p
3023 (type
, TREE_TYPE (op00type
))))
3025 tree type_domain
= TYPE_DOMAIN (op00type
);
3026 tree min_val
= size_zero_node
;
3027 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3028 min_val
= TYPE_MIN_VALUE (type_domain
);
3029 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
3030 TYPE_SIZE_UNIT (type
));
3031 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
3032 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
3033 NULL_TREE
, NULL_TREE
);
3035 /* Also handle conversion to an empty base class, which
3036 is represented with a NOP_EXPR. */
3037 else if (is_empty_class (type
)
3038 && CLASS_TYPE_P (op00type
)
3039 && DERIVED_FROM_P (type
, op00type
))
3044 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3045 else if (RECORD_OR_UNION_TYPE_P (op00type
))
3047 tree field
= TYPE_FIELDS (op00type
);
3048 for (; field
; field
= DECL_CHAIN (field
))
3049 if (TREE_CODE (field
) == FIELD_DECL
3050 && TREE_TYPE (field
) != error_mark_node
3051 && tree_int_cst_equal (byte_position (field
), op01
)
3052 && (same_type_ignoring_top_level_qualifiers_p
3053 (TREE_TYPE (field
), type
)))
3054 return fold_build3 (COMPONENT_REF
, type
, op00
,
3059 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3060 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
3061 && (same_type_ignoring_top_level_qualifiers_p
3062 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
3065 tree min_val
= size_zero_node
;
3066 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
3070 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
3071 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
3072 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
3073 min_val
= TYPE_MIN_VALUE (type_domain
);
3074 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
3082 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
3084 bool *non_constant_p
, bool *overflow_p
)
3086 tree orig_op0
= TREE_OPERAND (t
, 0);
3087 bool empty_base
= false;
3089 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3090 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3092 if (TREE_CODE (t
) == MEM_REF
3093 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
3095 gcc_assert (ctx
->quiet
);
3096 *non_constant_p
= true;
3100 /* First try to simplify it directly. */
3101 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
3105 /* If that didn't work, evaluate the operand first. */
3106 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
3107 /*lval*/false, non_constant_p
,
3109 /* Don't VERIFY_CONSTANT here. */
3110 if (*non_constant_p
)
3113 if (!lval
&& integer_zerop (op0
))
3116 error ("dereferencing a null pointer");
3117 *non_constant_p
= true;
3121 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
3125 /* We couldn't fold to a constant value. Make sure it's not
3126 something we should have been able to fold. */
3129 if (TREE_CODE (sub
) == ADDR_EXPR
)
3131 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3132 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3133 /* DR 1188 says we don't have to deal with this. */
3135 error ("accessing value of %qE through a %qT glvalue in a "
3136 "constant expression", build_fold_indirect_ref (sub
),
3138 *non_constant_p
= true;
3142 if (lval
&& op0
!= orig_op0
)
3143 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3145 VERIFY_CONSTANT (t
);
3150 r
= cxx_eval_constant_expression (ctx
, r
,
3151 lval
, non_constant_p
, overflow_p
);
3152 if (*non_constant_p
)
3155 /* If we're pulling out the value of an empty base, make sure
3156 that the whole object is constant and then return an empty
3158 if (empty_base
&& !lval
)
3160 VERIFY_CONSTANT (r
);
3161 r
= build_constructor (TREE_TYPE (t
), NULL
);
3162 TREE_CONSTANT (r
) = true;
3168 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3169 Shared between potential_constant_expression and
3170 cxx_eval_constant_expression. */
3173 non_const_var_error (tree r
)
3175 tree type
= TREE_TYPE (r
);
3176 error ("the value of %qD is not usable in a constant "
3178 /* Avoid error cascade. */
3179 if (DECL_INITIAL (r
) == error_mark_node
)
3181 if (DECL_DECLARED_CONSTEXPR_P (r
))
3182 inform (DECL_SOURCE_LOCATION (r
),
3183 "%qD used in its own initializer", r
);
3184 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3186 if (!CP_TYPE_CONST_P (type
))
3187 inform (DECL_SOURCE_LOCATION (r
),
3188 "%q#D is not const", r
);
3189 else if (CP_TYPE_VOLATILE_P (type
))
3190 inform (DECL_SOURCE_LOCATION (r
),
3191 "%q#D is volatile", r
);
3192 else if (!DECL_INITIAL (r
)
3193 || !TREE_CONSTANT (DECL_INITIAL (r
))
3194 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3195 inform (DECL_SOURCE_LOCATION (r
),
3196 "%qD was not initialized with a constant "
3201 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
3202 inform (DECL_SOURCE_LOCATION (r
),
3203 "%qD was not initialized with a constant "
3207 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3208 inform (DECL_SOURCE_LOCATION (r
),
3209 "%qD was not declared %<constexpr%>", r
);
3211 inform (DECL_SOURCE_LOCATION (r
),
3212 "%qD does not have integral or enumeration type",
3217 /* Subroutine of cxx_eval_constant_expression.
3218 Like cxx_eval_unary_expression, except for trinary expressions. */
3221 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3223 bool *non_constant_p
, bool *overflow_p
)
3229 for (i
= 0; i
< 3; i
++)
3231 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3233 non_constant_p
, overflow_p
);
3234 VERIFY_CONSTANT (args
[i
]);
3237 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3238 args
[0], args
[1], args
[2]);
3239 if (val
== NULL_TREE
)
3241 VERIFY_CONSTANT (val
);
3245 /* True if T was declared in a function declared to be constexpr, and
3246 therefore potentially constant in C++14. */
3249 var_in_constexpr_fn (tree t
)
3251 tree ctx
= DECL_CONTEXT (t
);
3252 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3253 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3256 /* True if T was declared in a function that might be constexpr: either a
3257 function that was declared constexpr, or a C++17 lambda op(). */
3260 var_in_maybe_constexpr_fn (tree t
)
3262 if (cxx_dialect
>= cxx1z
3263 && DECL_FUNCTION_SCOPE_P (t
)
3264 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3266 return var_in_constexpr_fn (t
);
3269 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3270 build_over_call we implement trivial copy of a class with tail padding using
3271 assignment of character arrays, which is valid in normal code, but not in
3272 constexpr evaluation. We don't need to worry about clobbering tail padding
3273 in constexpr evaluation, so strip the type punning. */
3276 maybe_simplify_trivial_copy (tree
&target
, tree
&init
)
3278 if (TREE_CODE (target
) == MEM_REF
3279 && TREE_CODE (init
) == MEM_REF
3280 && TREE_TYPE (target
) == TREE_TYPE (init
)
3281 && TREE_CODE (TREE_TYPE (target
)) == ARRAY_TYPE
3282 && TREE_TYPE (TREE_TYPE (target
)) == unsigned_char_type_node
)
3284 target
= build_fold_indirect_ref (TREE_OPERAND (target
, 0));
3285 init
= build_fold_indirect_ref (TREE_OPERAND (init
, 0));
3289 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3292 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3294 bool *non_constant_p
, bool *overflow_p
)
3296 constexpr_ctx new_ctx
= *ctx
;
3298 tree init
= TREE_OPERAND (t
, 1);
3299 if (TREE_CLOBBER_P (init
))
3300 /* Just ignore clobbers. */
3303 /* First we figure out where we're storing to. */
3304 tree target
= TREE_OPERAND (t
, 0);
3306 maybe_simplify_trivial_copy (target
, init
);
3308 tree type
= TREE_TYPE (target
);
3309 target
= cxx_eval_constant_expression (ctx
, target
,
3311 non_constant_p
, overflow_p
);
3312 if (*non_constant_p
)
3315 /* cxx_eval_array_reference for lval = true allows references one past
3316 end of array, because it does not know if it is just taking address
3317 (which is valid), or actual dereference. Here we know it is
3318 a dereference, so diagnose it here. */
3319 for (tree probe
= target
; probe
; )
3321 switch (TREE_CODE (probe
))
3325 ary
= TREE_OPERAND (probe
, 0);
3326 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
3327 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
3328 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
3329 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
3332 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false,
3333 non_constant_p
, overflow_p
);
3334 VERIFY_CONSTANT (nelts
);
3335 gcc_assert (TREE_CODE (nelts
) == INTEGER_CST
3336 && TREE_CODE (TREE_OPERAND (probe
, 1)) == INTEGER_CST
);
3337 if (wi::eq_p (TREE_OPERAND (probe
, 1), nelts
))
3339 diag_array_subscript (ctx
, ary
, TREE_OPERAND (probe
, 1));
3340 *non_constant_p
= true;
3347 probe
= TREE_OPERAND (probe
, 0);
3356 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3358 /* For initialization of an empty base, the original target will be
3359 *(base*)this, which the above evaluation resolves to the object
3360 argument, which has the derived type rather than the base type. In
3361 this situation, just evaluate the initializer and return, since
3362 there's no actual data to store. */
3363 gcc_assert (is_empty_class (type
));
3364 return cxx_eval_constant_expression (ctx
, init
, false,
3365 non_constant_p
, overflow_p
);
3368 /* And then find the underlying variable. */
3369 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3370 tree object
= NULL_TREE
;
3371 for (tree probe
= target
; object
== NULL_TREE
; )
3373 switch (TREE_CODE (probe
))
3378 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3379 vec_safe_push (refs
, TREE_TYPE (probe
));
3380 probe
= TREE_OPERAND (probe
, 0);
3388 /* And then find/build up our initializer for the path to the subobject
3389 we're initializing. */
3391 if (object
== ctx
->object
&& VAR_P (object
)
3392 && DECL_NAME (object
) && ctx
->call
== NULL
)
3393 /* The variable we're building up an aggregate initializer for is outside
3394 the constant-expression, so don't evaluate the store. We check
3395 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3397 else if (DECL_P (object
))
3398 valp
= ctx
->values
->get (object
);
3403 /* A constant-expression cannot modify objects from outside the
3404 constant-expression. */
3406 error ("modification of %qE is not a constant expression", object
);
3407 *non_constant_p
= true;
3410 type
= TREE_TYPE (object
);
3411 bool no_zero_init
= true;
3413 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3414 while (!refs
->is_empty())
3416 if (*valp
== NULL_TREE
)
3418 *valp
= build_constructor (type
, NULL
);
3419 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3421 else if (TREE_CODE (*valp
) == STRING_CST
)
3423 /* An array was initialized with a string constant, and now
3424 we're writing into one of its elements. Explode the
3425 single initialization into a set of element
3427 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3429 tree string
= *valp
;
3430 tree elt_type
= TREE_TYPE (type
);
3431 unsigned chars_per_elt
= (TYPE_PRECISION (elt_type
)
3432 / TYPE_PRECISION (char_type_node
));
3433 unsigned num_elts
= TREE_STRING_LENGTH (string
) / chars_per_elt
;
3434 tree ary_ctor
= build_constructor (type
, NULL
);
3436 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor
), num_elts
);
3437 for (unsigned ix
= 0; ix
!= num_elts
; ix
++)
3439 constructor_elt elt
=
3441 build_int_cst (size_type_node
, ix
),
3442 extract_string_elt (string
, chars_per_elt
, ix
)
3444 CONSTRUCTOR_ELTS (ary_ctor
)->quick_push (elt
);
3450 /* If the value of object is already zero-initialized, any new ctors for
3451 subobjects will also be zero-initialized. */
3452 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3454 vec_safe_push (ctors
, *valp
);
3456 enum tree_code code
= TREE_CODE (type
);
3458 tree index
= refs
->pop();
3460 constructor_elt
*cep
= NULL
;
3461 if (code
== ARRAY_TYPE
)
3464 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3465 gcc_assert (i
>= 0);
3466 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3467 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3471 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3473 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3474 Usually we meet initializers in that order, but it is
3475 possible for base types to be placed not in program
3477 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3478 unsigned HOST_WIDE_INT idx
;
3480 if (code
== UNION_TYPE
&& CONSTRUCTOR_NELTS (*valp
)
3481 && CONSTRUCTOR_ELT (*valp
, 0)->index
!= index
)
3482 /* Changing active member. */
3483 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp
), 0);
3486 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3487 idx
++, fields
= DECL_CHAIN (fields
))
3489 if (index
== cep
->index
)
3492 /* The field we're initializing must be on the field
3493 list. Look to see if it is present before the
3494 field the current ELT initializes. */
3495 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3496 if (index
== fields
)
3500 /* We fell off the end of the CONSTRUCTOR, so insert a new
3501 entry at the end. */
3504 constructor_elt ce
= { index
, NULL_TREE
};
3506 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3507 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3513 release_tree_vector (refs
);
3515 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3517 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3518 wants to modify it. */
3519 if (*valp
== NULL_TREE
)
3521 *valp
= build_constructor (type
, NULL
);
3522 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3524 else if (TREE_CODE (*valp
) == PTRMEM_CST
)
3525 *valp
= cplus_expand_constant (*valp
);
3526 new_ctx
.ctor
= *valp
;
3527 new_ctx
.object
= target
;
3530 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3531 non_constant_p
, overflow_p
);
3532 /* Don't share a CONSTRUCTOR that might be changed later. */
3533 init
= unshare_constructor (init
);
3534 if (target
== object
)
3535 /* The hash table might have moved since the get earlier. */
3536 valp
= ctx
->values
->get (object
);
3538 if (TREE_CODE (init
) == CONSTRUCTOR
)
3540 /* An outer ctx->ctor might be pointing to *valp, so replace
3542 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3543 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3544 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3545 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3546 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3551 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3552 CONSTRUCTORs, if any. */
3555 bool c
= TREE_CONSTANT (init
);
3556 bool s
= TREE_SIDE_EFFECTS (init
);
3558 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3561 TREE_CONSTANT (elt
) = false;
3563 TREE_SIDE_EFFECTS (elt
) = true;
3565 release_tree_vector (ctors
);
3567 if (*non_constant_p
)
3575 /* Evaluate a ++ or -- expression. */
3578 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3580 bool *non_constant_p
, bool *overflow_p
)
3582 enum tree_code code
= TREE_CODE (t
);
3583 tree type
= TREE_TYPE (t
);
3584 tree op
= TREE_OPERAND (t
, 0);
3585 tree offset
= TREE_OPERAND (t
, 1);
3586 gcc_assert (TREE_CONSTANT (offset
));
3588 /* The operand as an lvalue. */
3589 op
= cxx_eval_constant_expression (ctx
, op
, true,
3590 non_constant_p
, overflow_p
);
3592 /* The operand as an rvalue. */
3593 tree val
= rvalue (op
);
3594 val
= cxx_eval_constant_expression (ctx
, val
, false,
3595 non_constant_p
, overflow_p
);
3596 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3597 a local array in a constexpr function. */
3598 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3600 VERIFY_CONSTANT (val
);
3602 /* The modified value. */
3603 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3605 if (POINTER_TYPE_P (type
))
3607 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3608 offset
= convert_to_ptrofftype (offset
);
3610 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3611 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3614 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3616 VERIFY_CONSTANT (mod
);
3618 /* Storing the modified value. */
3619 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3620 cxx_eval_constant_expression (ctx
, store
,
3621 true, non_constant_p
, overflow_p
);
3623 /* And the value of the expression. */
3624 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3626 /* Prefix ops are lvalues. */
3630 /* But we optimize when the caller wants an rvalue. */
3634 /* Postfix ops are rvalues. */
3638 /* Predicates for the meaning of *jump_target. */
3641 returns (tree
*jump_target
)
3644 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
3648 breaks (tree
*jump_target
)
3651 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3652 && LABEL_DECL_BREAK (*jump_target
))
3653 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3657 continues (tree
*jump_target
)
3660 && TREE_CODE (*jump_target
) == LABEL_DECL
3661 && LABEL_DECL_CONTINUE (*jump_target
);
3665 switches (tree
*jump_target
)
3668 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3671 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3672 STMT matches *jump_target. If we're looking for a case label and we see
3673 the default label, note it in ctx->css_state. */
3676 label_matches (const constexpr_ctx
*ctx
, tree
*jump_target
, tree stmt
)
3678 switch (TREE_CODE (*jump_target
))
3681 if (TREE_CODE (stmt
) == LABEL_EXPR
3682 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3687 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3689 gcc_assert (ctx
->css_state
!= NULL
);
3690 if (!CASE_LOW (stmt
))
3692 /* default: should appear just once in a SWITCH_EXPR
3693 body (excluding nested SWITCH_EXPR). */
3694 gcc_assert (*ctx
->css_state
!= css_default_seen
);
3695 /* When evaluating SWITCH_EXPR body for the second time,
3696 return true for the default: label. */
3697 if (*ctx
->css_state
== css_default_processing
)
3699 *ctx
->css_state
= css_default_seen
;
3701 else if (CASE_HIGH (stmt
))
3703 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3704 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3707 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3718 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3719 semantics, for switch, break, continue, and return. */
3722 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3723 bool *non_constant_p
, bool *overflow_p
,
3726 tree_stmt_iterator i
;
3728 /* In a statement-expression we want to return the last value.
3729 For empty statement expression return void_node. */
3733 local_target
= NULL_TREE
;
3734 jump_target
= &local_target
;
3736 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3738 tree stmt
= tsi_stmt (i
);
3739 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3740 non_constant_p
, overflow_p
,
3742 if (*non_constant_p
)
3744 if (returns (jump_target
) || breaks (jump_target
))
3750 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3751 semantics; continue semantics are covered by cxx_eval_statement_list. */
3754 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3755 bool *non_constant_p
, bool *overflow_p
,
3758 constexpr_ctx new_ctx
= *ctx
;
3760 tree body
= TREE_OPERAND (t
, 0);
3764 hash_set
<tree
> save_exprs
;
3765 new_ctx
.save_exprs
= &save_exprs
;
3767 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3768 non_constant_p
, overflow_p
, jump_target
);
3770 /* Forget saved values of SAVE_EXPRs. */
3771 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3772 iter
!= save_exprs
.end(); ++iter
)
3773 new_ctx
.values
->remove (*iter
);
3774 if (++count
>= constexpr_loop_limit
)
3777 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3778 "constexpr loop iteration count exceeds limit of %d "
3779 "(use -fconstexpr-loop-limit= to increase the limit)",
3780 constexpr_loop_limit
);
3781 *non_constant_p
= true;
3785 while (!returns (jump_target
)
3786 && !breaks (jump_target
)
3787 && !switches (jump_target
)
3788 && !*non_constant_p
);
3790 if (breaks (jump_target
))
3791 *jump_target
= NULL_TREE
;
3796 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3800 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3801 bool *non_constant_p
, bool *overflow_p
,
3804 tree cond
= TREE_OPERAND (t
, 0);
3805 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3806 non_constant_p
, overflow_p
);
3807 VERIFY_CONSTANT (cond
);
3808 *jump_target
= cond
;
3810 tree body
= TREE_OPERAND (t
, 1);
3811 constexpr_ctx new_ctx
= *ctx
;
3812 constexpr_switch_state css
= css_default_not_seen
;
3813 new_ctx
.css_state
= &css
;
3814 cxx_eval_constant_expression (&new_ctx
, body
, false,
3815 non_constant_p
, overflow_p
, jump_target
);
3816 if (switches (jump_target
) && css
== css_default_seen
)
3818 /* If the SWITCH_EXPR body has default: label, process it once again,
3819 this time instructing label_matches to return true for default:
3820 label on switches (jump_target). */
3821 css
= css_default_processing
;
3822 cxx_eval_constant_expression (&new_ctx
, body
, false,
3823 non_constant_p
, overflow_p
, jump_target
);
3825 if (breaks (jump_target
) || switches (jump_target
))
3826 *jump_target
= NULL_TREE
;
3830 /* Attempt to reduce the expression T to a constant value.
3831 On failure, issue diagnostic and return error_mark_node. */
3832 /* FIXME unify with c_fully_fold */
3833 /* FIXME overflow_p is too global */
3836 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3838 bool *non_constant_p
, bool *overflow_p
,
3841 constexpr_ctx new_ctx
;
3844 if (jump_target
&& *jump_target
)
3846 /* If we are jumping, ignore all statements/expressions except those
3847 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
3848 switch (TREE_CODE (t
))
3851 case STATEMENT_LIST
:
3856 case CASE_LABEL_EXPR
:
3857 if (label_matches (ctx
, jump_target
, t
))
3859 *jump_target
= NULL_TREE
;
3865 if (t
== error_mark_node
)
3867 *non_constant_p
= true;
3870 if (CONSTANT_CLASS_P (t
))
3872 if (TREE_OVERFLOW (t
))
3875 permerror (input_location
, "overflow in constant expression");
3876 if (!flag_permissive
|| ctx
->quiet
)
3880 if (TREE_CODE (t
) == INTEGER_CST
3881 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
3882 && !integer_zerop (t
))
3885 error ("value %qE of type %qT is not a constant expression",
3887 *non_constant_p
= true;
3893 tree_code tcode
= TREE_CODE (t
);
3899 /* We ask for an rvalue for the RESULT_DECL when indirecting
3900 through an invisible reference, or in named return value
3902 return (*ctx
->values
->get (t
));
3905 if (DECL_HAS_VALUE_EXPR_P (t
))
3906 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
3907 lval
, non_constant_p
, overflow_p
);
3910 /* We used to not check lval for CONST_DECL, but darwin.c uses
3911 CONST_DECL for aggregate constants. */
3914 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
3915 && is_really_empty_class (TREE_TYPE (t
)))
3917 /* If the class is empty, we aren't actually loading anything. */
3918 r
= build_constructor (TREE_TYPE (t
), NULL
);
3919 TREE_CONSTANT (r
) = true;
3921 else if (ctx
->strict
)
3922 r
= decl_really_constant_value (t
);
3924 r
= decl_constant_value (t
);
3925 if (TREE_CODE (r
) == TARGET_EXPR
3926 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3927 r
= TARGET_EXPR_INITIAL (r
);
3929 if (tree
*p
= ctx
->values
->get (r
))
3930 if (*p
!= NULL_TREE
)
3935 non_const_var_error (r
);
3936 *non_constant_p
= true;
3944 case CASE_LABEL_EXPR
:
3949 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
3951 else if (tree
*p
= ctx
->values
->get (r
))
3954 /* Defer in case this is only used for its type. */;
3955 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3956 /* Defer, there's no lvalue->rvalue conversion. */;
3957 else if (COMPLETE_TYPE_P (TREE_TYPE (t
))
3958 && is_really_empty_class (TREE_TYPE (t
)))
3960 /* If the class is empty, we aren't actually loading anything. */
3961 r
= build_constructor (TREE_TYPE (t
), NULL
);
3962 TREE_CONSTANT (r
) = true;
3967 error ("%qE is not a constant expression", t
);
3968 *non_constant_p
= true;
3973 case AGGR_INIT_EXPR
:
3974 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3975 non_constant_p
, overflow_p
);
3980 r
= DECL_EXPR_DECL (t
);
3981 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3982 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3986 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3987 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3988 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3992 if (tree init
= DECL_INITIAL (r
))
3994 init
= cxx_eval_constant_expression (ctx
, init
,
3996 non_constant_p
, overflow_p
);
3997 /* Don't share a CONSTRUCTOR that might be changed. */
3998 init
= unshare_constructor (init
);
3999 ctx
->values
->put (r
, init
);
4001 else if (ctx
== &new_ctx
)
4002 /* We gave it a CONSTRUCTOR above. */;
4004 ctx
->values
->put (r
, NULL_TREE
);
4009 if (!literal_type_p (TREE_TYPE (t
)))
4013 error ("temporary of non-literal type %qT in a "
4014 "constant expression", TREE_TYPE (t
));
4015 explain_non_literal_class (TREE_TYPE (t
));
4017 *non_constant_p
= true;
4020 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
4022 /* We're being expanded without an explicit target, so start
4023 initializing a new object; expansion with an explicit target
4024 strips the TARGET_EXPR before we get here. */
4026 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
4027 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
4028 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
4029 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
4032 /* Pass false for 'lval' because this indicates
4033 initialization of a temporary. */
4034 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4036 non_constant_p
, overflow_p
);
4037 if (!*non_constant_p
)
4038 /* Adjust the type of the result to the type of the temporary. */
4039 r
= adjust_temp_type (TREE_TYPE (t
), r
);
4042 tree slot
= TARGET_EXPR_SLOT (t
);
4043 r
= unshare_constructor (r
);
4044 ctx
->values
->put (slot
, r
);
4051 gcc_assert (jump_target
== NULL
|| *jump_target
== NULL_TREE
);
4052 r
= cxx_eval_store_expression (ctx
, t
, lval
,
4053 non_constant_p
, overflow_p
);
4057 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4059 non_constant_p
, overflow_p
);
4063 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
4064 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4066 non_constant_p
, overflow_p
);
4071 /* Avoid evaluating a SAVE_EXPR more than once. */
4072 if (tree
*p
= ctx
->values
->get (t
))
4076 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
4077 non_constant_p
, overflow_p
);
4078 ctx
->values
->put (t
, r
);
4079 if (ctx
->save_exprs
)
4080 ctx
->save_exprs
->add (t
);
4084 case NON_LVALUE_EXPR
:
4085 case TRY_CATCH_EXPR
:
4087 case CLEANUP_POINT_EXPR
:
4088 case MUST_NOT_THROW_EXPR
:
4091 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4093 non_constant_p
, overflow_p
,
4097 case TRY_FINALLY_EXPR
:
4098 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4099 non_constant_p
, overflow_p
,
4101 if (!*non_constant_p
)
4102 /* Also evaluate the cleanup. */
4103 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
4104 non_constant_p
, overflow_p
,
4108 /* These differ from cxx_eval_unary_expression in that this doesn't
4109 check for a constant operand or result; an address can be
4110 constant without its operand being, and vice versa. */
4113 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
4114 non_constant_p
, overflow_p
);
4119 tree oldop
= TREE_OPERAND (t
, 0);
4120 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4122 non_constant_p
, overflow_p
);
4123 /* Don't VERIFY_CONSTANT here. */
4124 if (*non_constant_p
)
4126 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
4127 /* This function does more aggressive folding than fold itself. */
4128 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
4129 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
4138 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
4139 non_constant_p
, overflow_p
);
4140 if (r
== error_mark_node
)
4142 else if (r
== TREE_OPERAND (t
, 0))
4145 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
4150 case FIX_TRUNC_EXPR
:
4155 case TRUTH_NOT_EXPR
:
4156 case FIXED_CONVERT_EXPR
:
4157 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
4158 non_constant_p
, overflow_p
);
4162 r
= fold_sizeof_expr (t
);
4163 VERIFY_CONSTANT (r
);
4168 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4169 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4170 introduced by build_call_a. */
4171 tree op0
= TREE_OPERAND (t
, 0);
4172 tree op1
= TREE_OPERAND (t
, 1);
4174 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4175 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4176 r
= cxx_eval_constant_expression (ctx
, op0
,
4177 lval
, non_constant_p
, overflow_p
,
4181 /* Check that the LHS is constant and then discard it. */
4182 cxx_eval_constant_expression (ctx
, op0
,
4183 true, non_constant_p
, overflow_p
,
4185 if (*non_constant_p
)
4187 op1
= TREE_OPERAND (t
, 1);
4188 r
= cxx_eval_constant_expression (ctx
, op1
,
4189 lval
, non_constant_p
, overflow_p
,
4195 case POINTER_PLUS_EXPR
:
4199 case TRUNC_DIV_EXPR
:
4201 case FLOOR_DIV_EXPR
:
4202 case ROUND_DIV_EXPR
:
4203 case TRUNC_MOD_EXPR
:
4205 case ROUND_MOD_EXPR
:
4207 case EXACT_DIV_EXPR
:
4217 case TRUTH_XOR_EXPR
:
4224 case UNORDERED_EXPR
:
4234 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4235 non_constant_p
, overflow_p
);
4238 /* fold can introduce non-IF versions of these; still treat them as
4239 short-circuiting. */
4240 case TRUTH_AND_EXPR
:
4241 case TRUTH_ANDIF_EXPR
:
4242 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4245 non_constant_p
, overflow_p
);
4249 case TRUTH_ORIF_EXPR
:
4250 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4253 non_constant_p
, overflow_p
);
4257 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4258 non_constant_p
, overflow_p
);
4262 if (is_overloaded_fn (t
))
4264 /* We can only get here in checking mode via
4265 build_non_dependent_expr, because any expression that
4266 calls or takes the address of the function will have
4267 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4268 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4269 *non_constant_p
= true;
4272 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4273 non_constant_p
, overflow_p
);
4277 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4278 non_constant_p
, overflow_p
);
4282 if (jump_target
&& *jump_target
)
4284 /* When jumping to a label, the label might be either in the
4285 then or else blocks, so process then block first in skipping
4286 mode first, and if we are still in the skipping mode at its end,
4287 process the else block too. */
4288 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
4289 lval
, non_constant_p
, overflow_p
,
4292 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
4293 lval
, non_constant_p
, overflow_p
,
4299 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4300 non_constant_p
, overflow_p
,
4305 if (TREE_CONSTANT (t
))
4307 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4308 VECTOR_CST if applicable. */
4309 /* FIXME after GCC 6 branches, make the verify unconditional. */
4311 verify_constructor_flags (t
);
4313 recompute_constructor_flags (t
);
4314 if (TREE_CONSTANT (t
))
4317 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4318 non_constant_p
, overflow_p
);
4322 /* We can get this in a defaulted constructor for a class with a
4323 non-static data member of array type. Either the initializer will
4324 be NULL, meaning default-initialization, or it will be an lvalue
4325 or xvalue of the same type, meaning direct-initialization from the
4326 corresponding member. */
4327 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4328 non_constant_p
, overflow_p
);
4333 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4334 non_constant_p
, overflow_p
);
4338 case VIEW_CONVERT_EXPR
:
4340 case UNARY_PLUS_EXPR
:
4342 tree oldop
= TREE_OPERAND (t
, 0);
4344 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4346 non_constant_p
, overflow_p
);
4347 if (*non_constant_p
)
4349 tree type
= TREE_TYPE (t
);
4350 if (TREE_CODE (op
) == PTRMEM_CST
4351 && !TYPE_PTRMEM_P (type
))
4352 op
= cplus_expand_constant (op
);
4353 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4355 if (same_type_ignoring_top_level_qualifiers_p (type
,
4357 return cp_fold_convert (type
, op
);
4361 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4362 "a reinterpret_cast is not a constant expression");
4363 *non_constant_p
= true;
4368 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4370 if (integer_zerop (op
))
4372 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4375 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4376 "dereferencing a null pointer");
4377 *non_constant_p
= true;
4380 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4382 tree from
= TREE_TYPE (op
);
4384 if (!can_convert (type
, from
, tf_none
))
4387 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4388 "conversion of %qT null pointer to %qT "
4389 "is not a constant expression",
4391 *non_constant_p
= true;
4398 /* This detects for example:
4399 reinterpret_cast<void*>(sizeof 0)
4402 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4403 "%<reinterpret_cast<%T>(%E)%> is not "
4404 "a constant expression",
4406 *non_constant_p
= true;
4410 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4411 /* We didn't fold at the top so we could check for ptr-int
4414 if (tcode
== UNARY_PLUS_EXPR
)
4415 r
= fold_convert (TREE_TYPE (t
), op
);
4417 r
= fold_build1 (tcode
, type
, op
);
4418 /* Conversion of an out-of-range value has implementation-defined
4419 behavior; the language considers it different from arithmetic
4420 overflow, which is undefined. */
4421 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4422 TREE_OVERFLOW (r
) = false;
4426 case EMPTY_CLASS_EXPR
:
4427 /* This is good enough for a function argument that might not get
4428 used, and they can't do anything with it, so just return it. */
4431 case STATEMENT_LIST
:
4433 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4434 return cxx_eval_statement_list (&new_ctx
, t
,
4435 non_constant_p
, overflow_p
, jump_target
);
4438 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4440 non_constant_p
, overflow_p
,
4443 case PREINCREMENT_EXPR
:
4444 case POSTINCREMENT_EXPR
:
4445 case PREDECREMENT_EXPR
:
4446 case POSTDECREMENT_EXPR
:
4447 return cxx_eval_increment_expression (ctx
, t
,
4448 lval
, non_constant_p
, overflow_p
);
4454 case VEC_DELETE_EXPR
:
4457 /* GCC internal stuff. */
4460 case WITH_CLEANUP_EXPR
:
4461 case NON_DEPENDENT_EXPR
:
4465 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4466 "expression %qE is not a constant expression", t
);
4467 *non_constant_p
= true;
4470 case PLACEHOLDER_EXPR
:
4471 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
)
4472 || !(same_type_ignoring_top_level_qualifiers_p
4473 (TREE_TYPE (t
), TREE_TYPE (ctx
->ctor
))))
4475 /* A placeholder without a referent. We can get here when
4476 checking whether NSDMIs are noexcept, or in massage_init_elt;
4477 just say it's non-constant for now. */
4478 gcc_assert (ctx
->quiet
);
4479 *non_constant_p
= true;
4484 /* Use of the value or address of the current object. We could
4485 use ctx->object unconditionally, but using ctx->ctor when we
4486 can is a minor optimization. */
4487 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
4488 return cxx_eval_constant_expression
4490 non_constant_p
, overflow_p
);
4496 tree cond
= TREE_OPERAND (t
, 0);
4497 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4498 non_constant_p
, overflow_p
);
4499 VERIFY_CONSTANT (cond
);
4500 if (integer_nonzerop (cond
))
4506 *jump_target
= TREE_OPERAND (t
, 0);
4507 gcc_assert (breaks (jump_target
) || continues (jump_target
));
4511 cxx_eval_loop_expr (ctx
, t
,
4512 non_constant_p
, overflow_p
, jump_target
);
4516 cxx_eval_switch_expr (ctx
, t
,
4517 non_constant_p
, overflow_p
, jump_target
);
4521 /* It's possible to get a requires-expression in a constant
4522 expression. For example:
4524 template<typename T> concept bool C() {
4525 return requires (T t) { t; };
4528 template<typename T> requires !C<T>() void f(T);
4530 Normalization leaves f with the associated constraint
4531 '!requires (T t) { ... }' which is not transformed into
4533 if (!processing_template_decl
)
4534 return evaluate_constraint_expression (t
, NULL_TREE
);
4536 *non_constant_p
= true;
4540 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
4541 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
4543 non_constant_p
, overflow_p
,
4548 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4550 /* This function doesn't know how to deal with pre-genericize
4551 statements; this can only happen with statement-expressions,
4552 so for now just fail. */
4554 error_at (EXPR_LOCATION (t
),
4555 "statement is not a constant expression");
4558 internal_error ("unexpected expression %qE of kind %s", t
,
4559 get_tree_code_name (TREE_CODE (t
)));
4560 *non_constant_p
= true;
4564 if (r
== error_mark_node
)
4565 *non_constant_p
= true;
4567 if (*non_constant_p
)
4574 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4575 bool strict
= true, tree object
= NULL_TREE
)
4577 bool non_constant_p
= false;
4578 bool overflow_p
= false;
4579 hash_map
<tree
,tree
> map
;
4581 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
,
4582 allow_non_constant
, strict
};
4584 tree type
= initialized_type (t
);
4586 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4588 /* In C++14 an NSDMI can participate in aggregate initialization,
4589 and can refer to the address of the object being initialized, so
4590 we need to pass in the relevant VAR_DECL if we want to do the
4591 evaluation in a single pass. The evaluation will dynamically
4592 update ctx.values for the VAR_DECL. We use the same strategy
4593 for C++11 constexpr constructors that refer to the object being
4595 ctx
.ctor
= build_constructor (type
, NULL
);
4596 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4599 if (TREE_CODE (t
) == TARGET_EXPR
)
4600 object
= TARGET_EXPR_SLOT (t
);
4601 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4602 object
= AGGR_INIT_EXPR_SLOT (t
);
4604 ctx
.object
= object
;
4606 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4607 (type
, TREE_TYPE (object
)));
4608 if (object
&& DECL_P (object
))
4609 map
.put (object
, ctx
.ctor
);
4610 if (TREE_CODE (r
) == TARGET_EXPR
)
4611 /* Avoid creating another CONSTRUCTOR when we expand the
4613 r
= TARGET_EXPR_INITIAL (r
);
4616 r
= cxx_eval_constant_expression (&ctx
, r
,
4617 false, &non_constant_p
, &overflow_p
);
4619 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4621 /* Mutable logic is a bit tricky: we want to allow initialization of
4622 constexpr variables with mutable members, but we can't copy those
4623 members to another constexpr variable. */
4624 if (TREE_CODE (r
) == CONSTRUCTOR
4625 && CONSTRUCTOR_MUTABLE_POISON (r
))
4627 if (!allow_non_constant
)
4628 error ("%qE is not a constant expression because it refers to "
4629 "mutable subobjects of %qT", t
, type
);
4630 non_constant_p
= true;
4633 if (TREE_CODE (r
) == CONSTRUCTOR
4634 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r
))
4636 if (!allow_non_constant
)
4637 error ("%qE is not a constant expression because it refers to "
4638 "an incompletely initialized variable", t
);
4639 TREE_CONSTANT (r
) = false;
4640 non_constant_p
= true;
4643 /* Technically we should check this for all subexpressions, but that
4644 runs into problems with our internal representation of pointer
4645 subtraction and the 5.19 rules are still in flux. */
4646 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4647 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4648 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4650 if (!allow_non_constant
)
4651 error ("conversion from pointer type %qT "
4652 "to arithmetic type %qT in a constant expression",
4653 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4654 non_constant_p
= true;
4657 if (!non_constant_p
&& overflow_p
)
4658 non_constant_p
= true;
4660 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4662 bool should_unshare
= true;
4663 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4664 should_unshare
= false;
4666 if (non_constant_p
&& !allow_non_constant
)
4667 return error_mark_node
;
4668 else if (non_constant_p
&& TREE_CONSTANT (r
))
4670 /* This isn't actually constant, so unset TREE_CONSTANT. */
4673 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4674 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4676 r
= build_nop (TREE_TYPE (r
), r
);
4677 TREE_CONSTANT (r
) = false;
4679 else if (non_constant_p
|| r
== t
)
4683 r
= unshare_expr (r
);
4685 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4687 if (TREE_CODE (t
) == TARGET_EXPR
4688 && TARGET_EXPR_INITIAL (t
) == r
)
4692 r
= get_target_expr (r
);
4693 TREE_CONSTANT (r
) = true;
4701 /* Returns true if T is a valid subexpression of a constant expression,
4702 even if it isn't itself a constant expression. */
4705 is_sub_constant_expr (tree t
)
4707 bool non_constant_p
= false;
4708 bool overflow_p
= false;
4709 hash_map
<tree
, tree
> map
;
4711 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, NULL
, true, true };
4713 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4715 return !non_constant_p
&& !overflow_p
;
4718 /* If T represents a constant expression returns its reduced value.
4719 Otherwise return error_mark_node. If T is dependent, then
4723 cxx_constant_value (tree t
, tree decl
)
4725 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4728 /* Helper routine for fold_simple function. Either return simplified
4729 expression T, otherwise NULL_TREE.
4730 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4731 even if we are within template-declaration. So be careful on call, as in
4732 such case types can be undefined. */
4735 fold_simple_1 (tree t
)
4738 enum tree_code code
= TREE_CODE (t
);
4750 return fold_sizeof_expr (t
);
4758 case TRUTH_NOT_EXPR
:
4760 case VIEW_CONVERT_EXPR
:
4763 case FIX_TRUNC_EXPR
:
4764 case FIXED_CONVERT_EXPR
:
4765 case ADDR_SPACE_CONVERT_EXPR
:
4767 op1
= TREE_OPERAND (t
, 0);
4769 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4773 if (CONVERT_EXPR_CODE_P (code
)
4774 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4775 TREE_OVERFLOW (t
) = false;
4783 /* If T is a simple constant expression, returns its simplified value.
4784 Otherwise returns T. In contrast to maybe_constant_value do we
4785 simplify only few operations on constant-expressions, and we don't
4786 try to simplify constexpressions. */
4789 fold_simple (tree t
)
4792 if (processing_template_decl
)
4795 r
= fold_simple_1 (t
);
4802 /* If T is a constant expression, returns its reduced value.
4803 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4804 Otherwise, returns a version of T without TREE_CONSTANT. */
4806 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4809 maybe_constant_value (tree t
, tree decl
)
4813 if (!potential_nondependent_constant_expression (t
))
4815 if (TREE_OVERFLOW_P (t
))
4817 t
= build_nop (TREE_TYPE (t
), t
);
4818 TREE_CONSTANT (t
) = false;
4822 else if (CONSTANT_CLASS_P (t
))
4823 /* No caching or evaluation needed. */
4826 if (cv_cache
== NULL
)
4827 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4828 if (tree
*cached
= cv_cache
->get (t
))
4831 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4832 gcc_checking_assert (r
== t
4833 || CONVERT_EXPR_P (t
)
4834 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4835 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4836 || !cp_tree_equal (r
, t
));
4837 cv_cache
->put (t
, r
);
4841 /* Dispose of the whole CV_CACHE. */
4844 clear_cv_cache (void)
4846 if (cv_cache
!= NULL
)
4850 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4853 clear_cv_and_fold_caches (void)
4856 clear_fold_cache ();
4859 /* Like maybe_constant_value but first fully instantiate the argument.
4861 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4862 (t, tf_none) followed by maybe_constant_value but is more efficient,
4863 because calls instantiation_dependent_expression_p and
4864 potential_constant_expression at most once. */
4867 fold_non_dependent_expr (tree t
)
4872 /* If we're in a template, but T isn't value dependent, simplify
4873 it. We're supposed to treat:
4875 template <typename T> void f(T[1 + 1]);
4876 template <typename T> void f(T[2]);
4878 as two declarations of the same function, for example. */
4879 if (processing_template_decl
)
4881 if (potential_nondependent_constant_expression (t
))
4883 processing_template_decl_sentinel s
;
4884 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4886 if (type_unknown_p (t
)
4887 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4889 if (TREE_OVERFLOW_P (t
))
4891 t
= build_nop (TREE_TYPE (t
), t
);
4892 TREE_CONSTANT (t
) = false;
4897 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4898 /* cp_tree_equal looks through NOPs, so allow them. */
4899 gcc_checking_assert (r
== t
4900 || CONVERT_EXPR_P (t
)
4901 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4902 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4903 || !cp_tree_equal (r
, t
));
4906 else if (TREE_OVERFLOW_P (t
))
4908 t
= build_nop (TREE_TYPE (t
), t
);
4909 TREE_CONSTANT (t
) = false;
4914 return maybe_constant_value (t
);
4917 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4918 than wrapped in a TARGET_EXPR. */
4921 maybe_constant_init (tree t
, tree decl
)
4925 if (TREE_CODE (t
) == EXPR_STMT
)
4926 t
= TREE_OPERAND (t
, 0);
4927 if (TREE_CODE (t
) == CONVERT_EXPR
4928 && VOID_TYPE_P (TREE_TYPE (t
)))
4929 t
= TREE_OPERAND (t
, 0);
4930 if (TREE_CODE (t
) == INIT_EXPR
)
4931 t
= TREE_OPERAND (t
, 1);
4932 if (TREE_CODE (t
) == TARGET_EXPR
)
4933 t
= TARGET_EXPR_INITIAL (t
);
4934 if (!potential_nondependent_static_init_expression (t
))
4935 /* Don't try to evaluate it. */;
4936 else if (CONSTANT_CLASS_P (t
))
4937 /* No evaluation needed. */;
4939 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
4940 if (TREE_CODE (t
) == TARGET_EXPR
)
4942 tree init
= TARGET_EXPR_INITIAL (t
);
4943 if (TREE_CODE (init
) == CONSTRUCTOR
)
4950 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
4951 /* Return true if the object referred to by REF has automatic or thread
4954 enum { ck_ok
, ck_bad
, ck_unknown
};
4956 check_automatic_or_tls (tree ref
)
4959 HOST_WIDE_INT bitsize
, bitpos
;
4961 int volatilep
= 0, unsignedp
= 0;
4962 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
4963 &mode
, &unsignedp
, &volatilep
, false);
4966 /* If there isn't a decl in the middle, we don't know the linkage here,
4967 and this isn't a constant expression anyway. */
4970 dk
= decl_storage_duration (decl
);
4971 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
4975 /* Return true if T denotes a potentially constant expression. Issue
4976 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
4977 an lvalue-rvalue conversion is implied.
4979 C++0x [expr.const] used to say
4981 6 An expression is a potential constant expression if it is
4982 a constant expression where all occurrences of function
4983 parameters are replaced by arbitrary constant expressions
4984 of the appropriate type.
4986 2 A conditional expression is a constant expression unless it
4987 involves one of the following as a potentially evaluated
4988 subexpression (3.2), but subexpressions of logical AND (5.14),
4989 logical OR (5.15), and conditional (5.16) operations that are
4990 not evaluated are not considered. */
4993 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
4994 tsubst_flags_t flags
)
4996 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
4997 enum { any
= false, rval
= true };
5001 if (t
== error_mark_node
)
5005 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
5006 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
5008 if (flags
& tf_error
)
5009 error_at (loc
, "expression %qE has side-effects", t
);
5012 if (CONSTANT_CLASS_P (t
))
5014 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
5015 && TREE_TYPE (t
) == error_mark_node
)
5018 switch (TREE_CODE (t
))
5024 case TEMPLATE_ID_EXPR
:
5027 case CASE_LABEL_EXPR
:
5033 case TEMPLATE_PARM_INDEX
:
5035 case IDENTIFIER_NODE
:
5036 case USERDEF_LITERAL
:
5037 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5043 case PLACEHOLDER_EXPR
:
5050 case AGGR_INIT_EXPR
:
5052 /* -- an invocation of a function other than a constexpr function
5053 or a constexpr constructor. */
5055 tree fun
= get_function_named_in_call (t
);
5056 const int nargs
= call_expr_nargs (t
);
5059 if (fun
== NULL_TREE
)
5061 /* Reset to allow the function to continue past the end
5062 of the block below. Otherwise return early. */
5065 if (TREE_CODE (t
) == CALL_EXPR
5066 && CALL_EXPR_FN (t
) == NULL_TREE
)
5067 switch (CALL_EXPR_IFN (t
))
5069 /* These should be ignored, they are optimized away from
5070 constexpr functions. */
5071 case IFN_UBSAN_NULL
:
5072 case IFN_UBSAN_BOUNDS
:
5073 case IFN_UBSAN_VPTR
:
5074 case IFN_FALLTHROUGH
:
5077 case IFN_ADD_OVERFLOW
:
5078 case IFN_SUB_OVERFLOW
:
5079 case IFN_MUL_OVERFLOW
:
5089 /* fold_call_expr can't do anything with IFN calls. */
5090 if (flags
& tf_error
)
5091 error_at (loc
, "call to internal function %qE", t
);
5096 if (fun
&& is_overloaded_fn (fun
))
5098 if (TREE_CODE (fun
) == FUNCTION_DECL
)
5100 if (builtin_valid_in_constant_expr_p (fun
))
5102 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
5103 /* Allow any built-in function; if the expansion
5104 isn't constant, we'll deal with that then. */
5105 && !is_builtin_fn (fun
))
5107 if (flags
& tf_error
)
5109 error_at (loc
, "call to non-constexpr function %qD",
5111 explain_invalid_constexpr_fn (fun
);
5115 /* A call to a non-static member function takes the address
5116 of the object as the first argument. But in a constant
5117 expression the address will be folded away, so look
5119 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5120 && !DECL_CONSTRUCTOR_P (fun
))
5122 tree x
= get_nth_callarg (t
, 0);
5123 if (is_this_parameter (x
))
5125 else if (!RECUR (x
, rval
))
5132 if (!RECUR (fun
, true))
5134 fun
= get_first_fn (fun
);
5136 /* Skip initial arguments to base constructors. */
5137 if (DECL_BASE_CONSTRUCTOR_P (fun
))
5138 i
= num_artificial_parms_for (fun
);
5139 fun
= DECL_ORIGIN (fun
);
5143 if (RECUR (fun
, rval
))
5144 /* Might end up being a constant function pointer. */;
5148 for (; i
< nargs
; ++i
)
5150 tree x
= get_nth_callarg (t
, i
);
5151 /* In a template, reference arguments haven't been converted to
5152 REFERENCE_TYPE and we might not even know if the parameter
5153 is a reference, so accept lvalue constants too. */
5154 bool rv
= processing_template_decl
? any
: rval
;
5161 case NON_LVALUE_EXPR
:
5162 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5163 -- an lvalue of integral type that refers to a non-volatile
5164 const variable or static data member initialized with
5165 constant expressions, or
5167 -- an lvalue of literal type that refers to non-volatile
5168 object defined with constexpr, or that refers to a
5169 sub-object of such an object; */
5170 return RECUR (TREE_OPERAND (t
, 0), rval
);
5173 if (DECL_HAS_VALUE_EXPR_P (t
))
5174 return RECUR (DECL_VALUE_EXPR (t
), rval
);
5176 && !var_in_maybe_constexpr_fn (t
)
5177 && !type_dependent_expression_p (t
)
5178 && !decl_constant_var_p (t
)
5180 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
5181 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
5182 && COMPLETE_TYPE_P (TREE_TYPE (t
))
5183 && !is_really_empty_class (TREE_TYPE (t
)))
5185 if (flags
& tf_error
)
5186 non_const_var_error (t
);
5193 case VIEW_CONVERT_EXPR
:
5194 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5195 may change to something more specific to type-punning (DR 1312). */
5197 tree from
= TREE_OPERAND (t
, 0);
5198 if (POINTER_TYPE_P (TREE_TYPE (t
))
5199 && TREE_CODE (from
) == INTEGER_CST
5200 && !integer_zerop (from
))
5202 if (flags
& tf_error
)
5203 error_at (loc
, "reinterpret_cast from integer to pointer");
5206 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
5209 case ADDRESSOF_EXPR
:
5210 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5211 t
= TREE_OPERAND (t
, 0);
5212 goto handle_addr_expr
;
5215 /* -- a unary operator & that is applied to an lvalue that
5216 designates an object with thread or automatic storage
5218 t
= TREE_OPERAND (t
, 0);
5220 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
5221 /* A pointer-to-member constant. */
5226 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5227 any checking here, as we might dereference the pointer later. If
5228 we remove this code, also remove check_automatic_or_tls. */
5229 i
= check_automatic_or_tls (t
);
5234 if (flags
& tf_error
)
5235 error ("address-of an object %qE with thread local or "
5236 "automatic storage is not a constant expression", t
);
5240 return RECUR (t
, any
);
5248 /* -- a class member access unless its postfix-expression is
5249 of literal type or of pointer to literal type. */
5250 /* This test would be redundant, as it follows from the
5251 postfix-expression being a potential constant expression. */
5252 if (type_unknown_p (t
))
5254 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5256 case EXPR_PACK_EXPANSION
:
5257 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5261 tree x
= TREE_OPERAND (t
, 0);
5263 if (is_this_parameter (x
))
5265 if (DECL_CONTEXT (x
)
5266 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
5268 if (flags
& tf_error
)
5269 error_at (loc
, "use of %<this%> in a constant expression");
5274 return RECUR (x
, rval
);
5277 case STATEMENT_LIST
:
5279 tree_stmt_iterator i
;
5280 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5282 if (!RECUR (tsi_stmt (i
), any
))
5290 if (cxx_dialect
< cxx14
)
5292 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5294 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5299 if (cxx_dialect
< cxx14
)
5301 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5303 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5308 if (!RECUR (DO_COND (t
), rval
))
5310 if (!RECUR (DO_BODY (t
), any
))
5315 if (!RECUR (FOR_INIT_STMT (t
), any
))
5317 if (!RECUR (FOR_COND (t
), rval
))
5319 if (!RECUR (FOR_EXPR (t
), any
))
5321 if (!RECUR (FOR_BODY (t
), any
))
5325 case RANGE_FOR_STMT
:
5326 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5328 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5333 if (!RECUR (WHILE_COND (t
), rval
))
5335 if (!RECUR (WHILE_BODY (t
), any
))
5340 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5342 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5343 unreachable labels would be checked. */
5347 return RECUR (STMT_EXPR_STMT (t
), rval
);
5350 case DYNAMIC_CAST_EXPR
:
5351 case PSEUDO_DTOR_EXPR
:
5355 case VEC_DELETE_EXPR
:
5360 case OMP_DISTRIBUTE
:
5363 case OMP_TARGET_DATA
:
5372 case OMP_TARGET_UPDATE
:
5373 case OMP_TARGET_ENTER_DATA
:
5374 case OMP_TARGET_EXIT_DATA
:
5376 case OMP_ATOMIC_READ
:
5377 case OMP_ATOMIC_CAPTURE_OLD
:
5378 case OMP_ATOMIC_CAPTURE_NEW
:
5382 case OACC_HOST_DATA
:
5386 case OACC_ENTER_DATA
:
5387 case OACC_EXIT_DATA
:
5391 /* GCC internal stuff. */
5394 case TRANSACTION_EXPR
:
5396 case AT_ENCODE_EXPR
:
5398 if (flags
& tf_error
)
5399 error_at (loc
, "expression %qE is not a constant expression", t
);
5403 /* -- a typeid expression whose operand is of polymorphic
5406 tree e
= TREE_OPERAND (t
, 0);
5407 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5408 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5410 if (flags
& tf_error
)
5411 error_at (loc
, "typeid-expression is not a constant expression "
5412 "because %qE is of polymorphic type", e
);
5431 case PREINCREMENT_EXPR
:
5432 case POSTINCREMENT_EXPR
:
5433 case PREDECREMENT_EXPR
:
5434 case POSTDECREMENT_EXPR
:
5435 if (cxx_dialect
< cxx14
)
5441 if (TYPE_P (TREE_OPERAND (t
, 0)))
5447 case FIX_TRUNC_EXPR
:
5451 case TRUTH_NOT_EXPR
:
5452 case FIXED_CONVERT_EXPR
:
5453 case UNARY_PLUS_EXPR
:
5454 case UNARY_LEFT_FOLD_EXPR
:
5455 case UNARY_RIGHT_FOLD_EXPR
:
5457 return RECUR (TREE_OPERAND (t
, 0), rval
);
5460 case CONST_CAST_EXPR
:
5461 case STATIC_CAST_EXPR
:
5462 case REINTERPRET_CAST_EXPR
:
5463 case IMPLICIT_CONV_EXPR
:
5464 if (cxx_dialect
< cxx11
5465 && !dependent_type_p (TREE_TYPE (t
))
5466 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5467 /* In C++98, a conversion to non-integral type can't be part of a
5468 constant expression. */
5470 if (flags
& tf_error
)
5472 "cast to non-integral type %qT in a constant expression",
5477 return (RECUR (TREE_OPERAND (t
, 0),
5478 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5481 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5483 case WITH_CLEANUP_EXPR
:
5484 case CLEANUP_POINT_EXPR
:
5485 case MUST_NOT_THROW_EXPR
:
5486 case TRY_CATCH_EXPR
:
5491 case NON_DEPENDENT_EXPR
:
5492 /* For convenience. */
5496 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5499 tmp
= DECL_EXPR_DECL (t
);
5500 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5502 if (TREE_STATIC (tmp
))
5504 if (flags
& tf_error
)
5505 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5506 "%<static%> in %<constexpr%> function", tmp
);
5509 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5511 if (flags
& tf_error
)
5512 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5513 "%<thread_local%> in %<constexpr%> function", tmp
);
5516 else if (!DECL_NONTRIVIALLY_INITIALIZED_P (tmp
))
5518 if (flags
& tf_error
)
5519 error_at (DECL_SOURCE_LOCATION (tmp
), "uninitialized "
5520 "variable %qD in %<constexpr%> function", tmp
);
5524 return RECUR (tmp
, want_rval
);
5526 case TRY_FINALLY_EXPR
:
5527 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5528 && RECUR (TREE_OPERAND (t
, 1), any
));
5531 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5534 if (!literal_type_p (TREE_TYPE (t
)))
5536 if (flags
& tf_error
)
5538 error_at (loc
, "temporary of non-literal type %qT in a "
5539 "constant expression", TREE_TYPE (t
));
5540 explain_non_literal_class (TREE_TYPE (t
));
5546 return RECUR (TREE_OPERAND (t
, 1), rval
);
5550 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5551 constructor_elt
*ce
;
5552 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5553 if (!RECUR (ce
->value
, want_rval
))
5560 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5561 || DECL_P (TREE_PURPOSE (t
)));
5562 if (!RECUR (TREE_VALUE (t
), want_rval
))
5564 if (TREE_CHAIN (t
) == NULL_TREE
)
5566 return RECUR (TREE_CHAIN (t
), want_rval
);
5569 case TRUNC_DIV_EXPR
:
5571 case FLOOR_DIV_EXPR
:
5572 case ROUND_DIV_EXPR
:
5573 case TRUNC_MOD_EXPR
:
5575 case ROUND_MOD_EXPR
:
5577 tree denom
= TREE_OPERAND (t
, 1);
5578 if (!RECUR (denom
, rval
))
5580 /* We can't call cxx_eval_outermost_constant_expr on an expression
5581 that hasn't been through instantiate_non_dependent_expr yet. */
5582 if (!processing_template_decl
)
5583 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5584 if (integer_zerop (denom
))
5586 if (flags
& tf_error
)
5587 error ("division by zero is not a constant expression");
5593 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5599 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5600 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5601 introduced by build_call_a. */
5602 tree op0
= TREE_OPERAND (t
, 0);
5603 tree op1
= TREE_OPERAND (t
, 1);
5605 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5606 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5607 return RECUR (op0
, want_rval
);
5612 /* If the first operand is the non-short-circuit constant, look at
5613 the second operand; otherwise we only care about the first one for
5615 case TRUTH_AND_EXPR
:
5616 case TRUTH_ANDIF_EXPR
:
5617 tmp
= boolean_true_node
;
5620 case TRUTH_ORIF_EXPR
:
5621 tmp
= boolean_false_node
;
5624 tree op
= TREE_OPERAND (t
, 0);
5625 if (!RECUR (op
, rval
))
5627 if (!processing_template_decl
)
5628 op
= cxx_eval_outermost_constant_expr (op
, true);
5629 if (tree_int_cst_equal (op
, tmp
))
5630 return RECUR (TREE_OPERAND (t
, 1), rval
);
5637 case POINTER_PLUS_EXPR
:
5639 case EXACT_DIV_EXPR
:
5649 case TRUTH_XOR_EXPR
:
5650 case UNORDERED_EXPR
:
5663 case ARRAY_RANGE_REF
:
5667 case BINARY_LEFT_FOLD_EXPR
:
5668 case BINARY_RIGHT_FOLD_EXPR
:
5670 for (i
= 0; i
< 2; ++i
)
5671 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5675 case CILK_SYNC_STMT
:
5676 case CILK_SPAWN_STMT
:
5677 case ARRAY_NOTATION_REF
:
5682 for (i
= 0; i
< 3; ++i
)
5683 if (!RECUR (TREE_OPERAND (t
, i
), true))
5688 if (COND_EXPR_IS_VEC_DELETE (t
))
5690 if (flags
& tf_error
)
5691 error_at (loc
, "%<delete[]%> is not a constant expression");
5697 /* If the condition is a known constant, we know which of the legs we
5698 care about; otherwise we only require that the condition and
5699 either of the legs be potentially constant. */
5700 tmp
= TREE_OPERAND (t
, 0);
5701 if (!RECUR (tmp
, rval
))
5703 if (!processing_template_decl
)
5704 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5705 if (integer_zerop (tmp
))
5706 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5707 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5708 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5709 for (i
= 1; i
< 3; ++i
)
5710 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5711 want_rval
, strict
, tf_none
))
5713 if (flags
& tf_error
)
5714 error_at (loc
, "expression %qE is not a constant expression", t
);
5718 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5720 if (flags
& tf_error
)
5722 error_at (loc
, "non-constant array initialization");
5723 diagnose_non_constexpr_vec_init (t
);
5729 /* We can see these in statement-expressions. */
5733 case EMPTY_CLASS_EXPR
:
5738 tree
*target
= &TREE_OPERAND (t
, 0);
5739 /* Gotos representing break and continue are OK. */
5740 if (breaks (target
) || continues (target
))
5742 if (flags
& tf_error
)
5743 error_at (loc
, "%<goto%> is not a constant expression");
5748 gcc_assert (tree_to_uhwi (TREE_OPERAND (t
, 1)) == annot_expr_ivdep_kind
);
5749 return RECUR (TREE_OPERAND (t
, 0), rval
);
5752 if (objc_is_property_ref (t
))
5755 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5762 /* The main entry point to the above. */
5765 potential_constant_expression (tree t
)
5767 return potential_constant_expression_1 (t
, false, true, tf_none
);
5771 potential_static_init_expression (tree t
)
5773 return potential_constant_expression_1 (t
, false, false, tf_none
);
5776 /* As above, but require a constant rvalue. */
5779 potential_rvalue_constant_expression (tree t
)
5781 return potential_constant_expression_1 (t
, true, true, tf_none
);
5784 /* Like above, but complain about non-constant expressions. */
5787 require_potential_constant_expression (tree t
)
5789 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
5792 /* Cross product of the above. */
5795 require_potential_rvalue_constant_expression (tree t
)
5797 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
5800 /* Returns true if T is a potential constant expression that is not
5801 instantiation-dependent, and therefore a candidate for constant folding even
5805 potential_nondependent_constant_expression (tree t
)
5807 return (!type_unknown_p (t
)
5808 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5809 && potential_constant_expression (t
)
5810 && !instantiation_dependent_expression_p (t
));
5813 /* Returns true if T is a potential static initializer expression that is not
5814 instantiation-dependent. */
5817 potential_nondependent_static_init_expression (tree t
)
5819 return (!type_unknown_p (t
)
5820 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5821 && potential_static_init_expression (t
)
5822 && !instantiation_dependent_expression_p (t
));
5825 /* Finalize constexpr processing after parsing. */
5828 fini_constexpr (void)
5830 /* The contexpr call and fundef copies tables are no longer needed. */
5831 constexpr_call_table
= NULL
;
5832 fundef_copies_table
= NULL
;
5835 #include "gt-cp-constexpr.h"