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
))
105 error ("the type %qT of constexpr variable %qD is not literal",
109 error ("variable %qD of non-literal type %qT in %<constexpr%> "
110 "function", decl
, type
);
111 cp_function_chain
->invalid_constexpr
= true;
113 explain_non_literal_class (type
);
120 /* Representation of entries in the constexpr function definition table. */
122 struct GTY((for_user
)) constexpr_fundef
{
127 struct constexpr_fundef_hasher
: ggc_hasher
<constexpr_fundef
*>
129 static hashval_t
hash (constexpr_fundef
*);
130 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
133 /* This table holds all constexpr function definitions seen in
134 the current translation unit. */
136 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
138 /* Utility function used for managing the constexpr function table.
139 Return true if the entries pointed to by P and Q are for the
140 same constexpr function. */
143 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
145 return lhs
->decl
== rhs
->decl
;
148 /* Utility function used for managing the constexpr function table.
149 Return a hash value for the entry pointed to by Q. */
152 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
154 return DECL_UID (fundef
->decl
);
157 /* Return a previously saved definition of function FUN. */
159 static constexpr_fundef
*
160 retrieve_constexpr_fundef (tree fun
)
162 constexpr_fundef fundef
= { NULL
, NULL
};
163 if (constexpr_fundef_table
== NULL
)
167 return constexpr_fundef_table
->find (&fundef
);
170 /* Check whether the parameter and return types of FUN are valid for a
171 constexpr function, and complain if COMPLAIN. */
174 is_valid_constexpr_fn (tree fun
, bool complain
)
178 if (DECL_INHERITED_CTOR_BASE (fun
)
179 && TREE_CODE (fun
) == TEMPLATE_DECL
)
183 error ("inherited constructor %qD is not constexpr",
184 get_inherited_ctor (fun
));
188 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
189 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
190 if (!literal_type_p (TREE_TYPE (parm
)))
195 error ("invalid type for parameter %d of constexpr "
196 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
197 explain_non_literal_class (TREE_TYPE (parm
));
202 if (!DECL_CONSTRUCTOR_P (fun
))
204 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
205 if (!literal_type_p (rettype
))
210 error ("invalid return type %qT of constexpr function %q+D",
212 explain_non_literal_class (rettype
);
216 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
217 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
222 error ("enclosing class of constexpr non-static member "
223 "function %q+#D is not a literal type", fun
);
224 explain_non_literal_class (DECL_CONTEXT (fun
));
228 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
232 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
238 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
239 for a member of an anonymous aggregate, INIT is the initializer for that
240 member, and VEC_OUTER is the vector of constructor elements for the class
241 whose constructor we are processing. Add the initializer to the vector
242 and return true to indicate success. */
245 build_anon_member_initialization (tree member
, tree init
,
246 vec
<constructor_elt
, va_gc
> **vec_outer
)
248 /* MEMBER presents the relevant fields from the inside out, but we need
249 to build up the initializer from the outside in so that we can reuse
250 previously built CONSTRUCTORs if this is, say, the second field in an
251 anonymous struct. So we use a vec as a stack. */
252 auto_vec
<tree
, 2> fields
;
255 fields
.safe_push (TREE_OPERAND (member
, 1));
256 member
= TREE_OPERAND (member
, 0);
258 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
259 && TREE_CODE (member
) == COMPONENT_REF
);
261 /* VEC has the constructor elements vector for the context of FIELD.
262 If FIELD is an anonymous aggregate, we will push inside it. */
263 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
265 while (field
= fields
.pop(),
266 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
269 /* If there is already an outer constructor entry for the anonymous
270 aggregate FIELD, use it; otherwise, insert one. */
271 if (vec_safe_is_empty (*vec
)
272 || (*vec
)->last().index
!= field
)
274 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
275 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
278 ctor
= (*vec
)->last().value
;
279 vec
= &CONSTRUCTOR_ELTS (ctor
);
282 /* Now we're at the innermost field, the one that isn't an anonymous
283 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
284 gcc_assert (fields
.is_empty());
285 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
290 /* Subroutine of build_constexpr_constructor_member_initializers.
291 The expression tree T represents a data member initialization
292 in a (constexpr) constructor definition. Build a pairing of
293 the data member with its initializer, and prepend that pair
294 to the existing initialization pair INITS. */
297 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
300 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
301 t
= TREE_OPERAND (t
, 0);
302 if (TREE_CODE (t
) == EXPR_STMT
)
303 t
= TREE_OPERAND (t
, 0);
304 if (t
== error_mark_node
)
306 if (TREE_CODE (t
) == STATEMENT_LIST
)
308 tree_stmt_iterator i
;
309 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
311 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
316 if (TREE_CODE (t
) == CLEANUP_STMT
)
318 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
319 but we can in a constexpr constructor for a non-literal class. Just
320 ignore it; either all the initialization will be constant, in which
321 case the cleanup can't run, or it can't be constexpr.
322 Still recurse into CLEANUP_BODY. */
323 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
325 if (TREE_CODE (t
) == CONVERT_EXPR
)
326 t
= TREE_OPERAND (t
, 0);
327 if (TREE_CODE (t
) == INIT_EXPR
328 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
329 use what this function builds for cx_check_missing_mem_inits, and
330 assignment in the ctor body doesn't count. */
331 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
333 member
= TREE_OPERAND (t
, 0);
334 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
336 else if (TREE_CODE (t
) == CALL_EXPR
)
338 tree fn
= get_callee_fndecl (t
);
339 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
340 /* We're only interested in calls to subobject constructors. */
342 member
= CALL_EXPR_ARG (t
, 0);
343 /* We don't use build_cplus_new here because it complains about
344 abstract bases. Leaving the call unwrapped means that it has the
345 wrong type, but cxx_eval_constant_expression doesn't care. */
346 init
= break_out_target_exprs (t
);
348 else if (TREE_CODE (t
) == BIND_EXPR
)
349 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
351 /* Don't add anything else to the CONSTRUCTOR. */
353 if (INDIRECT_REF_P (member
))
354 member
= TREE_OPERAND (member
, 0);
355 if (TREE_CODE (member
) == NOP_EXPR
)
359 if (TREE_CODE (op
) == ADDR_EXPR
)
361 gcc_assert (same_type_ignoring_top_level_qualifiers_p
362 (TREE_TYPE (TREE_TYPE (op
)),
363 TREE_TYPE (TREE_TYPE (member
))));
364 /* Initializing a cv-qualified member; we need to look through
368 else if (op
== current_class_ptr
369 && (same_type_ignoring_top_level_qualifiers_p
370 (TREE_TYPE (TREE_TYPE (member
)),
371 current_class_type
)))
372 /* Delegating constructor. */
376 /* This is an initializer for an empty base; keep it for now so
377 we can check it in cxx_eval_bare_aggregate. */
378 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
381 if (TREE_CODE (member
) == ADDR_EXPR
)
382 member
= TREE_OPERAND (member
, 0);
383 if (TREE_CODE (member
) == COMPONENT_REF
)
385 tree aggr
= TREE_OPERAND (member
, 0);
386 if (TREE_CODE (aggr
) != COMPONENT_REF
)
387 /* Normal member initialization. */
388 member
= TREE_OPERAND (member
, 1);
389 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
390 /* Initializing a member of an anonymous union. */
391 return build_anon_member_initialization (member
, init
, vec
);
393 /* We're initializing a vtable pointer in a base. Leave it as
394 COMPONENT_REF so we remember the path to get to the vfield. */
395 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
398 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
402 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
403 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
404 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
407 check_constexpr_bind_expr_vars (tree t
)
409 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
411 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
412 if (TREE_CODE (var
) == TYPE_DECL
413 && DECL_IMPLICIT_TYPEDEF_P (var
))
418 /* Subroutine of check_constexpr_ctor_body. */
421 check_constexpr_ctor_body_1 (tree last
, tree list
)
423 switch (TREE_CODE (list
))
426 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
)
430 case CLEANUP_POINT_EXPR
:
431 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
435 if (!check_constexpr_bind_expr_vars (list
)
436 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
450 /* Make sure that there are no statements after LAST in the constructor
451 body represented by LIST. */
454 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
456 /* C++14 doesn't require a constexpr ctor to have an empty body. */
457 if (cxx_dialect
>= cxx14
)
461 if (TREE_CODE (list
) == STATEMENT_LIST
)
463 tree_stmt_iterator i
= tsi_last (list
);
464 for (; !tsi_end_p (i
); tsi_prev (&i
))
466 tree t
= tsi_stmt (i
);
469 if (!check_constexpr_ctor_body_1 (last
, t
))
476 else if (list
!= last
477 && !check_constexpr_ctor_body_1 (last
, list
))
482 error ("constexpr constructor does not have empty body");
483 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
488 /* V is a vector of constructor elements built up for the base and member
489 initializers of a constructor for TYPE. They need to be in increasing
490 offset order, which they might not be yet if TYPE has a primary base
491 which is not first in the base-clause or a vptr and at least one base
492 all of which are non-primary. */
494 static vec
<constructor_elt
, va_gc
> *
495 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
497 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
503 field_type
= BINFO_TYPE (pri
);
504 else if (TYPE_CONTAINS_VPTR_P (type
))
505 field_type
= vtbl_ptr_type_node
;
509 /* Find the element for the primary base or vptr and move it to the
510 beginning of the vec. */
511 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
512 if (TREE_TYPE (ce
->index
) == field_type
)
515 if (i
> 0 && i
< vec_safe_length (v
))
517 vec
<constructor_elt
, va_gc
> &vref
= *v
;
518 constructor_elt elt
= vref
[i
];
527 /* Build compile-time evalable representations of member-initializer list
528 for a constexpr constructor. */
531 build_constexpr_constructor_member_initializers (tree type
, tree body
)
533 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
535 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
536 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
537 body
= TREE_OPERAND (body
, 0);
538 if (TREE_CODE (body
) == STATEMENT_LIST
)
539 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
540 body
= BIND_EXPR_BODY (body
);
541 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
543 body
= TREE_OPERAND (body
, 0);
544 if (TREE_CODE (body
) == EXPR_STMT
)
545 body
= TREE_OPERAND (body
, 0);
546 if (TREE_CODE (body
) == INIT_EXPR
547 && (same_type_ignoring_top_level_qualifiers_p
548 (TREE_TYPE (TREE_OPERAND (body
, 0)),
549 current_class_type
)))
552 return TREE_OPERAND (body
, 1);
554 ok
= build_data_member_initialization (body
, &vec
);
556 else if (TREE_CODE (body
) == STATEMENT_LIST
)
558 tree_stmt_iterator i
;
559 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
561 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
566 else if (TREE_CODE (body
) == TRY_BLOCK
)
568 error ("body of %<constexpr%> constructor cannot be "
569 "a function-try-block");
570 return error_mark_node
;
572 else if (EXPR_P (body
))
573 ok
= build_data_member_initialization (body
, &vec
);
575 gcc_assert (errorcount
> 0);
578 if (vec_safe_length (vec
) > 0)
580 /* In a delegating constructor, return the target. */
581 constructor_elt
*ce
= &(*vec
)[0];
582 if (ce
->index
== current_class_ptr
)
589 vec
= sort_constexpr_mem_initializers (type
, vec
);
590 return build_constructor (type
, vec
);
593 return error_mark_node
;
596 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
597 declared to be constexpr, or a sub-statement thereof. Returns the
598 return value if suitable, error_mark_node for a statement not allowed in
599 a constexpr function, or NULL_TREE if no return value was found. */
602 constexpr_fn_retval (tree body
)
604 switch (TREE_CODE (body
))
608 tree_stmt_iterator i
;
609 tree expr
= NULL_TREE
;
610 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
612 tree s
= constexpr_fn_retval (tsi_stmt (i
));
613 if (s
== error_mark_node
)
614 return error_mark_node
;
615 else if (s
== NULL_TREE
)
616 /* Keep iterating. */;
618 /* Multiple return statements. */
619 return error_mark_node
;
627 return break_out_target_exprs (TREE_OPERAND (body
, 0));
631 tree decl
= DECL_EXPR_DECL (body
);
632 if (TREE_CODE (decl
) == USING_DECL
633 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
634 || DECL_ARTIFICIAL (decl
))
636 return error_mark_node
;
639 case CLEANUP_POINT_EXPR
:
640 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
643 if (!check_constexpr_bind_expr_vars (body
))
644 return error_mark_node
;
645 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
651 return error_mark_node
;
655 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
656 FUN; do the necessary transformations to turn it into a single expression
657 that we can store in the hash table. */
660 massage_constexpr_body (tree fun
, tree body
)
662 if (DECL_CONSTRUCTOR_P (fun
))
663 body
= build_constexpr_constructor_member_initializers
664 (DECL_CONTEXT (fun
), body
);
665 else if (cxx_dialect
< cxx14
)
667 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
668 body
= EH_SPEC_STMTS (body
);
669 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
670 body
= TREE_OPERAND (body
, 0);
671 body
= constexpr_fn_retval (body
);
676 /* FUN is a constexpr constructor with massaged body BODY. Return true
677 if some bases/fields are uninitialized, and complain if COMPLAIN. */
680 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
687 if (TREE_CODE (body
) != CONSTRUCTOR
)
690 nelts
= CONSTRUCTOR_NELTS (body
);
691 ctype
= DECL_CONTEXT (fun
);
692 field
= TYPE_FIELDS (ctype
);
694 if (TREE_CODE (ctype
) == UNION_TYPE
)
696 if (nelts
== 0 && next_initializable_field (field
))
699 error ("%<constexpr%> constructor for union %qT must "
700 "initialize exactly one non-static data member", ctype
);
707 for (i
= 0; i
<= nelts
; ++i
)
714 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
715 /* Skip base and vtable inits. */
716 if (TREE_CODE (index
) != FIELD_DECL
717 || DECL_ARTIFICIAL (index
))
720 for (; field
!= index
; field
= DECL_CHAIN (field
))
723 if (TREE_CODE (field
) != FIELD_DECL
724 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
725 || DECL_ARTIFICIAL (field
))
727 ftype
= strip_array_types (TREE_TYPE (field
));
728 if (type_has_constexpr_default_constructor (ftype
))
730 /* It's OK to skip a member with a trivial constexpr ctor.
731 A constexpr ctor that isn't trivial should have been
733 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
739 error ("member %qD must be initialized by mem-initializer "
740 "in %<constexpr%> constructor", field
);
741 inform (DECL_SOURCE_LOCATION (field
), "declared here");
744 if (field
== NULL_TREE
)
746 field
= DECL_CHAIN (field
);
752 /* We are processing the definition of the constexpr function FUN.
753 Check that its BODY fulfills the propriate requirements and
754 enter it in the constexpr function definition table.
755 For constructor BODY is actually the TREE_LIST of the
756 member-initializer list. */
759 register_constexpr_fundef (tree fun
, tree body
)
761 constexpr_fundef entry
;
762 constexpr_fundef
**slot
;
764 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
767 body
= massage_constexpr_body (fun
, body
);
768 if (body
== NULL_TREE
|| body
== error_mark_node
)
770 if (!DECL_CONSTRUCTOR_P (fun
))
771 error ("body of constexpr function %qD not a return-statement", fun
);
775 if (!potential_rvalue_constant_expression (body
))
777 if (!DECL_GENERATED_P (fun
))
778 require_potential_rvalue_constant_expression (body
);
782 if (DECL_CONSTRUCTOR_P (fun
)
783 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
786 /* Create the constexpr function table if necessary. */
787 if (constexpr_fundef_table
== NULL
)
788 constexpr_fundef_table
789 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
793 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
795 gcc_assert (*slot
== NULL
);
796 *slot
= ggc_alloc
<constexpr_fundef
> ();
802 /* FUN is a non-constexpr function called in a context that requires a
803 constant expression. If it comes from a constexpr template, explain why
804 the instantiation isn't constexpr. */
807 explain_invalid_constexpr_fn (tree fun
)
809 static hash_set
<tree
> *diagnosed
;
812 /* Only diagnose defaulted functions or instantiations. */
813 if (!DECL_DEFAULTED_FN (fun
)
814 && !is_instantiation_of_constexpr (fun
))
816 if (diagnosed
== NULL
)
817 diagnosed
= new hash_set
<tree
>;
818 if (diagnosed
->add (fun
))
819 /* Already explained. */
822 save_loc
= input_location
;
823 input_location
= DECL_SOURCE_LOCATION (fun
);
824 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
825 /* First check the declaration. */
826 if (is_valid_constexpr_fn (fun
, true))
828 /* Then if it's OK, the body. */
829 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
830 explain_implicit_non_constexpr (fun
);
833 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
834 require_potential_rvalue_constant_expression (body
);
835 if (DECL_CONSTRUCTOR_P (fun
))
836 cx_check_missing_mem_inits (fun
, body
, true);
839 input_location
= save_loc
;
842 /* Objects of this type represent calls to constexpr functions
843 along with the bindings of parameters to their arguments, for
844 the purpose of compile time evaluation. */
846 struct GTY((for_user
)) constexpr_call
{
847 /* Description of the constexpr function definition. */
848 constexpr_fundef
*fundef
;
849 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
850 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
851 Note: This arrangement is made to accommodate the use of
852 iterative_hash_template_arg (see pt.c). If you change this
853 representation, also change the hash calculation in
854 cxx_eval_call_expression. */
856 /* Result of the call.
857 NULL means the call is being evaluated.
858 error_mark_node means that the evaluation was erroneous;
859 otherwise, the actuall value of the call. */
861 /* The hash of this call; we remember it here to avoid having to
862 recalculate it when expanding the hash table. */
866 struct constexpr_call_hasher
: ggc_hasher
<constexpr_call
*>
868 static hashval_t
hash (constexpr_call
*);
869 static bool equal (constexpr_call
*, constexpr_call
*);
872 /* The constexpr expansion context. CALL is the current function
873 expansion, CTOR is the current aggregate initializer, OBJECT is the
874 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
875 is a map of values of variables initialized within the expression. */
877 struct constexpr_ctx
{
878 /* The innermost call we're evaluating. */
879 constexpr_call
*call
;
880 /* Values for any temporaries or local variables within the
881 constant-expression. */
882 hash_map
<tree
,tree
> *values
;
883 /* The CONSTRUCTOR we're currently building up for an aggregate
886 /* The object we're building the CONSTRUCTOR for. */
888 /* Whether we should error on a non-constant expression or fail quietly. */
890 /* Whether we are strictly conforming to constant expression rules or
891 trying harder to get a constant value. */
895 /* A table of all constexpr calls that have been evaluated by the
896 compiler in this translation unit. */
898 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
900 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
901 bool, bool *, bool *, tree
* = NULL
);
903 /* Compute a hash value for a constexpr call representation. */
906 constexpr_call_hasher::hash (constexpr_call
*info
)
911 /* Return true if the objects pointed to by P and Q represent calls
912 to the same constexpr function with the same arguments.
913 Otherwise, return false. */
916 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
922 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
924 lhs_bindings
= lhs
->bindings
;
925 rhs_bindings
= rhs
->bindings
;
926 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
928 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
929 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
930 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
931 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
933 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
934 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
936 return lhs_bindings
== rhs_bindings
;
939 /* Initialize the constexpr call table, if needed. */
942 maybe_initialize_constexpr_call_table (void)
944 if (constexpr_call_table
== NULL
)
945 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
948 /* We have an expression tree T that represents a call, either CALL_EXPR
949 or AGGR_INIT_EXPR. If the call is lexically to a named function,
950 retrun the _DECL for that function. */
953 get_function_named_in_call (tree t
)
956 switch (TREE_CODE (t
))
959 fun
= CALL_EXPR_FN (t
);
963 fun
= AGGR_INIT_EXPR_FN (t
);
970 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
971 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
972 fun
= TREE_OPERAND (fun
, 0);
976 /* We have an expression tree T that represents a call, either CALL_EXPR
977 or AGGR_INIT_EXPR. Return the Nth argument. */
980 get_nth_callarg (tree t
, int n
)
982 switch (TREE_CODE (t
))
985 return CALL_EXPR_ARG (t
, n
);
988 return AGGR_INIT_EXPR_ARG (t
, n
);
996 /* Look up the binding of the function parameter T in a constexpr
997 function call context CALL. */
1000 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
1002 tree b
= purpose_member (t
, call
->bindings
);
1003 return TREE_VALUE (b
);
1006 /* Attempt to evaluate T which represents a call to a builtin function.
1007 We assume here that all builtin functions evaluate to scalar types
1008 represented by _CST nodes. */
1011 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
,
1013 bool *non_constant_p
, bool *overflow_p
)
1015 const int nargs
= call_expr_nargs (t
);
1016 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1019 for (i
= 0; i
< nargs
; ++i
)
1021 args
[i
] = cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, i
),
1023 non_constant_p
, overflow_p
);
1024 if (ctx
->quiet
&& *non_constant_p
)
1027 if (*non_constant_p
)
1029 new_call
= fold_build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1030 CALL_EXPR_FN (t
), nargs
, args
);
1031 VERIFY_CONSTANT (new_call
);
1035 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1036 the type of the value to match. */
1039 adjust_temp_type (tree type
, tree temp
)
1041 if (TREE_TYPE (temp
) == type
)
1043 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1044 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1045 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1046 gcc_assert (scalarish_type_p (type
));
1047 return cp_fold_convert (type
, temp
);
1050 /* True if we want to use the new handling of constexpr calls based on
1052 #define use_new_call true
1054 /* Subroutine of cxx_eval_call_expression.
1055 We are processing a call expression (either CALL_EXPR or
1056 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1057 all arguments and bind their values to correspondings
1058 parameters, making up the NEW_CALL context. */
1061 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1062 constexpr_call
*new_call
,
1063 bool *non_constant_p
, bool *overflow_p
,
1064 bool *non_constant_args
)
1066 const int nargs
= call_expr_nargs (t
);
1067 tree fun
= new_call
->fundef
->decl
;
1068 tree parms
= DECL_ARGUMENTS (fun
);
1070 tree
*p
= &new_call
->bindings
;
1071 for (i
= 0; i
< nargs
; ++i
)
1074 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1075 x
= get_nth_callarg (t
, i
);
1076 /* For member function, the first argument is a pointer to the implied
1077 object. For a constructor, it might still be a dummy object, in
1078 which case we get the real argument from ctx. */
1079 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1080 && is_dummy_object (x
))
1083 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1086 if (parms
&& DECL_BY_REFERENCE (parms
) && !use_new_call
)
1088 /* cp_genericize made this a reference for argument passing, but
1089 we don't want to treat it like one for C++11 constexpr
1090 evaluation. C++14 constexpr evaluation uses the genericized
1092 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1093 gcc_assert (TREE_CODE (TREE_TYPE (x
)) == REFERENCE_TYPE
);
1094 type
= TREE_TYPE (type
);
1095 x
= convert_from_reference (x
);
1098 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1099 non_constant_p
, overflow_p
);
1100 /* Don't VERIFY_CONSTANT here. */
1101 if (*non_constant_p
&& ctx
->quiet
)
1103 /* Just discard ellipsis args after checking their constantitude. */
1106 if (*non_constant_p
)
1107 /* Don't try to adjust the type of non-constant args. */
1110 /* Make sure the binding has the same type as the parm. */
1111 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1112 arg
= adjust_temp_type (type
, arg
);
1113 if (!TREE_CONSTANT (arg
))
1114 *non_constant_args
= true;
1115 *p
= build_tree_list (parms
, arg
);
1116 p
= &TREE_CHAIN (*p
);
1118 parms
= TREE_CHAIN (parms
);
1122 /* Variables and functions to manage constexpr call expansion context.
1123 These do not need to be marked for PCH or GC. */
1125 /* FIXME remember and print actual constant arguments. */
1126 static vec
<tree
> call_stack
= vNULL
;
1127 static int call_stack_tick
;
1128 static int last_cx_error_tick
;
1131 push_cx_call_context (tree call
)
1134 if (!EXPR_HAS_LOCATION (call
))
1135 SET_EXPR_LOCATION (call
, input_location
);
1136 call_stack
.safe_push (call
);
1137 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1143 pop_cx_call_context (void)
1150 cx_error_context (void)
1152 vec
<tree
> r
= vNULL
;
1153 if (call_stack_tick
!= last_cx_error_tick
1154 && !call_stack
.is_empty ())
1156 last_cx_error_tick
= call_stack_tick
;
1160 /* Subroutine of cxx_eval_constant_expression.
1161 Evaluate the call expression tree T in the context of OLD_CALL expression
1165 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1167 bool *non_constant_p
, bool *overflow_p
)
1169 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1170 tree fun
= get_function_named_in_call (t
);
1171 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1174 if (fun
== NULL_TREE
)
1175 switch (CALL_EXPR_IFN (t
))
1177 case IFN_UBSAN_NULL
:
1178 case IFN_UBSAN_BOUNDS
:
1179 case IFN_UBSAN_VPTR
:
1183 error_at (loc
, "call to internal function");
1184 *non_constant_p
= true;
1188 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1190 /* Might be a constexpr function pointer. */
1191 fun
= cxx_eval_constant_expression (ctx
, fun
,
1192 /*lval*/false, non_constant_p
,
1195 if (TREE_CODE (fun
) == ADDR_EXPR
)
1196 fun
= TREE_OPERAND (fun
, 0);
1198 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1200 if (!ctx
->quiet
&& !*non_constant_p
)
1201 error_at (loc
, "expression %qE does not designate a constexpr "
1203 *non_constant_p
= true;
1206 if (DECL_CLONED_FUNCTION_P (fun
))
1207 fun
= DECL_CLONED_FUNCTION (fun
);
1209 if (is_ubsan_builtin_p (fun
))
1212 if (is_builtin_fn (fun
))
1213 return cxx_eval_builtin_function_call (ctx
, t
,
1214 lval
, non_constant_p
, overflow_p
);
1215 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1219 error_at (loc
, "call to non-constexpr function %qD", fun
);
1220 explain_invalid_constexpr_fn (fun
);
1222 *non_constant_p
= true;
1226 /* Shortcut trivial constructor/op=. */
1227 if (trivial_fn_p (fun
))
1229 if (call_expr_nargs (t
) == 2)
1231 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
1232 return cxx_eval_constant_expression (ctx
, arg
,
1233 lval
, non_constant_p
,
1236 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1237 && AGGR_INIT_ZERO_FIRST (t
))
1238 return build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1241 /* If in direct recursive call, optimize definition search. */
1242 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1243 new_call
.fundef
= ctx
->call
->fundef
;
1246 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1247 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
1251 if (DECL_INITIAL (fun
))
1253 /* The definition of fun was somehow unsuitable. */
1254 error_at (loc
, "%qD called in a constant expression", fun
);
1255 explain_invalid_constexpr_fn (fun
);
1258 error_at (loc
, "%qD used before its definition", fun
);
1260 *non_constant_p
= true;
1265 constexpr_ctx new_ctx
= *ctx
;
1266 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1267 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1269 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1270 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1271 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1272 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1273 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1274 ctx
->values
->put (new_ctx
.object
, ctor
);
1278 bool non_constant_args
= false;
1279 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1280 non_constant_p
, overflow_p
, &non_constant_args
);
1281 if (*non_constant_p
)
1284 depth_ok
= push_cx_call_context (t
);
1286 tree result
= NULL_TREE
;
1288 constexpr_call
*entry
= NULL
;
1289 if (!non_constant_args
)
1291 new_call
.hash
= iterative_hash_template_arg
1292 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1294 /* If we have seen this call before, we are done. */
1295 maybe_initialize_constexpr_call_table ();
1296 constexpr_call
**slot
1297 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1301 /* We need to keep a pointer to the entry, not just the slot, as the
1302 slot can move in the call to cxx_eval_builtin_function_call. */
1303 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1306 /* Calls which are in progress have their result set to NULL
1307 so that we can detect circular dependencies. */
1308 else if (entry
->result
== NULL
)
1311 error ("call has circular dependency");
1312 *non_constant_p
= true;
1313 entry
->result
= result
= error_mark_node
;
1316 result
= entry
->result
;
1322 error ("constexpr evaluation depth exceeds maximum of %d (use "
1323 "-fconstexpr-depth= to increase the maximum)",
1324 max_constexpr_depth
);
1325 *non_constant_p
= true;
1326 result
= error_mark_node
;
1330 if (!result
|| result
== error_mark_node
)
1334 new_ctx
.call
= &new_call
;
1335 result
= (cxx_eval_constant_expression
1336 (&new_ctx
, new_call
.fundef
->body
,
1338 non_constant_p
, overflow_p
));
1342 if (DECL_SAVED_TREE (fun
) == NULL_TREE
1343 && (DECL_CONSTRUCTOR_P (fun
) || DECL_DESTRUCTOR_P (fun
)))
1344 /* The maybe-in-charge 'tor had its DECL_SAVED_TREE
1345 cleared, try the first clone. */
1346 fun
= DECL_CHAIN (fun
);
1347 gcc_assert (DECL_SAVED_TREE (fun
));
1350 /* Unshare the whole function body. */
1351 tree body
= copy_fn (fun
, parms
, res
);
1353 /* Associate the bindings with the remapped parms. */
1354 tree bound
= new_call
.bindings
;
1355 tree remapped
= parms
;
1358 tree oparm
= TREE_PURPOSE (bound
);
1359 tree arg
= TREE_VALUE (bound
);
1360 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1361 ctx
->values
->put (remapped
, arg
);
1362 bound
= TREE_CHAIN (bound
);
1363 remapped
= DECL_CHAIN (remapped
);
1365 /* Add the RESULT_DECL to the values map, too. */
1366 tree slot
= NULL_TREE
;
1367 if (DECL_BY_REFERENCE (res
))
1369 slot
= AGGR_INIT_EXPR_SLOT (t
);
1370 tree addr
= build_address (slot
);
1371 addr
= build_nop (TREE_TYPE (res
), addr
);
1372 ctx
->values
->put (res
, addr
);
1373 ctx
->values
->put (slot
, NULL_TREE
);
1376 ctx
->values
->put (res
, NULL_TREE
);
1378 tree jump_target
= NULL_TREE
;
1379 cxx_eval_constant_expression (ctx
, body
,
1380 lval
, non_constant_p
, overflow_p
,
1383 if (DECL_CONSTRUCTOR_P (fun
))
1384 /* This can be null for a subobject constructor call, in
1385 which case what we care about is the initialization
1386 side-effects rather than the value. We could get at the
1387 value by evaluating *this, but we don't bother; there's
1388 no need to put such a call in the hash table. */
1389 result
= lval
? ctx
->object
: ctx
->ctor
;
1390 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1394 result
= *ctx
->values
->get (slot
? slot
: res
);
1395 if (result
== NULL_TREE
&& !*non_constant_p
)
1398 error ("constexpr call flows off the end "
1400 *non_constant_p
= true;
1404 /* Remove the parms/result from the values map. Is it worth
1405 bothering to do this when the map itself is only live for
1406 one constexpr evaluation? If so, maybe also clear out
1407 other vars from call, maybe in BIND_EXPR handling? */
1408 ctx
->values
->remove (res
);
1410 ctx
->values
->remove (slot
);
1411 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1412 ctx
->values
->remove (parm
);
1416 if (result
== error_mark_node
)
1417 *non_constant_p
= true;
1418 if (*non_constant_p
)
1419 result
= error_mark_node
;
1422 /* If this was a call to initialize an object, set the type of
1423 the CONSTRUCTOR to the type of that object. */
1424 if (DECL_CONSTRUCTOR_P (fun
) && !use_new_call
)
1426 tree ob_arg
= get_nth_callarg (t
, 0);
1427 STRIP_NOPS (ob_arg
);
1428 gcc_assert (TYPE_PTR_P (TREE_TYPE (ob_arg
))
1429 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
1430 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
1437 entry
->result
= result
;
1440 pop_cx_call_context ();
1441 return unshare_expr (result
);
1444 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1447 reduced_constant_expression_p (tree t
)
1449 switch (TREE_CODE (t
))
1452 /* Even if we can't lower this yet, it's constant. */
1456 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1457 tree elt
; unsigned HOST_WIDE_INT idx
;
1458 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1459 if (!reduced_constant_expression_p (elt
))
1464 /* FIXME are we calling this too much? */
1465 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1469 /* Some expressions may have constant operands but are not constant
1470 themselves, such as 1/0. Call this function (or rather, the macro
1471 following it) to check for that condition.
1473 We only call this in places that require an arithmetic constant, not in
1474 places where we might have a non-constant expression that can be a
1475 component of a constant expression, such as the address of a constexpr
1476 variable that might be dereferenced later. */
1479 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1482 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1484 if (!allow_non_constant
)
1485 error ("%q+E is not a constant expression", t
);
1486 *non_constant_p
= true;
1488 if (TREE_OVERFLOW_P (t
))
1490 if (!allow_non_constant
)
1492 permerror (input_location
, "overflow in constant expression");
1493 /* If we're being permissive (and are in an enforcing
1494 context), ignore the overflow. */
1495 if (flag_permissive
)
1496 return *non_constant_p
;
1500 return *non_constant_p
;
1503 /* Check whether the shift operation with code CODE and type TYPE on LHS
1504 and RHS is undefined. If it is, give an error with an explanation,
1505 and return true; return false otherwise. */
1508 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1509 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1511 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1512 || TREE_CODE (lhs
) != INTEGER_CST
1513 || TREE_CODE (rhs
) != INTEGER_CST
)
1516 tree lhstype
= TREE_TYPE (lhs
);
1517 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1519 /* [expr.shift] The behavior is undefined if the right operand
1520 is negative, or greater than or equal to the length in bits
1521 of the promoted left operand. */
1522 if (tree_int_cst_sgn (rhs
) == -1)
1525 error_at (loc
, "right operand of shift expression %q+E is negative",
1526 build2_loc (loc
, code
, type
, lhs
, rhs
));
1529 if (compare_tree_int (rhs
, uprec
) >= 0)
1532 error_at (loc
, "right operand of shift expression %q+E is >= than "
1533 "the precision of the left operand",
1534 build2_loc (loc
, code
, type
, lhs
, rhs
));
1538 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1539 if E1 has a signed type and non-negative value, and E1x2^E2 is
1540 representable in the corresponding unsigned type of the result type,
1541 then that value, converted to the result type, is the resulting value;
1542 otherwise, the behavior is undefined. */
1543 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1544 && (cxx_dialect
>= cxx11
))
1546 if (tree_int_cst_sgn (lhs
) == -1)
1549 error_at (loc
, "left operand of shift expression %q+E is negative",
1550 build2_loc (loc
, code
, type
, lhs
, rhs
));
1553 /* For signed x << y the following:
1554 (unsigned) x >> ((prec (lhs) - 1) - y)
1555 if > 1, is undefined. The right-hand side of this formula
1556 is the highest bit of the LHS that can be set (starting from 0),
1557 so that the shift doesn't overflow. We then right-shift the LHS
1558 to see whether any other bit is set making the original shift
1559 undefined -- the result is not representable in the corresponding
1561 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1562 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1563 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1564 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1565 if (tree_int_cst_lt (integer_one_node
, t
))
1568 error_at (loc
, "shift expression %q+E overflows",
1569 build2_loc (loc
, code
, type
, lhs
, rhs
));
1576 /* Subroutine of cxx_eval_constant_expression.
1577 Attempt to reduce the unary expression tree T to a compile time value.
1578 If successful, return the value. Otherwise issue a diagnostic
1579 and return error_mark_node. */
1582 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1584 bool *non_constant_p
, bool *overflow_p
)
1587 tree orig_arg
= TREE_OPERAND (t
, 0);
1588 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1589 non_constant_p
, overflow_p
);
1590 VERIFY_CONSTANT (arg
);
1591 location_t loc
= EXPR_LOCATION (t
);
1592 enum tree_code code
= TREE_CODE (t
);
1593 tree type
= TREE_TYPE (t
);
1594 r
= fold_unary_loc (loc
, code
, type
, arg
);
1597 if (arg
== orig_arg
)
1600 r
= build1_loc (loc
, code
, type
, arg
);
1602 VERIFY_CONSTANT (r
);
1606 /* Subroutine of cxx_eval_constant_expression.
1607 Like cxx_eval_unary_expression, except for binary expressions. */
1610 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1612 bool *non_constant_p
, bool *overflow_p
)
1615 tree orig_lhs
= TREE_OPERAND (t
, 0);
1616 tree orig_rhs
= TREE_OPERAND (t
, 1);
1618 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1619 non_constant_p
, overflow_p
);
1620 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1621 a local array in a constexpr function. */
1622 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1624 VERIFY_CONSTANT (lhs
);
1625 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1626 non_constant_p
, overflow_p
);
1628 VERIFY_CONSTANT (rhs
);
1630 location_t loc
= EXPR_LOCATION (t
);
1631 enum tree_code code
= TREE_CODE (t
);
1632 tree type
= TREE_TYPE (t
);
1633 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1636 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1639 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1641 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1642 *non_constant_p
= true;
1644 VERIFY_CONSTANT (r
);
1648 /* Subroutine of cxx_eval_constant_expression.
1649 Attempt to evaluate condition expressions. Dead branches are not
1653 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1655 bool *non_constant_p
, bool *overflow_p
,
1658 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1660 non_constant_p
, overflow_p
);
1661 VERIFY_CONSTANT (val
);
1662 /* Don't VERIFY_CONSTANT the other operands. */
1663 if (integer_zerop (val
))
1664 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1666 non_constant_p
, overflow_p
,
1668 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1670 non_constant_p
, overflow_p
,
1674 /* Subroutine of cxx_eval_constant_expression.
1675 Attempt to reduce a reference to an array slot. */
1678 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
1680 bool *non_constant_p
, bool *overflow_p
)
1682 tree oldary
= TREE_OPERAND (t
, 0);
1683 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
1685 non_constant_p
, overflow_p
);
1689 unsigned len
, elem_nchars
= 1;
1690 if (*non_constant_p
)
1692 oldidx
= TREE_OPERAND (t
, 1);
1693 index
= cxx_eval_constant_expression (ctx
, oldidx
,
1695 non_constant_p
, overflow_p
);
1696 VERIFY_CONSTANT (index
);
1697 if (lval
&& ary
== oldary
&& index
== oldidx
)
1700 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
1701 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
1702 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1703 len
= CONSTRUCTOR_NELTS (ary
);
1704 else if (TREE_CODE (ary
) == STRING_CST
)
1706 elem_nchars
= (TYPE_PRECISION (elem_type
)
1707 / TYPE_PRECISION (char_type_node
));
1708 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
1712 /* We can't do anything with other tree codes, so use
1713 VERIFY_CONSTANT to complain and fail. */
1714 VERIFY_CONSTANT (ary
);
1717 if (compare_tree_int (index
, len
) >= 0)
1719 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
1721 /* If it's within the array bounds but doesn't have an explicit
1722 initializer, it's value-initialized. */
1723 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
1724 return cxx_eval_constant_expression (ctx
, val
,
1726 non_constant_p
, overflow_p
);
1730 error ("array subscript out of bound");
1731 *non_constant_p
= true;
1734 else if (tree_int_cst_lt (index
, integer_zero_node
))
1737 error ("negative array subscript");
1738 *non_constant_p
= true;
1741 i
= tree_to_shwi (index
);
1742 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1743 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
1744 else if (elem_nchars
== 1)
1745 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
1746 TREE_STRING_POINTER (ary
)[i
]);
1749 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
1750 return native_interpret_expr (type
, (const unsigned char *)
1751 TREE_STRING_POINTER (ary
)
1752 + i
* elem_nchars
, elem_nchars
);
1754 /* Don't VERIFY_CONSTANT here. */
1757 /* Subroutine of cxx_eval_constant_expression.
1758 Attempt to reduce a field access of a value of class type. */
1761 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
1763 bool *non_constant_p
, bool *overflow_p
)
1765 unsigned HOST_WIDE_INT i
;
1768 tree part
= TREE_OPERAND (t
, 1);
1769 tree orig_whole
= TREE_OPERAND (t
, 0);
1770 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1772 non_constant_p
, overflow_p
);
1773 if (whole
== orig_whole
)
1776 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
1777 whole
, part
, NULL_TREE
);
1778 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1780 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
1783 error ("%qE is not a constant expression", orig_whole
);
1784 *non_constant_p
= true;
1786 if (DECL_MUTABLE_P (part
))
1789 error ("mutable %qD is not usable in a constant expression", part
);
1790 *non_constant_p
= true;
1792 if (*non_constant_p
)
1794 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1801 /* We're in the middle of initializing it. */
1805 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
1806 && CONSTRUCTOR_NELTS (whole
) > 0)
1808 /* DR 1188 says we don't have to deal with this. */
1810 error ("accessing %qD member instead of initialized %qD member in "
1811 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
1812 *non_constant_p
= true;
1816 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
1818 /* 'whole' is part of the aggregate initializer we're currently
1819 building; if there's no initializer for this member yet, that's an
1822 error ("accessing uninitialized member %qD", part
);
1823 *non_constant_p
= true;
1827 /* If there's no explicit init for this field, it's value-initialized. */
1828 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
1829 return cxx_eval_constant_expression (ctx
, value
,
1831 non_constant_p
, overflow_p
);
1834 /* Subroutine of cxx_eval_constant_expression.
1835 Attempt to reduce a field access of a value of class type that is
1836 expressed as a BIT_FIELD_REF. */
1839 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
1841 bool *non_constant_p
, bool *overflow_p
)
1843 tree orig_whole
= TREE_OPERAND (t
, 0);
1844 tree retval
, fldval
, utype
, mask
;
1845 bool fld_seen
= false;
1846 HOST_WIDE_INT istart
, isize
;
1847 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1849 non_constant_p
, overflow_p
);
1850 tree start
, field
, value
;
1851 unsigned HOST_WIDE_INT i
;
1853 if (whole
== orig_whole
)
1855 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1857 if (!*non_constant_p
1858 && TREE_CODE (whole
) != VECTOR_CST
1859 && TREE_CODE (whole
) != CONSTRUCTOR
)
1862 error ("%qE is not a constant expression", orig_whole
);
1863 *non_constant_p
= true;
1865 if (*non_constant_p
)
1868 if (TREE_CODE (whole
) == VECTOR_CST
)
1869 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
1870 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
1872 start
= TREE_OPERAND (t
, 2);
1873 istart
= tree_to_shwi (start
);
1874 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
1875 utype
= TREE_TYPE (t
);
1876 if (!TYPE_UNSIGNED (utype
))
1877 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
1878 retval
= build_int_cst (utype
, 0);
1879 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1881 tree bitpos
= bit_position (field
);
1882 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
1884 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
1885 && TREE_CODE (value
) == INTEGER_CST
1886 && tree_fits_shwi_p (bitpos
)
1887 && tree_fits_shwi_p (DECL_SIZE (field
)))
1889 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
1890 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
1891 HOST_WIDE_INT shift
;
1892 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
1894 fldval
= fold_convert (utype
, value
);
1895 mask
= build_int_cst_type (utype
, -1);
1896 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
1897 size_int (TYPE_PRECISION (utype
) - sz
));
1898 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
1899 size_int (TYPE_PRECISION (utype
) - sz
));
1900 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
1901 shift
= bit
- istart
;
1902 if (BYTES_BIG_ENDIAN
)
1903 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
1904 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
1906 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
1912 return fold_convert (TREE_TYPE (t
), retval
);
1914 return error_mark_node
;
1917 /* Subroutine of cxx_eval_constant_expression.
1918 Evaluate a short-circuited logical expression T in the context
1919 of a given constexpr CALL. BAILOUT_VALUE is the value for
1920 early return. CONTINUE_VALUE is used here purely for
1921 sanity check purposes. */
1924 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
1925 tree bailout_value
, tree continue_value
,
1927 bool *non_constant_p
, bool *overflow_p
)
1930 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1932 non_constant_p
, overflow_p
);
1933 VERIFY_CONSTANT (lhs
);
1934 if (tree_int_cst_equal (lhs
, bailout_value
))
1936 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
1937 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1938 lval
, non_constant_p
,
1940 VERIFY_CONSTANT (r
);
1944 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
1945 CONSTRUCTOR elements to initialize (part of) an object containing that
1946 field. Return a pointer to the constructor_elt corresponding to the
1947 initialization of the field. */
1949 static constructor_elt
*
1950 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
1952 tree aggr
= TREE_OPERAND (ref
, 0);
1953 tree field
= TREE_OPERAND (ref
, 1);
1955 constructor_elt
*ce
;
1957 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
1959 if (TREE_CODE (aggr
) == COMPONENT_REF
)
1961 constructor_elt
*base_ce
1962 = base_field_constructor_elt (v
, aggr
);
1963 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
1966 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
1967 if (ce
->index
== field
)
1974 /* Some of the expressions fed to the constexpr mechanism are calls to
1975 constructors, which have type void. In that case, return the type being
1976 initialized by the constructor. */
1979 initialized_type (tree t
)
1983 tree type
= cv_unqualified (TREE_TYPE (t
));
1984 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
1986 /* A constructor call has void type, so we need to look deeper. */
1987 tree fn
= get_function_named_in_call (t
);
1988 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
1989 && DECL_CXX_CONSTRUCTOR_P (fn
))
1990 type
= DECL_CONTEXT (fn
);
1995 /* We're about to initialize element INDEX of an array or class from VALUE.
1996 Set up NEW_CTX appropriately by adjusting .object to refer to the
1997 subobject and creating a new CONSTRUCTOR if the element is itself
1998 a class or array. */
2001 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2002 tree index
, tree
&value
)
2006 if (index
&& TREE_CODE (index
) != INTEGER_CST
2007 && TREE_CODE (index
) != FIELD_DECL
)
2008 /* This won't have an element in the new CONSTRUCTOR. */
2011 tree type
= initialized_type (value
);
2012 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2013 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2016 /* The sub-aggregate initializer might contain a placeholder;
2017 update object to refer to the subobject and ctor to refer to
2018 the (newly created) sub-initializer. */
2020 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2021 tree elt
= build_constructor (type
, NULL
);
2022 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2025 if (TREE_CODE (value
) == TARGET_EXPR
)
2026 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2027 value
= TARGET_EXPR_INITIAL (value
);
2030 /* We're about to process an initializer for a class or array TYPE. Make
2031 sure that CTX is set up appropriately. */
2034 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2036 /* We don't bother building a ctor for an empty base subobject. */
2037 if (is_empty_class (type
))
2040 /* We're in the middle of an initializer that might involve placeholders;
2041 our caller should have created a CONSTRUCTOR for us to put the
2042 initializer into. We will either return that constructor or T. */
2043 gcc_assert (ctx
->ctor
);
2044 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2045 (type
, TREE_TYPE (ctx
->ctor
)));
2046 gcc_assert (CONSTRUCTOR_NELTS (ctx
->ctor
) == 0);
2048 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2049 (type
, TREE_TYPE (ctx
->object
)));
2050 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2051 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2054 /* Subroutine of cxx_eval_constant_expression.
2055 The expression tree T denotes a C-style array or a C-style
2056 aggregate. Reduce it to a constant expression. */
2059 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2061 bool *non_constant_p
, bool *overflow_p
)
2063 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2064 bool changed
= false;
2065 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2067 verify_ctor_sanity (ctx
, TREE_TYPE (t
));
2068 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2069 vec_alloc (*p
, vec_safe_length (v
));
2071 unsigned i
; tree index
, value
;
2072 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2074 constexpr_ctx new_ctx
;
2075 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2076 if (new_ctx
.ctor
!= ctx
->ctor
)
2077 /* If we built a new CONSTRUCTOR, attach it now so that other
2078 initializers can refer to it. */
2079 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2080 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2082 non_constant_p
, overflow_p
);
2083 /* Don't VERIFY_CONSTANT here. */
2084 if (ctx
->quiet
&& *non_constant_p
)
2088 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2090 /* This is an initialization of a vfield inside a base
2091 subaggregate that we already initialized; push this
2092 initialization into the previous initialization. */
2093 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2098 && (TREE_CODE (index
) == NOP_EXPR
2099 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2101 /* This is an initializer for an empty base; now that we've
2102 checked that it's constant, we can ignore it. */
2103 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2106 else if (new_ctx
.ctor
!= ctx
->ctor
)
2108 /* We appended this element above; update the value. */
2109 gcc_assert ((*p
)->last().index
== index
);
2110 (*p
)->last().value
= elt
;
2113 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2115 if (*non_constant_p
|| !changed
)
2118 /* We're done building this CONSTRUCTOR, so now we can interpret an
2119 element without an explicit initializer as value-initialized. */
2120 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2121 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2126 /* Subroutine of cxx_eval_constant_expression.
2127 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2128 initialization of a non-static data member of array type. Reduce it to a
2131 Note that apart from value-initialization (when VALUE_INIT is true),
2132 this is only intended to support value-initialization and the
2133 initializations done by defaulted constructors for classes with
2134 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2135 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2136 for the copy/move constructor. */
2139 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2140 bool value_init
, bool lval
,
2141 bool *non_constant_p
, bool *overflow_p
)
2143 tree elttype
= TREE_TYPE (atype
);
2144 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2145 verify_ctor_sanity (ctx
, atype
);
2146 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2147 vec_alloc (*p
, max
+ 1);
2148 bool pre_init
= false;
2149 unsigned HOST_WIDE_INT i
;
2151 /* For the default constructor, build up a call to the default
2152 constructor of the element type. We only need to handle class types
2153 here, as for a constructor to be constexpr, all members must be
2154 initialized, which for a defaulted default constructor means they must
2155 be of a class type with a constexpr default constructor. */
2156 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2157 /* We only do this at the lowest level. */;
2158 else if (value_init
)
2160 init
= build_value_init (elttype
, tf_warning_or_error
);
2165 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2166 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2167 &argvec
, elttype
, LOOKUP_NORMAL
,
2168 tf_warning_or_error
);
2169 release_tree_vector (argvec
);
2170 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2174 for (i
= 0; i
< max
; ++i
)
2176 tree idx
= build_int_cst (size_type_node
, i
);
2178 constexpr_ctx new_ctx
;
2179 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2180 if (new_ctx
.ctor
!= ctx
->ctor
)
2181 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2182 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2184 /* A multidimensional array; recurse. */
2185 if (value_init
|| init
== NULL_TREE
)
2186 eltinit
= NULL_TREE
;
2188 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2189 tf_warning_or_error
);
2190 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2192 non_constant_p
, overflow_p
);
2196 /* Initializing an element using value or default initialization
2197 we just pre-built above. */
2198 eltinit
= (cxx_eval_constant_expression
2200 lval
, non_constant_p
, overflow_p
));
2204 /* Copying an element. */
2205 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2206 (atype
, TREE_TYPE (init
)));
2207 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2208 tf_warning_or_error
);
2209 if (!real_lvalue_p (init
))
2210 eltinit
= move (eltinit
);
2211 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2212 eltinit
= (cxx_eval_constant_expression
2213 (&new_ctx
, eltinit
, lval
,
2214 non_constant_p
, overflow_p
));
2216 if (*non_constant_p
&& !ctx
->quiet
)
2218 if (new_ctx
.ctor
!= ctx
->ctor
)
2220 /* We appended this element above; update the value. */
2221 gcc_assert ((*p
)->last().index
== idx
);
2222 (*p
)->last().value
= eltinit
;
2225 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2228 if (!*non_constant_p
)
2231 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2237 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2239 bool *non_constant_p
, bool *overflow_p
)
2241 tree atype
= TREE_TYPE (t
);
2242 tree init
= VEC_INIT_EXPR_INIT (t
);
2243 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2244 VEC_INIT_EXPR_VALUE_INIT (t
),
2245 lval
, non_constant_p
, overflow_p
);
2246 if (*non_constant_p
)
2252 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2253 match. We want to be less strict for simple *& folding; if we have a
2254 non-const temporary that we access through a const pointer, that should
2255 work. We handle this here rather than change fold_indirect_ref_1
2256 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2257 don't really make sense outside of constant expression evaluation. Also
2258 we want to allow folding to COMPONENT_REF, which could cause trouble
2259 with TBAA in fold_indirect_ref_1.
2261 Try to keep this function synced with fold_indirect_ref_1. */
2264 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2270 subtype
= TREE_TYPE (sub
);
2271 if (!POINTER_TYPE_P (subtype
))
2274 if (TREE_CODE (sub
) == ADDR_EXPR
)
2276 tree op
= TREE_OPERAND (sub
, 0);
2277 tree optype
= TREE_TYPE (op
);
2279 /* *&CONST_DECL -> to the value of the const decl. */
2280 if (TREE_CODE (op
) == CONST_DECL
)
2281 return DECL_INITIAL (op
);
2282 /* *&p => p; make sure to handle *&"str"[cst] here. */
2283 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
2285 tree fop
= fold_read_from_constant_string (op
);
2291 /* *(foo *)&fooarray => fooarray[0] */
2292 else if (TREE_CODE (optype
) == ARRAY_TYPE
2293 && (same_type_ignoring_top_level_qualifiers_p
2294 (type
, TREE_TYPE (optype
))))
2296 tree type_domain
= TYPE_DOMAIN (optype
);
2297 tree min_val
= size_zero_node
;
2298 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2299 min_val
= TYPE_MIN_VALUE (type_domain
);
2300 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2301 NULL_TREE
, NULL_TREE
);
2303 /* *(foo *)&complexfoo => __real__ complexfoo */
2304 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2305 && (same_type_ignoring_top_level_qualifiers_p
2306 (type
, TREE_TYPE (optype
))))
2307 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2308 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2309 else if (TREE_CODE (optype
) == VECTOR_TYPE
2310 && (same_type_ignoring_top_level_qualifiers_p
2311 (type
, TREE_TYPE (optype
))))
2313 tree part_width
= TYPE_SIZE (type
);
2314 tree index
= bitsize_int (0);
2315 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2317 /* Also handle conversion to an empty base class, which
2318 is represented with a NOP_EXPR. */
2319 else if (is_empty_class (type
)
2320 && CLASS_TYPE_P (optype
)
2321 && DERIVED_FROM_P (type
, optype
))
2326 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2327 else if (RECORD_OR_UNION_TYPE_P (optype
))
2329 tree field
= TYPE_FIELDS (optype
);
2330 for (; field
; field
= DECL_CHAIN (field
))
2331 if (TREE_CODE (field
) == FIELD_DECL
2332 && integer_zerop (byte_position (field
))
2333 && (same_type_ignoring_top_level_qualifiers_p
2334 (TREE_TYPE (field
), type
)))
2336 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2341 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2342 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2344 tree op00
= TREE_OPERAND (sub
, 0);
2345 tree op01
= TREE_OPERAND (sub
, 1);
2348 if (TREE_CODE (op00
) == ADDR_EXPR
)
2351 op00
= TREE_OPERAND (op00
, 0);
2352 op00type
= TREE_TYPE (op00
);
2354 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2355 if (TREE_CODE (op00type
) == VECTOR_TYPE
2356 && (same_type_ignoring_top_level_qualifiers_p
2357 (type
, TREE_TYPE (op00type
))))
2359 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2360 tree part_width
= TYPE_SIZE (type
);
2361 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2362 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2363 tree index
= bitsize_int (indexi
);
2365 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2366 return fold_build3_loc (loc
,
2367 BIT_FIELD_REF
, type
, op00
,
2371 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2372 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2373 && (same_type_ignoring_top_level_qualifiers_p
2374 (type
, TREE_TYPE (op00type
))))
2376 tree size
= TYPE_SIZE_UNIT (type
);
2377 if (tree_int_cst_equal (size
, op01
))
2378 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2380 /* ((foo *)&fooarray)[1] => fooarray[1] */
2381 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2382 && (same_type_ignoring_top_level_qualifiers_p
2383 (type
, TREE_TYPE (op00type
))))
2385 tree type_domain
= TYPE_DOMAIN (op00type
);
2386 tree min_val
= size_zero_node
;
2387 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2388 min_val
= TYPE_MIN_VALUE (type_domain
);
2389 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2390 TYPE_SIZE_UNIT (type
));
2391 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2392 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2393 NULL_TREE
, NULL_TREE
);
2395 /* Also handle conversion to an empty base class, which
2396 is represented with a NOP_EXPR. */
2397 else if (is_empty_class (type
)
2398 && CLASS_TYPE_P (op00type
)
2399 && DERIVED_FROM_P (type
, op00type
))
2404 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2405 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2407 tree field
= TYPE_FIELDS (op00type
);
2408 for (; field
; field
= DECL_CHAIN (field
))
2409 if (TREE_CODE (field
) == FIELD_DECL
2410 && tree_int_cst_equal (byte_position (field
), op01
)
2411 && (same_type_ignoring_top_level_qualifiers_p
2412 (TREE_TYPE (field
), type
)))
2414 return fold_build3 (COMPONENT_REF
, type
, op00
,
2421 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2422 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2423 && (same_type_ignoring_top_level_qualifiers_p
2424 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2427 tree min_val
= size_zero_node
;
2428 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2432 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2433 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2434 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2435 min_val
= TYPE_MIN_VALUE (type_domain
);
2436 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2444 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2446 bool *non_constant_p
, bool *overflow_p
)
2448 tree orig_op0
= TREE_OPERAND (t
, 0);
2449 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2450 /*lval*/false, non_constant_p
,
2452 bool empty_base
= false;
2455 /* Don't VERIFY_CONSTANT here. */
2456 if (*non_constant_p
)
2459 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2463 r
= cxx_eval_constant_expression (ctx
, r
,
2464 lval
, non_constant_p
, overflow_p
);
2469 if (TREE_CODE (sub
) == ADDR_EXPR
)
2471 /* We couldn't fold to a constant value. Make sure it's not
2472 something we should have been able to fold. */
2473 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2474 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
2475 /* DR 1188 says we don't have to deal with this. */
2477 error ("accessing value of %qE through a %qT glvalue in a "
2478 "constant expression", build_fold_indirect_ref (sub
),
2480 *non_constant_p
= true;
2485 /* If we're pulling out the value of an empty base, make sure
2486 that the whole object is constant and then return an empty
2488 if (empty_base
&& !lval
)
2490 VERIFY_CONSTANT (r
);
2491 r
= build_constructor (TREE_TYPE (t
), NULL
);
2492 TREE_CONSTANT (r
) = true;
2497 if (lval
&& op0
!= orig_op0
)
2498 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
2500 VERIFY_CONSTANT (t
);
2506 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2507 Shared between potential_constant_expression and
2508 cxx_eval_constant_expression. */
2511 non_const_var_error (tree r
)
2513 tree type
= TREE_TYPE (r
);
2514 error ("the value of %qD is not usable in a constant "
2516 /* Avoid error cascade. */
2517 if (DECL_INITIAL (r
) == error_mark_node
)
2519 if (DECL_DECLARED_CONSTEXPR_P (r
))
2520 inform (DECL_SOURCE_LOCATION (r
),
2521 "%qD used in its own initializer", r
);
2522 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
2524 if (!CP_TYPE_CONST_P (type
))
2525 inform (DECL_SOURCE_LOCATION (r
),
2526 "%q#D is not const", r
);
2527 else if (CP_TYPE_VOLATILE_P (type
))
2528 inform (DECL_SOURCE_LOCATION (r
),
2529 "%q#D is volatile", r
);
2530 else if (!DECL_INITIAL (r
)
2531 || !TREE_CONSTANT (DECL_INITIAL (r
)))
2532 inform (DECL_SOURCE_LOCATION (r
),
2533 "%qD was not initialized with a constant "
2540 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
2541 inform (DECL_SOURCE_LOCATION (r
),
2542 "%qD was not declared %<constexpr%>", r
);
2544 inform (DECL_SOURCE_LOCATION (r
),
2545 "%qD does not have integral or enumeration type",
2550 /* Subroutine of cxx_eval_constant_expression.
2551 Like cxx_eval_unary_expression, except for trinary expressions. */
2554 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
2556 bool *non_constant_p
, bool *overflow_p
)
2562 for (i
= 0; i
< 3; i
++)
2564 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
2566 non_constant_p
, overflow_p
);
2567 VERIFY_CONSTANT (args
[i
]);
2570 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
2571 args
[0], args
[1], args
[2]);
2572 if (val
== NULL_TREE
)
2574 VERIFY_CONSTANT (val
);
2579 var_in_constexpr_fn (tree t
)
2581 tree ctx
= DECL_CONTEXT (t
);
2582 return (cxx_dialect
>= cxx14
&& ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
2583 && DECL_DECLARED_CONSTEXPR_P (ctx
));
2586 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
2589 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
2591 bool *non_constant_p
, bool *overflow_p
)
2593 constexpr_ctx new_ctx
= *ctx
;
2595 /* First we figure out where we're storing to. */
2596 tree target
= TREE_OPERAND (t
, 0);
2597 target
= cxx_eval_constant_expression (ctx
, target
,
2599 non_constant_p
, overflow_p
);
2600 if (*non_constant_p
)
2603 /* And then find the underlying variable. */
2604 vec
<tree
,va_gc
> *refs
= make_tree_vector();
2605 tree object
= NULL_TREE
;
2606 for (tree probe
= target
; object
== NULL_TREE
; )
2608 switch (TREE_CODE (probe
))
2613 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
2614 vec_safe_push (refs
, TREE_TYPE (probe
));
2615 probe
= TREE_OPERAND (probe
, 0);
2623 /* And then find/build up our initializer for the path to the subobject
2624 we're initializing. */
2626 if (DECL_P (object
))
2627 valp
= ctx
->values
->get (object
);
2632 /* A constant-expression cannot modify objects from outside the
2633 constant-expression. */
2635 error ("modification of %qE is not a constant-expression", object
);
2636 *non_constant_p
= true;
2639 tree type
= TREE_TYPE (object
);
2640 while (!refs
->is_empty())
2642 if (*valp
== NULL_TREE
)
2644 *valp
= build_constructor (type
, NULL
);
2645 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = true;
2650 ce
.index
= refs
->pop();
2651 ce
.value
= NULL_TREE
;
2653 unsigned HOST_WIDE_INT idx
= 0;
2654 constructor_elt
*cep
= NULL
;
2656 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
2659 if (cp_tree_equal (ce
.index
, cep
->index
))
2662 cep
= vec_safe_push (CONSTRUCTOR_ELTS (*valp
), ce
);
2665 release_tree_vector (refs
);
2667 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
2669 /* Create a new CONSTRUCTOR in case evaluation of the initializer
2670 wants to modify it. */
2671 *valp
= new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
2672 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
2673 new_ctx
.object
= target
;
2676 tree init
= cxx_eval_constant_expression (&new_ctx
, TREE_OPERAND (t
, 1),
2678 non_constant_p
, overflow_p
);
2679 if (target
== object
)
2680 /* The hash table might have moved since the get earlier. */
2681 ctx
->values
->put (object
, init
);
2685 if (*non_constant_p
)
2693 /* Evaluate a ++ or -- expression. */
2696 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
2698 bool *non_constant_p
, bool *overflow_p
)
2700 enum tree_code code
= TREE_CODE (t
);
2701 tree type
= TREE_TYPE (t
);
2702 tree op
= TREE_OPERAND (t
, 0);
2703 tree offset
= TREE_OPERAND (t
, 1);
2704 gcc_assert (TREE_CONSTANT (offset
));
2706 /* The operand as an lvalue. */
2707 op
= cxx_eval_constant_expression (ctx
, op
, true,
2708 non_constant_p
, overflow_p
);
2710 /* The operand as an rvalue. */
2711 tree val
= rvalue (op
);
2712 val
= cxx_eval_constant_expression (ctx
, val
, false,
2713 non_constant_p
, overflow_p
);
2714 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2715 a local array in a constexpr function. */
2716 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
2718 VERIFY_CONSTANT (val
);
2720 /* The modified value. */
2721 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
2723 if (POINTER_TYPE_P (type
))
2725 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
2726 offset
= convert_to_ptrofftype (offset
);
2728 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
2729 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
2732 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
2734 VERIFY_CONSTANT (mod
);
2736 /* Storing the modified value. */
2737 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
2738 cxx_eval_constant_expression (ctx
, store
,
2739 true, non_constant_p
, overflow_p
);
2741 /* And the value of the expression. */
2742 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
2744 /* Prefix ops are lvalues. */
2748 /* But we optimize when the caller wants an rvalue. */
2752 /* Postfix ops are rvalues. */
2756 /* Predicates for the meaning of *jump_target. */
2759 returns (tree
*jump_target
)
2762 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
2766 breaks (tree
*jump_target
)
2769 && TREE_CODE (*jump_target
) == LABEL_DECL
2770 && LABEL_DECL_BREAK (*jump_target
);
2774 continues (tree
*jump_target
)
2777 && TREE_CODE (*jump_target
) == LABEL_DECL
2778 && LABEL_DECL_CONTINUE (*jump_target
);
2782 switches (tree
*jump_target
)
2785 && TREE_CODE (*jump_target
) == INTEGER_CST
;
2788 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
2789 at I matches *jump_target. If we're looking for a case label and we see
2790 the default label, copy I into DEFAULT_LABEL. */
2793 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
2794 tree_stmt_iterator
& default_label
)
2796 tree stmt
= tsi_stmt (i
);
2797 switch (TREE_CODE (*jump_target
))
2800 if (TREE_CODE (stmt
) == LABEL_EXPR
2801 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
2806 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
2808 if (!CASE_LOW (stmt
))
2810 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
2821 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
2822 semantics, for switch, break, continue, and return. */
2825 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
2826 bool *non_constant_p
, bool *overflow_p
,
2829 tree_stmt_iterator i
;
2830 tree_stmt_iterator default_label
= tree_stmt_iterator();
2832 /* In a statement-expression we want to return the last value. */
2836 local_target
= NULL_TREE
;
2837 jump_target
= &local_target
;
2839 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
2842 tree stmt
= tsi_stmt (i
);
2845 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
2846 /* The label we want might be inside. */;
2847 else if (label_matches (jump_target
, i
, default_label
))
2849 *jump_target
= NULL_TREE
;
2853 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
2854 non_constant_p
, overflow_p
,
2856 if (*non_constant_p
)
2858 if (returns (jump_target
) || breaks (jump_target
))
2861 if (switches (jump_target
) && !tsi_end_p (default_label
))
2864 *jump_target
= NULL_TREE
;
2870 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
2871 semantics; continue semantics are covered by cxx_eval_statement_list. */
2874 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
2875 bool *non_constant_p
, bool *overflow_p
,
2878 tree body
= TREE_OPERAND (t
, 0);
2881 cxx_eval_statement_list (ctx
, body
,
2882 non_constant_p
, overflow_p
, jump_target
);
2883 if (returns (jump_target
) || breaks (jump_target
) || *non_constant_p
)
2886 if (breaks (jump_target
))
2887 *jump_target
= NULL_TREE
;
2891 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
2895 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
2896 bool *non_constant_p
, bool *overflow_p
,
2899 tree cond
= TREE_OPERAND (t
, 0);
2900 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
2901 non_constant_p
, overflow_p
);
2902 VERIFY_CONSTANT (cond
);
2903 *jump_target
= cond
;
2905 tree body
= TREE_OPERAND (t
, 1);
2906 cxx_eval_statement_list (ctx
, body
,
2907 non_constant_p
, overflow_p
, jump_target
);
2908 if (breaks (jump_target
) || switches (jump_target
))
2909 *jump_target
= NULL_TREE
;
2913 /* Attempt to reduce the expression T to a constant value.
2914 On failure, issue diagnostic and return error_mark_node. */
2915 /* FIXME unify with c_fully_fold */
2916 /* FIXME overflow_p is too global */
2919 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
2921 bool *non_constant_p
, bool *overflow_p
,
2924 constexpr_ctx new_ctx
;
2927 if (t
== error_mark_node
)
2929 *non_constant_p
= true;
2932 if (CONSTANT_CLASS_P (t
))
2934 if (TREE_CODE (t
) == PTRMEM_CST
)
2935 t
= cplus_expand_constant (t
);
2936 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| ctx
->quiet
))
2940 if (TREE_CODE (t
) != NOP_EXPR
2941 && reduced_constant_expression_p (t
))
2944 switch (TREE_CODE (t
))
2949 /* We ask for an rvalue for the RESULT_DECL when indirecting
2950 through an invisible reference. */
2951 gcc_assert (DECL_BY_REFERENCE (t
));
2952 return (*ctx
->values
->get (t
));
2957 /* else fall through. */
2960 r
= decl_really_constant_value (t
);
2962 r
= decl_constant_value (t
);
2963 if (TREE_CODE (r
) == TARGET_EXPR
2964 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
2965 r
= TARGET_EXPR_INITIAL (r
);
2966 if (TREE_CODE (r
) == VAR_DECL
)
2967 if (tree
*p
= ctx
->values
->get (r
))
2972 non_const_var_error (r
);
2973 *non_constant_p
= true;
2981 case CASE_LABEL_EXPR
:
2985 if (!use_new_call
&& ctx
2986 && ctx
->call
&& DECL_CONTEXT (t
) == ctx
->call
->fundef
->decl
)
2987 r
= lookup_parameter_binding (ctx
->call
, t
);
2988 else if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
2990 else if (tree
*p
= ctx
->values
->get (r
))
2993 /* Defer in case this is only used for its type. */;
2994 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
2995 /* Defer, there's no lvalue->rvalue conversion. */;
2996 else if (is_empty_class (TREE_TYPE (t
)))
2998 /* If the class is empty, we aren't actually loading anything. */
2999 r
= build_constructor (TREE_TYPE (t
), NULL
);
3000 TREE_CONSTANT (r
) = true;
3005 error ("%qE is not a constant expression", t
);
3006 *non_constant_p
= true;
3011 case AGGR_INIT_EXPR
:
3012 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3013 non_constant_p
, overflow_p
);
3018 r
= DECL_EXPR_DECL (t
);
3019 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3020 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3024 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3025 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3026 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3030 if (tree init
= DECL_INITIAL (r
))
3032 init
= cxx_eval_constant_expression (ctx
, init
,
3034 non_constant_p
, overflow_p
);
3035 ctx
->values
->put (r
, init
);
3037 else if (ctx
== &new_ctx
)
3038 /* We gave it a CONSTRUCTOR above. */;
3040 ctx
->values
->put (r
, NULL_TREE
);
3045 if (!literal_type_p (TREE_TYPE (t
)))
3049 error ("temporary of non-literal type %qT in a "
3050 "constant expression", TREE_TYPE (t
));
3051 explain_non_literal_class (TREE_TYPE (t
));
3053 *non_constant_p
= true;
3056 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3058 /* We're being expanded without an explicit target, so start
3059 initializing a new object; expansion with an explicit target
3060 strips the TARGET_EXPR before we get here. */
3062 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3063 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3064 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3065 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3068 /* Pass false for 'lval' because this indicates
3069 initialization of a temporary. */
3070 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3072 non_constant_p
, overflow_p
);
3073 if (!*non_constant_p
)
3074 /* Adjust the type of the result to the type of the temporary. */
3075 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3078 tree slot
= TARGET_EXPR_SLOT (t
);
3079 ctx
->values
->put (slot
, r
);
3087 /* In C++11 constexpr evaluation we are looking for the value,
3088 not the side-effect of the initialization. */
3089 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3091 non_constant_p
, overflow_p
);
3094 /* else fall through */
3096 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3097 non_constant_p
, overflow_p
);
3101 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3103 non_constant_p
, overflow_p
);
3107 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3109 non_constant_p
, overflow_p
);
3114 /* Avoid evaluating a SAVE_EXPR more than once. */
3115 if (tree
*p
= ctx
->values
->get (t
))
3119 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3120 non_constant_p
, overflow_p
);
3121 ctx
->values
->put (t
, r
);
3125 case NON_LVALUE_EXPR
:
3126 case TRY_CATCH_EXPR
:
3127 case CLEANUP_POINT_EXPR
:
3128 case MUST_NOT_THROW_EXPR
:
3131 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3133 non_constant_p
, overflow_p
,
3137 /* These differ from cxx_eval_unary_expression in that this doesn't
3138 check for a constant operand or result; an address can be
3139 constant without its operand being, and vice versa. */
3141 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3142 non_constant_p
, overflow_p
);
3147 tree oldop
= TREE_OPERAND (t
, 0);
3148 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3150 non_constant_p
, overflow_p
);
3151 /* Don't VERIFY_CONSTANT here. */
3152 if (*non_constant_p
)
3154 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3155 /* This function does more aggressive folding than fold itself. */
3156 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3157 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3165 case FIX_TRUNC_EXPR
:
3170 case TRUTH_NOT_EXPR
:
3171 case FIXED_CONVERT_EXPR
:
3172 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3173 non_constant_p
, overflow_p
);
3177 if (SIZEOF_EXPR_TYPE_P (t
))
3178 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
3179 SIZEOF_EXPR
, false);
3180 else if (TYPE_P (TREE_OPERAND (t
, 0)))
3181 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3184 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3186 if (r
== error_mark_node
)
3188 VERIFY_CONSTANT (r
);
3193 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3194 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3195 introduced by build_call_a. */
3196 tree op0
= TREE_OPERAND (t
, 0);
3197 tree op1
= TREE_OPERAND (t
, 1);
3199 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3200 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3201 r
= cxx_eval_constant_expression (ctx
, op0
,
3202 lval
, non_constant_p
, overflow_p
,
3206 /* Check that the LHS is constant and then discard it. */
3207 cxx_eval_constant_expression (ctx
, op0
,
3208 true, non_constant_p
, overflow_p
,
3210 op1
= TREE_OPERAND (t
, 1);
3211 r
= cxx_eval_constant_expression (ctx
, op1
,
3212 lval
, non_constant_p
, overflow_p
,
3218 case POINTER_PLUS_EXPR
:
3222 case TRUNC_DIV_EXPR
:
3224 case FLOOR_DIV_EXPR
:
3225 case ROUND_DIV_EXPR
:
3226 case TRUNC_MOD_EXPR
:
3228 case ROUND_MOD_EXPR
:
3230 case EXACT_DIV_EXPR
:
3240 case TRUTH_XOR_EXPR
:
3247 case UNORDERED_EXPR
:
3257 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3258 non_constant_p
, overflow_p
);
3261 /* fold can introduce non-IF versions of these; still treat them as
3262 short-circuiting. */
3263 case TRUTH_AND_EXPR
:
3264 case TRUTH_ANDIF_EXPR
:
3265 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
3268 non_constant_p
, overflow_p
);
3272 case TRUTH_ORIF_EXPR
:
3273 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
3276 non_constant_p
, overflow_p
);
3280 r
= cxx_eval_array_reference (ctx
, t
, lval
,
3281 non_constant_p
, overflow_p
);
3285 if (is_overloaded_fn (t
))
3287 /* We can only get here in checking mode via
3288 build_non_dependent_expr, because any expression that
3289 calls or takes the address of the function will have
3290 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3291 gcc_checking_assert (ctx
->quiet
|| errorcount
);
3292 *non_constant_p
= true;
3295 r
= cxx_eval_component_reference (ctx
, t
, lval
,
3296 non_constant_p
, overflow_p
);
3300 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
3301 non_constant_p
, overflow_p
);
3306 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
3307 non_constant_p
, overflow_p
,
3312 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
3313 non_constant_p
, overflow_p
);
3317 /* We can get this in a defaulted constructor for a class with a
3318 non-static data member of array type. Either the initializer will
3319 be NULL, meaning default-initialization, or it will be an lvalue
3320 or xvalue of the same type, meaning direct-initialization from the
3321 corresponding member. */
3322 r
= cxx_eval_vec_init (ctx
, t
, lval
,
3323 non_constant_p
, overflow_p
);
3328 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
3329 non_constant_p
, overflow_p
);
3333 case VIEW_CONVERT_EXPR
:
3336 tree oldop
= TREE_OPERAND (t
, 0);
3337 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3339 non_constant_p
, overflow_p
);
3340 if (*non_constant_p
)
3342 if (POINTER_TYPE_P (TREE_TYPE (t
))
3343 && TREE_CODE (op
) == INTEGER_CST
3344 && !integer_zerop (op
))
3347 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3348 "reinterpret_cast from integer to pointer");
3349 *non_constant_p
= true;
3353 /* We didn't fold at the top so we could check for ptr-int
3356 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
3357 /* Conversion of an out-of-range value has implementation-defined
3358 behavior; the language considers it different from arithmetic
3359 overflow, which is undefined. */
3360 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
3361 TREE_OVERFLOW (r
) = false;
3365 case EMPTY_CLASS_EXPR
:
3366 /* This is good enough for a function argument that might not get
3367 used, and they can't do anything with it, so just return it. */
3370 case STATEMENT_LIST
:
3372 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3373 return cxx_eval_statement_list (&new_ctx
, t
,
3374 non_constant_p
, overflow_p
, jump_target
);
3377 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
3379 non_constant_p
, overflow_p
,
3382 case PREINCREMENT_EXPR
:
3383 case POSTINCREMENT_EXPR
:
3384 case PREDECREMENT_EXPR
:
3385 case POSTDECREMENT_EXPR
:
3386 return cxx_eval_increment_expression (ctx
, t
,
3387 lval
, non_constant_p
, overflow_p
);
3393 case VEC_DELETE_EXPR
:
3396 /* GCC internal stuff. */
3399 case WITH_CLEANUP_EXPR
:
3400 case NON_DEPENDENT_EXPR
:
3404 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3405 "expression %qE is not a constant-expression", t
);
3406 *non_constant_p
= true;
3409 case PLACEHOLDER_EXPR
:
3410 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
))
3412 /* A placeholder without a referent. We can get here when
3413 checking whether NSDMIs are noexcept, or in massage_init_elt;
3414 just say it's non-constant for now. */
3415 gcc_assert (ctx
->quiet
);
3416 *non_constant_p
= true;
3421 /* Use of the value or address of the current object. We could
3422 use ctx->object unconditionally, but using ctx->ctor when we
3423 can is a minor optimization. */
3424 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
3425 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3426 (TREE_TYPE (t
), TREE_TYPE (ctor
)));
3427 return cxx_eval_constant_expression
3429 non_constant_p
, overflow_p
);
3434 *jump_target
= TREE_OPERAND (t
, 0);
3435 gcc_assert (breaks (jump_target
) || continues (jump_target
));
3439 cxx_eval_loop_expr (ctx
, t
,
3440 non_constant_p
, overflow_p
, jump_target
);
3444 cxx_eval_switch_expr (ctx
, t
,
3445 non_constant_p
, overflow_p
, jump_target
);
3449 internal_error ("unexpected expression %qE of kind %s", t
,
3450 get_tree_code_name (TREE_CODE (t
)));
3451 *non_constant_p
= true;
3455 if (r
== error_mark_node
)
3456 *non_constant_p
= true;
3458 if (*non_constant_p
)
3465 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
3466 bool strict
= true, tree object
= NULL_TREE
)
3468 bool non_constant_p
= false;
3469 bool overflow_p
= false;
3470 hash_map
<tree
,tree
> map
;
3471 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, allow_non_constant
, strict
};
3472 tree type
= initialized_type (t
);
3474 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3476 /* In C++14 an NSDMI can participate in aggregate initialization,
3477 and can refer to the address of the object being initialized, so
3478 we need to pass in the relevant VAR_DECL if we want to do the
3479 evaluation in a single pass. The evaluation will dynamically
3480 update ctx.values for the VAR_DECL. We use the same strategy
3481 for C++11 constexpr constructors that refer to the object being
3483 ctx
.ctor
= build_constructor (type
, NULL
);
3484 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
3487 if (TREE_CODE (t
) == TARGET_EXPR
)
3488 object
= TARGET_EXPR_SLOT (t
);
3489 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3490 object
= AGGR_INIT_EXPR_SLOT (t
);
3492 ctx
.object
= object
;
3494 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3495 (type
, TREE_TYPE (object
)));
3496 if (object
&& DECL_P (object
))
3497 map
.put (object
, ctx
.ctor
);
3498 if (TREE_CODE (r
) == TARGET_EXPR
)
3499 /* Avoid creating another CONSTRUCTOR when we expand the
3501 r
= TARGET_EXPR_INITIAL (r
);
3504 r
= cxx_eval_constant_expression (&ctx
, r
,
3505 false, &non_constant_p
, &overflow_p
);
3507 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
3509 /* Mutable logic is a bit tricky: we want to allow initialization of
3510 constexpr variables with mutable members, but we can't copy those
3511 members to another constexpr variable. */
3512 if (TREE_CODE (r
) == CONSTRUCTOR
3513 && CONSTRUCTOR_MUTABLE_POISON (r
))
3515 if (!allow_non_constant
)
3516 error ("%qE is not a constant expression because it refers to "
3517 "mutable subobjects of %qT", t
, type
);
3518 non_constant_p
= true;
3521 /* Technically we should check this for all subexpressions, but that
3522 runs into problems with our internal representation of pointer
3523 subtraction and the 5.19 rules are still in flux. */
3524 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
3525 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
3526 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
3528 if (!allow_non_constant
)
3529 error ("conversion from pointer type %qT "
3530 "to arithmetic type %qT in a constant-expression",
3531 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
3532 non_constant_p
= true;
3535 if (!non_constant_p
&& overflow_p
)
3536 non_constant_p
= true;
3538 if (non_constant_p
&& !allow_non_constant
)
3539 return error_mark_node
;
3540 else if (non_constant_p
&& TREE_CONSTANT (r
))
3542 /* This isn't actually constant, so unset TREE_CONSTANT. */
3545 else if (TREE_CODE (r
) == CONSTRUCTOR
)
3546 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
3548 r
= build_nop (TREE_TYPE (r
), r
);
3549 TREE_CONSTANT (r
) = false;
3551 else if (non_constant_p
|| r
== t
)
3554 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
3556 if (TREE_CODE (t
) == TARGET_EXPR
3557 && TARGET_EXPR_INITIAL (t
) == r
)
3561 r
= get_target_expr (r
);
3562 TREE_CONSTANT (r
) = true;
3570 /* Returns true if T is a valid subexpression of a constant expression,
3571 even if it isn't itself a constant expression. */
3574 is_sub_constant_expr (tree t
)
3576 bool non_constant_p
= false;
3577 bool overflow_p
= false;
3578 hash_map
<tree
, tree
> map
;
3579 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, true, true };
3580 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
3582 return !non_constant_p
&& !overflow_p
;
3585 /* If T represents a constant expression returns its reduced value.
3586 Otherwise return error_mark_node. If T is dependent, then
3590 cxx_constant_value (tree t
, tree decl
)
3592 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
3595 /* If T is a constant expression, returns its reduced value.
3596 Otherwise, if T does not have TREE_CONSTANT set, returns T.
3597 Otherwise, returns a version of T without TREE_CONSTANT. */
3600 maybe_constant_value (tree t
, tree decl
)
3604 if (instantiation_dependent_expression_p (t
)
3605 || type_unknown_p (t
)
3606 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3607 || !potential_constant_expression (t
))
3609 if (TREE_OVERFLOW_P (t
))
3611 t
= build_nop (TREE_TYPE (t
), t
);
3612 TREE_CONSTANT (t
) = false;
3617 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
3618 #ifdef ENABLE_CHECKING
3619 /* cp_tree_equal looks through NOPs, so allow them. */
3621 || CONVERT_EXPR_P (t
)
3622 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3623 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3624 || !cp_tree_equal (r
, t
));
3629 /* Like maybe_constant_value but first fully instantiate the argument.
3631 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3632 (t, tf_none) followed by maybe_constant_value but is more efficient,
3633 because calls instantiation_dependent_expression_p and
3634 potential_constant_expression at most once. */
3637 fold_non_dependent_expr (tree t
)
3642 /* If we're in a template, but T isn't value dependent, simplify
3643 it. We're supposed to treat:
3645 template <typename T> void f(T[1 + 1]);
3646 template <typename T> void f(T[2]);
3648 as two declarations of the same function, for example. */
3649 if (processing_template_decl
)
3651 if (!instantiation_dependent_expression_p (t
)
3652 && potential_constant_expression (t
))
3654 processing_template_decl_sentinel s
;
3655 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
3657 if (type_unknown_p (t
)
3658 || BRACE_ENCLOSED_INITIALIZER_P (t
))
3660 if (TREE_OVERFLOW_P (t
))
3662 t
= build_nop (TREE_TYPE (t
), t
);
3663 TREE_CONSTANT (t
) = false;
3668 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
3669 #ifdef ENABLE_CHECKING
3670 /* cp_tree_equal looks through NOPs, so allow them. */
3672 || CONVERT_EXPR_P (t
)
3673 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3674 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3675 || !cp_tree_equal (r
, t
));
3679 else if (TREE_OVERFLOW_P (t
))
3681 t
= build_nop (TREE_TYPE (t
), t
);
3682 TREE_CONSTANT (t
) = false;
3687 return maybe_constant_value (t
);
3690 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3691 than wrapped in a TARGET_EXPR. */
3694 maybe_constant_init (tree t
, tree decl
)
3696 if (TREE_CODE (t
) == EXPR_STMT
)
3697 t
= TREE_OPERAND (t
, 0);
3698 if (TREE_CODE (t
) == CONVERT_EXPR
3699 && VOID_TYPE_P (TREE_TYPE (t
)))
3700 t
= TREE_OPERAND (t
, 0);
3701 if (TREE_CODE (t
) == INIT_EXPR
)
3702 t
= TREE_OPERAND (t
, 1);
3703 if (instantiation_dependent_expression_p (t
)
3704 || type_unknown_p (t
)
3705 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3706 || !potential_static_init_expression (t
))
3707 /* Don't try to evaluate it. */;
3709 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
3710 if (TREE_CODE (t
) == TARGET_EXPR
)
3712 tree init
= TARGET_EXPR_INITIAL (t
);
3713 if (TREE_CODE (init
) == CONSTRUCTOR
)
3720 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
3721 /* Return true if the object referred to by REF has automatic or thread
3724 enum { ck_ok
, ck_bad
, ck_unknown
};
3726 check_automatic_or_tls (tree ref
)
3729 HOST_WIDE_INT bitsize
, bitpos
;
3731 int volatilep
= 0, unsignedp
= 0;
3732 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
3733 &mode
, &unsignedp
, &volatilep
, false);
3736 /* If there isn't a decl in the middle, we don't know the linkage here,
3737 and this isn't a constant expression anyway. */
3740 dk
= decl_storage_duration (decl
);
3741 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
3745 /* Return true if T denotes a potentially constant expression. Issue
3746 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
3747 an lvalue-rvalue conversion is implied.
3749 C++0x [expr.const] used to say
3751 6 An expression is a potential constant expression if it is
3752 a constant expression where all occurrences of function
3753 parameters are replaced by arbitrary constant expressions
3754 of the appropriate type.
3756 2 A conditional expression is a constant expression unless it
3757 involves one of the following as a potentially evaluated
3758 subexpression (3.2), but subexpressions of logical AND (5.14),
3759 logical OR (5.15), and conditional (5.16) operations that are
3760 not evaluated are not considered. */
3763 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
3764 tsubst_flags_t flags
)
3766 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
3767 enum { any
= false, rval
= true };
3771 if (t
== error_mark_node
)
3775 if (TREE_THIS_VOLATILE (t
))
3777 if (flags
& tf_error
)
3778 error ("expression %qE has side-effects", t
);
3781 if (CONSTANT_CLASS_P (t
))
3784 switch (TREE_CODE (t
))
3790 case TEMPLATE_ID_EXPR
:
3793 case CASE_LABEL_EXPR
:
3799 case TEMPLATE_PARM_INDEX
:
3801 case IDENTIFIER_NODE
:
3802 case USERDEF_LITERAL
:
3803 /* We can see a FIELD_DECL in a pointer-to-member expression. */
3808 case PLACEHOLDER_EXPR
:
3813 case AGGR_INIT_EXPR
:
3815 /* -- an invocation of a function other than a constexpr function
3816 or a constexpr constructor. */
3818 tree fun
= get_function_named_in_call (t
);
3819 const int nargs
= call_expr_nargs (t
);
3822 if (fun
== NULL_TREE
)
3824 if (TREE_CODE (t
) == CALL_EXPR
3825 && CALL_EXPR_FN (t
) == NULL_TREE
)
3826 switch (CALL_EXPR_IFN (t
))
3828 /* These should be ignored, they are optimized away from
3829 constexpr functions. */
3830 case IFN_UBSAN_NULL
:
3831 case IFN_UBSAN_BOUNDS
:
3832 case IFN_UBSAN_VPTR
:
3837 /* fold_call_expr can't do anything with IFN calls. */
3838 if (flags
& tf_error
)
3839 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3840 "call to internal function");
3843 if (is_overloaded_fn (fun
))
3845 if (TREE_CODE (fun
) == FUNCTION_DECL
)
3847 if (builtin_valid_in_constant_expr_p (fun
))
3849 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
3850 /* Allow any built-in function; if the expansion
3851 isn't constant, we'll deal with that then. */
3852 && !is_builtin_fn (fun
))
3854 if (flags
& tf_error
)
3856 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3857 "call to non-constexpr function %qD", fun
);
3858 explain_invalid_constexpr_fn (fun
);
3862 /* A call to a non-static member function takes the address
3863 of the object as the first argument. But in a constant
3864 expression the address will be folded away, so look
3866 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
3867 && !DECL_CONSTRUCTOR_P (fun
))
3869 tree x
= get_nth_callarg (t
, 0);
3870 if (is_this_parameter (x
))
3872 else if (!RECUR (x
, rval
))
3879 if (!RECUR (fun
, true))
3881 fun
= get_first_fn (fun
);
3883 /* Skip initial arguments to base constructors. */
3884 if (DECL_BASE_CONSTRUCTOR_P (fun
))
3885 i
= num_artificial_parms_for (fun
);
3886 fun
= DECL_ORIGIN (fun
);
3890 if (RECUR (fun
, rval
))
3891 /* Might end up being a constant function pointer. */;
3895 for (; i
< nargs
; ++i
)
3897 tree x
= get_nth_callarg (t
, i
);
3898 /* In a template, reference arguments haven't been converted to
3899 REFERENCE_TYPE and we might not even know if the parameter
3900 is a reference, so accept lvalue constants too. */
3901 bool rv
= processing_template_decl
? any
: rval
;
3908 case NON_LVALUE_EXPR
:
3909 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
3910 -- an lvalue of integral type that refers to a non-volatile
3911 const variable or static data member initialized with
3912 constant expressions, or
3914 -- an lvalue of literal type that refers to non-volatile
3915 object defined with constexpr, or that refers to a
3916 sub-object of such an object; */
3917 return RECUR (TREE_OPERAND (t
, 0), rval
);
3921 && !decl_constant_var_p (t
)
3923 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
3924 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
3925 && !var_in_constexpr_fn (t
)
3926 && !type_dependent_expression_p (t
))
3928 if (flags
& tf_error
)
3929 non_const_var_error (t
);
3936 case VIEW_CONVERT_EXPR
:
3937 /* -- a reinterpret_cast. FIXME not implemented, and this rule
3938 may change to something more specific to type-punning (DR 1312). */
3940 tree from
= TREE_OPERAND (t
, 0);
3941 if (POINTER_TYPE_P (TREE_TYPE (t
))
3942 && TREE_CODE (from
) == INTEGER_CST
3943 && !integer_zerop (from
))
3945 if (flags
& tf_error
)
3946 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3947 "reinterpret_cast from integer to pointer");
3950 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
3954 /* -- a unary operator & that is applied to an lvalue that
3955 designates an object with thread or automatic storage
3957 t
= TREE_OPERAND (t
, 0);
3959 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
3960 /* A pointer-to-member constant. */
3964 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
3965 any checking here, as we might dereference the pointer later. If
3966 we remove this code, also remove check_automatic_or_tls. */
3967 i
= check_automatic_or_tls (t
);
3972 if (flags
& tf_error
)
3973 error ("address-of an object %qE with thread local or "
3974 "automatic storage is not a constant expression", t
);
3978 return RECUR (t
, any
);
3984 /* -- a class member access unless its postfix-expression is
3985 of literal type or of pointer to literal type. */
3986 /* This test would be redundant, as it follows from the
3987 postfix-expression being a potential constant expression. */
3988 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
3990 case EXPR_PACK_EXPANSION
:
3991 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
3995 tree x
= TREE_OPERAND (t
, 0);
3997 if (is_this_parameter (x
))
3999 if (DECL_CONTEXT (x
)
4000 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4002 if (flags
& tf_error
)
4003 error ("use of %<this%> in a constant expression");
4008 return RECUR (x
, rval
);
4011 case STATEMENT_LIST
:
4013 tree_stmt_iterator i
;
4014 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4016 if (!RECUR (tsi_stmt (i
), any
))
4024 if (cxx_dialect
< cxx14
)
4026 if (!RECUR (TREE_OPERAND (t
, 0), any
))
4028 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
4033 if (cxx_dialect
< cxx14
)
4035 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
4037 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
4042 if (!RECUR (IF_COND (t
), rval
))
4044 if (!RECUR (THEN_CLAUSE (t
), any
))
4046 if (!RECUR (ELSE_CLAUSE (t
), any
))
4051 if (!RECUR (DO_COND (t
), rval
))
4053 if (!RECUR (DO_BODY (t
), any
))
4058 if (!RECUR (FOR_INIT_STMT (t
), any
))
4060 if (!RECUR (FOR_COND (t
), rval
))
4062 if (!RECUR (FOR_EXPR (t
), any
))
4064 if (!RECUR (FOR_BODY (t
), any
))
4069 if (!RECUR (WHILE_COND (t
), rval
))
4071 if (!RECUR (WHILE_BODY (t
), any
))
4076 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
4078 if (!RECUR (SWITCH_STMT_BODY (t
), any
))
4083 return RECUR (STMT_EXPR_STMT (t
), rval
);
4086 case DYNAMIC_CAST_EXPR
:
4087 case PSEUDO_DTOR_EXPR
:
4091 case VEC_DELETE_EXPR
:
4094 case OMP_ATOMIC_READ
:
4095 case OMP_ATOMIC_CAPTURE_OLD
:
4096 case OMP_ATOMIC_CAPTURE_NEW
:
4097 /* GCC internal stuff. */
4100 case TRANSACTION_EXPR
:
4103 if (flags
& tf_error
)
4104 error ("expression %qE is not a constant-expression", t
);
4108 /* -- a typeid expression whose operand is of polymorphic
4111 tree e
= TREE_OPERAND (t
, 0);
4112 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
4113 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
4115 if (flags
& tf_error
)
4116 error ("typeid-expression is not a constant expression "
4117 "because %qE is of polymorphic type", e
);
4124 /* -- a subtraction where both operands are pointers. */
4125 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
4126 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
4128 if (flags
& tf_error
)
4129 error ("difference of two pointer expressions is not "
4130 "a constant expression");
4142 /* -- a relational or equality operator where at least
4143 one of the operands is a pointer. */
4144 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
4145 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
4147 if (flags
& tf_error
)
4148 error ("pointer comparison expression is not a "
4149 "constant expression");
4155 case PREINCREMENT_EXPR
:
4156 case POSTINCREMENT_EXPR
:
4157 case PREDECREMENT_EXPR
:
4158 case POSTDECREMENT_EXPR
:
4159 if (cxx_dialect
< cxx14
)
4165 if (TYPE_P (TREE_OPERAND (t
, 0)))
4167 /* else fall through. */
4173 case FIX_TRUNC_EXPR
:
4177 case TRUTH_NOT_EXPR
:
4178 case FIXED_CONVERT_EXPR
:
4179 case UNARY_PLUS_EXPR
:
4181 return RECUR (TREE_OPERAND (t
, 0), rval
);
4184 case CONST_CAST_EXPR
:
4185 case STATIC_CAST_EXPR
:
4186 case REINTERPRET_CAST_EXPR
:
4187 case IMPLICIT_CONV_EXPR
:
4188 if (cxx_dialect
< cxx11
4189 && !dependent_type_p (TREE_TYPE (t
))
4190 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
4191 /* In C++98, a conversion to non-integral type can't be part of a
4192 constant expression. */
4194 if (flags
& tf_error
)
4195 error ("cast to non-integral type %qT in a constant expression",
4200 return (RECUR (TREE_OPERAND (t
, 0),
4201 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
4204 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
4206 case WITH_CLEANUP_EXPR
:
4207 case CLEANUP_POINT_EXPR
:
4208 case MUST_NOT_THROW_EXPR
:
4209 case TRY_CATCH_EXPR
:
4214 case NON_DEPENDENT_EXPR
:
4215 /* For convenience. */
4217 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4220 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4223 if (!literal_type_p (TREE_TYPE (t
)))
4225 if (flags
& tf_error
)
4227 error ("temporary of non-literal type %qT in a "
4228 "constant expression", TREE_TYPE (t
));
4229 explain_non_literal_class (TREE_TYPE (t
));
4234 return RECUR (TREE_OPERAND (t
, 1), rval
);
4238 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4239 constructor_elt
*ce
;
4240 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4241 if (!RECUR (ce
->value
, want_rval
))
4248 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
4249 || DECL_P (TREE_PURPOSE (t
)));
4250 if (!RECUR (TREE_VALUE (t
), want_rval
))
4252 if (TREE_CHAIN (t
) == NULL_TREE
)
4254 return RECUR (TREE_CHAIN (t
), want_rval
);
4257 case TRUNC_DIV_EXPR
:
4259 case FLOOR_DIV_EXPR
:
4260 case ROUND_DIV_EXPR
:
4261 case TRUNC_MOD_EXPR
:
4263 case ROUND_MOD_EXPR
:
4265 tree denom
= TREE_OPERAND (t
, 1);
4266 if (!RECUR (denom
, rval
))
4268 /* We can't call cxx_eval_outermost_constant_expr on an expression
4269 that hasn't been through instantiate_non_dependent_expr yet. */
4270 if (!processing_template_decl
)
4271 denom
= cxx_eval_outermost_constant_expr (denom
, true);
4272 if (integer_zerop (denom
))
4274 if (flags
& tf_error
)
4275 error ("division by zero is not a constant-expression");
4281 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4287 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4288 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4289 introduced by build_call_a. */
4290 tree op0
= TREE_OPERAND (t
, 0);
4291 tree op1
= TREE_OPERAND (t
, 1);
4293 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4294 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4295 return RECUR (op0
, want_rval
);
4300 /* If the first operand is the non-short-circuit constant, look at
4301 the second operand; otherwise we only care about the first one for
4303 case TRUTH_AND_EXPR
:
4304 case TRUTH_ANDIF_EXPR
:
4305 tmp
= boolean_true_node
;
4308 case TRUTH_ORIF_EXPR
:
4309 tmp
= boolean_false_node
;
4312 tree op
= TREE_OPERAND (t
, 0);
4313 if (!RECUR (op
, rval
))
4315 if (!processing_template_decl
)
4316 op
= cxx_eval_outermost_constant_expr (op
, true);
4317 if (tree_int_cst_equal (op
, tmp
))
4318 return RECUR (TREE_OPERAND (t
, 1), rval
);
4325 case POINTER_PLUS_EXPR
:
4327 case EXACT_DIV_EXPR
:
4337 case TRUTH_XOR_EXPR
:
4338 case UNORDERED_EXPR
:
4351 case ARRAY_RANGE_REF
:
4355 for (i
= 0; i
< 2; ++i
)
4356 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
4360 case CILK_SYNC_STMT
:
4361 case CILK_SPAWN_STMT
:
4362 case ARRAY_NOTATION_REF
:
4367 for (i
= 0; i
< 3; ++i
)
4368 if (!RECUR (TREE_OPERAND (t
, i
), true))
4374 /* If the condition is a known constant, we know which of the legs we
4375 care about; otherwise we only require that the condition and
4376 either of the legs be potentially constant. */
4377 tmp
= TREE_OPERAND (t
, 0);
4378 if (!RECUR (tmp
, rval
))
4380 if (!processing_template_decl
)
4381 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
4382 if (integer_zerop (tmp
))
4383 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
4384 else if (TREE_CODE (tmp
) == INTEGER_CST
)
4385 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4386 for (i
= 1; i
< 3; ++i
)
4387 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
4388 want_rval
, strict
, tf_none
))
4390 if (flags
& tf_error
)
4391 error ("expression %qE is not a constant-expression", t
);
4395 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
4397 if (flags
& tf_error
)
4399 error ("non-constant array initialization");
4400 diagnose_non_constexpr_vec_init (t
);
4405 if (objc_is_property_ref (t
))
4408 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
4415 /* The main entry point to the above. */
4418 potential_constant_expression (tree t
)
4420 return potential_constant_expression_1 (t
, false, true, tf_none
);
4424 potential_static_init_expression (tree t
)
4426 return potential_constant_expression_1 (t
, false, false, tf_none
);
4429 /* As above, but require a constant rvalue. */
4432 potential_rvalue_constant_expression (tree t
)
4434 return potential_constant_expression_1 (t
, true, true, tf_none
);
4437 /* Like above, but complain about non-constant expressions. */
4440 require_potential_constant_expression (tree t
)
4442 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
4445 /* Cross product of the above. */
4448 require_potential_rvalue_constant_expression (tree t
)
4450 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
4453 #include "gt-cp-constexpr.h"