1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2015 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "double-int.h"
39 #include "c-family/c-objc.h"
40 #include "tree-iterator.h"
43 #include "tree-inline.h"
46 static bool verify_constant (tree
, bool, bool *, bool *);
47 #define VERIFY_CONSTANT(X) \
49 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
53 /* Returns true iff FUN is an instantiation of a constexpr function
54 template or a defaulted constexpr function. */
57 is_instantiation_of_constexpr (tree fun
)
59 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
60 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
61 || (DECL_DEFAULTED_FN (fun
)
62 && DECL_DECLARED_CONSTEXPR_P (fun
)));
65 /* Return true if T is a literal type. */
68 literal_type_p (tree t
)
71 || TREE_CODE (t
) == VECTOR_TYPE
72 || TREE_CODE (t
) == REFERENCE_TYPE
73 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
77 t
= complete_type (t
);
78 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
79 return CLASSTYPE_LITERAL_P (t
);
81 if (TREE_CODE (t
) == ARRAY_TYPE
)
82 return literal_type_p (strip_array_types (t
));
86 /* If DECL is a variable declared `constexpr', require its type
87 be literal. Return the DECL if OK, otherwise NULL. */
90 ensure_literal_type_for_constexpr_object (tree decl
)
92 tree type
= TREE_TYPE (decl
);
94 && (DECL_DECLARED_CONSTEXPR_P (decl
)
95 || var_in_constexpr_fn (decl
))
96 && !processing_template_decl
)
98 tree stype
= strip_array_types (type
);
99 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
100 /* Don't complain here, we'll complain about incompleteness
101 when we try to initialize the variable. */;
102 else if (!literal_type_p (type
))
104 if (DECL_DECLARED_CONSTEXPR_P (decl
))
106 error ("the type %qT of constexpr variable %qD is not literal",
108 explain_non_literal_class (type
);
112 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
114 error ("variable %qD of non-literal type %qT in %<constexpr%> "
115 "function", decl
, type
);
116 explain_non_literal_class (type
);
118 cp_function_chain
->invalid_constexpr
= true;
126 /* Representation of entries in the constexpr function definition table. */
128 struct GTY((for_user
)) constexpr_fundef
{
133 struct constexpr_fundef_hasher
: ggc_hasher
<constexpr_fundef
*>
135 static hashval_t
hash (constexpr_fundef
*);
136 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
139 /* This table holds all constexpr function definitions seen in
140 the current translation unit. */
142 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
144 /* Utility function used for managing the constexpr function table.
145 Return true if the entries pointed to by P and Q are for the
146 same constexpr function. */
149 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
151 return lhs
->decl
== rhs
->decl
;
154 /* Utility function used for managing the constexpr function table.
155 Return a hash value for the entry pointed to by Q. */
158 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
160 return DECL_UID (fundef
->decl
);
163 /* Return a previously saved definition of function FUN. */
165 static constexpr_fundef
*
166 retrieve_constexpr_fundef (tree fun
)
168 constexpr_fundef fundef
= { NULL
, NULL
};
169 if (constexpr_fundef_table
== NULL
)
173 return constexpr_fundef_table
->find (&fundef
);
176 /* Check whether the parameter and return types of FUN are valid for a
177 constexpr function, and complain if COMPLAIN. */
180 is_valid_constexpr_fn (tree fun
, bool complain
)
184 if (DECL_INHERITED_CTOR_BASE (fun
)
185 && TREE_CODE (fun
) == TEMPLATE_DECL
)
189 error ("inherited constructor %qD is not constexpr",
190 get_inherited_ctor (fun
));
194 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
195 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
196 if (!literal_type_p (TREE_TYPE (parm
)))
201 error ("invalid type for parameter %d of constexpr "
202 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
203 explain_non_literal_class (TREE_TYPE (parm
));
208 if (!DECL_CONSTRUCTOR_P (fun
))
210 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
211 if (!literal_type_p (rettype
))
216 error ("invalid return type %qT of constexpr function %q+D",
218 explain_non_literal_class (rettype
);
222 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
223 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
228 error ("enclosing class of constexpr non-static member "
229 "function %q+#D is not a literal type", fun
);
230 explain_non_literal_class (DECL_CONTEXT (fun
));
234 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
238 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
244 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
245 for a member of an anonymous aggregate, INIT is the initializer for that
246 member, and VEC_OUTER is the vector of constructor elements for the class
247 whose constructor we are processing. Add the initializer to the vector
248 and return true to indicate success. */
251 build_anon_member_initialization (tree member
, tree init
,
252 vec
<constructor_elt
, va_gc
> **vec_outer
)
254 /* MEMBER presents the relevant fields from the inside out, but we need
255 to build up the initializer from the outside in so that we can reuse
256 previously built CONSTRUCTORs if this is, say, the second field in an
257 anonymous struct. So we use a vec as a stack. */
258 auto_vec
<tree
, 2> fields
;
261 fields
.safe_push (TREE_OPERAND (member
, 1));
262 member
= TREE_OPERAND (member
, 0);
264 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
265 && TREE_CODE (member
) == COMPONENT_REF
);
267 /* VEC has the constructor elements vector for the context of FIELD.
268 If FIELD is an anonymous aggregate, we will push inside it. */
269 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
271 while (field
= fields
.pop(),
272 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
275 /* If there is already an outer constructor entry for the anonymous
276 aggregate FIELD, use it; otherwise, insert one. */
277 if (vec_safe_is_empty (*vec
)
278 || (*vec
)->last().index
!= field
)
280 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
281 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
284 ctor
= (*vec
)->last().value
;
285 vec
= &CONSTRUCTOR_ELTS (ctor
);
288 /* Now we're at the innermost field, the one that isn't an anonymous
289 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
290 gcc_assert (fields
.is_empty());
291 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
296 /* Subroutine of build_constexpr_constructor_member_initializers.
297 The expression tree T represents a data member initialization
298 in a (constexpr) constructor definition. Build a pairing of
299 the data member with its initializer, and prepend that pair
300 to the existing initialization pair INITS. */
303 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
306 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
307 t
= TREE_OPERAND (t
, 0);
308 if (TREE_CODE (t
) == EXPR_STMT
)
309 t
= TREE_OPERAND (t
, 0);
310 if (t
== error_mark_node
)
312 if (TREE_CODE (t
) == STATEMENT_LIST
)
314 tree_stmt_iterator i
;
315 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
317 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
322 if (TREE_CODE (t
) == CLEANUP_STMT
)
324 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
325 but we can in a constexpr constructor for a non-literal class. Just
326 ignore it; either all the initialization will be constant, in which
327 case the cleanup can't run, or it can't be constexpr.
328 Still recurse into CLEANUP_BODY. */
329 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
331 if (TREE_CODE (t
) == CONVERT_EXPR
)
332 t
= TREE_OPERAND (t
, 0);
333 if (TREE_CODE (t
) == INIT_EXPR
334 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
335 use what this function builds for cx_check_missing_mem_inits, and
336 assignment in the ctor body doesn't count. */
337 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
339 member
= TREE_OPERAND (t
, 0);
340 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
342 else if (TREE_CODE (t
) == CALL_EXPR
)
344 tree fn
= get_callee_fndecl (t
);
345 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
346 /* We're only interested in calls to subobject constructors. */
348 member
= CALL_EXPR_ARG (t
, 0);
349 /* We don't use build_cplus_new here because it complains about
350 abstract bases. Leaving the call unwrapped means that it has the
351 wrong type, but cxx_eval_constant_expression doesn't care. */
352 init
= break_out_target_exprs (t
);
354 else if (TREE_CODE (t
) == BIND_EXPR
)
355 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
357 /* Don't add anything else to the CONSTRUCTOR. */
359 if (INDIRECT_REF_P (member
))
360 member
= TREE_OPERAND (member
, 0);
361 if (TREE_CODE (member
) == NOP_EXPR
)
365 if (TREE_CODE (op
) == ADDR_EXPR
)
367 gcc_assert (same_type_ignoring_top_level_qualifiers_p
368 (TREE_TYPE (TREE_TYPE (op
)),
369 TREE_TYPE (TREE_TYPE (member
))));
370 /* Initializing a cv-qualified member; we need to look through
374 else if (op
== current_class_ptr
375 && (same_type_ignoring_top_level_qualifiers_p
376 (TREE_TYPE (TREE_TYPE (member
)),
377 current_class_type
)))
378 /* Delegating constructor. */
382 /* This is an initializer for an empty base; keep it for now so
383 we can check it in cxx_eval_bare_aggregate. */
384 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
387 if (TREE_CODE (member
) == ADDR_EXPR
)
388 member
= TREE_OPERAND (member
, 0);
389 if (TREE_CODE (member
) == COMPONENT_REF
)
391 tree aggr
= TREE_OPERAND (member
, 0);
392 if (TREE_CODE (aggr
) != COMPONENT_REF
)
393 /* Normal member initialization. */
394 member
= TREE_OPERAND (member
, 1);
395 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
396 /* Initializing a member of an anonymous union. */
397 return build_anon_member_initialization (member
, init
, vec
);
399 /* We're initializing a vtable pointer in a base. Leave it as
400 COMPONENT_REF so we remember the path to get to the vfield. */
401 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
404 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
408 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
409 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
410 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
413 check_constexpr_bind_expr_vars (tree t
)
415 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
417 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
418 if (TREE_CODE (var
) == TYPE_DECL
419 && DECL_IMPLICIT_TYPEDEF_P (var
)
420 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
425 /* Subroutine of check_constexpr_ctor_body. */
428 check_constexpr_ctor_body_1 (tree last
, tree list
)
430 switch (TREE_CODE (list
))
433 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
)
437 case CLEANUP_POINT_EXPR
:
438 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
442 if (!check_constexpr_bind_expr_vars (list
)
443 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
457 /* Make sure that there are no statements after LAST in the constructor
458 body represented by LIST. */
461 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
463 /* C++14 doesn't require a constexpr ctor to have an empty body. */
464 if (cxx_dialect
>= cxx14
)
468 if (TREE_CODE (list
) == STATEMENT_LIST
)
470 tree_stmt_iterator i
= tsi_last (list
);
471 for (; !tsi_end_p (i
); tsi_prev (&i
))
473 tree t
= tsi_stmt (i
);
476 if (!check_constexpr_ctor_body_1 (last
, t
))
483 else if (list
!= last
484 && !check_constexpr_ctor_body_1 (last
, list
))
489 error ("constexpr constructor does not have empty body");
490 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
495 /* V is a vector of constructor elements built up for the base and member
496 initializers of a constructor for TYPE. They need to be in increasing
497 offset order, which they might not be yet if TYPE has a primary base
498 which is not first in the base-clause or a vptr and at least one base
499 all of which are non-primary. */
501 static vec
<constructor_elt
, va_gc
> *
502 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
504 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
510 field_type
= BINFO_TYPE (pri
);
511 else if (TYPE_CONTAINS_VPTR_P (type
))
512 field_type
= vtbl_ptr_type_node
;
516 /* Find the element for the primary base or vptr and move it to the
517 beginning of the vec. */
518 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
519 if (TREE_TYPE (ce
->index
) == field_type
)
522 if (i
> 0 && i
< vec_safe_length (v
))
524 vec
<constructor_elt
, va_gc
> &vref
= *v
;
525 constructor_elt elt
= vref
[i
];
534 /* Build compile-time evalable representations of member-initializer list
535 for a constexpr constructor. */
538 build_constexpr_constructor_member_initializers (tree type
, tree body
)
540 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
542 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
543 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
544 body
= TREE_OPERAND (body
, 0);
545 if (TREE_CODE (body
) == STATEMENT_LIST
)
546 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
547 body
= BIND_EXPR_BODY (body
);
548 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
550 body
= TREE_OPERAND (body
, 0);
551 if (TREE_CODE (body
) == EXPR_STMT
)
552 body
= TREE_OPERAND (body
, 0);
553 if (TREE_CODE (body
) == INIT_EXPR
554 && (same_type_ignoring_top_level_qualifiers_p
555 (TREE_TYPE (TREE_OPERAND (body
, 0)),
556 current_class_type
)))
559 return TREE_OPERAND (body
, 1);
561 ok
= build_data_member_initialization (body
, &vec
);
563 else if (TREE_CODE (body
) == STATEMENT_LIST
)
565 tree_stmt_iterator i
;
566 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
568 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
573 else if (TREE_CODE (body
) == TRY_BLOCK
)
575 error ("body of %<constexpr%> constructor cannot be "
576 "a function-try-block");
577 return error_mark_node
;
579 else if (EXPR_P (body
))
580 ok
= build_data_member_initialization (body
, &vec
);
582 gcc_assert (errorcount
> 0);
585 if (vec_safe_length (vec
) > 0)
587 /* In a delegating constructor, return the target. */
588 constructor_elt
*ce
= &(*vec
)[0];
589 if (ce
->index
== current_class_ptr
)
596 vec
= sort_constexpr_mem_initializers (type
, vec
);
597 return build_constructor (type
, vec
);
600 return error_mark_node
;
603 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
604 declared to be constexpr, or a sub-statement thereof. Returns the
605 return value if suitable, error_mark_node for a statement not allowed in
606 a constexpr function, or NULL_TREE if no return value was found. */
609 constexpr_fn_retval (tree body
)
611 switch (TREE_CODE (body
))
615 tree_stmt_iterator i
;
616 tree expr
= NULL_TREE
;
617 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
619 tree s
= constexpr_fn_retval (tsi_stmt (i
));
620 if (s
== error_mark_node
)
621 return error_mark_node
;
622 else if (s
== NULL_TREE
)
623 /* Keep iterating. */;
625 /* Multiple return statements. */
626 return error_mark_node
;
634 return break_out_target_exprs (TREE_OPERAND (body
, 0));
638 tree decl
= DECL_EXPR_DECL (body
);
639 if (TREE_CODE (decl
) == USING_DECL
640 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
641 || DECL_ARTIFICIAL (decl
))
643 return error_mark_node
;
646 case CLEANUP_POINT_EXPR
:
647 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
650 if (!check_constexpr_bind_expr_vars (body
))
651 return error_mark_node
;
652 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
658 return error_mark_node
;
662 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
663 FUN; do the necessary transformations to turn it into a single expression
664 that we can store in the hash table. */
667 massage_constexpr_body (tree fun
, tree body
)
669 if (DECL_CONSTRUCTOR_P (fun
))
670 body
= build_constexpr_constructor_member_initializers
671 (DECL_CONTEXT (fun
), body
);
672 else if (cxx_dialect
< cxx14
)
674 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
675 body
= EH_SPEC_STMTS (body
);
676 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
677 body
= TREE_OPERAND (body
, 0);
678 body
= constexpr_fn_retval (body
);
683 /* FUN is a constexpr constructor with massaged body BODY. Return true
684 if some bases/fields are uninitialized, and complain if COMPLAIN. */
687 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
694 if (TREE_CODE (body
) != CONSTRUCTOR
)
697 nelts
= CONSTRUCTOR_NELTS (body
);
698 ctype
= DECL_CONTEXT (fun
);
699 field
= TYPE_FIELDS (ctype
);
701 if (TREE_CODE (ctype
) == UNION_TYPE
)
703 if (nelts
== 0 && next_initializable_field (field
))
706 error ("%<constexpr%> constructor for union %qT must "
707 "initialize exactly one non-static data member", ctype
);
714 for (i
= 0; i
<= nelts
; ++i
)
721 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
722 /* Skip base and vtable inits. */
723 if (TREE_CODE (index
) != FIELD_DECL
724 || DECL_ARTIFICIAL (index
))
727 for (; field
!= index
; field
= DECL_CHAIN (field
))
730 if (TREE_CODE (field
) != FIELD_DECL
731 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
732 || DECL_ARTIFICIAL (field
))
734 ftype
= strip_array_types (TREE_TYPE (field
));
735 if (type_has_constexpr_default_constructor (ftype
))
737 /* It's OK to skip a member with a trivial constexpr ctor.
738 A constexpr ctor that isn't trivial should have been
740 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
746 error ("member %qD must be initialized by mem-initializer "
747 "in %<constexpr%> constructor", field
);
748 inform (DECL_SOURCE_LOCATION (field
), "declared here");
751 if (field
== NULL_TREE
)
753 field
= DECL_CHAIN (field
);
759 /* We are processing the definition of the constexpr function FUN.
760 Check that its BODY fulfills the propriate requirements and
761 enter it in the constexpr function definition table.
762 For constructor BODY is actually the TREE_LIST of the
763 member-initializer list. */
766 register_constexpr_fundef (tree fun
, tree body
)
768 constexpr_fundef entry
;
769 constexpr_fundef
**slot
;
771 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
774 body
= massage_constexpr_body (fun
, body
);
775 if (body
== NULL_TREE
|| body
== error_mark_node
)
777 if (!DECL_CONSTRUCTOR_P (fun
))
778 error ("body of constexpr function %qD not a return-statement", fun
);
782 if (!potential_rvalue_constant_expression (body
))
784 if (!DECL_GENERATED_P (fun
))
785 require_potential_rvalue_constant_expression (body
);
789 if (DECL_CONSTRUCTOR_P (fun
)
790 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
793 /* Create the constexpr function table if necessary. */
794 if (constexpr_fundef_table
== NULL
)
795 constexpr_fundef_table
796 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
800 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
802 gcc_assert (*slot
== NULL
);
803 *slot
= ggc_alloc
<constexpr_fundef
> ();
809 /* FUN is a non-constexpr function called in a context that requires a
810 constant expression. If it comes from a constexpr template, explain why
811 the instantiation isn't constexpr. */
814 explain_invalid_constexpr_fn (tree fun
)
816 static hash_set
<tree
> *diagnosed
;
819 /* Only diagnose defaulted functions or instantiations. */
820 if (!DECL_DEFAULTED_FN (fun
)
821 && !is_instantiation_of_constexpr (fun
))
823 if (diagnosed
== NULL
)
824 diagnosed
= new hash_set
<tree
>;
825 if (diagnosed
->add (fun
))
826 /* Already explained. */
829 save_loc
= input_location
;
830 input_location
= DECL_SOURCE_LOCATION (fun
);
831 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
832 /* First check the declaration. */
833 if (is_valid_constexpr_fn (fun
, true))
835 /* Then if it's OK, the body. */
836 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
837 explain_implicit_non_constexpr (fun
);
840 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
841 require_potential_rvalue_constant_expression (body
);
842 if (DECL_CONSTRUCTOR_P (fun
))
843 cx_check_missing_mem_inits (fun
, body
, true);
846 input_location
= save_loc
;
849 /* Objects of this type represent calls to constexpr functions
850 along with the bindings of parameters to their arguments, for
851 the purpose of compile time evaluation. */
853 struct GTY((for_user
)) constexpr_call
{
854 /* Description of the constexpr function definition. */
855 constexpr_fundef
*fundef
;
856 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
857 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
858 Note: This arrangement is made to accommodate the use of
859 iterative_hash_template_arg (see pt.c). If you change this
860 representation, also change the hash calculation in
861 cxx_eval_call_expression. */
863 /* Result of the call.
864 NULL means the call is being evaluated.
865 error_mark_node means that the evaluation was erroneous;
866 otherwise, the actuall value of the call. */
868 /* The hash of this call; we remember it here to avoid having to
869 recalculate it when expanding the hash table. */
873 struct constexpr_call_hasher
: ggc_hasher
<constexpr_call
*>
875 static hashval_t
hash (constexpr_call
*);
876 static bool equal (constexpr_call
*, constexpr_call
*);
879 /* The constexpr expansion context. CALL is the current function
880 expansion, CTOR is the current aggregate initializer, OBJECT is the
881 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
882 is a map of values of variables initialized within the expression. */
884 struct constexpr_ctx
{
885 /* The innermost call we're evaluating. */
886 constexpr_call
*call
;
887 /* Values for any temporaries or local variables within the
888 constant-expression. */
889 hash_map
<tree
,tree
> *values
;
890 /* The CONSTRUCTOR we're currently building up for an aggregate
893 /* The object we're building the CONSTRUCTOR for. */
895 /* Whether we should error on a non-constant expression or fail quietly. */
897 /* Whether we are strictly conforming to constant expression rules or
898 trying harder to get a constant value. */
902 /* A table of all constexpr calls that have been evaluated by the
903 compiler in this translation unit. */
905 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
907 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
908 bool, bool *, bool *, tree
* = NULL
);
910 /* Compute a hash value for a constexpr call representation. */
913 constexpr_call_hasher::hash (constexpr_call
*info
)
918 /* Return true if the objects pointed to by P and Q represent calls
919 to the same constexpr function with the same arguments.
920 Otherwise, return false. */
923 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
929 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
931 lhs_bindings
= lhs
->bindings
;
932 rhs_bindings
= rhs
->bindings
;
933 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
935 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
936 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
937 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
938 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
940 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
941 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
943 return lhs_bindings
== rhs_bindings
;
946 /* Initialize the constexpr call table, if needed. */
949 maybe_initialize_constexpr_call_table (void)
951 if (constexpr_call_table
== NULL
)
952 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
955 /* We have an expression tree T that represents a call, either CALL_EXPR
956 or AGGR_INIT_EXPR. If the call is lexically to a named function,
957 retrun the _DECL for that function. */
960 get_function_named_in_call (tree t
)
963 switch (TREE_CODE (t
))
966 fun
= CALL_EXPR_FN (t
);
970 fun
= AGGR_INIT_EXPR_FN (t
);
977 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
978 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
979 fun
= TREE_OPERAND (fun
, 0);
983 /* We have an expression tree T that represents a call, either CALL_EXPR
984 or AGGR_INIT_EXPR. Return the Nth argument. */
987 get_nth_callarg (tree t
, int n
)
989 switch (TREE_CODE (t
))
992 return CALL_EXPR_ARG (t
, n
);
995 return AGGR_INIT_EXPR_ARG (t
, n
);
1003 /* Look up the binding of the function parameter T in a constexpr
1004 function call context CALL. */
1007 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
1009 tree b
= purpose_member (t
, call
->bindings
);
1010 return TREE_VALUE (b
);
1013 /* Attempt to evaluate T which represents a call to a builtin function.
1014 We assume here that all builtin functions evaluate to scalar types
1015 represented by _CST nodes. */
1018 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
,
1020 bool *non_constant_p
, bool *overflow_p
)
1022 const int nargs
= call_expr_nargs (t
);
1023 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1026 for (i
= 0; i
< nargs
; ++i
)
1028 args
[i
] = cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, i
),
1030 non_constant_p
, overflow_p
);
1031 if (ctx
->quiet
&& *non_constant_p
)
1034 if (*non_constant_p
)
1036 new_call
= fold_build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1037 CALL_EXPR_FN (t
), nargs
, args
);
1038 VERIFY_CONSTANT (new_call
);
1042 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1043 the type of the value to match. */
1046 adjust_temp_type (tree type
, tree temp
)
1048 if (TREE_TYPE (temp
) == type
)
1050 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1051 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1052 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1053 gcc_assert (scalarish_type_p (type
));
1054 return cp_fold_convert (type
, temp
);
1057 /* True if we want to use the new handling of constexpr calls based on
1059 #define use_new_call true
1061 /* Subroutine of cxx_eval_call_expression.
1062 We are processing a call expression (either CALL_EXPR or
1063 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1064 all arguments and bind their values to correspondings
1065 parameters, making up the NEW_CALL context. */
1068 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1069 constexpr_call
*new_call
,
1070 bool *non_constant_p
, bool *overflow_p
,
1071 bool *non_constant_args
)
1073 const int nargs
= call_expr_nargs (t
);
1074 tree fun
= new_call
->fundef
->decl
;
1075 tree parms
= DECL_ARGUMENTS (fun
);
1077 tree
*p
= &new_call
->bindings
;
1078 for (i
= 0; i
< nargs
; ++i
)
1081 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1082 x
= get_nth_callarg (t
, i
);
1083 /* For member function, the first argument is a pointer to the implied
1084 object. For a constructor, it might still be a dummy object, in
1085 which case we get the real argument from ctx. */
1086 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1087 && is_dummy_object (x
))
1090 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1093 if (parms
&& DECL_BY_REFERENCE (parms
) && !use_new_call
)
1095 /* cp_genericize made this a reference for argument passing, but
1096 we don't want to treat it like one for C++11 constexpr
1097 evaluation. C++14 constexpr evaluation uses the genericized
1099 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1100 gcc_assert (TREE_CODE (TREE_TYPE (x
)) == REFERENCE_TYPE
);
1101 type
= TREE_TYPE (type
);
1102 x
= convert_from_reference (x
);
1105 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1106 non_constant_p
, overflow_p
);
1107 /* Don't VERIFY_CONSTANT here. */
1108 if (*non_constant_p
&& ctx
->quiet
)
1110 /* Just discard ellipsis args after checking their constantitude. */
1113 if (*non_constant_p
)
1114 /* Don't try to adjust the type of non-constant args. */
1117 /* Make sure the binding has the same type as the parm. */
1118 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1119 arg
= adjust_temp_type (type
, arg
);
1120 if (!TREE_CONSTANT (arg
))
1121 *non_constant_args
= true;
1122 *p
= build_tree_list (parms
, arg
);
1123 p
= &TREE_CHAIN (*p
);
1125 parms
= TREE_CHAIN (parms
);
1129 /* Variables and functions to manage constexpr call expansion context.
1130 These do not need to be marked for PCH or GC. */
1132 /* FIXME remember and print actual constant arguments. */
1133 static vec
<tree
> call_stack
= vNULL
;
1134 static int call_stack_tick
;
1135 static int last_cx_error_tick
;
1138 push_cx_call_context (tree call
)
1141 if (!EXPR_HAS_LOCATION (call
))
1142 SET_EXPR_LOCATION (call
, input_location
);
1143 call_stack
.safe_push (call
);
1144 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1150 pop_cx_call_context (void)
1157 cx_error_context (void)
1159 vec
<tree
> r
= vNULL
;
1160 if (call_stack_tick
!= last_cx_error_tick
1161 && !call_stack
.is_empty ())
1163 last_cx_error_tick
= call_stack_tick
;
1167 /* Subroutine of cxx_eval_constant_expression.
1168 Evaluate the call expression tree T in the context of OLD_CALL expression
1172 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1174 bool *non_constant_p
, bool *overflow_p
)
1176 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1177 tree fun
= get_function_named_in_call (t
);
1178 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1181 if (fun
== NULL_TREE
)
1182 switch (CALL_EXPR_IFN (t
))
1184 case IFN_UBSAN_NULL
:
1185 case IFN_UBSAN_BOUNDS
:
1186 case IFN_UBSAN_VPTR
:
1190 error_at (loc
, "call to internal function");
1191 *non_constant_p
= true;
1195 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1197 /* Might be a constexpr function pointer. */
1198 fun
= cxx_eval_constant_expression (ctx
, fun
,
1199 /*lval*/false, non_constant_p
,
1202 if (TREE_CODE (fun
) == ADDR_EXPR
)
1203 fun
= TREE_OPERAND (fun
, 0);
1205 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1207 if (!ctx
->quiet
&& !*non_constant_p
)
1208 error_at (loc
, "expression %qE does not designate a constexpr "
1210 *non_constant_p
= true;
1213 if (DECL_CLONED_FUNCTION_P (fun
))
1214 fun
= DECL_CLONED_FUNCTION (fun
);
1216 if (is_ubsan_builtin_p (fun
))
1219 if (is_builtin_fn (fun
))
1220 return cxx_eval_builtin_function_call (ctx
, t
,
1221 lval
, non_constant_p
, overflow_p
);
1222 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1226 error_at (loc
, "call to non-constexpr function %qD", fun
);
1227 explain_invalid_constexpr_fn (fun
);
1229 *non_constant_p
= true;
1233 /* Shortcut trivial constructor/op=. */
1234 if (trivial_fn_p (fun
))
1236 if (call_expr_nargs (t
) == 2)
1238 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
1239 return cxx_eval_constant_expression (ctx
, arg
,
1240 lval
, non_constant_p
,
1243 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1244 && AGGR_INIT_ZERO_FIRST (t
))
1245 return build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1248 /* If in direct recursive call, optimize definition search. */
1249 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1250 new_call
.fundef
= ctx
->call
->fundef
;
1253 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1254 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
1258 if (DECL_INITIAL (fun
))
1260 /* The definition of fun was somehow unsuitable. */
1261 error_at (loc
, "%qD called in a constant expression", fun
);
1262 explain_invalid_constexpr_fn (fun
);
1265 error_at (loc
, "%qD used before its definition", fun
);
1267 *non_constant_p
= true;
1272 constexpr_ctx new_ctx
= *ctx
;
1273 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1274 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1276 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1277 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1278 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1279 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1280 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1281 ctx
->values
->put (new_ctx
.object
, ctor
);
1285 bool non_constant_args
= false;
1286 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1287 non_constant_p
, overflow_p
, &non_constant_args
);
1288 if (*non_constant_p
)
1291 depth_ok
= push_cx_call_context (t
);
1293 tree result
= NULL_TREE
;
1295 constexpr_call
*entry
= NULL
;
1296 if (!non_constant_args
)
1298 new_call
.hash
= iterative_hash_template_arg
1299 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1301 /* If we have seen this call before, we are done. */
1302 maybe_initialize_constexpr_call_table ();
1303 constexpr_call
**slot
1304 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1308 /* We need to keep a pointer to the entry, not just the slot, as the
1309 slot can move in the call to cxx_eval_builtin_function_call. */
1310 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1313 /* Calls which are in progress have their result set to NULL
1314 so that we can detect circular dependencies. */
1315 else if (entry
->result
== NULL
)
1318 error ("call has circular dependency");
1319 *non_constant_p
= true;
1320 entry
->result
= result
= error_mark_node
;
1323 result
= entry
->result
;
1329 error ("constexpr evaluation depth exceeds maximum of %d (use "
1330 "-fconstexpr-depth= to increase the maximum)",
1331 max_constexpr_depth
);
1332 *non_constant_p
= true;
1333 result
= error_mark_node
;
1337 if (!result
|| result
== error_mark_node
)
1341 new_ctx
.call
= &new_call
;
1342 result
= (cxx_eval_constant_expression
1343 (&new_ctx
, new_call
.fundef
->body
,
1345 non_constant_p
, overflow_p
));
1349 if (DECL_SAVED_TREE (fun
) == NULL_TREE
1350 && (DECL_CONSTRUCTOR_P (fun
) || DECL_DESTRUCTOR_P (fun
)))
1351 /* The maybe-in-charge 'tor had its DECL_SAVED_TREE
1352 cleared, try a clone. */
1353 for (fun
= DECL_CHAIN (fun
);
1354 fun
&& DECL_CLONED_FUNCTION_P (fun
);
1355 fun
= DECL_CHAIN (fun
))
1356 if (DECL_SAVED_TREE (fun
))
1358 gcc_assert (DECL_SAVED_TREE (fun
));
1361 /* Unshare the whole function body. */
1362 tree body
= copy_fn (fun
, parms
, res
);
1364 /* Associate the bindings with the remapped parms. */
1365 tree bound
= new_call
.bindings
;
1366 tree remapped
= parms
;
1369 tree oparm
= TREE_PURPOSE (bound
);
1370 tree arg
= TREE_VALUE (bound
);
1371 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1372 ctx
->values
->put (remapped
, arg
);
1373 bound
= TREE_CHAIN (bound
);
1374 remapped
= DECL_CHAIN (remapped
);
1376 /* Add the RESULT_DECL to the values map, too. */
1377 tree slot
= NULL_TREE
;
1378 if (DECL_BY_REFERENCE (res
))
1380 slot
= AGGR_INIT_EXPR_SLOT (t
);
1381 tree addr
= build_address (slot
);
1382 addr
= build_nop (TREE_TYPE (res
), addr
);
1383 ctx
->values
->put (res
, addr
);
1384 ctx
->values
->put (slot
, NULL_TREE
);
1387 ctx
->values
->put (res
, NULL_TREE
);
1389 tree jump_target
= NULL_TREE
;
1390 cxx_eval_constant_expression (ctx
, body
,
1391 lval
, non_constant_p
, overflow_p
,
1394 if (DECL_CONSTRUCTOR_P (fun
))
1395 /* This can be null for a subobject constructor call, in
1396 which case what we care about is the initialization
1397 side-effects rather than the value. We could get at the
1398 value by evaluating *this, but we don't bother; there's
1399 no need to put such a call in the hash table. */
1400 result
= lval
? ctx
->object
: ctx
->ctor
;
1401 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1405 result
= *ctx
->values
->get (slot
? slot
: res
);
1406 if (result
== NULL_TREE
&& !*non_constant_p
)
1409 error ("constexpr call flows off the end "
1411 *non_constant_p
= true;
1415 /* Remove the parms/result from the values map. Is it worth
1416 bothering to do this when the map itself is only live for
1417 one constexpr evaluation? If so, maybe also clear out
1418 other vars from call, maybe in BIND_EXPR handling? */
1419 ctx
->values
->remove (res
);
1421 ctx
->values
->remove (slot
);
1422 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1423 ctx
->values
->remove (parm
);
1427 if (result
== error_mark_node
)
1428 *non_constant_p
= true;
1429 if (*non_constant_p
)
1430 result
= error_mark_node
;
1433 /* If this was a call to initialize an object, set the type of
1434 the CONSTRUCTOR to the type of that object. */
1435 if (DECL_CONSTRUCTOR_P (fun
) && !use_new_call
)
1437 tree ob_arg
= get_nth_callarg (t
, 0);
1438 STRIP_NOPS (ob_arg
);
1439 gcc_assert (TYPE_PTR_P (TREE_TYPE (ob_arg
))
1440 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
1441 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
1448 entry
->result
= result
;
1451 pop_cx_call_context ();
1452 return unshare_expr (result
);
1455 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1458 reduced_constant_expression_p (tree t
)
1460 switch (TREE_CODE (t
))
1463 /* Even if we can't lower this yet, it's constant. */
1467 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1468 tree elt
; unsigned HOST_WIDE_INT idx
;
1469 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1470 if (!reduced_constant_expression_p (elt
))
1475 /* FIXME are we calling this too much? */
1476 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1480 /* Some expressions may have constant operands but are not constant
1481 themselves, such as 1/0. Call this function (or rather, the macro
1482 following it) to check for that condition.
1484 We only call this in places that require an arithmetic constant, not in
1485 places where we might have a non-constant expression that can be a
1486 component of a constant expression, such as the address of a constexpr
1487 variable that might be dereferenced later. */
1490 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1493 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1495 if (!allow_non_constant
)
1496 error ("%q+E is not a constant expression", t
);
1497 *non_constant_p
= true;
1499 if (TREE_OVERFLOW_P (t
))
1501 if (!allow_non_constant
)
1503 permerror (input_location
, "overflow in constant expression");
1504 /* If we're being permissive (and are in an enforcing
1505 context), ignore the overflow. */
1506 if (flag_permissive
)
1507 return *non_constant_p
;
1511 return *non_constant_p
;
1514 /* Check whether the shift operation with code CODE and type TYPE on LHS
1515 and RHS is undefined. If it is, give an error with an explanation,
1516 and return true; return false otherwise. */
1519 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1520 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1522 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1523 || TREE_CODE (lhs
) != INTEGER_CST
1524 || TREE_CODE (rhs
) != INTEGER_CST
)
1527 tree lhstype
= TREE_TYPE (lhs
);
1528 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1530 /* [expr.shift] The behavior is undefined if the right operand
1531 is negative, or greater than or equal to the length in bits
1532 of the promoted left operand. */
1533 if (tree_int_cst_sgn (rhs
) == -1)
1536 error_at (loc
, "right operand of shift expression %q+E is negative",
1537 build2_loc (loc
, code
, type
, lhs
, rhs
));
1540 if (compare_tree_int (rhs
, uprec
) >= 0)
1543 error_at (loc
, "right operand of shift expression %q+E is >= than "
1544 "the precision of the left operand",
1545 build2_loc (loc
, code
, type
, lhs
, rhs
));
1549 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1550 if E1 has a signed type and non-negative value, and E1x2^E2 is
1551 representable in the corresponding unsigned type of the result type,
1552 then that value, converted to the result type, is the resulting value;
1553 otherwise, the behavior is undefined. */
1554 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1555 && (cxx_dialect
>= cxx11
))
1557 if (tree_int_cst_sgn (lhs
) == -1)
1560 error_at (loc
, "left operand of shift expression %q+E is negative",
1561 build2_loc (loc
, code
, type
, lhs
, rhs
));
1564 /* For signed x << y the following:
1565 (unsigned) x >> ((prec (lhs) - 1) - y)
1566 if > 1, is undefined. The right-hand side of this formula
1567 is the highest bit of the LHS that can be set (starting from 0),
1568 so that the shift doesn't overflow. We then right-shift the LHS
1569 to see whether any other bit is set making the original shift
1570 undefined -- the result is not representable in the corresponding
1572 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1573 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1574 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1575 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1576 if (tree_int_cst_lt (integer_one_node
, t
))
1579 error_at (loc
, "shift expression %q+E overflows",
1580 build2_loc (loc
, code
, type
, lhs
, rhs
));
1587 /* Subroutine of cxx_eval_constant_expression.
1588 Attempt to reduce the unary expression tree T to a compile time value.
1589 If successful, return the value. Otherwise issue a diagnostic
1590 and return error_mark_node. */
1593 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1595 bool *non_constant_p
, bool *overflow_p
)
1598 tree orig_arg
= TREE_OPERAND (t
, 0);
1599 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1600 non_constant_p
, overflow_p
);
1601 VERIFY_CONSTANT (arg
);
1602 location_t loc
= EXPR_LOCATION (t
);
1603 enum tree_code code
= TREE_CODE (t
);
1604 tree type
= TREE_TYPE (t
);
1605 r
= fold_unary_loc (loc
, code
, type
, arg
);
1608 if (arg
== orig_arg
)
1611 r
= build1_loc (loc
, code
, type
, arg
);
1613 VERIFY_CONSTANT (r
);
1617 /* Subroutine of cxx_eval_constant_expression.
1618 Like cxx_eval_unary_expression, except for binary expressions. */
1621 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1623 bool *non_constant_p
, bool *overflow_p
)
1626 tree orig_lhs
= TREE_OPERAND (t
, 0);
1627 tree orig_rhs
= TREE_OPERAND (t
, 1);
1629 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1630 non_constant_p
, overflow_p
);
1631 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1632 a local array in a constexpr function. */
1633 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1635 VERIFY_CONSTANT (lhs
);
1636 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1637 non_constant_p
, overflow_p
);
1639 VERIFY_CONSTANT (rhs
);
1641 location_t loc
= EXPR_LOCATION (t
);
1642 enum tree_code code
= TREE_CODE (t
);
1643 tree type
= TREE_TYPE (t
);
1644 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1647 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1650 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1652 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1653 *non_constant_p
= true;
1655 VERIFY_CONSTANT (r
);
1659 /* Subroutine of cxx_eval_constant_expression.
1660 Attempt to evaluate condition expressions. Dead branches are not
1664 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1666 bool *non_constant_p
, bool *overflow_p
,
1669 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1671 non_constant_p
, overflow_p
);
1672 VERIFY_CONSTANT (val
);
1673 /* Don't VERIFY_CONSTANT the other operands. */
1674 if (integer_zerop (val
))
1675 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1677 non_constant_p
, overflow_p
,
1679 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1681 non_constant_p
, overflow_p
,
1685 /* Subroutine of cxx_eval_constant_expression.
1686 Attempt to reduce a reference to an array slot. */
1689 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
1691 bool *non_constant_p
, bool *overflow_p
)
1693 tree oldary
= TREE_OPERAND (t
, 0);
1694 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
1696 non_constant_p
, overflow_p
);
1700 unsigned len
, elem_nchars
= 1;
1701 if (*non_constant_p
)
1703 oldidx
= TREE_OPERAND (t
, 1);
1704 index
= cxx_eval_constant_expression (ctx
, oldidx
,
1706 non_constant_p
, overflow_p
);
1707 VERIFY_CONSTANT (index
);
1708 if (lval
&& ary
== oldary
&& index
== oldidx
)
1711 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
1712 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
1713 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1714 len
= CONSTRUCTOR_NELTS (ary
);
1715 else if (TREE_CODE (ary
) == STRING_CST
)
1717 elem_nchars
= (TYPE_PRECISION (elem_type
)
1718 / TYPE_PRECISION (char_type_node
));
1719 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
1723 /* We can't do anything with other tree codes, so use
1724 VERIFY_CONSTANT to complain and fail. */
1725 VERIFY_CONSTANT (ary
);
1728 if (compare_tree_int (index
, len
) >= 0)
1730 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
1732 /* If it's within the array bounds but doesn't have an explicit
1733 initializer, it's value-initialized. */
1734 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
1735 return cxx_eval_constant_expression (ctx
, val
,
1737 non_constant_p
, overflow_p
);
1741 error ("array subscript out of bound");
1742 *non_constant_p
= true;
1745 else if (tree_int_cst_lt (index
, integer_zero_node
))
1748 error ("negative array subscript");
1749 *non_constant_p
= true;
1752 i
= tree_to_shwi (index
);
1753 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1754 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
1755 else if (elem_nchars
== 1)
1756 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
1757 TREE_STRING_POINTER (ary
)[i
]);
1760 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
1761 return native_interpret_expr (type
, (const unsigned char *)
1762 TREE_STRING_POINTER (ary
)
1763 + i
* elem_nchars
, elem_nchars
);
1765 /* Don't VERIFY_CONSTANT here. */
1768 /* Subroutine of cxx_eval_constant_expression.
1769 Attempt to reduce a field access of a value of class type. */
1772 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
1774 bool *non_constant_p
, bool *overflow_p
)
1776 unsigned HOST_WIDE_INT i
;
1779 tree part
= TREE_OPERAND (t
, 1);
1780 tree orig_whole
= TREE_OPERAND (t
, 0);
1781 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1783 non_constant_p
, overflow_p
);
1784 if (whole
== orig_whole
)
1787 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
1788 whole
, part
, NULL_TREE
);
1789 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1791 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
1794 error ("%qE is not a constant expression", orig_whole
);
1795 *non_constant_p
= true;
1797 if (DECL_MUTABLE_P (part
))
1800 error ("mutable %qD is not usable in a constant expression", part
);
1801 *non_constant_p
= true;
1803 if (*non_constant_p
)
1805 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1812 /* We're in the middle of initializing it. */
1816 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
1817 && CONSTRUCTOR_NELTS (whole
) > 0)
1819 /* DR 1188 says we don't have to deal with this. */
1821 error ("accessing %qD member instead of initialized %qD member in "
1822 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
1823 *non_constant_p
= true;
1827 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
1829 /* 'whole' is part of the aggregate initializer we're currently
1830 building; if there's no initializer for this member yet, that's an
1833 error ("accessing uninitialized member %qD", part
);
1834 *non_constant_p
= true;
1838 /* If there's no explicit init for this field, it's value-initialized. */
1839 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
1840 return cxx_eval_constant_expression (ctx
, value
,
1842 non_constant_p
, overflow_p
);
1845 /* Subroutine of cxx_eval_constant_expression.
1846 Attempt to reduce a field access of a value of class type that is
1847 expressed as a BIT_FIELD_REF. */
1850 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
1852 bool *non_constant_p
, bool *overflow_p
)
1854 tree orig_whole
= TREE_OPERAND (t
, 0);
1855 tree retval
, fldval
, utype
, mask
;
1856 bool fld_seen
= false;
1857 HOST_WIDE_INT istart
, isize
;
1858 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1860 non_constant_p
, overflow_p
);
1861 tree start
, field
, value
;
1862 unsigned HOST_WIDE_INT i
;
1864 if (whole
== orig_whole
)
1866 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1868 if (!*non_constant_p
1869 && TREE_CODE (whole
) != VECTOR_CST
1870 && TREE_CODE (whole
) != CONSTRUCTOR
)
1873 error ("%qE is not a constant expression", orig_whole
);
1874 *non_constant_p
= true;
1876 if (*non_constant_p
)
1879 if (TREE_CODE (whole
) == VECTOR_CST
)
1880 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
1881 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
1883 start
= TREE_OPERAND (t
, 2);
1884 istart
= tree_to_shwi (start
);
1885 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
1886 utype
= TREE_TYPE (t
);
1887 if (!TYPE_UNSIGNED (utype
))
1888 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
1889 retval
= build_int_cst (utype
, 0);
1890 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1892 tree bitpos
= bit_position (field
);
1893 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
1895 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
1896 && TREE_CODE (value
) == INTEGER_CST
1897 && tree_fits_shwi_p (bitpos
)
1898 && tree_fits_shwi_p (DECL_SIZE (field
)))
1900 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
1901 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
1902 HOST_WIDE_INT shift
;
1903 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
1905 fldval
= fold_convert (utype
, value
);
1906 mask
= build_int_cst_type (utype
, -1);
1907 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
1908 size_int (TYPE_PRECISION (utype
) - sz
));
1909 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
1910 size_int (TYPE_PRECISION (utype
) - sz
));
1911 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
1912 shift
= bit
- istart
;
1913 if (BYTES_BIG_ENDIAN
)
1914 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
1915 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
1917 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
1923 return fold_convert (TREE_TYPE (t
), retval
);
1925 return error_mark_node
;
1928 /* Subroutine of cxx_eval_constant_expression.
1929 Evaluate a short-circuited logical expression T in the context
1930 of a given constexpr CALL. BAILOUT_VALUE is the value for
1931 early return. CONTINUE_VALUE is used here purely for
1932 sanity check purposes. */
1935 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
1936 tree bailout_value
, tree continue_value
,
1938 bool *non_constant_p
, bool *overflow_p
)
1941 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1943 non_constant_p
, overflow_p
);
1944 VERIFY_CONSTANT (lhs
);
1945 if (tree_int_cst_equal (lhs
, bailout_value
))
1947 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
1948 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1949 lval
, non_constant_p
,
1951 VERIFY_CONSTANT (r
);
1955 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
1956 CONSTRUCTOR elements to initialize (part of) an object containing that
1957 field. Return a pointer to the constructor_elt corresponding to the
1958 initialization of the field. */
1960 static constructor_elt
*
1961 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
1963 tree aggr
= TREE_OPERAND (ref
, 0);
1964 tree field
= TREE_OPERAND (ref
, 1);
1966 constructor_elt
*ce
;
1968 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
1970 if (TREE_CODE (aggr
) == COMPONENT_REF
)
1972 constructor_elt
*base_ce
1973 = base_field_constructor_elt (v
, aggr
);
1974 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
1977 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
1978 if (ce
->index
== field
)
1985 /* Some of the expressions fed to the constexpr mechanism are calls to
1986 constructors, which have type void. In that case, return the type being
1987 initialized by the constructor. */
1990 initialized_type (tree t
)
1994 tree type
= cv_unqualified (TREE_TYPE (t
));
1995 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
1997 /* A constructor call has void type, so we need to look deeper. */
1998 tree fn
= get_function_named_in_call (t
);
1999 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2000 && DECL_CXX_CONSTRUCTOR_P (fn
))
2001 type
= DECL_CONTEXT (fn
);
2006 /* We're about to initialize element INDEX of an array or class from VALUE.
2007 Set up NEW_CTX appropriately by adjusting .object to refer to the
2008 subobject and creating a new CONSTRUCTOR if the element is itself
2009 a class or array. */
2012 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2013 tree index
, tree
&value
)
2017 if (index
&& TREE_CODE (index
) != INTEGER_CST
2018 && TREE_CODE (index
) != FIELD_DECL
)
2019 /* This won't have an element in the new CONSTRUCTOR. */
2022 tree type
= initialized_type (value
);
2023 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2024 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2027 /* The sub-aggregate initializer might contain a placeholder;
2028 update object to refer to the subobject and ctor to refer to
2029 the (newly created) sub-initializer. */
2031 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2032 tree elt
= build_constructor (type
, NULL
);
2033 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2036 if (TREE_CODE (value
) == TARGET_EXPR
)
2037 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2038 value
= TARGET_EXPR_INITIAL (value
);
2041 /* We're about to process an initializer for a class or array TYPE. Make
2042 sure that CTX is set up appropriately. */
2045 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2047 /* We don't bother building a ctor for an empty base subobject. */
2048 if (is_empty_class (type
))
2051 /* We're in the middle of an initializer that might involve placeholders;
2052 our caller should have created a CONSTRUCTOR for us to put the
2053 initializer into. We will either return that constructor or T. */
2054 gcc_assert (ctx
->ctor
);
2055 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2056 (type
, TREE_TYPE (ctx
->ctor
)));
2057 gcc_assert (CONSTRUCTOR_NELTS (ctx
->ctor
) == 0);
2059 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2060 (type
, TREE_TYPE (ctx
->object
)));
2061 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2062 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2065 /* Subroutine of cxx_eval_constant_expression.
2066 The expression tree T denotes a C-style array or a C-style
2067 aggregate. Reduce it to a constant expression. */
2070 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2072 bool *non_constant_p
, bool *overflow_p
)
2074 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2075 bool changed
= false;
2076 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2078 verify_ctor_sanity (ctx
, TREE_TYPE (t
));
2079 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2080 vec_alloc (*p
, vec_safe_length (v
));
2082 unsigned i
; tree index
, value
;
2083 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2085 constexpr_ctx new_ctx
;
2086 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2087 if (new_ctx
.ctor
!= ctx
->ctor
)
2088 /* If we built a new CONSTRUCTOR, attach it now so that other
2089 initializers can refer to it. */
2090 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2091 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2093 non_constant_p
, overflow_p
);
2094 /* Don't VERIFY_CONSTANT here. */
2095 if (ctx
->quiet
&& *non_constant_p
)
2099 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2101 /* This is an initialization of a vfield inside a base
2102 subaggregate that we already initialized; push this
2103 initialization into the previous initialization. */
2104 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2109 && (TREE_CODE (index
) == NOP_EXPR
2110 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2112 /* This is an initializer for an empty base; now that we've
2113 checked that it's constant, we can ignore it. */
2114 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2117 else if (new_ctx
.ctor
!= ctx
->ctor
)
2119 /* We appended this element above; update the value. */
2120 gcc_assert ((*p
)->last().index
== index
);
2121 (*p
)->last().value
= elt
;
2124 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2126 if (*non_constant_p
|| !changed
)
2129 /* We're done building this CONSTRUCTOR, so now we can interpret an
2130 element without an explicit initializer as value-initialized. */
2131 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2132 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2137 /* Subroutine of cxx_eval_constant_expression.
2138 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2139 initialization of a non-static data member of array type. Reduce it to a
2142 Note that apart from value-initialization (when VALUE_INIT is true),
2143 this is only intended to support value-initialization and the
2144 initializations done by defaulted constructors for classes with
2145 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2146 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2147 for the copy/move constructor. */
2150 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2151 bool value_init
, bool lval
,
2152 bool *non_constant_p
, bool *overflow_p
)
2154 tree elttype
= TREE_TYPE (atype
);
2155 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2156 verify_ctor_sanity (ctx
, atype
);
2157 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2158 vec_alloc (*p
, max
+ 1);
2159 bool pre_init
= false;
2160 unsigned HOST_WIDE_INT i
;
2162 /* For the default constructor, build up a call to the default
2163 constructor of the element type. We only need to handle class types
2164 here, as for a constructor to be constexpr, all members must be
2165 initialized, which for a defaulted default constructor means they must
2166 be of a class type with a constexpr default constructor. */
2167 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2168 /* We only do this at the lowest level. */;
2169 else if (value_init
)
2171 init
= build_value_init (elttype
, tf_warning_or_error
);
2176 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2177 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2178 &argvec
, elttype
, LOOKUP_NORMAL
,
2179 tf_warning_or_error
);
2180 release_tree_vector (argvec
);
2181 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2185 for (i
= 0; i
< max
; ++i
)
2187 tree idx
= build_int_cst (size_type_node
, i
);
2189 constexpr_ctx new_ctx
;
2190 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2191 if (new_ctx
.ctor
!= ctx
->ctor
)
2192 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2193 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2195 /* A multidimensional array; recurse. */
2196 if (value_init
|| init
== NULL_TREE
)
2197 eltinit
= NULL_TREE
;
2199 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2200 tf_warning_or_error
);
2201 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2203 non_constant_p
, overflow_p
);
2207 /* Initializing an element using value or default initialization
2208 we just pre-built above. */
2209 eltinit
= (cxx_eval_constant_expression
2211 lval
, non_constant_p
, overflow_p
));
2215 /* Copying an element. */
2216 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2217 (atype
, TREE_TYPE (init
)));
2218 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2219 tf_warning_or_error
);
2220 if (!real_lvalue_p (init
))
2221 eltinit
= move (eltinit
);
2222 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2223 eltinit
= (cxx_eval_constant_expression
2224 (&new_ctx
, eltinit
, lval
,
2225 non_constant_p
, overflow_p
));
2227 if (*non_constant_p
&& !ctx
->quiet
)
2229 if (new_ctx
.ctor
!= ctx
->ctor
)
2231 /* We appended this element above; update the value. */
2232 gcc_assert ((*p
)->last().index
== idx
);
2233 (*p
)->last().value
= eltinit
;
2236 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2239 if (!*non_constant_p
)
2242 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2248 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2250 bool *non_constant_p
, bool *overflow_p
)
2252 tree atype
= TREE_TYPE (t
);
2253 tree init
= VEC_INIT_EXPR_INIT (t
);
2254 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2255 VEC_INIT_EXPR_VALUE_INIT (t
),
2256 lval
, non_constant_p
, overflow_p
);
2257 if (*non_constant_p
)
2263 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2264 match. We want to be less strict for simple *& folding; if we have a
2265 non-const temporary that we access through a const pointer, that should
2266 work. We handle this here rather than change fold_indirect_ref_1
2267 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2268 don't really make sense outside of constant expression evaluation. Also
2269 we want to allow folding to COMPONENT_REF, which could cause trouble
2270 with TBAA in fold_indirect_ref_1.
2272 Try to keep this function synced with fold_indirect_ref_1. */
2275 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2281 subtype
= TREE_TYPE (sub
);
2282 if (!POINTER_TYPE_P (subtype
))
2285 if (TREE_CODE (sub
) == ADDR_EXPR
)
2287 tree op
= TREE_OPERAND (sub
, 0);
2288 tree optype
= TREE_TYPE (op
);
2290 /* *&CONST_DECL -> to the value of the const decl. */
2291 if (TREE_CODE (op
) == CONST_DECL
)
2292 return DECL_INITIAL (op
);
2293 /* *&p => p; make sure to handle *&"str"[cst] here. */
2294 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
2296 tree fop
= fold_read_from_constant_string (op
);
2302 /* *(foo *)&fooarray => fooarray[0] */
2303 else if (TREE_CODE (optype
) == ARRAY_TYPE
2304 && (same_type_ignoring_top_level_qualifiers_p
2305 (type
, TREE_TYPE (optype
))))
2307 tree type_domain
= TYPE_DOMAIN (optype
);
2308 tree min_val
= size_zero_node
;
2309 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2310 min_val
= TYPE_MIN_VALUE (type_domain
);
2311 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2312 NULL_TREE
, NULL_TREE
);
2314 /* *(foo *)&complexfoo => __real__ complexfoo */
2315 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2316 && (same_type_ignoring_top_level_qualifiers_p
2317 (type
, TREE_TYPE (optype
))))
2318 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2319 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2320 else if (TREE_CODE (optype
) == VECTOR_TYPE
2321 && (same_type_ignoring_top_level_qualifiers_p
2322 (type
, TREE_TYPE (optype
))))
2324 tree part_width
= TYPE_SIZE (type
);
2325 tree index
= bitsize_int (0);
2326 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2328 /* Also handle conversion to an empty base class, which
2329 is represented with a NOP_EXPR. */
2330 else if (is_empty_class (type
)
2331 && CLASS_TYPE_P (optype
)
2332 && DERIVED_FROM_P (type
, optype
))
2337 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2338 else if (RECORD_OR_UNION_TYPE_P (optype
))
2340 tree field
= TYPE_FIELDS (optype
);
2341 for (; field
; field
= DECL_CHAIN (field
))
2342 if (TREE_CODE (field
) == FIELD_DECL
2343 && integer_zerop (byte_position (field
))
2344 && (same_type_ignoring_top_level_qualifiers_p
2345 (TREE_TYPE (field
), type
)))
2347 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2352 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2353 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2355 tree op00
= TREE_OPERAND (sub
, 0);
2356 tree op01
= TREE_OPERAND (sub
, 1);
2359 if (TREE_CODE (op00
) == ADDR_EXPR
)
2362 op00
= TREE_OPERAND (op00
, 0);
2363 op00type
= TREE_TYPE (op00
);
2365 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2366 if (TREE_CODE (op00type
) == VECTOR_TYPE
2367 && (same_type_ignoring_top_level_qualifiers_p
2368 (type
, TREE_TYPE (op00type
))))
2370 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2371 tree part_width
= TYPE_SIZE (type
);
2372 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2373 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2374 tree index
= bitsize_int (indexi
);
2376 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2377 return fold_build3_loc (loc
,
2378 BIT_FIELD_REF
, type
, op00
,
2382 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2383 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2384 && (same_type_ignoring_top_level_qualifiers_p
2385 (type
, TREE_TYPE (op00type
))))
2387 tree size
= TYPE_SIZE_UNIT (type
);
2388 if (tree_int_cst_equal (size
, op01
))
2389 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2391 /* ((foo *)&fooarray)[1] => fooarray[1] */
2392 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2393 && (same_type_ignoring_top_level_qualifiers_p
2394 (type
, TREE_TYPE (op00type
))))
2396 tree type_domain
= TYPE_DOMAIN (op00type
);
2397 tree min_val
= size_zero_node
;
2398 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2399 min_val
= TYPE_MIN_VALUE (type_domain
);
2400 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2401 TYPE_SIZE_UNIT (type
));
2402 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2403 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2404 NULL_TREE
, NULL_TREE
);
2406 /* Also handle conversion to an empty base class, which
2407 is represented with a NOP_EXPR. */
2408 else if (is_empty_class (type
)
2409 && CLASS_TYPE_P (op00type
)
2410 && DERIVED_FROM_P (type
, op00type
))
2415 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2416 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2418 tree field
= TYPE_FIELDS (op00type
);
2419 for (; field
; field
= DECL_CHAIN (field
))
2420 if (TREE_CODE (field
) == FIELD_DECL
2421 && tree_int_cst_equal (byte_position (field
), op01
)
2422 && (same_type_ignoring_top_level_qualifiers_p
2423 (TREE_TYPE (field
), type
)))
2425 return fold_build3 (COMPONENT_REF
, type
, op00
,
2432 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2433 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2434 && (same_type_ignoring_top_level_qualifiers_p
2435 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2438 tree min_val
= size_zero_node
;
2439 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2443 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2444 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2445 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2446 min_val
= TYPE_MIN_VALUE (type_domain
);
2447 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2455 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2457 bool *non_constant_p
, bool *overflow_p
)
2459 tree orig_op0
= TREE_OPERAND (t
, 0);
2460 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2461 /*lval*/false, non_constant_p
,
2463 bool empty_base
= false;
2466 /* Don't VERIFY_CONSTANT here. */
2467 if (*non_constant_p
)
2470 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2474 r
= cxx_eval_constant_expression (ctx
, r
,
2475 lval
, non_constant_p
, overflow_p
);
2480 if (TREE_CODE (sub
) == ADDR_EXPR
)
2482 /* We couldn't fold to a constant value. Make sure it's not
2483 something we should have been able to fold. */
2484 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2485 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
2486 /* DR 1188 says we don't have to deal with this. */
2488 error ("accessing value of %qE through a %qT glvalue in a "
2489 "constant expression", build_fold_indirect_ref (sub
),
2491 *non_constant_p
= true;
2496 /* If we're pulling out the value of an empty base, make sure
2497 that the whole object is constant and then return an empty
2499 if (empty_base
&& !lval
)
2501 VERIFY_CONSTANT (r
);
2502 r
= build_constructor (TREE_TYPE (t
), NULL
);
2503 TREE_CONSTANT (r
) = true;
2508 if (lval
&& op0
!= orig_op0
)
2509 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
2511 VERIFY_CONSTANT (t
);
2517 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2518 Shared between potential_constant_expression and
2519 cxx_eval_constant_expression. */
2522 non_const_var_error (tree r
)
2524 tree type
= TREE_TYPE (r
);
2525 error ("the value of %qD is not usable in a constant "
2527 /* Avoid error cascade. */
2528 if (DECL_INITIAL (r
) == error_mark_node
)
2530 if (DECL_DECLARED_CONSTEXPR_P (r
))
2531 inform (DECL_SOURCE_LOCATION (r
),
2532 "%qD used in its own initializer", r
);
2533 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
2535 if (!CP_TYPE_CONST_P (type
))
2536 inform (DECL_SOURCE_LOCATION (r
),
2537 "%q#D is not const", r
);
2538 else if (CP_TYPE_VOLATILE_P (type
))
2539 inform (DECL_SOURCE_LOCATION (r
),
2540 "%q#D is volatile", r
);
2541 else if (!DECL_INITIAL (r
)
2542 || !TREE_CONSTANT (DECL_INITIAL (r
)))
2543 inform (DECL_SOURCE_LOCATION (r
),
2544 "%qD was not initialized with a constant "
2551 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
2552 inform (DECL_SOURCE_LOCATION (r
),
2553 "%qD was not declared %<constexpr%>", r
);
2555 inform (DECL_SOURCE_LOCATION (r
),
2556 "%qD does not have integral or enumeration type",
2561 /* Subroutine of cxx_eval_constant_expression.
2562 Like cxx_eval_unary_expression, except for trinary expressions. */
2565 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
2567 bool *non_constant_p
, bool *overflow_p
)
2573 for (i
= 0; i
< 3; i
++)
2575 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
2577 non_constant_p
, overflow_p
);
2578 VERIFY_CONSTANT (args
[i
]);
2581 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
2582 args
[0], args
[1], args
[2]);
2583 if (val
== NULL_TREE
)
2585 VERIFY_CONSTANT (val
);
2590 var_in_constexpr_fn (tree t
)
2592 tree ctx
= DECL_CONTEXT (t
);
2593 return (cxx_dialect
>= cxx14
&& ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
2594 && DECL_DECLARED_CONSTEXPR_P (ctx
));
2597 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
2600 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
2602 bool *non_constant_p
, bool *overflow_p
)
2604 constexpr_ctx new_ctx
= *ctx
;
2606 /* First we figure out where we're storing to. */
2607 tree target
= TREE_OPERAND (t
, 0);
2608 target
= cxx_eval_constant_expression (ctx
, target
,
2610 non_constant_p
, overflow_p
);
2611 if (*non_constant_p
)
2614 /* And then find the underlying variable. */
2615 vec
<tree
,va_gc
> *refs
= make_tree_vector();
2616 tree object
= NULL_TREE
;
2617 for (tree probe
= target
; object
== NULL_TREE
; )
2619 switch (TREE_CODE (probe
))
2624 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
2625 vec_safe_push (refs
, TREE_TYPE (probe
));
2626 probe
= TREE_OPERAND (probe
, 0);
2634 /* And then find/build up our initializer for the path to the subobject
2635 we're initializing. */
2637 if (DECL_P (object
))
2638 valp
= ctx
->values
->get (object
);
2643 /* A constant-expression cannot modify objects from outside the
2644 constant-expression. */
2646 error ("modification of %qE is not a constant-expression", object
);
2647 *non_constant_p
= true;
2650 tree type
= TREE_TYPE (object
);
2651 while (!refs
->is_empty())
2653 if (*valp
== NULL_TREE
)
2655 *valp
= build_constructor (type
, NULL
);
2656 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = true;
2661 ce
.index
= refs
->pop();
2662 ce
.value
= NULL_TREE
;
2664 unsigned HOST_WIDE_INT idx
= 0;
2665 constructor_elt
*cep
= NULL
;
2667 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
2670 if (cp_tree_equal (ce
.index
, cep
->index
))
2673 cep
= vec_safe_push (CONSTRUCTOR_ELTS (*valp
), ce
);
2676 release_tree_vector (refs
);
2678 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
2680 /* Create a new CONSTRUCTOR in case evaluation of the initializer
2681 wants to modify it. */
2682 *valp
= new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
2683 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
2684 new_ctx
.object
= target
;
2687 tree init
= cxx_eval_constant_expression (&new_ctx
, TREE_OPERAND (t
, 1),
2689 non_constant_p
, overflow_p
);
2690 if (target
== object
)
2691 /* The hash table might have moved since the get earlier. */
2692 ctx
->values
->put (object
, init
);
2696 if (*non_constant_p
)
2704 /* Evaluate a ++ or -- expression. */
2707 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
2709 bool *non_constant_p
, bool *overflow_p
)
2711 enum tree_code code
= TREE_CODE (t
);
2712 tree type
= TREE_TYPE (t
);
2713 tree op
= TREE_OPERAND (t
, 0);
2714 tree offset
= TREE_OPERAND (t
, 1);
2715 gcc_assert (TREE_CONSTANT (offset
));
2717 /* The operand as an lvalue. */
2718 op
= cxx_eval_constant_expression (ctx
, op
, true,
2719 non_constant_p
, overflow_p
);
2721 /* The operand as an rvalue. */
2722 tree val
= rvalue (op
);
2723 val
= cxx_eval_constant_expression (ctx
, val
, false,
2724 non_constant_p
, overflow_p
);
2725 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2726 a local array in a constexpr function. */
2727 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
2729 VERIFY_CONSTANT (val
);
2731 /* The modified value. */
2732 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
2734 if (POINTER_TYPE_P (type
))
2736 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
2737 offset
= convert_to_ptrofftype (offset
);
2739 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
2740 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
2743 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
2745 VERIFY_CONSTANT (mod
);
2747 /* Storing the modified value. */
2748 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
2749 cxx_eval_constant_expression (ctx
, store
,
2750 true, non_constant_p
, overflow_p
);
2752 /* And the value of the expression. */
2753 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
2755 /* Prefix ops are lvalues. */
2759 /* But we optimize when the caller wants an rvalue. */
2763 /* Postfix ops are rvalues. */
2767 /* Predicates for the meaning of *jump_target. */
2770 returns (tree
*jump_target
)
2773 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
2777 breaks (tree
*jump_target
)
2780 && TREE_CODE (*jump_target
) == LABEL_DECL
2781 && LABEL_DECL_BREAK (*jump_target
);
2785 continues (tree
*jump_target
)
2788 && TREE_CODE (*jump_target
) == LABEL_DECL
2789 && LABEL_DECL_CONTINUE (*jump_target
);
2793 switches (tree
*jump_target
)
2796 && TREE_CODE (*jump_target
) == INTEGER_CST
;
2799 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
2800 at I matches *jump_target. If we're looking for a case label and we see
2801 the default label, copy I into DEFAULT_LABEL. */
2804 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
2805 tree_stmt_iterator
& default_label
)
2807 tree stmt
= tsi_stmt (i
);
2808 switch (TREE_CODE (*jump_target
))
2811 if (TREE_CODE (stmt
) == LABEL_EXPR
2812 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
2817 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
2819 if (!CASE_LOW (stmt
))
2821 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
2832 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
2833 semantics, for switch, break, continue, and return. */
2836 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
2837 bool *non_constant_p
, bool *overflow_p
,
2840 tree_stmt_iterator i
;
2841 tree_stmt_iterator default_label
= tree_stmt_iterator();
2843 /* In a statement-expression we want to return the last value. */
2847 local_target
= NULL_TREE
;
2848 jump_target
= &local_target
;
2850 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
2853 tree stmt
= tsi_stmt (i
);
2856 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
2857 /* The label we want might be inside. */;
2858 else if (label_matches (jump_target
, i
, default_label
))
2860 *jump_target
= NULL_TREE
;
2864 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
2865 non_constant_p
, overflow_p
,
2867 if (*non_constant_p
)
2869 if (returns (jump_target
) || breaks (jump_target
))
2872 if (switches (jump_target
) && !tsi_end_p (default_label
))
2875 *jump_target
= NULL_TREE
;
2881 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
2882 semantics; continue semantics are covered by cxx_eval_statement_list. */
2885 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
2886 bool *non_constant_p
, bool *overflow_p
,
2889 tree body
= TREE_OPERAND (t
, 0);
2892 cxx_eval_statement_list (ctx
, body
,
2893 non_constant_p
, overflow_p
, jump_target
);
2894 if (returns (jump_target
) || breaks (jump_target
) || *non_constant_p
)
2897 if (breaks (jump_target
))
2898 *jump_target
= NULL_TREE
;
2902 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
2906 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
2907 bool *non_constant_p
, bool *overflow_p
,
2910 tree cond
= TREE_OPERAND (t
, 0);
2911 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
2912 non_constant_p
, overflow_p
);
2913 VERIFY_CONSTANT (cond
);
2914 *jump_target
= cond
;
2916 tree body
= TREE_OPERAND (t
, 1);
2917 cxx_eval_statement_list (ctx
, body
,
2918 non_constant_p
, overflow_p
, jump_target
);
2919 if (breaks (jump_target
) || switches (jump_target
))
2920 *jump_target
= NULL_TREE
;
2924 /* Attempt to reduce the expression T to a constant value.
2925 On failure, issue diagnostic and return error_mark_node. */
2926 /* FIXME unify with c_fully_fold */
2927 /* FIXME overflow_p is too global */
2930 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
2932 bool *non_constant_p
, bool *overflow_p
,
2935 constexpr_ctx new_ctx
;
2938 if (t
== error_mark_node
)
2940 *non_constant_p
= true;
2943 if (CONSTANT_CLASS_P (t
))
2945 if (TREE_CODE (t
) == PTRMEM_CST
)
2946 t
= cplus_expand_constant (t
);
2947 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| ctx
->quiet
))
2952 switch (TREE_CODE (t
))
2957 /* We ask for an rvalue for the RESULT_DECL when indirecting
2958 through an invisible reference, or in named return value
2960 return (*ctx
->values
->get (t
));
2964 /* We used to not check lval for CONST_DECL, but darwin.c uses
2965 CONST_DECL for aggregate constants. */
2969 r
= decl_really_constant_value (t
);
2971 r
= decl_constant_value (t
);
2972 if (TREE_CODE (r
) == TARGET_EXPR
2973 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
2974 r
= TARGET_EXPR_INITIAL (r
);
2975 if (TREE_CODE (r
) == VAR_DECL
)
2976 if (tree
*p
= ctx
->values
->get (r
))
2981 non_const_var_error (r
);
2982 *non_constant_p
= true;
2990 case CASE_LABEL_EXPR
:
2994 if (!use_new_call
&& ctx
2995 && ctx
->call
&& DECL_CONTEXT (t
) == ctx
->call
->fundef
->decl
)
2996 r
= lookup_parameter_binding (ctx
->call
, t
);
2997 else if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
2999 else if (tree
*p
= ctx
->values
->get (r
))
3002 /* Defer in case this is only used for its type. */;
3003 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3004 /* Defer, there's no lvalue->rvalue conversion. */;
3005 else if (is_empty_class (TREE_TYPE (t
)))
3007 /* If the class is empty, we aren't actually loading anything. */
3008 r
= build_constructor (TREE_TYPE (t
), NULL
);
3009 TREE_CONSTANT (r
) = true;
3014 error ("%qE is not a constant expression", t
);
3015 *non_constant_p
= true;
3020 case AGGR_INIT_EXPR
:
3021 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3022 non_constant_p
, overflow_p
);
3027 r
= DECL_EXPR_DECL (t
);
3028 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3029 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3033 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3034 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3035 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3039 if (tree init
= DECL_INITIAL (r
))
3041 init
= cxx_eval_constant_expression (ctx
, init
,
3043 non_constant_p
, overflow_p
);
3044 ctx
->values
->put (r
, init
);
3046 else if (ctx
== &new_ctx
)
3047 /* We gave it a CONSTRUCTOR above. */;
3049 ctx
->values
->put (r
, NULL_TREE
);
3054 if (!literal_type_p (TREE_TYPE (t
)))
3058 error ("temporary of non-literal type %qT in a "
3059 "constant expression", TREE_TYPE (t
));
3060 explain_non_literal_class (TREE_TYPE (t
));
3062 *non_constant_p
= true;
3065 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3067 /* We're being expanded without an explicit target, so start
3068 initializing a new object; expansion with an explicit target
3069 strips the TARGET_EXPR before we get here. */
3071 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3072 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3073 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3074 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3077 /* Pass false for 'lval' because this indicates
3078 initialization of a temporary. */
3079 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3081 non_constant_p
, overflow_p
);
3082 if (!*non_constant_p
)
3083 /* Adjust the type of the result to the type of the temporary. */
3084 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3087 tree slot
= TARGET_EXPR_SLOT (t
);
3088 ctx
->values
->put (slot
, r
);
3096 /* In C++11 constexpr evaluation we are looking for the value,
3097 not the side-effect of the initialization. */
3098 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3100 non_constant_p
, overflow_p
);
3103 /* else fall through */
3105 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3106 non_constant_p
, overflow_p
);
3110 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3112 non_constant_p
, overflow_p
);
3116 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
3117 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3119 non_constant_p
, overflow_p
);
3124 /* Avoid evaluating a SAVE_EXPR more than once. */
3125 if (tree
*p
= ctx
->values
->get (t
))
3129 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3130 non_constant_p
, overflow_p
);
3131 ctx
->values
->put (t
, r
);
3135 case NON_LVALUE_EXPR
:
3136 case TRY_CATCH_EXPR
:
3137 case CLEANUP_POINT_EXPR
:
3138 case MUST_NOT_THROW_EXPR
:
3141 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3143 non_constant_p
, overflow_p
,
3147 /* These differ from cxx_eval_unary_expression in that this doesn't
3148 check for a constant operand or result; an address can be
3149 constant without its operand being, and vice versa. */
3151 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3152 non_constant_p
, overflow_p
);
3157 tree oldop
= TREE_OPERAND (t
, 0);
3158 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3160 non_constant_p
, overflow_p
);
3161 /* Don't VERIFY_CONSTANT here. */
3162 if (*non_constant_p
)
3164 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3165 /* This function does more aggressive folding than fold itself. */
3166 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3167 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3175 case FIX_TRUNC_EXPR
:
3180 case TRUTH_NOT_EXPR
:
3181 case FIXED_CONVERT_EXPR
:
3182 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3183 non_constant_p
, overflow_p
);
3187 if (SIZEOF_EXPR_TYPE_P (t
))
3188 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
3189 SIZEOF_EXPR
, false);
3190 else if (TYPE_P (TREE_OPERAND (t
, 0)))
3191 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3194 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3196 if (r
== error_mark_node
)
3198 VERIFY_CONSTANT (r
);
3203 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3204 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3205 introduced by build_call_a. */
3206 tree op0
= TREE_OPERAND (t
, 0);
3207 tree op1
= TREE_OPERAND (t
, 1);
3209 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3210 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3211 r
= cxx_eval_constant_expression (ctx
, op0
,
3212 lval
, non_constant_p
, overflow_p
,
3216 /* Check that the LHS is constant and then discard it. */
3217 cxx_eval_constant_expression (ctx
, op0
,
3218 true, non_constant_p
, overflow_p
,
3220 op1
= TREE_OPERAND (t
, 1);
3221 r
= cxx_eval_constant_expression (ctx
, op1
,
3222 lval
, non_constant_p
, overflow_p
,
3228 case POINTER_PLUS_EXPR
:
3232 case TRUNC_DIV_EXPR
:
3234 case FLOOR_DIV_EXPR
:
3235 case ROUND_DIV_EXPR
:
3236 case TRUNC_MOD_EXPR
:
3238 case ROUND_MOD_EXPR
:
3240 case EXACT_DIV_EXPR
:
3250 case TRUTH_XOR_EXPR
:
3257 case UNORDERED_EXPR
:
3267 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3268 non_constant_p
, overflow_p
);
3271 /* fold can introduce non-IF versions of these; still treat them as
3272 short-circuiting. */
3273 case TRUTH_AND_EXPR
:
3274 case TRUTH_ANDIF_EXPR
:
3275 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
3278 non_constant_p
, overflow_p
);
3282 case TRUTH_ORIF_EXPR
:
3283 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
3286 non_constant_p
, overflow_p
);
3290 r
= cxx_eval_array_reference (ctx
, t
, lval
,
3291 non_constant_p
, overflow_p
);
3295 if (is_overloaded_fn (t
))
3297 /* We can only get here in checking mode via
3298 build_non_dependent_expr, because any expression that
3299 calls or takes the address of the function will have
3300 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3301 gcc_checking_assert (ctx
->quiet
|| errorcount
);
3302 *non_constant_p
= true;
3305 r
= cxx_eval_component_reference (ctx
, t
, lval
,
3306 non_constant_p
, overflow_p
);
3310 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
3311 non_constant_p
, overflow_p
);
3316 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
3317 non_constant_p
, overflow_p
,
3322 if (TREE_CONSTANT (t
))
3323 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3324 VECTOR_CST if applicable. */
3326 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
3327 non_constant_p
, overflow_p
);
3331 /* We can get this in a defaulted constructor for a class with a
3332 non-static data member of array type. Either the initializer will
3333 be NULL, meaning default-initialization, or it will be an lvalue
3334 or xvalue of the same type, meaning direct-initialization from the
3335 corresponding member. */
3336 r
= cxx_eval_vec_init (ctx
, t
, lval
,
3337 non_constant_p
, overflow_p
);
3342 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
3343 non_constant_p
, overflow_p
);
3347 case VIEW_CONVERT_EXPR
:
3350 tree oldop
= TREE_OPERAND (t
, 0);
3351 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3353 non_constant_p
, overflow_p
);
3354 if (*non_constant_p
)
3356 if (POINTER_TYPE_P (TREE_TYPE (t
))
3357 && TREE_CODE (op
) == INTEGER_CST
3358 && !integer_zerop (op
))
3361 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3362 "reinterpret_cast from integer to pointer");
3363 *non_constant_p
= true;
3367 /* We didn't fold at the top so we could check for ptr-int
3370 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
3371 /* Conversion of an out-of-range value has implementation-defined
3372 behavior; the language considers it different from arithmetic
3373 overflow, which is undefined. */
3374 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
3375 TREE_OVERFLOW (r
) = false;
3379 case EMPTY_CLASS_EXPR
:
3380 /* This is good enough for a function argument that might not get
3381 used, and they can't do anything with it, so just return it. */
3384 case STATEMENT_LIST
:
3386 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3387 return cxx_eval_statement_list (&new_ctx
, t
,
3388 non_constant_p
, overflow_p
, jump_target
);
3391 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
3393 non_constant_p
, overflow_p
,
3396 case PREINCREMENT_EXPR
:
3397 case POSTINCREMENT_EXPR
:
3398 case PREDECREMENT_EXPR
:
3399 case POSTDECREMENT_EXPR
:
3400 return cxx_eval_increment_expression (ctx
, t
,
3401 lval
, non_constant_p
, overflow_p
);
3407 case VEC_DELETE_EXPR
:
3410 /* GCC internal stuff. */
3413 case WITH_CLEANUP_EXPR
:
3414 case NON_DEPENDENT_EXPR
:
3418 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3419 "expression %qE is not a constant-expression", t
);
3420 *non_constant_p
= true;
3423 case PLACEHOLDER_EXPR
:
3424 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
))
3426 /* A placeholder without a referent. We can get here when
3427 checking whether NSDMIs are noexcept, or in massage_init_elt;
3428 just say it's non-constant for now. */
3429 gcc_assert (ctx
->quiet
);
3430 *non_constant_p
= true;
3435 /* Use of the value or address of the current object. We could
3436 use ctx->object unconditionally, but using ctx->ctor when we
3437 can is a minor optimization. */
3438 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
3439 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3440 (TREE_TYPE (t
), TREE_TYPE (ctor
)));
3441 return cxx_eval_constant_expression
3443 non_constant_p
, overflow_p
);
3448 *jump_target
= TREE_OPERAND (t
, 0);
3449 gcc_assert (breaks (jump_target
) || continues (jump_target
));
3453 cxx_eval_loop_expr (ctx
, t
,
3454 non_constant_p
, overflow_p
, jump_target
);
3458 cxx_eval_switch_expr (ctx
, t
,
3459 non_constant_p
, overflow_p
, jump_target
);
3463 if (STATEMENT_CODE_P (TREE_CODE (t
)))
3465 /* This function doesn't know how to deal with pre-genericize
3466 statements; this can only happen with statement-expressions,
3467 so for now just fail. */
3469 error_at (EXPR_LOCATION (t
),
3470 "statement is not a constant-expression");
3473 internal_error ("unexpected expression %qE of kind %s", t
,
3474 get_tree_code_name (TREE_CODE (t
)));
3475 *non_constant_p
= true;
3479 if (r
== error_mark_node
)
3480 *non_constant_p
= true;
3482 if (*non_constant_p
)
3489 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
3490 bool strict
= true, tree object
= NULL_TREE
)
3492 bool non_constant_p
= false;
3493 bool overflow_p
= false;
3494 hash_map
<tree
,tree
> map
;
3495 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, allow_non_constant
, strict
};
3496 tree type
= initialized_type (t
);
3498 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3500 /* In C++14 an NSDMI can participate in aggregate initialization,
3501 and can refer to the address of the object being initialized, so
3502 we need to pass in the relevant VAR_DECL if we want to do the
3503 evaluation in a single pass. The evaluation will dynamically
3504 update ctx.values for the VAR_DECL. We use the same strategy
3505 for C++11 constexpr constructors that refer to the object being
3507 ctx
.ctor
= build_constructor (type
, NULL
);
3508 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
3511 if (TREE_CODE (t
) == TARGET_EXPR
)
3512 object
= TARGET_EXPR_SLOT (t
);
3513 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3514 object
= AGGR_INIT_EXPR_SLOT (t
);
3516 ctx
.object
= object
;
3518 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3519 (type
, TREE_TYPE (object
)));
3520 if (object
&& DECL_P (object
))
3521 map
.put (object
, ctx
.ctor
);
3522 if (TREE_CODE (r
) == TARGET_EXPR
)
3523 /* Avoid creating another CONSTRUCTOR when we expand the
3525 r
= TARGET_EXPR_INITIAL (r
);
3528 r
= cxx_eval_constant_expression (&ctx
, r
,
3529 false, &non_constant_p
, &overflow_p
);
3531 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
3533 /* Mutable logic is a bit tricky: we want to allow initialization of
3534 constexpr variables with mutable members, but we can't copy those
3535 members to another constexpr variable. */
3536 if (TREE_CODE (r
) == CONSTRUCTOR
3537 && CONSTRUCTOR_MUTABLE_POISON (r
))
3539 if (!allow_non_constant
)
3540 error ("%qE is not a constant expression because it refers to "
3541 "mutable subobjects of %qT", t
, type
);
3542 non_constant_p
= true;
3545 /* Technically we should check this for all subexpressions, but that
3546 runs into problems with our internal representation of pointer
3547 subtraction and the 5.19 rules are still in flux. */
3548 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
3549 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
3550 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
3552 if (!allow_non_constant
)
3553 error ("conversion from pointer type %qT "
3554 "to arithmetic type %qT in a constant-expression",
3555 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
3556 non_constant_p
= true;
3559 if (!non_constant_p
&& overflow_p
)
3560 non_constant_p
= true;
3562 if (non_constant_p
&& !allow_non_constant
)
3563 return error_mark_node
;
3564 else if (non_constant_p
&& TREE_CONSTANT (r
))
3566 /* This isn't actually constant, so unset TREE_CONSTANT. */
3569 else if (TREE_CODE (r
) == CONSTRUCTOR
)
3570 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
3572 r
= build_nop (TREE_TYPE (r
), r
);
3573 TREE_CONSTANT (r
) = false;
3575 else if (non_constant_p
|| r
== t
)
3578 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
3580 if (TREE_CODE (t
) == TARGET_EXPR
3581 && TARGET_EXPR_INITIAL (t
) == r
)
3585 r
= get_target_expr (r
);
3586 TREE_CONSTANT (r
) = true;
3594 /* Returns true if T is a valid subexpression of a constant expression,
3595 even if it isn't itself a constant expression. */
3598 is_sub_constant_expr (tree t
)
3600 bool non_constant_p
= false;
3601 bool overflow_p
= false;
3602 hash_map
<tree
, tree
> map
;
3603 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, true, true };
3604 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
3606 return !non_constant_p
&& !overflow_p
;
3609 /* If T represents a constant expression returns its reduced value.
3610 Otherwise return error_mark_node. If T is dependent, then
3614 cxx_constant_value (tree t
, tree decl
)
3616 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
3619 /* If T is a constant expression, returns its reduced value.
3620 Otherwise, if T does not have TREE_CONSTANT set, returns T.
3621 Otherwise, returns a version of T without TREE_CONSTANT. */
3624 maybe_constant_value (tree t
, tree decl
)
3628 if (instantiation_dependent_expression_p (t
)
3629 || type_unknown_p (t
)
3630 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3631 || !potential_constant_expression (t
))
3633 if (TREE_OVERFLOW_P (t
))
3635 t
= build_nop (TREE_TYPE (t
), t
);
3636 TREE_CONSTANT (t
) = false;
3641 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
3642 #ifdef ENABLE_CHECKING
3644 || CONVERT_EXPR_P (t
)
3645 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3646 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3647 || !cp_tree_equal (r
, t
));
3652 /* Like maybe_constant_value but first fully instantiate the argument.
3654 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3655 (t, tf_none) followed by maybe_constant_value but is more efficient,
3656 because calls instantiation_dependent_expression_p and
3657 potential_constant_expression at most once. */
3660 fold_non_dependent_expr (tree t
)
3665 /* If we're in a template, but T isn't value dependent, simplify
3666 it. We're supposed to treat:
3668 template <typename T> void f(T[1 + 1]);
3669 template <typename T> void f(T[2]);
3671 as two declarations of the same function, for example. */
3672 if (processing_template_decl
)
3674 if (!instantiation_dependent_expression_p (t
)
3675 && potential_constant_expression (t
))
3677 processing_template_decl_sentinel s
;
3678 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
3680 if (type_unknown_p (t
)
3681 || BRACE_ENCLOSED_INITIALIZER_P (t
))
3683 if (TREE_OVERFLOW_P (t
))
3685 t
= build_nop (TREE_TYPE (t
), t
);
3686 TREE_CONSTANT (t
) = false;
3691 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
3692 #ifdef ENABLE_CHECKING
3693 /* cp_tree_equal looks through NOPs, so allow them. */
3695 || CONVERT_EXPR_P (t
)
3696 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3697 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3698 || !cp_tree_equal (r
, t
));
3702 else if (TREE_OVERFLOW_P (t
))
3704 t
= build_nop (TREE_TYPE (t
), t
);
3705 TREE_CONSTANT (t
) = false;
3710 return maybe_constant_value (t
);
3713 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3714 than wrapped in a TARGET_EXPR. */
3717 maybe_constant_init (tree t
, tree decl
)
3719 if (TREE_CODE (t
) == EXPR_STMT
)
3720 t
= TREE_OPERAND (t
, 0);
3721 if (TREE_CODE (t
) == CONVERT_EXPR
3722 && VOID_TYPE_P (TREE_TYPE (t
)))
3723 t
= TREE_OPERAND (t
, 0);
3724 if (TREE_CODE (t
) == INIT_EXPR
)
3725 t
= TREE_OPERAND (t
, 1);
3726 if (instantiation_dependent_expression_p (t
)
3727 || type_unknown_p (t
)
3728 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3729 || !potential_static_init_expression (t
))
3730 /* Don't try to evaluate it. */;
3732 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
3733 if (TREE_CODE (t
) == TARGET_EXPR
)
3735 tree init
= TARGET_EXPR_INITIAL (t
);
3736 if (TREE_CODE (init
) == CONSTRUCTOR
)
3743 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
3744 /* Return true if the object referred to by REF has automatic or thread
3747 enum { ck_ok
, ck_bad
, ck_unknown
};
3749 check_automatic_or_tls (tree ref
)
3752 HOST_WIDE_INT bitsize
, bitpos
;
3754 int volatilep
= 0, unsignedp
= 0;
3755 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
3756 &mode
, &unsignedp
, &volatilep
, false);
3759 /* If there isn't a decl in the middle, we don't know the linkage here,
3760 and this isn't a constant expression anyway. */
3763 dk
= decl_storage_duration (decl
);
3764 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
3768 /* Return true if T denotes a potentially constant expression. Issue
3769 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
3770 an lvalue-rvalue conversion is implied.
3772 C++0x [expr.const] used to say
3774 6 An expression is a potential constant expression if it is
3775 a constant expression where all occurrences of function
3776 parameters are replaced by arbitrary constant expressions
3777 of the appropriate type.
3779 2 A conditional expression is a constant expression unless it
3780 involves one of the following as a potentially evaluated
3781 subexpression (3.2), but subexpressions of logical AND (5.14),
3782 logical OR (5.15), and conditional (5.16) operations that are
3783 not evaluated are not considered. */
3786 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
3787 tsubst_flags_t flags
)
3789 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
3790 enum { any
= false, rval
= true };
3794 if (t
== error_mark_node
)
3798 if (TREE_THIS_VOLATILE (t
))
3800 if (flags
& tf_error
)
3801 error ("expression %qE has side-effects", t
);
3804 if (CONSTANT_CLASS_P (t
))
3807 switch (TREE_CODE (t
))
3813 case TEMPLATE_ID_EXPR
:
3816 case CASE_LABEL_EXPR
:
3822 case TEMPLATE_PARM_INDEX
:
3824 case IDENTIFIER_NODE
:
3825 case USERDEF_LITERAL
:
3826 /* We can see a FIELD_DECL in a pointer-to-member expression. */
3831 case PLACEHOLDER_EXPR
:
3836 case AGGR_INIT_EXPR
:
3838 /* -- an invocation of a function other than a constexpr function
3839 or a constexpr constructor. */
3841 tree fun
= get_function_named_in_call (t
);
3842 const int nargs
= call_expr_nargs (t
);
3845 if (fun
== NULL_TREE
)
3847 if (TREE_CODE (t
) == CALL_EXPR
3848 && CALL_EXPR_FN (t
) == NULL_TREE
)
3849 switch (CALL_EXPR_IFN (t
))
3851 /* These should be ignored, they are optimized away from
3852 constexpr functions. */
3853 case IFN_UBSAN_NULL
:
3854 case IFN_UBSAN_BOUNDS
:
3855 case IFN_UBSAN_VPTR
:
3860 /* fold_call_expr can't do anything with IFN calls. */
3861 if (flags
& tf_error
)
3862 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3863 "call to internal function");
3866 if (is_overloaded_fn (fun
))
3868 if (TREE_CODE (fun
) == FUNCTION_DECL
)
3870 if (builtin_valid_in_constant_expr_p (fun
))
3872 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
3873 /* Allow any built-in function; if the expansion
3874 isn't constant, we'll deal with that then. */
3875 && !is_builtin_fn (fun
))
3877 if (flags
& tf_error
)
3879 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3880 "call to non-constexpr function %qD", fun
);
3881 explain_invalid_constexpr_fn (fun
);
3885 /* A call to a non-static member function takes the address
3886 of the object as the first argument. But in a constant
3887 expression the address will be folded away, so look
3889 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
3890 && !DECL_CONSTRUCTOR_P (fun
))
3892 tree x
= get_nth_callarg (t
, 0);
3893 if (is_this_parameter (x
))
3895 else if (!RECUR (x
, rval
))
3902 if (!RECUR (fun
, true))
3904 fun
= get_first_fn (fun
);
3906 /* Skip initial arguments to base constructors. */
3907 if (DECL_BASE_CONSTRUCTOR_P (fun
))
3908 i
= num_artificial_parms_for (fun
);
3909 fun
= DECL_ORIGIN (fun
);
3913 if (RECUR (fun
, rval
))
3914 /* Might end up being a constant function pointer. */;
3918 for (; i
< nargs
; ++i
)
3920 tree x
= get_nth_callarg (t
, i
);
3921 /* In a template, reference arguments haven't been converted to
3922 REFERENCE_TYPE and we might not even know if the parameter
3923 is a reference, so accept lvalue constants too. */
3924 bool rv
= processing_template_decl
? any
: rval
;
3931 case NON_LVALUE_EXPR
:
3932 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
3933 -- an lvalue of integral type that refers to a non-volatile
3934 const variable or static data member initialized with
3935 constant expressions, or
3937 -- an lvalue of literal type that refers to non-volatile
3938 object defined with constexpr, or that refers to a
3939 sub-object of such an object; */
3940 return RECUR (TREE_OPERAND (t
, 0), rval
);
3944 && !decl_constant_var_p (t
)
3946 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
3947 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
3948 && !var_in_constexpr_fn (t
)
3949 && !type_dependent_expression_p (t
))
3951 if (flags
& tf_error
)
3952 non_const_var_error (t
);
3959 case VIEW_CONVERT_EXPR
:
3960 /* -- a reinterpret_cast. FIXME not implemented, and this rule
3961 may change to something more specific to type-punning (DR 1312). */
3963 tree from
= TREE_OPERAND (t
, 0);
3964 if (POINTER_TYPE_P (TREE_TYPE (t
))
3965 && TREE_CODE (from
) == INTEGER_CST
3966 && !integer_zerop (from
))
3968 if (flags
& tf_error
)
3969 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3970 "reinterpret_cast from integer to pointer");
3973 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
3977 /* -- a unary operator & that is applied to an lvalue that
3978 designates an object with thread or automatic storage
3980 t
= TREE_OPERAND (t
, 0);
3982 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
3983 /* A pointer-to-member constant. */
3987 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
3988 any checking here, as we might dereference the pointer later. If
3989 we remove this code, also remove check_automatic_or_tls. */
3990 i
= check_automatic_or_tls (t
);
3995 if (flags
& tf_error
)
3996 error ("address-of an object %qE with thread local or "
3997 "automatic storage is not a constant expression", t
);
4001 return RECUR (t
, any
);
4007 /* -- a class member access unless its postfix-expression is
4008 of literal type or of pointer to literal type. */
4009 /* This test would be redundant, as it follows from the
4010 postfix-expression being a potential constant expression. */
4011 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4013 case EXPR_PACK_EXPANSION
:
4014 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
4018 tree x
= TREE_OPERAND (t
, 0);
4020 if (is_this_parameter (x
))
4022 if (DECL_CONTEXT (x
)
4023 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4025 if (flags
& tf_error
)
4026 error ("use of %<this%> in a constant expression");
4031 return RECUR (x
, rval
);
4034 case STATEMENT_LIST
:
4036 tree_stmt_iterator i
;
4037 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4039 if (!RECUR (tsi_stmt (i
), any
))
4047 if (cxx_dialect
< cxx14
)
4049 if (!RECUR (TREE_OPERAND (t
, 0), any
))
4051 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
4056 if (cxx_dialect
< cxx14
)
4058 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
4060 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
4065 if (!RECUR (IF_COND (t
), rval
))
4067 if (!RECUR (THEN_CLAUSE (t
), any
))
4069 if (!RECUR (ELSE_CLAUSE (t
), any
))
4074 if (!RECUR (DO_COND (t
), rval
))
4076 if (!RECUR (DO_BODY (t
), any
))
4081 if (!RECUR (FOR_INIT_STMT (t
), any
))
4083 if (!RECUR (FOR_COND (t
), rval
))
4085 if (!RECUR (FOR_EXPR (t
), any
))
4087 if (!RECUR (FOR_BODY (t
), any
))
4092 if (!RECUR (WHILE_COND (t
), rval
))
4094 if (!RECUR (WHILE_BODY (t
), any
))
4099 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
4101 if (!RECUR (SWITCH_STMT_BODY (t
), any
))
4106 return RECUR (STMT_EXPR_STMT (t
), rval
);
4109 case DYNAMIC_CAST_EXPR
:
4110 case PSEUDO_DTOR_EXPR
:
4114 case VEC_DELETE_EXPR
:
4117 case OMP_ATOMIC_READ
:
4118 case OMP_ATOMIC_CAPTURE_OLD
:
4119 case OMP_ATOMIC_CAPTURE_NEW
:
4120 /* GCC internal stuff. */
4123 case TRANSACTION_EXPR
:
4126 if (flags
& tf_error
)
4127 error ("expression %qE is not a constant-expression", t
);
4131 /* -- a typeid expression whose operand is of polymorphic
4134 tree e
= TREE_OPERAND (t
, 0);
4135 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
4136 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
4138 if (flags
& tf_error
)
4139 error ("typeid-expression is not a constant expression "
4140 "because %qE is of polymorphic type", e
);
4147 /* -- a subtraction where both operands are pointers. */
4148 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
4149 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
4151 if (flags
& tf_error
)
4152 error ("difference of two pointer expressions is not "
4153 "a constant expression");
4165 /* -- a relational or equality operator where at least
4166 one of the operands is a pointer. */
4167 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
4168 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
4170 if (flags
& tf_error
)
4171 error ("pointer comparison expression is not a "
4172 "constant expression");
4178 case PREINCREMENT_EXPR
:
4179 case POSTINCREMENT_EXPR
:
4180 case PREDECREMENT_EXPR
:
4181 case POSTDECREMENT_EXPR
:
4182 if (cxx_dialect
< cxx14
)
4188 if (TYPE_P (TREE_OPERAND (t
, 0)))
4190 /* else fall through. */
4196 case FIX_TRUNC_EXPR
:
4200 case TRUTH_NOT_EXPR
:
4201 case FIXED_CONVERT_EXPR
:
4202 case UNARY_PLUS_EXPR
:
4204 return RECUR (TREE_OPERAND (t
, 0), rval
);
4207 case CONST_CAST_EXPR
:
4208 case STATIC_CAST_EXPR
:
4209 case REINTERPRET_CAST_EXPR
:
4210 case IMPLICIT_CONV_EXPR
:
4211 if (cxx_dialect
< cxx11
4212 && !dependent_type_p (TREE_TYPE (t
))
4213 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
4214 /* In C++98, a conversion to non-integral type can't be part of a
4215 constant expression. */
4217 if (flags
& tf_error
)
4218 error ("cast to non-integral type %qT in a constant expression",
4223 return (RECUR (TREE_OPERAND (t
, 0),
4224 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
4227 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
4229 case WITH_CLEANUP_EXPR
:
4230 case CLEANUP_POINT_EXPR
:
4231 case MUST_NOT_THROW_EXPR
:
4232 case TRY_CATCH_EXPR
:
4237 case NON_DEPENDENT_EXPR
:
4238 /* For convenience. */
4240 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4243 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4246 if (!literal_type_p (TREE_TYPE (t
)))
4248 if (flags
& tf_error
)
4250 error ("temporary of non-literal type %qT in a "
4251 "constant expression", TREE_TYPE (t
));
4252 explain_non_literal_class (TREE_TYPE (t
));
4257 return RECUR (TREE_OPERAND (t
, 1), rval
);
4261 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4262 constructor_elt
*ce
;
4263 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4264 if (!RECUR (ce
->value
, want_rval
))
4271 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
4272 || DECL_P (TREE_PURPOSE (t
)));
4273 if (!RECUR (TREE_VALUE (t
), want_rval
))
4275 if (TREE_CHAIN (t
) == NULL_TREE
)
4277 return RECUR (TREE_CHAIN (t
), want_rval
);
4280 case TRUNC_DIV_EXPR
:
4282 case FLOOR_DIV_EXPR
:
4283 case ROUND_DIV_EXPR
:
4284 case TRUNC_MOD_EXPR
:
4286 case ROUND_MOD_EXPR
:
4288 tree denom
= TREE_OPERAND (t
, 1);
4289 if (!RECUR (denom
, rval
))
4291 /* We can't call cxx_eval_outermost_constant_expr on an expression
4292 that hasn't been through instantiate_non_dependent_expr yet. */
4293 if (!processing_template_decl
)
4294 denom
= cxx_eval_outermost_constant_expr (denom
, true);
4295 if (integer_zerop (denom
))
4297 if (flags
& tf_error
)
4298 error ("division by zero is not a constant-expression");
4304 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4310 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4311 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4312 introduced by build_call_a. */
4313 tree op0
= TREE_OPERAND (t
, 0);
4314 tree op1
= TREE_OPERAND (t
, 1);
4316 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4317 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4318 return RECUR (op0
, want_rval
);
4323 /* If the first operand is the non-short-circuit constant, look at
4324 the second operand; otherwise we only care about the first one for
4326 case TRUTH_AND_EXPR
:
4327 case TRUTH_ANDIF_EXPR
:
4328 tmp
= boolean_true_node
;
4331 case TRUTH_ORIF_EXPR
:
4332 tmp
= boolean_false_node
;
4335 tree op
= TREE_OPERAND (t
, 0);
4336 if (!RECUR (op
, rval
))
4338 if (!processing_template_decl
)
4339 op
= cxx_eval_outermost_constant_expr (op
, true);
4340 if (tree_int_cst_equal (op
, tmp
))
4341 return RECUR (TREE_OPERAND (t
, 1), rval
);
4348 case POINTER_PLUS_EXPR
:
4350 case EXACT_DIV_EXPR
:
4360 case TRUTH_XOR_EXPR
:
4361 case UNORDERED_EXPR
:
4374 case ARRAY_RANGE_REF
:
4378 for (i
= 0; i
< 2; ++i
)
4379 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
4383 case CILK_SYNC_STMT
:
4384 case CILK_SPAWN_STMT
:
4385 case ARRAY_NOTATION_REF
:
4390 for (i
= 0; i
< 3; ++i
)
4391 if (!RECUR (TREE_OPERAND (t
, i
), true))
4397 /* If the condition is a known constant, we know which of the legs we
4398 care about; otherwise we only require that the condition and
4399 either of the legs be potentially constant. */
4400 tmp
= TREE_OPERAND (t
, 0);
4401 if (!RECUR (tmp
, rval
))
4403 if (!processing_template_decl
)
4404 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
4405 if (integer_zerop (tmp
))
4406 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
4407 else if (TREE_CODE (tmp
) == INTEGER_CST
)
4408 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4409 for (i
= 1; i
< 3; ++i
)
4410 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
4411 want_rval
, strict
, tf_none
))
4413 if (flags
& tf_error
)
4414 error ("expression %qE is not a constant-expression", t
);
4418 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
4420 if (flags
& tf_error
)
4422 error ("non-constant array initialization");
4423 diagnose_non_constexpr_vec_init (t
);
4428 if (objc_is_property_ref (t
))
4431 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
4438 /* The main entry point to the above. */
4441 potential_constant_expression (tree t
)
4443 return potential_constant_expression_1 (t
, false, true, tf_none
);
4447 potential_static_init_expression (tree t
)
4449 return potential_constant_expression_1 (t
, false, false, tf_none
);
4452 /* As above, but require a constant rvalue. */
4455 potential_rvalue_constant_expression (tree t
)
4457 return potential_constant_expression_1 (t
, true, true, tf_none
);
4460 /* Like above, but complain about non-constant expressions. */
4463 require_potential_constant_expression (tree t
)
4465 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
4468 /* Cross product of the above. */
4471 require_potential_rvalue_constant_expression (tree t
)
4473 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
4476 #include "gt-cp-constexpr.h"