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 /* Subroutine of cxx_eval_constant_expression.
2925 Attempt to reduce a POINTER_PLUS_EXPR expression T. */
2928 cxx_eval_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
2929 bool lval
, bool *non_constant_p
,
2932 tree op00
= TREE_OPERAND (t
, 0);
2933 tree op01
= TREE_OPERAND (t
, 1);
2934 location_t loc
= EXPR_LOCATION (t
);
2936 op00
= cxx_eval_constant_expression (ctx
, op00
, lval
,
2937 non_constant_p
, overflow_p
);
2940 if (TREE_CODE (op00
) != ADDR_EXPR
)
2943 op00
= TREE_OPERAND (op00
, 0);
2945 /* &A[i] p+ j => &A[i + j] */
2946 if (TREE_CODE (op00
) == ARRAY_REF
2947 && TREE_CODE (TREE_OPERAND (op00
, 1)) == INTEGER_CST
2948 && TREE_CODE (op01
) == INTEGER_CST
)
2950 tree type
= TREE_TYPE (op00
);
2951 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (op00
, 1));
2952 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (op00
, 0)));
2953 /* Don't fold an out-of-bound access. */
2954 if (!tree_int_cst_le (t
, nelts
))
2956 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2958 op01
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
,
2959 cp_fold_convert (ssizetype
, op01
),
2960 TYPE_SIZE_UNIT (type
));
2961 t
= size_binop_loc (loc
, PLUS_EXPR
, op01
, t
);
2962 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (op00
, 0),
2963 t
, NULL_TREE
, NULL_TREE
);
2964 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2965 return cxx_eval_constant_expression (ctx
, t
, lval
, non_constant_p
,
2972 /* Attempt to reduce the expression T to a constant value.
2973 On failure, issue diagnostic and return error_mark_node. */
2974 /* FIXME unify with c_fully_fold */
2975 /* FIXME overflow_p is too global */
2978 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
2980 bool *non_constant_p
, bool *overflow_p
,
2983 constexpr_ctx new_ctx
;
2986 if (t
== error_mark_node
)
2988 *non_constant_p
= true;
2991 if (CONSTANT_CLASS_P (t
))
2993 if (TREE_CODE (t
) == PTRMEM_CST
)
2994 t
= cplus_expand_constant (t
);
2995 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| ctx
->quiet
))
3000 switch (TREE_CODE (t
))
3005 /* We ask for an rvalue for the RESULT_DECL when indirecting
3006 through an invisible reference, or in named return value
3008 return (*ctx
->values
->get (t
));
3012 /* We used to not check lval for CONST_DECL, but darwin.c uses
3013 CONST_DECL for aggregate constants. */
3017 r
= decl_really_constant_value (t
);
3019 r
= decl_constant_value (t
);
3020 if (TREE_CODE (r
) == TARGET_EXPR
3021 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3022 r
= TARGET_EXPR_INITIAL (r
);
3023 if (TREE_CODE (r
) == VAR_DECL
)
3024 if (tree
*p
= ctx
->values
->get (r
))
3029 non_const_var_error (r
);
3030 *non_constant_p
= true;
3038 case CASE_LABEL_EXPR
:
3042 if (!use_new_call
&& ctx
3043 && ctx
->call
&& DECL_CONTEXT (t
) == ctx
->call
->fundef
->decl
)
3044 r
= lookup_parameter_binding (ctx
->call
, t
);
3045 else if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
3047 else if (tree
*p
= ctx
->values
->get (r
))
3050 /* Defer in case this is only used for its type. */;
3051 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3052 /* Defer, there's no lvalue->rvalue conversion. */;
3053 else if (is_empty_class (TREE_TYPE (t
)))
3055 /* If the class is empty, we aren't actually loading anything. */
3056 r
= build_constructor (TREE_TYPE (t
), NULL
);
3057 TREE_CONSTANT (r
) = true;
3062 error ("%qE is not a constant expression", t
);
3063 *non_constant_p
= true;
3068 case AGGR_INIT_EXPR
:
3069 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3070 non_constant_p
, overflow_p
);
3075 r
= DECL_EXPR_DECL (t
);
3076 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3077 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3081 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3082 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3083 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3087 if (tree init
= DECL_INITIAL (r
))
3089 init
= cxx_eval_constant_expression (ctx
, init
,
3091 non_constant_p
, overflow_p
);
3092 ctx
->values
->put (r
, init
);
3094 else if (ctx
== &new_ctx
)
3095 /* We gave it a CONSTRUCTOR above. */;
3097 ctx
->values
->put (r
, NULL_TREE
);
3102 if (!literal_type_p (TREE_TYPE (t
)))
3106 error ("temporary of non-literal type %qT in a "
3107 "constant expression", TREE_TYPE (t
));
3108 explain_non_literal_class (TREE_TYPE (t
));
3110 *non_constant_p
= true;
3113 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3115 /* We're being expanded without an explicit target, so start
3116 initializing a new object; expansion with an explicit target
3117 strips the TARGET_EXPR before we get here. */
3119 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3120 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3121 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3122 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3125 /* Pass false for 'lval' because this indicates
3126 initialization of a temporary. */
3127 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3129 non_constant_p
, overflow_p
);
3130 if (!*non_constant_p
)
3131 /* Adjust the type of the result to the type of the temporary. */
3132 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3135 tree slot
= TARGET_EXPR_SLOT (t
);
3136 ctx
->values
->put (slot
, r
);
3144 /* In C++11 constexpr evaluation we are looking for the value,
3145 not the side-effect of the initialization. */
3146 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3148 non_constant_p
, overflow_p
);
3151 /* else fall through */
3153 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3154 non_constant_p
, overflow_p
);
3158 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3160 non_constant_p
, overflow_p
);
3164 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
3165 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3167 non_constant_p
, overflow_p
);
3172 /* Avoid evaluating a SAVE_EXPR more than once. */
3173 if (tree
*p
= ctx
->values
->get (t
))
3177 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3178 non_constant_p
, overflow_p
);
3179 ctx
->values
->put (t
, r
);
3183 case NON_LVALUE_EXPR
:
3184 case TRY_CATCH_EXPR
:
3185 case CLEANUP_POINT_EXPR
:
3186 case MUST_NOT_THROW_EXPR
:
3189 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3191 non_constant_p
, overflow_p
,
3195 /* These differ from cxx_eval_unary_expression in that this doesn't
3196 check for a constant operand or result; an address can be
3197 constant without its operand being, and vice versa. */
3199 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3200 non_constant_p
, overflow_p
);
3205 tree oldop
= TREE_OPERAND (t
, 0);
3206 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3208 non_constant_p
, overflow_p
);
3209 /* Don't VERIFY_CONSTANT here. */
3210 if (*non_constant_p
)
3212 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3213 /* This function does more aggressive folding than fold itself. */
3214 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3215 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3223 case FIX_TRUNC_EXPR
:
3228 case TRUTH_NOT_EXPR
:
3229 case FIXED_CONVERT_EXPR
:
3230 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3231 non_constant_p
, overflow_p
);
3235 if (SIZEOF_EXPR_TYPE_P (t
))
3236 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
3237 SIZEOF_EXPR
, false);
3238 else if (TYPE_P (TREE_OPERAND (t
, 0)))
3239 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3242 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3244 if (r
== error_mark_node
)
3246 VERIFY_CONSTANT (r
);
3251 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3252 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3253 introduced by build_call_a. */
3254 tree op0
= TREE_OPERAND (t
, 0);
3255 tree op1
= TREE_OPERAND (t
, 1);
3257 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3258 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3259 r
= cxx_eval_constant_expression (ctx
, op0
,
3260 lval
, non_constant_p
, overflow_p
,
3264 /* Check that the LHS is constant and then discard it. */
3265 cxx_eval_constant_expression (ctx
, op0
,
3266 true, non_constant_p
, overflow_p
,
3268 op1
= TREE_OPERAND (t
, 1);
3269 r
= cxx_eval_constant_expression (ctx
, op1
,
3270 lval
, non_constant_p
, overflow_p
,
3276 case POINTER_PLUS_EXPR
:
3277 r
= cxx_eval_pointer_plus_expression (ctx
, t
, lval
, non_constant_p
,
3281 /* else fall through */
3286 case TRUNC_DIV_EXPR
:
3288 case FLOOR_DIV_EXPR
:
3289 case ROUND_DIV_EXPR
:
3290 case TRUNC_MOD_EXPR
:
3292 case ROUND_MOD_EXPR
:
3294 case EXACT_DIV_EXPR
:
3304 case TRUTH_XOR_EXPR
:
3311 case UNORDERED_EXPR
:
3321 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3322 non_constant_p
, overflow_p
);
3325 /* fold can introduce non-IF versions of these; still treat them as
3326 short-circuiting. */
3327 case TRUTH_AND_EXPR
:
3328 case TRUTH_ANDIF_EXPR
:
3329 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
3332 non_constant_p
, overflow_p
);
3336 case TRUTH_ORIF_EXPR
:
3337 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
3340 non_constant_p
, overflow_p
);
3344 r
= cxx_eval_array_reference (ctx
, t
, lval
,
3345 non_constant_p
, overflow_p
);
3349 if (is_overloaded_fn (t
))
3351 /* We can only get here in checking mode via
3352 build_non_dependent_expr, because any expression that
3353 calls or takes the address of the function will have
3354 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3355 gcc_checking_assert (ctx
->quiet
|| errorcount
);
3356 *non_constant_p
= true;
3359 r
= cxx_eval_component_reference (ctx
, t
, lval
,
3360 non_constant_p
, overflow_p
);
3364 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
3365 non_constant_p
, overflow_p
);
3370 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
3371 non_constant_p
, overflow_p
,
3376 if (TREE_CONSTANT (t
))
3377 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3378 VECTOR_CST if applicable. */
3380 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
3381 non_constant_p
, overflow_p
);
3385 /* We can get this in a defaulted constructor for a class with a
3386 non-static data member of array type. Either the initializer will
3387 be NULL, meaning default-initialization, or it will be an lvalue
3388 or xvalue of the same type, meaning direct-initialization from the
3389 corresponding member. */
3390 r
= cxx_eval_vec_init (ctx
, t
, lval
,
3391 non_constant_p
, overflow_p
);
3396 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
3397 non_constant_p
, overflow_p
);
3401 case VIEW_CONVERT_EXPR
:
3404 tree oldop
= TREE_OPERAND (t
, 0);
3405 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3407 non_constant_p
, overflow_p
);
3408 if (*non_constant_p
)
3410 if (POINTER_TYPE_P (TREE_TYPE (t
))
3411 && TREE_CODE (op
) == INTEGER_CST
3412 && !integer_zerop (op
))
3415 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3416 "reinterpret_cast from integer to pointer");
3417 *non_constant_p
= true;
3421 /* We didn't fold at the top so we could check for ptr-int
3424 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
3425 /* Conversion of an out-of-range value has implementation-defined
3426 behavior; the language considers it different from arithmetic
3427 overflow, which is undefined. */
3428 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
3429 TREE_OVERFLOW (r
) = false;
3433 case EMPTY_CLASS_EXPR
:
3434 /* This is good enough for a function argument that might not get
3435 used, and they can't do anything with it, so just return it. */
3438 case STATEMENT_LIST
:
3440 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3441 return cxx_eval_statement_list (&new_ctx
, t
,
3442 non_constant_p
, overflow_p
, jump_target
);
3445 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
3447 non_constant_p
, overflow_p
,
3450 case PREINCREMENT_EXPR
:
3451 case POSTINCREMENT_EXPR
:
3452 case PREDECREMENT_EXPR
:
3453 case POSTDECREMENT_EXPR
:
3454 return cxx_eval_increment_expression (ctx
, t
,
3455 lval
, non_constant_p
, overflow_p
);
3461 case VEC_DELETE_EXPR
:
3464 /* GCC internal stuff. */
3467 case WITH_CLEANUP_EXPR
:
3468 case NON_DEPENDENT_EXPR
:
3472 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3473 "expression %qE is not a constant-expression", t
);
3474 *non_constant_p
= true;
3477 case PLACEHOLDER_EXPR
:
3478 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
))
3480 /* A placeholder without a referent. We can get here when
3481 checking whether NSDMIs are noexcept, or in massage_init_elt;
3482 just say it's non-constant for now. */
3483 gcc_assert (ctx
->quiet
);
3484 *non_constant_p
= true;
3489 /* Use of the value or address of the current object. We could
3490 use ctx->object unconditionally, but using ctx->ctor when we
3491 can is a minor optimization. */
3492 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
3493 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3494 (TREE_TYPE (t
), TREE_TYPE (ctor
)));
3495 return cxx_eval_constant_expression
3497 non_constant_p
, overflow_p
);
3502 *jump_target
= TREE_OPERAND (t
, 0);
3503 gcc_assert (breaks (jump_target
) || continues (jump_target
));
3507 cxx_eval_loop_expr (ctx
, t
,
3508 non_constant_p
, overflow_p
, jump_target
);
3512 cxx_eval_switch_expr (ctx
, t
,
3513 non_constant_p
, overflow_p
, jump_target
);
3517 if (STATEMENT_CODE_P (TREE_CODE (t
)))
3519 /* This function doesn't know how to deal with pre-genericize
3520 statements; this can only happen with statement-expressions,
3521 so for now just fail. */
3523 error_at (EXPR_LOCATION (t
),
3524 "statement is not a constant-expression");
3527 internal_error ("unexpected expression %qE of kind %s", t
,
3528 get_tree_code_name (TREE_CODE (t
)));
3529 *non_constant_p
= true;
3533 if (r
== error_mark_node
)
3534 *non_constant_p
= true;
3536 if (*non_constant_p
)
3543 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
3544 bool strict
= true, tree object
= NULL_TREE
)
3546 bool non_constant_p
= false;
3547 bool overflow_p
= false;
3548 hash_map
<tree
,tree
> map
;
3549 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, allow_non_constant
, strict
};
3550 tree type
= initialized_type (t
);
3552 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3554 /* In C++14 an NSDMI can participate in aggregate initialization,
3555 and can refer to the address of the object being initialized, so
3556 we need to pass in the relevant VAR_DECL if we want to do the
3557 evaluation in a single pass. The evaluation will dynamically
3558 update ctx.values for the VAR_DECL. We use the same strategy
3559 for C++11 constexpr constructors that refer to the object being
3561 ctx
.ctor
= build_constructor (type
, NULL
);
3562 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
3565 if (TREE_CODE (t
) == TARGET_EXPR
)
3566 object
= TARGET_EXPR_SLOT (t
);
3567 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3568 object
= AGGR_INIT_EXPR_SLOT (t
);
3570 ctx
.object
= object
;
3572 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3573 (type
, TREE_TYPE (object
)));
3574 if (object
&& DECL_P (object
))
3575 map
.put (object
, ctx
.ctor
);
3576 if (TREE_CODE (r
) == TARGET_EXPR
)
3577 /* Avoid creating another CONSTRUCTOR when we expand the
3579 r
= TARGET_EXPR_INITIAL (r
);
3582 r
= cxx_eval_constant_expression (&ctx
, r
,
3583 false, &non_constant_p
, &overflow_p
);
3585 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
3587 /* Mutable logic is a bit tricky: we want to allow initialization of
3588 constexpr variables with mutable members, but we can't copy those
3589 members to another constexpr variable. */
3590 if (TREE_CODE (r
) == CONSTRUCTOR
3591 && CONSTRUCTOR_MUTABLE_POISON (r
))
3593 if (!allow_non_constant
)
3594 error ("%qE is not a constant expression because it refers to "
3595 "mutable subobjects of %qT", t
, type
);
3596 non_constant_p
= true;
3599 /* Technically we should check this for all subexpressions, but that
3600 runs into problems with our internal representation of pointer
3601 subtraction and the 5.19 rules are still in flux. */
3602 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
3603 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
3604 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
3606 if (!allow_non_constant
)
3607 error ("conversion from pointer type %qT "
3608 "to arithmetic type %qT in a constant-expression",
3609 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
3610 non_constant_p
= true;
3613 if (!non_constant_p
&& overflow_p
)
3614 non_constant_p
= true;
3616 if (non_constant_p
&& !allow_non_constant
)
3617 return error_mark_node
;
3618 else if (non_constant_p
&& TREE_CONSTANT (r
))
3620 /* This isn't actually constant, so unset TREE_CONSTANT. */
3623 else if (TREE_CODE (r
) == CONSTRUCTOR
)
3624 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
3626 r
= build_nop (TREE_TYPE (r
), r
);
3627 TREE_CONSTANT (r
) = false;
3629 else if (non_constant_p
|| r
== t
)
3632 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
3634 if (TREE_CODE (t
) == TARGET_EXPR
3635 && TARGET_EXPR_INITIAL (t
) == r
)
3639 r
= get_target_expr (r
);
3640 TREE_CONSTANT (r
) = true;
3648 /* Returns true if T is a valid subexpression of a constant expression,
3649 even if it isn't itself a constant expression. */
3652 is_sub_constant_expr (tree t
)
3654 bool non_constant_p
= false;
3655 bool overflow_p
= false;
3656 hash_map
<tree
, tree
> map
;
3657 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, true, true };
3658 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
3660 return !non_constant_p
&& !overflow_p
;
3663 /* If T represents a constant expression returns its reduced value.
3664 Otherwise return error_mark_node. If T is dependent, then
3668 cxx_constant_value (tree t
, tree decl
)
3670 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
3673 /* If T is a constant expression, returns its reduced value.
3674 Otherwise, if T does not have TREE_CONSTANT set, returns T.
3675 Otherwise, returns a version of T without TREE_CONSTANT. */
3678 maybe_constant_value (tree t
, tree decl
)
3682 if (instantiation_dependent_expression_p (t
)
3683 || type_unknown_p (t
)
3684 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3685 || !potential_constant_expression (t
))
3687 if (TREE_OVERFLOW_P (t
))
3689 t
= build_nop (TREE_TYPE (t
), t
);
3690 TREE_CONSTANT (t
) = false;
3695 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
3696 #ifdef ENABLE_CHECKING
3698 || CONVERT_EXPR_P (t
)
3699 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3700 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3701 || !cp_tree_equal (r
, t
));
3706 /* Like maybe_constant_value but first fully instantiate the argument.
3708 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3709 (t, tf_none) followed by maybe_constant_value but is more efficient,
3710 because calls instantiation_dependent_expression_p and
3711 potential_constant_expression at most once. */
3714 fold_non_dependent_expr (tree t
)
3719 /* If we're in a template, but T isn't value dependent, simplify
3720 it. We're supposed to treat:
3722 template <typename T> void f(T[1 + 1]);
3723 template <typename T> void f(T[2]);
3725 as two declarations of the same function, for example. */
3726 if (processing_template_decl
)
3728 if (!instantiation_dependent_expression_p (t
)
3729 && potential_constant_expression (t
))
3731 processing_template_decl_sentinel s
;
3732 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
3734 if (type_unknown_p (t
)
3735 || BRACE_ENCLOSED_INITIALIZER_P (t
))
3737 if (TREE_OVERFLOW_P (t
))
3739 t
= build_nop (TREE_TYPE (t
), t
);
3740 TREE_CONSTANT (t
) = false;
3745 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
3746 #ifdef ENABLE_CHECKING
3747 /* cp_tree_equal looks through NOPs, so allow them. */
3749 || CONVERT_EXPR_P (t
)
3750 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3751 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3752 || !cp_tree_equal (r
, t
));
3756 else if (TREE_OVERFLOW_P (t
))
3758 t
= build_nop (TREE_TYPE (t
), t
);
3759 TREE_CONSTANT (t
) = false;
3764 return maybe_constant_value (t
);
3767 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3768 than wrapped in a TARGET_EXPR. */
3771 maybe_constant_init (tree t
, tree decl
)
3773 if (TREE_CODE (t
) == EXPR_STMT
)
3774 t
= TREE_OPERAND (t
, 0);
3775 if (TREE_CODE (t
) == CONVERT_EXPR
3776 && VOID_TYPE_P (TREE_TYPE (t
)))
3777 t
= TREE_OPERAND (t
, 0);
3778 if (TREE_CODE (t
) == INIT_EXPR
)
3779 t
= TREE_OPERAND (t
, 1);
3780 if (instantiation_dependent_expression_p (t
)
3781 || type_unknown_p (t
)
3782 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3783 || !potential_static_init_expression (t
))
3784 /* Don't try to evaluate it. */;
3786 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
3787 if (TREE_CODE (t
) == TARGET_EXPR
)
3789 tree init
= TARGET_EXPR_INITIAL (t
);
3790 if (TREE_CODE (init
) == CONSTRUCTOR
)
3797 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
3798 /* Return true if the object referred to by REF has automatic or thread
3801 enum { ck_ok
, ck_bad
, ck_unknown
};
3803 check_automatic_or_tls (tree ref
)
3806 HOST_WIDE_INT bitsize
, bitpos
;
3808 int volatilep
= 0, unsignedp
= 0;
3809 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
3810 &mode
, &unsignedp
, &volatilep
, false);
3813 /* If there isn't a decl in the middle, we don't know the linkage here,
3814 and this isn't a constant expression anyway. */
3817 dk
= decl_storage_duration (decl
);
3818 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
3822 /* Return true if T denotes a potentially constant expression. Issue
3823 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
3824 an lvalue-rvalue conversion is implied.
3826 C++0x [expr.const] used to say
3828 6 An expression is a potential constant expression if it is
3829 a constant expression where all occurrences of function
3830 parameters are replaced by arbitrary constant expressions
3831 of the appropriate type.
3833 2 A conditional expression is a constant expression unless it
3834 involves one of the following as a potentially evaluated
3835 subexpression (3.2), but subexpressions of logical AND (5.14),
3836 logical OR (5.15), and conditional (5.16) operations that are
3837 not evaluated are not considered. */
3840 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
3841 tsubst_flags_t flags
)
3843 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
3844 enum { any
= false, rval
= true };
3848 if (t
== error_mark_node
)
3852 if (TREE_THIS_VOLATILE (t
))
3854 if (flags
& tf_error
)
3855 error ("expression %qE has side-effects", t
);
3858 if (CONSTANT_CLASS_P (t
))
3861 switch (TREE_CODE (t
))
3867 case TEMPLATE_ID_EXPR
:
3870 case CASE_LABEL_EXPR
:
3876 case TEMPLATE_PARM_INDEX
:
3878 case IDENTIFIER_NODE
:
3879 case USERDEF_LITERAL
:
3880 /* We can see a FIELD_DECL in a pointer-to-member expression. */
3885 case PLACEHOLDER_EXPR
:
3890 case AGGR_INIT_EXPR
:
3892 /* -- an invocation of a function other than a constexpr function
3893 or a constexpr constructor. */
3895 tree fun
= get_function_named_in_call (t
);
3896 const int nargs
= call_expr_nargs (t
);
3899 if (fun
== NULL_TREE
)
3901 if (TREE_CODE (t
) == CALL_EXPR
3902 && CALL_EXPR_FN (t
) == NULL_TREE
)
3903 switch (CALL_EXPR_IFN (t
))
3905 /* These should be ignored, they are optimized away from
3906 constexpr functions. */
3907 case IFN_UBSAN_NULL
:
3908 case IFN_UBSAN_BOUNDS
:
3909 case IFN_UBSAN_VPTR
:
3914 /* fold_call_expr can't do anything with IFN calls. */
3915 if (flags
& tf_error
)
3916 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3917 "call to internal function");
3920 if (is_overloaded_fn (fun
))
3922 if (TREE_CODE (fun
) == FUNCTION_DECL
)
3924 if (builtin_valid_in_constant_expr_p (fun
))
3926 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
3927 /* Allow any built-in function; if the expansion
3928 isn't constant, we'll deal with that then. */
3929 && !is_builtin_fn (fun
))
3931 if (flags
& tf_error
)
3933 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3934 "call to non-constexpr function %qD", fun
);
3935 explain_invalid_constexpr_fn (fun
);
3939 /* A call to a non-static member function takes the address
3940 of the object as the first argument. But in a constant
3941 expression the address will be folded away, so look
3943 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
3944 && !DECL_CONSTRUCTOR_P (fun
))
3946 tree x
= get_nth_callarg (t
, 0);
3947 if (is_this_parameter (x
))
3949 else if (!RECUR (x
, rval
))
3956 if (!RECUR (fun
, true))
3958 fun
= get_first_fn (fun
);
3960 /* Skip initial arguments to base constructors. */
3961 if (DECL_BASE_CONSTRUCTOR_P (fun
))
3962 i
= num_artificial_parms_for (fun
);
3963 fun
= DECL_ORIGIN (fun
);
3967 if (RECUR (fun
, rval
))
3968 /* Might end up being a constant function pointer. */;
3972 for (; i
< nargs
; ++i
)
3974 tree x
= get_nth_callarg (t
, i
);
3975 /* In a template, reference arguments haven't been converted to
3976 REFERENCE_TYPE and we might not even know if the parameter
3977 is a reference, so accept lvalue constants too. */
3978 bool rv
= processing_template_decl
? any
: rval
;
3985 case NON_LVALUE_EXPR
:
3986 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
3987 -- an lvalue of integral type that refers to a non-volatile
3988 const variable or static data member initialized with
3989 constant expressions, or
3991 -- an lvalue of literal type that refers to non-volatile
3992 object defined with constexpr, or that refers to a
3993 sub-object of such an object; */
3994 return RECUR (TREE_OPERAND (t
, 0), rval
);
3998 && !decl_constant_var_p (t
)
4000 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
4001 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
4002 && !var_in_constexpr_fn (t
)
4003 && !type_dependent_expression_p (t
))
4005 if (flags
& tf_error
)
4006 non_const_var_error (t
);
4013 case VIEW_CONVERT_EXPR
:
4014 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4015 may change to something more specific to type-punning (DR 1312). */
4017 tree from
= TREE_OPERAND (t
, 0);
4018 if (POINTER_TYPE_P (TREE_TYPE (t
))
4019 && TREE_CODE (from
) == INTEGER_CST
4020 && !integer_zerop (from
))
4022 if (flags
& tf_error
)
4023 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4024 "reinterpret_cast from integer to pointer");
4027 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
4031 /* -- a unary operator & that is applied to an lvalue that
4032 designates an object with thread or automatic storage
4034 t
= TREE_OPERAND (t
, 0);
4036 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
4037 /* A pointer-to-member constant. */
4041 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4042 any checking here, as we might dereference the pointer later. If
4043 we remove this code, also remove check_automatic_or_tls. */
4044 i
= check_automatic_or_tls (t
);
4049 if (flags
& tf_error
)
4050 error ("address-of an object %qE with thread local or "
4051 "automatic storage is not a constant expression", t
);
4055 return RECUR (t
, any
);
4061 /* -- a class member access unless its postfix-expression is
4062 of literal type or of pointer to literal type. */
4063 /* This test would be redundant, as it follows from the
4064 postfix-expression being a potential constant expression. */
4065 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4067 case EXPR_PACK_EXPANSION
:
4068 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
4072 tree x
= TREE_OPERAND (t
, 0);
4074 if (is_this_parameter (x
))
4076 if (DECL_CONTEXT (x
)
4077 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4079 if (flags
& tf_error
)
4080 error ("use of %<this%> in a constant expression");
4085 return RECUR (x
, rval
);
4088 case STATEMENT_LIST
:
4090 tree_stmt_iterator i
;
4091 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4093 if (!RECUR (tsi_stmt (i
), any
))
4101 if (cxx_dialect
< cxx14
)
4103 if (!RECUR (TREE_OPERAND (t
, 0), any
))
4105 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
4110 if (cxx_dialect
< cxx14
)
4112 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
4114 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
4119 if (!RECUR (IF_COND (t
), rval
))
4121 if (!RECUR (THEN_CLAUSE (t
), any
))
4123 if (!RECUR (ELSE_CLAUSE (t
), any
))
4128 if (!RECUR (DO_COND (t
), rval
))
4130 if (!RECUR (DO_BODY (t
), any
))
4135 if (!RECUR (FOR_INIT_STMT (t
), any
))
4137 if (!RECUR (FOR_COND (t
), rval
))
4139 if (!RECUR (FOR_EXPR (t
), any
))
4141 if (!RECUR (FOR_BODY (t
), any
))
4146 if (!RECUR (WHILE_COND (t
), rval
))
4148 if (!RECUR (WHILE_BODY (t
), any
))
4153 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
4155 if (!RECUR (SWITCH_STMT_BODY (t
), any
))
4160 return RECUR (STMT_EXPR_STMT (t
), rval
);
4163 case DYNAMIC_CAST_EXPR
:
4164 case PSEUDO_DTOR_EXPR
:
4168 case VEC_DELETE_EXPR
:
4171 case OMP_ATOMIC_READ
:
4172 case OMP_ATOMIC_CAPTURE_OLD
:
4173 case OMP_ATOMIC_CAPTURE_NEW
:
4174 /* GCC internal stuff. */
4177 case TRANSACTION_EXPR
:
4180 if (flags
& tf_error
)
4181 error ("expression %qE is not a constant-expression", t
);
4185 /* -- a typeid expression whose operand is of polymorphic
4188 tree e
= TREE_OPERAND (t
, 0);
4189 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
4190 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
4192 if (flags
& tf_error
)
4193 error ("typeid-expression is not a constant expression "
4194 "because %qE is of polymorphic type", e
);
4201 /* -- a subtraction where both operands are pointers. */
4202 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
4203 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
4205 if (flags
& tf_error
)
4206 error ("difference of two pointer expressions is not "
4207 "a constant expression");
4219 /* -- a relational or equality operator where at least
4220 one of the operands is a pointer. */
4221 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
4222 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
4224 if (flags
& tf_error
)
4225 error ("pointer comparison expression is not a "
4226 "constant expression");
4232 case PREINCREMENT_EXPR
:
4233 case POSTINCREMENT_EXPR
:
4234 case PREDECREMENT_EXPR
:
4235 case POSTDECREMENT_EXPR
:
4236 if (cxx_dialect
< cxx14
)
4242 if (TYPE_P (TREE_OPERAND (t
, 0)))
4244 /* else fall through. */
4250 case FIX_TRUNC_EXPR
:
4254 case TRUTH_NOT_EXPR
:
4255 case FIXED_CONVERT_EXPR
:
4256 case UNARY_PLUS_EXPR
:
4258 return RECUR (TREE_OPERAND (t
, 0), rval
);
4261 case CONST_CAST_EXPR
:
4262 case STATIC_CAST_EXPR
:
4263 case REINTERPRET_CAST_EXPR
:
4264 case IMPLICIT_CONV_EXPR
:
4265 if (cxx_dialect
< cxx11
4266 && !dependent_type_p (TREE_TYPE (t
))
4267 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
4268 /* In C++98, a conversion to non-integral type can't be part of a
4269 constant expression. */
4271 if (flags
& tf_error
)
4272 error ("cast to non-integral type %qT in a constant expression",
4277 return (RECUR (TREE_OPERAND (t
, 0),
4278 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
4281 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
4283 case WITH_CLEANUP_EXPR
:
4284 case CLEANUP_POINT_EXPR
:
4285 case MUST_NOT_THROW_EXPR
:
4286 case TRY_CATCH_EXPR
:
4291 case NON_DEPENDENT_EXPR
:
4292 /* For convenience. */
4294 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4297 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4300 if (!literal_type_p (TREE_TYPE (t
)))
4302 if (flags
& tf_error
)
4304 error ("temporary of non-literal type %qT in a "
4305 "constant expression", TREE_TYPE (t
));
4306 explain_non_literal_class (TREE_TYPE (t
));
4311 return RECUR (TREE_OPERAND (t
, 1), rval
);
4315 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4316 constructor_elt
*ce
;
4317 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4318 if (!RECUR (ce
->value
, want_rval
))
4325 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
4326 || DECL_P (TREE_PURPOSE (t
)));
4327 if (!RECUR (TREE_VALUE (t
), want_rval
))
4329 if (TREE_CHAIN (t
) == NULL_TREE
)
4331 return RECUR (TREE_CHAIN (t
), want_rval
);
4334 case TRUNC_DIV_EXPR
:
4336 case FLOOR_DIV_EXPR
:
4337 case ROUND_DIV_EXPR
:
4338 case TRUNC_MOD_EXPR
:
4340 case ROUND_MOD_EXPR
:
4342 tree denom
= TREE_OPERAND (t
, 1);
4343 if (!RECUR (denom
, rval
))
4345 /* We can't call cxx_eval_outermost_constant_expr on an expression
4346 that hasn't been through instantiate_non_dependent_expr yet. */
4347 if (!processing_template_decl
)
4348 denom
= cxx_eval_outermost_constant_expr (denom
, true);
4349 if (integer_zerop (denom
))
4351 if (flags
& tf_error
)
4352 error ("division by zero is not a constant-expression");
4358 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4364 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4365 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4366 introduced by build_call_a. */
4367 tree op0
= TREE_OPERAND (t
, 0);
4368 tree op1
= TREE_OPERAND (t
, 1);
4370 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4371 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4372 return RECUR (op0
, want_rval
);
4377 /* If the first operand is the non-short-circuit constant, look at
4378 the second operand; otherwise we only care about the first one for
4380 case TRUTH_AND_EXPR
:
4381 case TRUTH_ANDIF_EXPR
:
4382 tmp
= boolean_true_node
;
4385 case TRUTH_ORIF_EXPR
:
4386 tmp
= boolean_false_node
;
4389 tree op
= TREE_OPERAND (t
, 0);
4390 if (!RECUR (op
, rval
))
4392 if (!processing_template_decl
)
4393 op
= cxx_eval_outermost_constant_expr (op
, true);
4394 if (tree_int_cst_equal (op
, tmp
))
4395 return RECUR (TREE_OPERAND (t
, 1), rval
);
4402 case POINTER_PLUS_EXPR
:
4404 case EXACT_DIV_EXPR
:
4414 case TRUTH_XOR_EXPR
:
4415 case UNORDERED_EXPR
:
4428 case ARRAY_RANGE_REF
:
4433 for (i
= 0; i
< 2; ++i
)
4434 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
4438 case CILK_SYNC_STMT
:
4439 case CILK_SPAWN_STMT
:
4440 case ARRAY_NOTATION_REF
:
4445 for (i
= 0; i
< 3; ++i
)
4446 if (!RECUR (TREE_OPERAND (t
, i
), true))
4452 /* If the condition is a known constant, we know which of the legs we
4453 care about; otherwise we only require that the condition and
4454 either of the legs be potentially constant. */
4455 tmp
= TREE_OPERAND (t
, 0);
4456 if (!RECUR (tmp
, rval
))
4458 if (!processing_template_decl
)
4459 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
4460 if (integer_zerop (tmp
))
4461 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
4462 else if (TREE_CODE (tmp
) == INTEGER_CST
)
4463 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4464 for (i
= 1; i
< 3; ++i
)
4465 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
4466 want_rval
, strict
, tf_none
))
4468 if (flags
& tf_error
)
4469 error ("expression %qE is not a constant-expression", t
);
4473 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
4475 if (flags
& tf_error
)
4477 error ("non-constant array initialization");
4478 diagnose_non_constexpr_vec_init (t
);
4483 if (objc_is_property_ref (t
))
4486 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
4493 /* The main entry point to the above. */
4496 potential_constant_expression (tree t
)
4498 return potential_constant_expression_1 (t
, false, true, tf_none
);
4502 potential_static_init_expression (tree t
)
4504 return potential_constant_expression_1 (t
, false, false, tf_none
);
4507 /* As above, but require a constant rvalue. */
4510 potential_rvalue_constant_expression (tree t
)
4512 return potential_constant_expression_1 (t
, true, true, tf_none
);
4515 /* Like above, but complain about non-constant expressions. */
4518 require_potential_constant_expression (tree t
)
4520 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
4523 /* Cross product of the above. */
4526 require_potential_rvalue_constant_expression (tree t
)
4528 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
4531 #include "gt-cp-constexpr.h"