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-2016 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
34 #include "gimple-fold.h"
36 static bool verify_constant (tree
, bool, bool *, bool *);
37 #define VERIFY_CONSTANT(X) \
39 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
43 /* Returns true iff FUN is an instantiation of a constexpr function
44 template or a defaulted constexpr function. */
47 is_instantiation_of_constexpr (tree fun
)
49 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
50 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
51 || (DECL_DEFAULTED_FN (fun
)
52 && DECL_DECLARED_CONSTEXPR_P (fun
)));
55 /* Return true if T is a literal type. */
58 literal_type_p (tree t
)
62 || TREE_CODE (t
) == REFERENCE_TYPE
63 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
67 t
= complete_type (t
);
68 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
69 return CLASSTYPE_LITERAL_P (t
);
71 if (TREE_CODE (t
) == ARRAY_TYPE
)
72 return literal_type_p (strip_array_types (t
));
76 /* If DECL is a variable declared `constexpr', require its type
77 be literal. Return the DECL if OK, otherwise NULL. */
80 ensure_literal_type_for_constexpr_object (tree decl
)
82 tree type
= TREE_TYPE (decl
);
84 && (DECL_DECLARED_CONSTEXPR_P (decl
)
85 || var_in_constexpr_fn (decl
))
86 && !processing_template_decl
)
88 tree stype
= strip_array_types (type
);
89 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
90 /* Don't complain here, we'll complain about incompleteness
91 when we try to initialize the variable. */;
92 else if (!literal_type_p (type
))
94 if (DECL_DECLARED_CONSTEXPR_P (decl
))
96 error ("the type %qT of constexpr variable %qD is not literal",
98 explain_non_literal_class (type
);
102 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
104 error ("variable %qD of non-literal type %qT in %<constexpr%> "
105 "function", decl
, type
);
106 explain_non_literal_class (type
);
108 cp_function_chain
->invalid_constexpr
= true;
116 /* Representation of entries in the constexpr function definition table. */
118 struct GTY((for_user
)) constexpr_fundef
{
123 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
125 static hashval_t
hash (constexpr_fundef
*);
126 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
129 /* This table holds all constexpr function definitions seen in
130 the current translation unit. */
132 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
134 /* Utility function used for managing the constexpr function table.
135 Return true if the entries pointed to by P and Q are for the
136 same constexpr function. */
139 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
141 return lhs
->decl
== rhs
->decl
;
144 /* Utility function used for managing the constexpr function table.
145 Return a hash value for the entry pointed to by Q. */
148 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
150 return DECL_UID (fundef
->decl
);
153 /* Return a previously saved definition of function FUN. */
155 static constexpr_fundef
*
156 retrieve_constexpr_fundef (tree fun
)
158 constexpr_fundef fundef
= { NULL
, NULL
};
159 if (constexpr_fundef_table
== NULL
)
163 return constexpr_fundef_table
->find (&fundef
);
166 /* Check whether the parameter and return types of FUN are valid for a
167 constexpr function, and complain if COMPLAIN. */
170 is_valid_constexpr_fn (tree fun
, bool complain
)
174 if (DECL_INHERITED_CTOR_BASE (fun
)
175 && TREE_CODE (fun
) == TEMPLATE_DECL
)
179 error ("inherited constructor %qD is not constexpr",
180 get_inherited_ctor (fun
));
184 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
185 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
186 if (!literal_type_p (TREE_TYPE (parm
)))
191 error ("invalid type for parameter %d of constexpr "
192 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
193 explain_non_literal_class (TREE_TYPE (parm
));
198 if (!DECL_CONSTRUCTOR_P (fun
))
200 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
201 if (!literal_type_p (rettype
))
206 error ("invalid return type %qT of constexpr function %q+D",
208 explain_non_literal_class (rettype
);
212 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
213 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
218 error ("enclosing class of constexpr non-static member "
219 "function %q+#D is not a literal type", fun
);
220 explain_non_literal_class (DECL_CONTEXT (fun
));
224 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
228 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
234 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
235 for a member of an anonymous aggregate, INIT is the initializer for that
236 member, and VEC_OUTER is the vector of constructor elements for the class
237 whose constructor we are processing. Add the initializer to the vector
238 and return true to indicate success. */
241 build_anon_member_initialization (tree member
, tree init
,
242 vec
<constructor_elt
, va_gc
> **vec_outer
)
244 /* MEMBER presents the relevant fields from the inside out, but we need
245 to build up the initializer from the outside in so that we can reuse
246 previously built CONSTRUCTORs if this is, say, the second field in an
247 anonymous struct. So we use a vec as a stack. */
248 auto_vec
<tree
, 2> fields
;
251 fields
.safe_push (TREE_OPERAND (member
, 1));
252 member
= TREE_OPERAND (member
, 0);
254 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
255 && TREE_CODE (member
) == COMPONENT_REF
);
257 /* VEC has the constructor elements vector for the context of FIELD.
258 If FIELD is an anonymous aggregate, we will push inside it. */
259 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
261 while (field
= fields
.pop(),
262 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
265 /* If there is already an outer constructor entry for the anonymous
266 aggregate FIELD, use it; otherwise, insert one. */
267 if (vec_safe_is_empty (*vec
)
268 || (*vec
)->last().index
!= field
)
270 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
271 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
274 ctor
= (*vec
)->last().value
;
275 vec
= &CONSTRUCTOR_ELTS (ctor
);
278 /* Now we're at the innermost field, the one that isn't an anonymous
279 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
280 gcc_assert (fields
.is_empty());
281 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
286 /* Subroutine of build_constexpr_constructor_member_initializers.
287 The expression tree T represents a data member initialization
288 in a (constexpr) constructor definition. Build a pairing of
289 the data member with its initializer, and prepend that pair
290 to the existing initialization pair INITS. */
293 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
296 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
297 t
= TREE_OPERAND (t
, 0);
298 if (TREE_CODE (t
) == EXPR_STMT
)
299 t
= TREE_OPERAND (t
, 0);
300 if (t
== error_mark_node
)
302 if (TREE_CODE (t
) == STATEMENT_LIST
)
304 tree_stmt_iterator i
;
305 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
307 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
312 if (TREE_CODE (t
) == CLEANUP_STMT
)
314 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
315 but we can in a constexpr constructor for a non-literal class. Just
316 ignore it; either all the initialization will be constant, in which
317 case the cleanup can't run, or it can't be constexpr.
318 Still recurse into CLEANUP_BODY. */
319 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
321 if (TREE_CODE (t
) == CONVERT_EXPR
)
322 t
= TREE_OPERAND (t
, 0);
323 if (TREE_CODE (t
) == INIT_EXPR
324 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
325 use what this function builds for cx_check_missing_mem_inits, and
326 assignment in the ctor body doesn't count. */
327 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
329 member
= TREE_OPERAND (t
, 0);
330 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
332 else if (TREE_CODE (t
) == CALL_EXPR
)
334 tree fn
= get_callee_fndecl (t
);
335 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
336 /* We're only interested in calls to subobject constructors. */
338 member
= CALL_EXPR_ARG (t
, 0);
339 /* We don't use build_cplus_new here because it complains about
340 abstract bases. Leaving the call unwrapped means that it has the
341 wrong type, but cxx_eval_constant_expression doesn't care. */
342 init
= break_out_target_exprs (t
);
344 else if (TREE_CODE (t
) == BIND_EXPR
)
345 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
347 /* Don't add anything else to the CONSTRUCTOR. */
349 if (INDIRECT_REF_P (member
))
350 member
= TREE_OPERAND (member
, 0);
351 if (TREE_CODE (member
) == NOP_EXPR
)
355 if (TREE_CODE (op
) == ADDR_EXPR
)
357 gcc_assert (same_type_ignoring_top_level_qualifiers_p
358 (TREE_TYPE (TREE_TYPE (op
)),
359 TREE_TYPE (TREE_TYPE (member
))));
360 /* Initializing a cv-qualified member; we need to look through
364 else if (op
== current_class_ptr
365 && (same_type_ignoring_top_level_qualifiers_p
366 (TREE_TYPE (TREE_TYPE (member
)),
367 current_class_type
)))
368 /* Delegating constructor. */
372 /* This is an initializer for an empty base; keep it for now so
373 we can check it in cxx_eval_bare_aggregate. */
374 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
377 if (TREE_CODE (member
) == ADDR_EXPR
)
378 member
= TREE_OPERAND (member
, 0);
379 if (TREE_CODE (member
) == COMPONENT_REF
)
381 tree aggr
= TREE_OPERAND (member
, 0);
382 if (TREE_CODE (aggr
) != COMPONENT_REF
)
383 /* Normal member initialization. */
384 member
= TREE_OPERAND (member
, 1);
385 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
386 /* Initializing a member of an anonymous union. */
387 return build_anon_member_initialization (member
, init
, vec
);
389 /* We're initializing a vtable pointer in a base. Leave it as
390 COMPONENT_REF so we remember the path to get to the vfield. */
391 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
394 /* Value-initialization can produce multiple initializers for the
395 same field; use the last one. */
396 if (!vec_safe_is_empty (*vec
) && (*vec
)->last().index
== member
)
397 (*vec
)->last().value
= init
;
399 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
403 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
404 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
405 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
408 check_constexpr_bind_expr_vars (tree t
)
410 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
412 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
413 if (TREE_CODE (var
) == TYPE_DECL
414 && DECL_IMPLICIT_TYPEDEF_P (var
)
415 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
420 /* Subroutine of check_constexpr_ctor_body. */
423 check_constexpr_ctor_body_1 (tree last
, tree list
)
425 switch (TREE_CODE (list
))
428 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
429 || TREE_CODE (DECL_EXPR_DECL (list
)) == TYPE_DECL
)
433 case CLEANUP_POINT_EXPR
:
434 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
438 if (!check_constexpr_bind_expr_vars (list
)
439 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
453 /* Make sure that there are no statements after LAST in the constructor
454 body represented by LIST. */
457 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
459 /* C++14 doesn't require a constexpr ctor to have an empty body. */
460 if (cxx_dialect
>= cxx14
)
464 if (TREE_CODE (list
) == STATEMENT_LIST
)
466 tree_stmt_iterator i
= tsi_last (list
);
467 for (; !tsi_end_p (i
); tsi_prev (&i
))
469 tree t
= tsi_stmt (i
);
472 if (!check_constexpr_ctor_body_1 (last
, t
))
479 else if (list
!= last
480 && !check_constexpr_ctor_body_1 (last
, list
))
485 error ("constexpr constructor does not have empty body");
486 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
491 /* V is a vector of constructor elements built up for the base and member
492 initializers of a constructor for TYPE. They need to be in increasing
493 offset order, which they might not be yet if TYPE has a primary base
494 which is not first in the base-clause or a vptr and at least one base
495 all of which are non-primary. */
497 static vec
<constructor_elt
, va_gc
> *
498 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
500 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
506 field_type
= BINFO_TYPE (pri
);
507 else if (TYPE_CONTAINS_VPTR_P (type
))
508 field_type
= vtbl_ptr_type_node
;
512 /* Find the element for the primary base or vptr and move it to the
513 beginning of the vec. */
514 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
515 if (TREE_TYPE (ce
->index
) == field_type
)
518 if (i
> 0 && i
< vec_safe_length (v
))
520 vec
<constructor_elt
, va_gc
> &vref
= *v
;
521 constructor_elt elt
= vref
[i
];
530 /* Build compile-time evalable representations of member-initializer list
531 for a constexpr constructor. */
534 build_constexpr_constructor_member_initializers (tree type
, tree body
)
536 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
539 switch (TREE_CODE (body
))
541 case MUST_NOT_THROW_EXPR
:
543 body
= TREE_OPERAND (body
, 0);
547 for (tree_stmt_iterator i
= tsi_start (body
);
548 !tsi_end_p (i
); tsi_next (&i
))
551 if (TREE_CODE (body
) == BIND_EXPR
)
557 body
= BIND_EXPR_BODY (body
);
564 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
566 body
= TREE_OPERAND (body
, 0);
567 if (TREE_CODE (body
) == EXPR_STMT
)
568 body
= TREE_OPERAND (body
, 0);
569 if (TREE_CODE (body
) == INIT_EXPR
570 && (same_type_ignoring_top_level_qualifiers_p
571 (TREE_TYPE (TREE_OPERAND (body
, 0)),
572 current_class_type
)))
575 return TREE_OPERAND (body
, 1);
577 ok
= build_data_member_initialization (body
, &vec
);
579 else if (TREE_CODE (body
) == STATEMENT_LIST
)
581 tree_stmt_iterator i
;
582 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
584 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
589 else if (TREE_CODE (body
) == TRY_BLOCK
)
591 error ("body of %<constexpr%> constructor cannot be "
592 "a function-try-block");
593 return error_mark_node
;
595 else if (EXPR_P (body
))
596 ok
= build_data_member_initialization (body
, &vec
);
598 gcc_assert (errorcount
> 0);
601 if (vec_safe_length (vec
) > 0)
603 /* In a delegating constructor, return the target. */
604 constructor_elt
*ce
= &(*vec
)[0];
605 if (ce
->index
== current_class_ptr
)
612 vec
= sort_constexpr_mem_initializers (type
, vec
);
613 return build_constructor (type
, vec
);
616 return error_mark_node
;
619 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
620 declared to be constexpr, or a sub-statement thereof. Returns the
621 return value if suitable, error_mark_node for a statement not allowed in
622 a constexpr function, or NULL_TREE if no return value was found. */
625 constexpr_fn_retval (tree body
)
627 switch (TREE_CODE (body
))
631 tree_stmt_iterator i
;
632 tree expr
= NULL_TREE
;
633 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
635 tree s
= constexpr_fn_retval (tsi_stmt (i
));
636 if (s
== error_mark_node
)
637 return error_mark_node
;
638 else if (s
== NULL_TREE
)
639 /* Keep iterating. */;
641 /* Multiple return statements. */
642 return error_mark_node
;
650 return break_out_target_exprs (TREE_OPERAND (body
, 0));
654 tree decl
= DECL_EXPR_DECL (body
);
655 if (TREE_CODE (decl
) == USING_DECL
656 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
657 || DECL_ARTIFICIAL (decl
))
659 return error_mark_node
;
662 case CLEANUP_POINT_EXPR
:
663 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
666 if (!check_constexpr_bind_expr_vars (body
))
667 return error_mark_node
;
668 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
674 return error_mark_node
;
678 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
679 FUN; do the necessary transformations to turn it into a single expression
680 that we can store in the hash table. */
683 massage_constexpr_body (tree fun
, tree body
)
685 if (DECL_CONSTRUCTOR_P (fun
))
686 body
= build_constexpr_constructor_member_initializers
687 (DECL_CONTEXT (fun
), body
);
688 else if (cxx_dialect
< cxx14
)
690 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
691 body
= EH_SPEC_STMTS (body
);
692 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
693 body
= TREE_OPERAND (body
, 0);
694 body
= constexpr_fn_retval (body
);
699 /* FUN is a constexpr constructor with massaged body BODY. Return true
700 if some bases/fields are uninitialized, and complain if COMPLAIN. */
703 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
710 if (TREE_CODE (body
) != CONSTRUCTOR
)
713 nelts
= CONSTRUCTOR_NELTS (body
);
714 ctype
= DECL_CONTEXT (fun
);
715 field
= TYPE_FIELDS (ctype
);
717 if (TREE_CODE (ctype
) == UNION_TYPE
)
719 if (nelts
== 0 && next_initializable_field (field
))
722 error ("%<constexpr%> constructor for union %qT must "
723 "initialize exactly one non-static data member", ctype
);
730 for (i
= 0; i
<= nelts
; ++i
)
737 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
738 /* Skip base and vtable inits. */
739 if (TREE_CODE (index
) != FIELD_DECL
740 || DECL_ARTIFICIAL (index
))
743 for (; field
!= index
; field
= DECL_CHAIN (field
))
746 if (TREE_CODE (field
) != FIELD_DECL
747 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
748 || DECL_ARTIFICIAL (field
))
750 ftype
= strip_array_types (TREE_TYPE (field
));
751 if (type_has_constexpr_default_constructor (ftype
))
753 /* It's OK to skip a member with a trivial constexpr ctor.
754 A constexpr ctor that isn't trivial should have been
756 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
762 error ("member %qD must be initialized by mem-initializer "
763 "in %<constexpr%> constructor", field
);
764 inform (DECL_SOURCE_LOCATION (field
), "declared here");
767 if (field
== NULL_TREE
)
769 field
= DECL_CHAIN (field
);
775 /* We are processing the definition of the constexpr function FUN.
776 Check that its BODY fulfills the propriate requirements and
777 enter it in the constexpr function definition table.
778 For constructor BODY is actually the TREE_LIST of the
779 member-initializer list. */
782 register_constexpr_fundef (tree fun
, tree body
)
784 constexpr_fundef entry
;
785 constexpr_fundef
**slot
;
787 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
790 tree massaged
= massage_constexpr_body (fun
, body
);
791 if (massaged
== NULL_TREE
|| massaged
== error_mark_node
)
793 if (!DECL_CONSTRUCTOR_P (fun
))
794 error ("body of constexpr function %qD not a return-statement", fun
);
798 if (!potential_rvalue_constant_expression (massaged
))
800 if (!DECL_GENERATED_P (fun
))
801 require_potential_rvalue_constant_expression (massaged
);
805 if (DECL_CONSTRUCTOR_P (fun
)
806 && cx_check_missing_mem_inits (fun
, massaged
, !DECL_GENERATED_P (fun
)))
809 /* Create the constexpr function table if necessary. */
810 if (constexpr_fundef_table
== NULL
)
811 constexpr_fundef_table
812 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
816 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
818 gcc_assert (*slot
== NULL
);
819 *slot
= ggc_alloc
<constexpr_fundef
> ();
825 /* FUN is a non-constexpr function called in a context that requires a
826 constant expression. If it comes from a constexpr template, explain why
827 the instantiation isn't constexpr. */
830 explain_invalid_constexpr_fn (tree fun
)
832 static hash_set
<tree
> *diagnosed
;
835 /* Only diagnose defaulted functions or instantiations. */
836 if (!DECL_DEFAULTED_FN (fun
)
837 && !is_instantiation_of_constexpr (fun
))
839 if (diagnosed
== NULL
)
840 diagnosed
= new hash_set
<tree
>;
841 if (diagnosed
->add (fun
))
842 /* Already explained. */
845 save_loc
= input_location
;
846 input_location
= DECL_SOURCE_LOCATION (fun
);
847 inform (input_location
,
848 "%qD is not usable as a constexpr function because:", fun
);
849 /* First check the declaration. */
850 if (is_valid_constexpr_fn (fun
, true))
852 /* Then if it's OK, the body. */
853 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
854 explain_implicit_non_constexpr (fun
);
857 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
858 require_potential_rvalue_constant_expression (body
);
859 if (DECL_CONSTRUCTOR_P (fun
))
860 cx_check_missing_mem_inits (fun
, body
, true);
863 input_location
= save_loc
;
866 /* Objects of this type represent calls to constexpr functions
867 along with the bindings of parameters to their arguments, for
868 the purpose of compile time evaluation. */
870 struct GTY((for_user
)) constexpr_call
{
871 /* Description of the constexpr function definition. */
872 constexpr_fundef
*fundef
;
873 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
874 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
875 Note: This arrangement is made to accommodate the use of
876 iterative_hash_template_arg (see pt.c). If you change this
877 representation, also change the hash calculation in
878 cxx_eval_call_expression. */
880 /* Result of the call.
881 NULL means the call is being evaluated.
882 error_mark_node means that the evaluation was erroneous;
883 otherwise, the actuall value of the call. */
885 /* The hash of this call; we remember it here to avoid having to
886 recalculate it when expanding the hash table. */
890 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
892 static hashval_t
hash (constexpr_call
*);
893 static bool equal (constexpr_call
*, constexpr_call
*);
896 /* The constexpr expansion context. CALL is the current function
897 expansion, CTOR is the current aggregate initializer, OBJECT is the
898 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
899 is a map of values of variables initialized within the expression. */
901 struct constexpr_ctx
{
902 /* The innermost call we're evaluating. */
903 constexpr_call
*call
;
904 /* Values for any temporaries or local variables within the
905 constant-expression. */
906 hash_map
<tree
,tree
> *values
;
907 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
908 aren't inside a loop. */
909 hash_set
<tree
> *save_exprs
;
910 /* The CONSTRUCTOR we're currently building up for an aggregate
913 /* The object we're building the CONSTRUCTOR for. */
915 /* Whether we should error on a non-constant expression or fail quietly. */
917 /* Whether we are strictly conforming to constant expression rules or
918 trying harder to get a constant value. */
922 /* A table of all constexpr calls that have been evaluated by the
923 compiler in this translation unit. */
925 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
927 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
928 bool, bool *, bool *, tree
* = NULL
);
930 /* Compute a hash value for a constexpr call representation. */
933 constexpr_call_hasher::hash (constexpr_call
*info
)
938 /* Return true if the objects pointed to by P and Q represent calls
939 to the same constexpr function with the same arguments.
940 Otherwise, return false. */
943 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
949 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
951 lhs_bindings
= lhs
->bindings
;
952 rhs_bindings
= rhs
->bindings
;
953 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
955 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
956 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
957 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
958 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
960 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
961 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
963 return lhs_bindings
== rhs_bindings
;
966 /* Initialize the constexpr call table, if needed. */
969 maybe_initialize_constexpr_call_table (void)
971 if (constexpr_call_table
== NULL
)
972 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
975 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
976 a function happens to get called recursively, we unshare the callee
977 function's body and evaluate this unshared copy instead of evaluating the
980 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
981 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
982 that's keyed off of the original FUNCTION_DECL and whose value is a
983 TREE_LIST of this function's unused copies awaiting reuse.
985 This is not GC-deletable to avoid GC affecting UID generation. */
987 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
989 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
992 maybe_initialize_fundef_copies_table ()
994 if (fundef_copies_table
== NULL
)
995 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
998 /* Reuse a copy or create a new unshared copy of the function FUN.
999 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1000 is parms, TYPE is result. */
1003 get_fundef_copy (tree fun
)
1005 maybe_initialize_fundef_copies_table ();
1009 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1013 /* There is no cached function available, or in use. We can use
1014 the function directly. That the slot is now created records
1015 that this function is now in use. */
1016 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1017 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1019 else if (*slot
== NULL_TREE
)
1021 /* We've already used the function itself, so make a copy. */
1022 copy
= build_tree_list (NULL
, NULL
);
1023 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1027 /* We have a cached function available. */
1029 *slot
= TREE_CHAIN (copy
);
1035 /* Save the copy COPY of function FUN for later reuse by
1036 get_fundef_copy(). By construction, there will always be an entry
1040 save_fundef_copy (tree fun
, tree copy
)
1042 tree
*slot
= fundef_copies_table
->get (fun
);
1043 TREE_CHAIN (copy
) = *slot
;
1047 /* We have an expression tree T that represents a call, either CALL_EXPR
1048 or AGGR_INIT_EXPR. If the call is lexically to a named function,
1049 retrun the _DECL for that function. */
1052 get_function_named_in_call (tree t
)
1054 tree fun
= cp_get_callee (t
);
1055 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
1056 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
1057 fun
= TREE_OPERAND (fun
, 0);
1061 /* We have an expression tree T that represents a call, either CALL_EXPR
1062 or AGGR_INIT_EXPR. Return the Nth argument. */
1065 get_nth_callarg (tree t
, int n
)
1067 switch (TREE_CODE (t
))
1070 return CALL_EXPR_ARG (t
, n
);
1072 case AGGR_INIT_EXPR
:
1073 return AGGR_INIT_EXPR_ARG (t
, n
);
1081 /* Attempt to evaluate T which represents a call to a builtin function.
1082 We assume here that all builtin functions evaluate to scalar types
1083 represented by _CST nodes. */
1086 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1088 bool *non_constant_p
, bool *overflow_p
)
1090 const int nargs
= call_expr_nargs (t
);
1091 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1095 /* Don't fold __builtin_constant_p within a constexpr function. */
1096 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1099 && current_function_decl
1100 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1102 *non_constant_p
= true;
1106 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1107 return constant false for a non-constant argument. */
1108 constexpr_ctx new_ctx
= *ctx
;
1109 new_ctx
.quiet
= true;
1110 bool dummy1
= false, dummy2
= false;
1111 for (i
= 0; i
< nargs
; ++i
)
1113 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1114 false, &dummy1
, &dummy2
);
1116 /* For __built_in_constant_p, fold all expressions with constant values
1117 even if they aren't C++ constant-expressions. */
1118 args
[i
] = cp_fully_fold (args
[i
]);
1121 bool save_ffbcp
= force_folding_builtin_constant_p
;
1122 force_folding_builtin_constant_p
= true;
1123 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1124 CALL_EXPR_FN (t
), nargs
, args
);
1125 force_folding_builtin_constant_p
= save_ffbcp
;
1126 if (new_call
== NULL
)
1128 if (!*non_constant_p
&& !ctx
->quiet
)
1130 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1131 CALL_EXPR_FN (t
), nargs
, args
);
1132 error ("%q+E is not a constant expression", new_call
);
1134 *non_constant_p
= true;
1138 if (!potential_constant_expression (new_call
))
1140 if (!*non_constant_p
&& !ctx
->quiet
)
1141 error ("%q+E is not a constant expression", new_call
);
1142 *non_constant_p
= true;
1146 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1147 non_constant_p
, overflow_p
);
1150 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1151 the type of the value to match. */
1154 adjust_temp_type (tree type
, tree temp
)
1156 if (TREE_TYPE (temp
) == type
)
1158 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1159 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1160 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1161 gcc_assert (scalarish_type_p (type
));
1162 return cp_fold_convert (type
, temp
);
1165 /* Callback for walk_tree used by unshare_constructor. */
1168 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1172 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1177 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1178 subexpression, return an unshared copy of T. Otherwise return T. */
1181 unshare_constructor (tree t
)
1183 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1184 if (ctor
!= NULL_TREE
)
1185 return unshare_expr (t
);
1189 /* Subroutine of cxx_eval_call_expression.
1190 We are processing a call expression (either CALL_EXPR or
1191 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1192 all arguments and bind their values to correspondings
1193 parameters, making up the NEW_CALL context. */
1196 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1197 constexpr_call
*new_call
,
1198 bool *non_constant_p
, bool *overflow_p
,
1199 bool *non_constant_args
)
1201 const int nargs
= call_expr_nargs (t
);
1202 tree fun
= new_call
->fundef
->decl
;
1203 tree parms
= DECL_ARGUMENTS (fun
);
1205 tree
*p
= &new_call
->bindings
;
1206 for (i
= 0; i
< nargs
; ++i
)
1209 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1210 x
= get_nth_callarg (t
, i
);
1211 /* For member function, the first argument is a pointer to the implied
1212 object. For a constructor, it might still be a dummy object, in
1213 which case we get the real argument from ctx. */
1214 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1215 && is_dummy_object (x
))
1218 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1221 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1222 non_constant_p
, overflow_p
);
1223 /* Don't VERIFY_CONSTANT here. */
1224 if (*non_constant_p
&& ctx
->quiet
)
1226 /* Just discard ellipsis args after checking their constantitude. */
1230 if (!*non_constant_p
)
1232 /* Make sure the binding has the same type as the parm. But
1233 only for constant args. */
1234 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1235 arg
= adjust_temp_type (type
, arg
);
1236 if (!TREE_CONSTANT (arg
))
1237 *non_constant_args
= true;
1238 *p
= build_tree_list (parms
, arg
);
1239 p
= &TREE_CHAIN (*p
);
1241 parms
= TREE_CHAIN (parms
);
1245 /* Variables and functions to manage constexpr call expansion context.
1246 These do not need to be marked for PCH or GC. */
1248 /* FIXME remember and print actual constant arguments. */
1249 static vec
<tree
> call_stack
= vNULL
;
1250 static int call_stack_tick
;
1251 static int last_cx_error_tick
;
1254 push_cx_call_context (tree call
)
1257 if (!EXPR_HAS_LOCATION (call
))
1258 SET_EXPR_LOCATION (call
, input_location
);
1259 call_stack
.safe_push (call
);
1260 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1266 pop_cx_call_context (void)
1273 cx_error_context (void)
1275 vec
<tree
> r
= vNULL
;
1276 if (call_stack_tick
!= last_cx_error_tick
1277 && !call_stack
.is_empty ())
1279 last_cx_error_tick
= call_stack_tick
;
1283 /* Evaluate a call T to a GCC internal function when possible and return
1284 the evaluated result or, under the control of CTX, give an error, set
1285 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1288 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1290 bool *non_constant_p
, bool *overflow_p
)
1292 enum tree_code opcode
= ERROR_MARK
;
1294 switch (CALL_EXPR_IFN (t
))
1296 case IFN_UBSAN_NULL
:
1297 case IFN_UBSAN_BOUNDS
:
1298 case IFN_UBSAN_VPTR
:
1301 case IFN_ADD_OVERFLOW
:
1304 case IFN_SUB_OVERFLOW
:
1305 opcode
= MINUS_EXPR
;
1307 case IFN_MUL_OVERFLOW
:
1313 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1314 "call to internal function %qE", t
);
1315 *non_constant_p
= true;
1319 /* Evaluate constant arguments using OPCODE and return a complex
1320 number containing the result and the overflow bit. */
1321 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1322 non_constant_p
, overflow_p
);
1323 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1324 non_constant_p
, overflow_p
);
1326 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1328 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1329 tree type
= TREE_TYPE (TREE_TYPE (t
));
1330 tree result
= fold_binary_loc (loc
, opcode
, type
,
1331 fold_convert_loc (loc
, type
, arg0
),
1332 fold_convert_loc (loc
, type
, arg1
));
1334 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1335 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1336 if (TREE_OVERFLOW (result
))
1337 TREE_OVERFLOW (result
) = 0;
1339 return build_complex (TREE_TYPE (t
), result
, ovf
);
1342 *non_constant_p
= true;
1346 /* Subroutine of cxx_eval_constant_expression.
1347 Evaluate the call expression tree T in the context of OLD_CALL expression
1351 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1353 bool *non_constant_p
, bool *overflow_p
)
1355 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1356 tree fun
= get_function_named_in_call (t
);
1357 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1360 if (fun
== NULL_TREE
)
1361 return cxx_eval_internal_function (ctx
, t
, lval
,
1362 non_constant_p
, overflow_p
);
1364 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1366 /* Might be a constexpr function pointer. */
1367 fun
= cxx_eval_constant_expression (ctx
, fun
,
1368 /*lval*/false, non_constant_p
,
1371 if (TREE_CODE (fun
) == ADDR_EXPR
)
1372 fun
= TREE_OPERAND (fun
, 0);
1374 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1376 if (!ctx
->quiet
&& !*non_constant_p
)
1377 error_at (loc
, "expression %qE does not designate a constexpr "
1379 *non_constant_p
= true;
1382 if (DECL_CLONED_FUNCTION_P (fun
))
1383 fun
= DECL_CLONED_FUNCTION (fun
);
1385 if (is_ubsan_builtin_p (fun
))
1388 if (is_builtin_fn (fun
))
1389 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1390 lval
, non_constant_p
, overflow_p
);
1391 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1395 error_at (loc
, "call to non-constexpr function %qD", fun
);
1396 explain_invalid_constexpr_fn (fun
);
1398 *non_constant_p
= true;
1402 constexpr_ctx new_ctx
= *ctx
;
1403 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1404 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1406 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1407 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1408 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1409 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1410 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1411 ctx
->values
->put (new_ctx
.object
, ctor
);
1415 /* Shortcut trivial constructor/op=. */
1416 if (trivial_fn_p (fun
))
1418 tree init
= NULL_TREE
;
1419 if (call_expr_nargs (t
) == 2)
1420 init
= convert_from_reference (get_nth_callarg (t
, 1));
1421 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1422 && AGGR_INIT_ZERO_FIRST (t
))
1423 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1426 tree op
= get_nth_callarg (t
, 0);
1427 if (is_dummy_object (op
))
1430 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1431 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1432 return cxx_eval_constant_expression (ctx
, set
, lval
,
1433 non_constant_p
, overflow_p
);
1437 /* We can't defer instantiating the function any longer. */
1438 if (!DECL_INITIAL (fun
)
1439 && DECL_TEMPLOID_INSTANTIATION (fun
))
1442 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1446 /* If in direct recursive call, optimize definition search. */
1447 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1448 new_call
.fundef
= ctx
->call
->fundef
;
1451 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1452 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1453 || fun
== current_function_decl
)
1457 /* We need to check for current_function_decl here in case we're
1458 being called during cp_fold_function, because at that point
1459 DECL_INITIAL is set properly and we have a fundef but we
1460 haven't lowered invisirefs yet (c++/70344). */
1461 if (DECL_INITIAL (fun
) == error_mark_node
1462 || fun
== current_function_decl
)
1463 error_at (loc
, "%qD called in a constant expression before its "
1464 "definition is complete", fun
);
1465 else if (DECL_INITIAL (fun
))
1467 /* The definition of fun was somehow unsuitable. */
1468 error_at (loc
, "%qD called in a constant expression", fun
);
1469 explain_invalid_constexpr_fn (fun
);
1472 error_at (loc
, "%qD used before its definition", fun
);
1474 *non_constant_p
= true;
1479 bool non_constant_args
= false;
1480 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1481 non_constant_p
, overflow_p
, &non_constant_args
);
1482 if (*non_constant_p
)
1485 depth_ok
= push_cx_call_context (t
);
1487 tree result
= NULL_TREE
;
1489 constexpr_call
*entry
= NULL
;
1490 if (depth_ok
&& !non_constant_args
)
1492 new_call
.hash
= iterative_hash_template_arg
1493 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1495 /* If we have seen this call before, we are done. */
1496 maybe_initialize_constexpr_call_table ();
1497 constexpr_call
**slot
1498 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1502 /* We need to keep a pointer to the entry, not just the slot, as the
1503 slot can move in the call to cxx_eval_builtin_function_call. */
1504 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1507 /* Calls that are in progress have their result set to NULL,
1508 so that we can detect circular dependencies. */
1509 else if (entry
->result
== NULL
)
1512 error ("call has circular dependency");
1513 *non_constant_p
= true;
1514 entry
->result
= result
= error_mark_node
;
1517 result
= entry
->result
;
1523 error ("constexpr evaluation depth exceeds maximum of %d (use "
1524 "-fconstexpr-depth= to increase the maximum)",
1525 max_constexpr_depth
);
1526 *non_constant_p
= true;
1527 result
= error_mark_node
;
1531 if (result
&& result
!= error_mark_node
)
1533 else if (!DECL_SAVED_TREE (fun
))
1535 /* When at_eof >= 2, cgraph has started throwing away
1536 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1537 late code generation for VEC_INIT_EXPR, which needs to be
1538 completely reconsidered. */
1539 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1540 *non_constant_p
= true;
1544 tree body
, parms
, res
;
1546 /* Reuse or create a new unshared copy of this function's body. */
1547 tree copy
= get_fundef_copy (fun
);
1548 body
= TREE_PURPOSE (copy
);
1549 parms
= TREE_VALUE (copy
);
1550 res
= TREE_TYPE (copy
);
1552 /* Associate the bindings with the remapped parms. */
1553 tree bound
= new_call
.bindings
;
1554 tree remapped
= parms
;
1557 tree oparm
= TREE_PURPOSE (bound
);
1558 tree arg
= TREE_VALUE (bound
);
1559 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1560 /* Don't share a CONSTRUCTOR that might be changed. */
1561 arg
= unshare_constructor (arg
);
1562 ctx
->values
->put (remapped
, arg
);
1563 bound
= TREE_CHAIN (bound
);
1564 remapped
= DECL_CHAIN (remapped
);
1566 /* Add the RESULT_DECL to the values map, too. */
1567 tree slot
= NULL_TREE
;
1568 if (DECL_BY_REFERENCE (res
))
1570 slot
= AGGR_INIT_EXPR_SLOT (t
);
1571 tree addr
= build_address (slot
);
1572 addr
= build_nop (TREE_TYPE (res
), addr
);
1573 ctx
->values
->put (res
, addr
);
1574 ctx
->values
->put (slot
, NULL_TREE
);
1577 ctx
->values
->put (res
, NULL_TREE
);
1579 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1580 their values after the call. */
1581 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1582 hash_set
<tree
> save_exprs
;
1583 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1585 tree jump_target
= NULL_TREE
;
1586 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1587 lval
, non_constant_p
, overflow_p
,
1590 if (DECL_CONSTRUCTOR_P (fun
))
1591 /* This can be null for a subobject constructor call, in
1592 which case what we care about is the initialization
1593 side-effects rather than the value. We could get at the
1594 value by evaluating *this, but we don't bother; there's
1595 no need to put such a call in the hash table. */
1596 result
= lval
? ctx
->object
: ctx
->ctor
;
1597 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1601 result
= *ctx
->values
->get (slot
? slot
: res
);
1602 if (result
== NULL_TREE
&& !*non_constant_p
)
1605 error ("constexpr call flows off the end "
1607 *non_constant_p
= true;
1611 /* Forget the saved values of the callee's SAVE_EXPRs. */
1612 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1613 iter
!= save_exprs
.end(); ++iter
)
1614 ctx_with_save_exprs
.values
->remove (*iter
);
1616 /* Remove the parms/result from the values map. Is it worth
1617 bothering to do this when the map itself is only live for
1618 one constexpr evaluation? If so, maybe also clear out
1619 other vars from call, maybe in BIND_EXPR handling? */
1620 ctx
->values
->remove (res
);
1622 ctx
->values
->remove (slot
);
1623 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1624 ctx
->values
->remove (parm
);
1626 /* Make the unshared function copy we used available for re-use. */
1627 save_fundef_copy (fun
, copy
);
1630 if (result
== error_mark_node
)
1631 *non_constant_p
= true;
1632 if (*non_constant_p
|| *overflow_p
)
1633 result
= error_mark_node
;
1637 entry
->result
= result
;
1640 pop_cx_call_context ();
1641 return unshare_constructor (result
);
1644 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1647 reduced_constant_expression_p (tree t
)
1649 switch (TREE_CODE (t
))
1652 /* Even if we can't lower this yet, it's constant. */
1656 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1657 tree elt
; unsigned HOST_WIDE_INT idx
;
1658 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1659 if (!reduced_constant_expression_p (elt
))
1664 /* FIXME are we calling this too much? */
1665 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1669 /* Some expressions may have constant operands but are not constant
1670 themselves, such as 1/0. Call this function (or rather, the macro
1671 following it) to check for that condition.
1673 We only call this in places that require an arithmetic constant, not in
1674 places where we might have a non-constant expression that can be a
1675 component of a constant expression, such as the address of a constexpr
1676 variable that might be dereferenced later. */
1679 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1682 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1684 if (!allow_non_constant
)
1685 error ("%q+E is not a constant expression", t
);
1686 *non_constant_p
= true;
1688 if (TREE_OVERFLOW_P (t
))
1690 if (!allow_non_constant
)
1692 permerror (input_location
, "overflow in constant expression");
1693 /* If we're being permissive (and are in an enforcing
1694 context), ignore the overflow. */
1695 if (flag_permissive
)
1696 return *non_constant_p
;
1700 return *non_constant_p
;
1703 /* Check whether the shift operation with code CODE and type TYPE on LHS
1704 and RHS is undefined. If it is, give an error with an explanation,
1705 and return true; return false otherwise. */
1708 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1709 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1711 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1712 || TREE_CODE (lhs
) != INTEGER_CST
1713 || TREE_CODE (rhs
) != INTEGER_CST
)
1716 tree lhstype
= TREE_TYPE (lhs
);
1717 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1719 /* [expr.shift] The behavior is undefined if the right operand
1720 is negative, or greater than or equal to the length in bits
1721 of the promoted left operand. */
1722 if (tree_int_cst_sgn (rhs
) == -1)
1725 permerror (loc
, "right operand of shift expression %q+E is negative",
1726 build2_loc (loc
, code
, type
, lhs
, rhs
));
1727 return (!flag_permissive
|| ctx
->quiet
);
1729 if (compare_tree_int (rhs
, uprec
) >= 0)
1732 permerror (loc
, "right operand of shift expression %q+E is >= than "
1733 "the precision of the left operand",
1734 build2_loc (loc
, code
, type
, lhs
, rhs
));
1735 return (!flag_permissive
|| ctx
->quiet
);
1738 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1739 if E1 has a signed type and non-negative value, and E1x2^E2 is
1740 representable in the corresponding unsigned type of the result type,
1741 then that value, converted to the result type, is the resulting value;
1742 otherwise, the behavior is undefined. */
1743 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1744 && (cxx_dialect
>= cxx11
))
1746 if (tree_int_cst_sgn (lhs
) == -1)
1750 "left operand of shift expression %q+E is negative",
1751 build2_loc (loc
, code
, type
, lhs
, rhs
));
1752 return (!flag_permissive
|| ctx
->quiet
);
1754 /* For signed x << y the following:
1755 (unsigned) x >> ((prec (lhs) - 1) - y)
1756 if > 1, is undefined. The right-hand side of this formula
1757 is the highest bit of the LHS that can be set (starting from 0),
1758 so that the shift doesn't overflow. We then right-shift the LHS
1759 to see whether any other bit is set making the original shift
1760 undefined -- the result is not representable in the corresponding
1762 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1763 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1764 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1765 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1766 if (tree_int_cst_lt (integer_one_node
, t
))
1769 permerror (loc
, "shift expression %q+E overflows",
1770 build2_loc (loc
, code
, type
, lhs
, rhs
));
1771 return (!flag_permissive
|| ctx
->quiet
);
1777 /* Subroutine of cxx_eval_constant_expression.
1778 Attempt to reduce the unary expression tree T to a compile time value.
1779 If successful, return the value. Otherwise issue a diagnostic
1780 and return error_mark_node. */
1783 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1785 bool *non_constant_p
, bool *overflow_p
)
1788 tree orig_arg
= TREE_OPERAND (t
, 0);
1789 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1790 non_constant_p
, overflow_p
);
1791 VERIFY_CONSTANT (arg
);
1792 location_t loc
= EXPR_LOCATION (t
);
1793 enum tree_code code
= TREE_CODE (t
);
1794 tree type
= TREE_TYPE (t
);
1795 r
= fold_unary_loc (loc
, code
, type
, arg
);
1798 if (arg
== orig_arg
)
1801 r
= build1_loc (loc
, code
, type
, arg
);
1803 VERIFY_CONSTANT (r
);
1807 /* Subroutine of cxx_eval_constant_expression.
1808 Like cxx_eval_unary_expression, except for binary expressions. */
1811 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1813 bool *non_constant_p
, bool *overflow_p
)
1816 tree orig_lhs
= TREE_OPERAND (t
, 0);
1817 tree orig_rhs
= TREE_OPERAND (t
, 1);
1819 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1820 non_constant_p
, overflow_p
);
1821 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
1823 if (*non_constant_p
)
1825 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1826 non_constant_p
, overflow_p
);
1827 if (*non_constant_p
)
1830 location_t loc
= EXPR_LOCATION (t
);
1831 enum tree_code code
= TREE_CODE (t
);
1832 tree type
= TREE_TYPE (t
);
1834 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
1836 bool is_code_eq
= (code
== EQ_EXPR
);
1838 if (TREE_CODE (lhs
) == PTRMEM_CST
1839 && TREE_CODE (rhs
) == PTRMEM_CST
)
1840 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
1842 else if ((TREE_CODE (lhs
) == PTRMEM_CST
1843 || TREE_CODE (rhs
) == PTRMEM_CST
)
1844 && (null_member_pointer_value_p (lhs
)
1845 || null_member_pointer_value_p (rhs
)))
1846 r
= constant_boolean_node (!is_code_eq
, type
);
1847 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
1848 lhs
= cplus_expand_constant (lhs
);
1849 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
1850 rhs
= cplus_expand_constant (rhs
);
1852 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
1853 && integer_zerop (lhs
) && !integer_zerop (rhs
))
1856 error ("arithmetic involving a null pointer in %qE", lhs
);
1861 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1865 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1868 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1870 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1871 *non_constant_p
= true;
1872 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1873 a local array in a constexpr function. */
1874 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1876 VERIFY_CONSTANT (r
);
1880 /* Subroutine of cxx_eval_constant_expression.
1881 Attempt to evaluate condition expressions. Dead branches are not
1885 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1887 bool *non_constant_p
, bool *overflow_p
,
1890 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1892 non_constant_p
, overflow_p
);
1893 VERIFY_CONSTANT (val
);
1894 /* Don't VERIFY_CONSTANT the other operands. */
1895 if (integer_zerop (val
))
1896 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1898 non_constant_p
, overflow_p
,
1900 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1902 non_constant_p
, overflow_p
,
1906 /* Returns less than, equal to, or greater than zero if KEY is found to be
1907 less than, to match, or to be greater than the constructor_elt's INDEX. */
1910 array_index_cmp (tree key
, tree index
)
1912 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
1914 switch (TREE_CODE (index
))
1917 return tree_int_cst_compare (key
, index
);
1920 tree lo
= TREE_OPERAND (index
, 0);
1921 tree hi
= TREE_OPERAND (index
, 1);
1922 if (tree_int_cst_lt (key
, lo
))
1924 else if (tree_int_cst_lt (hi
, key
))
1934 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
1935 if none. If INSERT is true, insert a matching element rather than fail. */
1937 static HOST_WIDE_INT
1938 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
1940 if (tree_int_cst_sgn (dindex
) < 0)
1943 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
1944 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
1945 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
1947 unsigned HOST_WIDE_INT end
= len
;
1948 unsigned HOST_WIDE_INT begin
= 0;
1950 /* If the last element of the CONSTRUCTOR has its own index, we can assume
1951 that the same is true of the other elements and index directly. */
1954 tree cindex
= (*elts
)[end
-1].index
;
1955 if (TREE_CODE (cindex
) == INTEGER_CST
1956 && compare_tree_int (cindex
, end
-1) == 0)
1965 /* Otherwise, find a matching index by means of a binary search. */
1966 while (begin
!= end
)
1968 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
1969 constructor_elt
&elt
= (*elts
)[middle
];
1970 tree idx
= elt
.index
;
1972 int cmp
= array_index_cmp (dindex
, idx
);
1979 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
1981 /* We need to split the range. */
1983 tree lo
= TREE_OPERAND (idx
, 0);
1984 tree hi
= TREE_OPERAND (idx
, 1);
1985 if (tree_int_cst_lt (lo
, dindex
))
1987 /* There are still some lower elts; shorten the range. */
1988 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
1990 if (tree_int_cst_equal (lo
, new_hi
))
1991 /* Only one element left, no longer a range. */
1994 TREE_OPERAND (idx
, 1) = new_hi
;
1995 /* Append the element we want to insert. */
1998 e
.value
= unshare_constructor (elt
.value
);
1999 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2002 /* No lower elts, the range elt is now ours. */
2005 if (tree_int_cst_lt (dindex
, hi
))
2007 /* There are still some higher elts; append a range. */
2008 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2010 if (tree_int_cst_equal (new_lo
, hi
))
2013 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2014 e
.value
= unshare_constructor (elt
.value
);
2015 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2024 constructor_elt e
= { dindex
, NULL_TREE
};
2025 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2032 /* Under the control of CTX, issue a detailed diagnostic for
2033 an out-of-bounds subscript INDEX into the expression ARRAY. */
2036 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2040 tree arraytype
= TREE_TYPE (array
);
2042 /* Convert the unsigned array subscript to a signed integer to avoid
2043 printing huge numbers for small negative values. */
2044 tree sidx
= fold_convert (ssizetype
, index
);
2047 error ("array subscript value %qE is outside the bounds "
2048 "of array %qD of type %qT", sidx
, array
, arraytype
);
2049 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2052 error ("array subscript value %qE is outside the bounds "
2053 "of array type %qT", sidx
, arraytype
);
2057 /* Subroutine of cxx_eval_constant_expression.
2058 Attempt to reduce a reference to an array slot. */
2061 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2063 bool *non_constant_p
, bool *overflow_p
)
2065 tree oldary
= TREE_OPERAND (t
, 0);
2066 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2068 non_constant_p
, overflow_p
);
2072 unsigned len
, elem_nchars
= 1;
2073 if (*non_constant_p
)
2075 oldidx
= TREE_OPERAND (t
, 1);
2076 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2078 non_constant_p
, overflow_p
);
2079 VERIFY_CONSTANT (index
);
2080 if (lval
&& ary
== oldary
&& index
== oldidx
)
2083 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2084 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2085 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2086 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2087 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2088 ary
= TREE_OPERAND (ary
, 0);
2089 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2090 len
= CONSTRUCTOR_NELTS (ary
);
2091 else if (TREE_CODE (ary
) == STRING_CST
)
2093 elem_nchars
= (TYPE_PRECISION (elem_type
)
2094 / TYPE_PRECISION (char_type_node
));
2095 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2097 else if (TREE_CODE (ary
) == VECTOR_CST
)
2098 len
= VECTOR_CST_NELTS (ary
);
2101 /* We can't do anything with other tree codes, so use
2102 VERIFY_CONSTANT to complain and fail. */
2103 VERIFY_CONSTANT (ary
);
2107 if (!tree_fits_shwi_p (index
)
2108 || (i
= tree_to_shwi (index
)) < 0)
2110 diag_array_subscript (ctx
, ary
, index
);
2111 *non_constant_p
= true;
2116 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2117 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2118 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2119 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2123 /* For VLAs, the number of elements won't be an integer constant. */
2124 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2126 VERIFY_CONSTANT (nelts
);
2127 if (!tree_int_cst_lt (index
, nelts
))
2129 diag_array_subscript (ctx
, ary
, index
);
2130 *non_constant_p
= true;
2135 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2137 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2148 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2149 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2150 else if (TREE_CODE (ary
) == VECTOR_CST
)
2151 r
= VECTOR_CST_ELT (ary
, i
);
2152 else if (elem_nchars
== 1)
2153 r
= build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
2154 TREE_STRING_POINTER (ary
)[i
]);
2157 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
2158 r
= native_interpret_expr (type
, (const unsigned char *)
2159 TREE_STRING_POINTER (ary
)
2160 + i
* elem_nchars
, elem_nchars
);
2163 /* Don't VERIFY_CONSTANT here. */
2166 /* Otherwise the element doesn't have a value yet. */
2171 if (TREE_CODE (ary
) == CONSTRUCTOR
2172 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2174 /* 'ary' is part of the aggregate initializer we're currently
2175 building; if there's no initializer for this element yet,
2178 error ("accessing uninitialized array element");
2179 *non_constant_p
= true;
2183 /* If it's within the array bounds but doesn't have an explicit
2184 initializer, it's value-initialized. */
2185 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2186 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2190 /* Subroutine of cxx_eval_constant_expression.
2191 Attempt to reduce a field access of a value of class type. */
2194 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2196 bool *non_constant_p
, bool *overflow_p
)
2198 unsigned HOST_WIDE_INT i
;
2201 tree part
= TREE_OPERAND (t
, 1);
2202 tree orig_whole
= TREE_OPERAND (t
, 0);
2203 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2205 non_constant_p
, overflow_p
);
2206 if (TREE_CODE (whole
) == INDIRECT_REF
2207 && integer_zerop (TREE_OPERAND (whole
, 0))
2209 error ("dereferencing a null pointer in %qE", orig_whole
);
2211 if (TREE_CODE (whole
) == PTRMEM_CST
)
2212 whole
= cplus_expand_constant (whole
);
2213 if (whole
== orig_whole
)
2216 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2217 whole
, part
, NULL_TREE
);
2218 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2220 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2223 error ("%qE is not a constant expression", orig_whole
);
2224 *non_constant_p
= true;
2226 if (DECL_MUTABLE_P (part
))
2229 error ("mutable %qD is not usable in a constant expression", part
);
2230 *non_constant_p
= true;
2232 if (*non_constant_p
)
2234 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2241 /* We're in the middle of initializing it. */
2245 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2246 && CONSTRUCTOR_NELTS (whole
) > 0)
2248 /* DR 1188 says we don't have to deal with this. */
2250 error ("accessing %qD member instead of initialized %qD member in "
2251 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2252 *non_constant_p
= true;
2256 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2257 classes never get represented; throw together a value now. */
2258 if (is_really_empty_class (TREE_TYPE (t
)))
2259 return build_constructor (TREE_TYPE (t
), NULL
);
2261 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2263 /* 'whole' is part of the aggregate initializer we're currently
2264 building; if there's no initializer for this member yet, that's an
2267 error ("accessing uninitialized member %qD", part
);
2268 *non_constant_p
= true;
2272 /* If there's no explicit init for this field, it's value-initialized. */
2273 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2274 return cxx_eval_constant_expression (ctx
, value
,
2276 non_constant_p
, overflow_p
);
2279 /* Subroutine of cxx_eval_constant_expression.
2280 Attempt to reduce a field access of a value of class type that is
2281 expressed as a BIT_FIELD_REF. */
2284 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2286 bool *non_constant_p
, bool *overflow_p
)
2288 tree orig_whole
= TREE_OPERAND (t
, 0);
2289 tree retval
, fldval
, utype
, mask
;
2290 bool fld_seen
= false;
2291 HOST_WIDE_INT istart
, isize
;
2292 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2294 non_constant_p
, overflow_p
);
2295 tree start
, field
, value
;
2296 unsigned HOST_WIDE_INT i
;
2298 if (whole
== orig_whole
)
2300 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2302 if (!*non_constant_p
2303 && TREE_CODE (whole
) != VECTOR_CST
2304 && TREE_CODE (whole
) != CONSTRUCTOR
)
2307 error ("%qE is not a constant expression", orig_whole
);
2308 *non_constant_p
= true;
2310 if (*non_constant_p
)
2313 if (TREE_CODE (whole
) == VECTOR_CST
)
2314 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2315 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2317 start
= TREE_OPERAND (t
, 2);
2318 istart
= tree_to_shwi (start
);
2319 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2320 utype
= TREE_TYPE (t
);
2321 if (!TYPE_UNSIGNED (utype
))
2322 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2323 retval
= build_int_cst (utype
, 0);
2324 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2326 tree bitpos
= bit_position (field
);
2327 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2329 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2330 && TREE_CODE (value
) == INTEGER_CST
2331 && tree_fits_shwi_p (bitpos
)
2332 && tree_fits_shwi_p (DECL_SIZE (field
)))
2334 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2335 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2336 HOST_WIDE_INT shift
;
2337 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2339 fldval
= fold_convert (utype
, value
);
2340 mask
= build_int_cst_type (utype
, -1);
2341 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2342 size_int (TYPE_PRECISION (utype
) - sz
));
2343 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2344 size_int (TYPE_PRECISION (utype
) - sz
));
2345 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2346 shift
= bit
- istart
;
2347 if (BYTES_BIG_ENDIAN
)
2348 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2349 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2351 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2357 return fold_convert (TREE_TYPE (t
), retval
);
2359 return error_mark_node
;
2362 /* Subroutine of cxx_eval_constant_expression.
2363 Evaluate a short-circuited logical expression T in the context
2364 of a given constexpr CALL. BAILOUT_VALUE is the value for
2365 early return. CONTINUE_VALUE is used here purely for
2366 sanity check purposes. */
2369 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2370 tree bailout_value
, tree continue_value
,
2372 bool *non_constant_p
, bool *overflow_p
)
2375 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2377 non_constant_p
, overflow_p
);
2378 VERIFY_CONSTANT (lhs
);
2379 if (tree_int_cst_equal (lhs
, bailout_value
))
2381 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2382 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2383 lval
, non_constant_p
,
2385 VERIFY_CONSTANT (r
);
2389 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2390 CONSTRUCTOR elements to initialize (part of) an object containing that
2391 field. Return a pointer to the constructor_elt corresponding to the
2392 initialization of the field. */
2394 static constructor_elt
*
2395 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2397 tree aggr
= TREE_OPERAND (ref
, 0);
2398 tree field
= TREE_OPERAND (ref
, 1);
2400 constructor_elt
*ce
;
2402 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2404 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2406 constructor_elt
*base_ce
2407 = base_field_constructor_elt (v
, aggr
);
2408 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2411 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2412 if (ce
->index
== field
)
2419 /* Some of the expressions fed to the constexpr mechanism are calls to
2420 constructors, which have type void. In that case, return the type being
2421 initialized by the constructor. */
2424 initialized_type (tree t
)
2428 tree type
= cv_unqualified (TREE_TYPE (t
));
2429 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2431 /* A constructor call has void type, so we need to look deeper. */
2432 tree fn
= get_function_named_in_call (t
);
2433 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2434 && DECL_CXX_CONSTRUCTOR_P (fn
))
2435 type
= DECL_CONTEXT (fn
);
2440 /* We're about to initialize element INDEX of an array or class from VALUE.
2441 Set up NEW_CTX appropriately by adjusting .object to refer to the
2442 subobject and creating a new CONSTRUCTOR if the element is itself
2443 a class or array. */
2446 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2447 tree index
, tree
&value
)
2451 if (index
&& TREE_CODE (index
) != INTEGER_CST
2452 && TREE_CODE (index
) != FIELD_DECL
)
2453 /* This won't have an element in the new CONSTRUCTOR. */
2456 tree type
= initialized_type (value
);
2457 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2458 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2461 /* The sub-aggregate initializer might contain a placeholder;
2462 update object to refer to the subobject and ctor to refer to
2463 the (newly created) sub-initializer. */
2465 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2466 tree elt
= build_constructor (type
, NULL
);
2467 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2470 if (TREE_CODE (value
) == TARGET_EXPR
)
2471 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2472 value
= TARGET_EXPR_INITIAL (value
);
2475 /* We're about to process an initializer for a class or array TYPE. Make
2476 sure that CTX is set up appropriately. */
2479 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2481 /* We don't bother building a ctor for an empty base subobject. */
2482 if (is_empty_class (type
))
2485 /* We're in the middle of an initializer that might involve placeholders;
2486 our caller should have created a CONSTRUCTOR for us to put the
2487 initializer into. We will either return that constructor or T. */
2488 gcc_assert (ctx
->ctor
);
2489 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2490 (type
, TREE_TYPE (ctx
->ctor
)));
2491 /* We used to check that ctx->ctor was empty, but that isn't the case when
2492 the object is zero-initialized before calling the constructor. */
2494 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2495 (type
, TREE_TYPE (ctx
->object
)));
2496 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2497 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2500 /* Subroutine of cxx_eval_constant_expression.
2501 The expression tree T denotes a C-style array or a C-style
2502 aggregate. Reduce it to a constant expression. */
2505 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2507 bool *non_constant_p
, bool *overflow_p
)
2509 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2510 bool changed
= false;
2511 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2512 tree type
= TREE_TYPE (t
);
2514 constexpr_ctx new_ctx
;
2515 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2517 /* We don't really need the ctx->ctor business for a PMF or
2518 vector, but it's simpler to use the same code. */
2520 new_ctx
.ctor
= build_constructor (type
, NULL
);
2521 new_ctx
.object
= NULL_TREE
;
2524 verify_ctor_sanity (ctx
, type
);
2525 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2526 vec_alloc (*p
, vec_safe_length (v
));
2530 bool constant_p
= true;
2531 bool side_effects_p
= false;
2532 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2534 tree orig_value
= value
;
2535 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2536 if (new_ctx
.ctor
!= ctx
->ctor
)
2537 /* If we built a new CONSTRUCTOR, attach it now so that other
2538 initializers can refer to it. */
2539 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2540 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2542 non_constant_p
, overflow_p
);
2543 /* Don't VERIFY_CONSTANT here. */
2544 if (ctx
->quiet
&& *non_constant_p
)
2546 if (elt
!= orig_value
)
2549 if (!TREE_CONSTANT (elt
))
2551 if (TREE_SIDE_EFFECTS (elt
))
2552 side_effects_p
= true;
2553 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2555 /* This is an initialization of a vfield inside a base
2556 subaggregate that we already initialized; push this
2557 initialization into the previous initialization. */
2558 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2563 && (TREE_CODE (index
) == NOP_EXPR
2564 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2566 /* This is an initializer for an empty base; now that we've
2567 checked that it's constant, we can ignore it. */
2568 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2571 else if (new_ctx
.ctor
!= ctx
->ctor
)
2573 /* We appended this element above; update the value. */
2574 gcc_assert ((*p
)->last().index
== index
);
2575 (*p
)->last().value
= elt
;
2578 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2580 if (*non_constant_p
|| !changed
)
2583 /* We're done building this CONSTRUCTOR, so now we can interpret an
2584 element without an explicit initializer as value-initialized. */
2585 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2586 TREE_CONSTANT (t
) = constant_p
;
2587 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2588 if (VECTOR_TYPE_P (type
))
2593 /* Subroutine of cxx_eval_constant_expression.
2594 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2595 initialization of a non-static data member of array type. Reduce it to a
2598 Note that apart from value-initialization (when VALUE_INIT is true),
2599 this is only intended to support value-initialization and the
2600 initializations done by defaulted constructors for classes with
2601 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2602 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2603 for the copy/move constructor. */
2606 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2607 bool value_init
, bool lval
,
2608 bool *non_constant_p
, bool *overflow_p
)
2610 tree elttype
= TREE_TYPE (atype
);
2611 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2612 verify_ctor_sanity (ctx
, atype
);
2613 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2614 vec_alloc (*p
, max
+ 1);
2615 bool pre_init
= false;
2616 unsigned HOST_WIDE_INT i
;
2618 /* For the default constructor, build up a call to the default
2619 constructor of the element type. We only need to handle class types
2620 here, as for a constructor to be constexpr, all members must be
2621 initialized, which for a defaulted default constructor means they must
2622 be of a class type with a constexpr default constructor. */
2623 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2624 /* We only do this at the lowest level. */;
2625 else if (value_init
)
2627 init
= build_value_init (elttype
, tf_warning_or_error
);
2632 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2633 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2634 &argvec
, elttype
, LOOKUP_NORMAL
,
2635 tf_warning_or_error
);
2636 release_tree_vector (argvec
);
2637 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2641 for (i
= 0; i
< max
; ++i
)
2643 tree idx
= build_int_cst (size_type_node
, i
);
2646 constexpr_ctx new_ctx
;
2647 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2648 if (new_ctx
.ctor
!= ctx
->ctor
)
2649 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2650 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2652 /* A multidimensional array; recurse. */
2653 if (value_init
|| init
== NULL_TREE
)
2655 eltinit
= NULL_TREE
;
2659 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2660 tf_warning_or_error
);
2661 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2663 non_constant_p
, overflow_p
);
2667 /* Initializing an element using value or default initialization
2668 we just pre-built above. */
2669 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2670 non_constant_p
, overflow_p
);
2675 /* Copying an element. */
2676 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2677 (atype
, TREE_TYPE (init
)));
2678 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2679 tf_warning_or_error
);
2680 if (!lvalue_p (init
))
2681 eltinit
= move (eltinit
);
2682 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2683 eltinit
= (cxx_eval_constant_expression
2684 (&new_ctx
, eltinit
, lval
,
2685 non_constant_p
, overflow_p
));
2687 if (*non_constant_p
&& !ctx
->quiet
)
2689 if (new_ctx
.ctor
!= ctx
->ctor
)
2691 /* We appended this element above; update the value. */
2692 gcc_assert ((*p
)->last().index
== idx
);
2693 (*p
)->last().value
= eltinit
;
2696 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2697 /* Reuse the result of cxx_eval_constant_expression call
2698 from the first iteration to all others if it is a constant
2699 initializer that doesn't require relocations. */
2702 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2703 == null_pointer_node
))
2705 if (new_ctx
.ctor
!= ctx
->ctor
)
2706 eltinit
= new_ctx
.ctor
;
2707 for (i
= 1; i
< max
; ++i
)
2709 idx
= build_int_cst (size_type_node
, i
);
2710 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2716 if (!*non_constant_p
)
2719 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2725 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2727 bool *non_constant_p
, bool *overflow_p
)
2729 tree atype
= TREE_TYPE (t
);
2730 tree init
= VEC_INIT_EXPR_INIT (t
);
2731 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2732 VEC_INIT_EXPR_VALUE_INIT (t
),
2733 lval
, non_constant_p
, overflow_p
);
2734 if (*non_constant_p
)
2740 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2741 match. We want to be less strict for simple *& folding; if we have a
2742 non-const temporary that we access through a const pointer, that should
2743 work. We handle this here rather than change fold_indirect_ref_1
2744 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2745 don't really make sense outside of constant expression evaluation. Also
2746 we want to allow folding to COMPONENT_REF, which could cause trouble
2747 with TBAA in fold_indirect_ref_1.
2749 Try to keep this function synced with fold_indirect_ref_1. */
2752 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2758 subtype
= TREE_TYPE (sub
);
2759 if (!POINTER_TYPE_P (subtype
))
2762 if (TREE_CODE (sub
) == ADDR_EXPR
)
2764 tree op
= TREE_OPERAND (sub
, 0);
2765 tree optype
= TREE_TYPE (op
);
2767 /* *&CONST_DECL -> to the value of the const decl. */
2768 if (TREE_CODE (op
) == CONST_DECL
)
2769 return DECL_INITIAL (op
);
2770 /* *&p => p; make sure to handle *&"str"[cst] here. */
2771 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2772 /* Also handle the case where the desired type is an array of unknown
2773 bounds because the variable has had its bounds deduced since the
2774 ADDR_EXPR was created. */
2775 || (TREE_CODE (type
) == ARRAY_TYPE
2776 && TREE_CODE (optype
) == ARRAY_TYPE
2777 && TYPE_DOMAIN (type
) == NULL_TREE
2778 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
2781 tree fop
= fold_read_from_constant_string (op
);
2787 /* *(foo *)&fooarray => fooarray[0] */
2788 else if (TREE_CODE (optype
) == ARRAY_TYPE
2789 && (same_type_ignoring_top_level_qualifiers_p
2790 (type
, TREE_TYPE (optype
))))
2792 tree type_domain
= TYPE_DOMAIN (optype
);
2793 tree min_val
= size_zero_node
;
2794 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2795 min_val
= TYPE_MIN_VALUE (type_domain
);
2796 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2797 NULL_TREE
, NULL_TREE
);
2799 /* *(foo *)&complexfoo => __real__ complexfoo */
2800 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2801 && (same_type_ignoring_top_level_qualifiers_p
2802 (type
, TREE_TYPE (optype
))))
2803 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2804 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2805 else if (VECTOR_TYPE_P (optype
)
2806 && (same_type_ignoring_top_level_qualifiers_p
2807 (type
, TREE_TYPE (optype
))))
2809 tree part_width
= TYPE_SIZE (type
);
2810 tree index
= bitsize_int (0);
2811 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2813 /* Also handle conversion to an empty base class, which
2814 is represented with a NOP_EXPR. */
2815 else if (is_empty_class (type
)
2816 && CLASS_TYPE_P (optype
)
2817 && DERIVED_FROM_P (type
, optype
))
2822 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2823 else if (RECORD_OR_UNION_TYPE_P (optype
))
2825 tree field
= TYPE_FIELDS (optype
);
2826 for (; field
; field
= DECL_CHAIN (field
))
2827 if (TREE_CODE (field
) == FIELD_DECL
2828 && integer_zerop (byte_position (field
))
2829 && (same_type_ignoring_top_level_qualifiers_p
2830 (TREE_TYPE (field
), type
)))
2832 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2837 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2838 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2840 tree op00
= TREE_OPERAND (sub
, 0);
2841 tree op01
= TREE_OPERAND (sub
, 1);
2844 if (TREE_CODE (op00
) == ADDR_EXPR
)
2847 op00
= TREE_OPERAND (op00
, 0);
2848 op00type
= TREE_TYPE (op00
);
2850 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2851 if (VECTOR_TYPE_P (op00type
)
2852 && (same_type_ignoring_top_level_qualifiers_p
2853 (type
, TREE_TYPE (op00type
))))
2855 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2856 tree part_width
= TYPE_SIZE (type
);
2857 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2858 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2859 tree index
= bitsize_int (indexi
);
2861 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2862 return fold_build3_loc (loc
,
2863 BIT_FIELD_REF
, type
, op00
,
2867 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2868 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2869 && (same_type_ignoring_top_level_qualifiers_p
2870 (type
, TREE_TYPE (op00type
))))
2872 tree size
= TYPE_SIZE_UNIT (type
);
2873 if (tree_int_cst_equal (size
, op01
))
2874 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2876 /* ((foo *)&fooarray)[1] => fooarray[1] */
2877 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2878 && (same_type_ignoring_top_level_qualifiers_p
2879 (type
, TREE_TYPE (op00type
))))
2881 tree type_domain
= TYPE_DOMAIN (op00type
);
2882 tree min_val
= size_zero_node
;
2883 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2884 min_val
= TYPE_MIN_VALUE (type_domain
);
2885 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2886 TYPE_SIZE_UNIT (type
));
2887 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2888 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2889 NULL_TREE
, NULL_TREE
);
2891 /* Also handle conversion to an empty base class, which
2892 is represented with a NOP_EXPR. */
2893 else if (is_empty_class (type
)
2894 && CLASS_TYPE_P (op00type
)
2895 && DERIVED_FROM_P (type
, op00type
))
2900 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2901 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2903 tree field
= TYPE_FIELDS (op00type
);
2904 for (; field
; field
= DECL_CHAIN (field
))
2905 if (TREE_CODE (field
) == FIELD_DECL
2906 && tree_int_cst_equal (byte_position (field
), op01
)
2907 && (same_type_ignoring_top_level_qualifiers_p
2908 (TREE_TYPE (field
), type
)))
2910 return fold_build3 (COMPONENT_REF
, type
, op00
,
2917 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2918 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2919 && (same_type_ignoring_top_level_qualifiers_p
2920 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2923 tree min_val
= size_zero_node
;
2924 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2928 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2929 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2930 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2931 min_val
= TYPE_MIN_VALUE (type_domain
);
2932 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2940 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2942 bool *non_constant_p
, bool *overflow_p
)
2944 tree orig_op0
= TREE_OPERAND (t
, 0);
2945 bool empty_base
= false;
2947 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
2948 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
2950 if (TREE_CODE (t
) == MEM_REF
2951 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
2953 gcc_assert (ctx
->quiet
);
2954 *non_constant_p
= true;
2958 /* First try to simplify it directly. */
2959 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
2963 /* If that didn't work, evaluate the operand first. */
2964 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2965 /*lval*/false, non_constant_p
,
2967 /* Don't VERIFY_CONSTANT here. */
2968 if (*non_constant_p
)
2971 if (!lval
&& integer_zerop (op0
))
2974 error ("dereferencing a null pointer");
2975 *non_constant_p
= true;
2979 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2983 /* We couldn't fold to a constant value. Make sure it's not
2984 something we should have been able to fold. */
2987 if (TREE_CODE (sub
) == ADDR_EXPR
)
2989 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2990 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
2991 /* DR 1188 says we don't have to deal with this. */
2993 error ("accessing value of %qE through a %qT glvalue in a "
2994 "constant expression", build_fold_indirect_ref (sub
),
2996 *non_constant_p
= true;
3000 if (lval
&& op0
!= orig_op0
)
3001 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3003 VERIFY_CONSTANT (t
);
3008 r
= cxx_eval_constant_expression (ctx
, r
,
3009 lval
, non_constant_p
, overflow_p
);
3010 if (*non_constant_p
)
3013 /* If we're pulling out the value of an empty base, make sure
3014 that the whole object is constant and then return an empty
3016 if (empty_base
&& !lval
)
3018 VERIFY_CONSTANT (r
);
3019 r
= build_constructor (TREE_TYPE (t
), NULL
);
3020 TREE_CONSTANT (r
) = true;
3026 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3027 Shared between potential_constant_expression and
3028 cxx_eval_constant_expression. */
3031 non_const_var_error (tree r
)
3033 tree type
= TREE_TYPE (r
);
3034 error ("the value of %qD is not usable in a constant "
3036 /* Avoid error cascade. */
3037 if (DECL_INITIAL (r
) == error_mark_node
)
3039 if (DECL_DECLARED_CONSTEXPR_P (r
))
3040 inform (DECL_SOURCE_LOCATION (r
),
3041 "%qD used in its own initializer", r
);
3042 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3044 if (!CP_TYPE_CONST_P (type
))
3045 inform (DECL_SOURCE_LOCATION (r
),
3046 "%q#D is not const", r
);
3047 else if (CP_TYPE_VOLATILE_P (type
))
3048 inform (DECL_SOURCE_LOCATION (r
),
3049 "%q#D is volatile", r
);
3050 else if (!DECL_INITIAL (r
)
3051 || !TREE_CONSTANT (DECL_INITIAL (r
))
3052 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3053 inform (DECL_SOURCE_LOCATION (r
),
3054 "%qD was not initialized with a constant "
3061 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3062 inform (DECL_SOURCE_LOCATION (r
),
3063 "%qD was not declared %<constexpr%>", r
);
3065 inform (DECL_SOURCE_LOCATION (r
),
3066 "%qD does not have integral or enumeration type",
3071 /* Subroutine of cxx_eval_constant_expression.
3072 Like cxx_eval_unary_expression, except for trinary expressions. */
3075 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3077 bool *non_constant_p
, bool *overflow_p
)
3083 for (i
= 0; i
< 3; i
++)
3085 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3087 non_constant_p
, overflow_p
);
3088 VERIFY_CONSTANT (args
[i
]);
3091 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3092 args
[0], args
[1], args
[2]);
3093 if (val
== NULL_TREE
)
3095 VERIFY_CONSTANT (val
);
3100 var_in_constexpr_fn (tree t
)
3102 tree ctx
= DECL_CONTEXT (t
);
3103 return (cxx_dialect
>= cxx14
&& ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3104 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3107 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3110 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3112 bool *non_constant_p
, bool *overflow_p
)
3114 constexpr_ctx new_ctx
= *ctx
;
3116 tree init
= TREE_OPERAND (t
, 1);
3117 if (TREE_CLOBBER_P (init
))
3118 /* Just ignore clobbers. */
3121 /* First we figure out where we're storing to. */
3122 tree target
= TREE_OPERAND (t
, 0);
3123 tree type
= TREE_TYPE (target
);
3124 target
= cxx_eval_constant_expression (ctx
, target
,
3126 non_constant_p
, overflow_p
);
3127 if (*non_constant_p
)
3130 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3132 /* For initialization of an empty base, the original target will be
3133 *(base*)this, which the above evaluation resolves to the object
3134 argument, which has the derived type rather than the base type. In
3135 this situation, just evaluate the initializer and return, since
3136 there's no actual data to store. */
3137 gcc_assert (is_empty_class (type
));
3138 return cxx_eval_constant_expression (ctx
, init
, false,
3139 non_constant_p
, overflow_p
);
3142 /* And then find the underlying variable. */
3143 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3144 tree object
= NULL_TREE
;
3145 for (tree probe
= target
; object
== NULL_TREE
; )
3147 switch (TREE_CODE (probe
))
3152 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3153 vec_safe_push (refs
, TREE_TYPE (probe
));
3154 probe
= TREE_OPERAND (probe
, 0);
3162 /* And then find/build up our initializer for the path to the subobject
3163 we're initializing. */
3165 if (DECL_P (object
))
3166 valp
= ctx
->values
->get (object
);
3171 /* A constant-expression cannot modify objects from outside the
3172 constant-expression. */
3174 error ("modification of %qE is not a constant-expression", object
);
3175 *non_constant_p
= true;
3178 type
= TREE_TYPE (object
);
3179 bool no_zero_init
= true;
3181 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3182 while (!refs
->is_empty())
3184 if (*valp
== NULL_TREE
)
3186 *valp
= build_constructor (type
, NULL
);
3187 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3189 /* If the value of object is already zero-initialized, any new ctors for
3190 subobjects will also be zero-initialized. */
3191 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3193 vec_safe_push (ctors
, *valp
);
3195 enum tree_code code
= TREE_CODE (type
);
3197 tree index
= refs
->pop();
3199 constructor_elt
*cep
= NULL
;
3200 if (code
== ARRAY_TYPE
)
3203 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3204 gcc_assert (i
>= 0);
3205 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3206 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3210 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3212 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3213 Usually we meet initializers in that order, but it is
3214 possible for base types to be placed not in program
3216 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3217 unsigned HOST_WIDE_INT idx
;
3220 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3221 idx
++, fields
= DECL_CHAIN (fields
))
3223 if (index
== cep
->index
)
3226 /* The field we're initializing must be on the field
3227 list. Look to see if it is present before the
3228 field the current ELT initializes. */
3229 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3230 if (index
== fields
)
3234 /* We fell off the end of the CONSTRUCTOR, so insert a new
3235 entry at the end. */
3238 constructor_elt ce
= { index
, NULL_TREE
};
3240 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3241 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3247 release_tree_vector (refs
);
3249 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3251 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3252 wants to modify it. */
3253 if (*valp
== NULL_TREE
)
3255 *valp
= new_ctx
.ctor
= build_constructor (type
, NULL
);
3256 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = no_zero_init
;
3259 new_ctx
.ctor
= *valp
;
3260 new_ctx
.object
= target
;
3263 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3264 non_constant_p
, overflow_p
);
3265 /* Don't share a CONSTRUCTOR that might be changed later. */
3266 init
= unshare_constructor (init
);
3267 if (target
== object
)
3268 /* The hash table might have moved since the get earlier. */
3269 valp
= ctx
->values
->get (object
);
3271 if (TREE_CODE (init
) == CONSTRUCTOR
)
3273 /* An outer ctx->ctor might be pointing to *valp, so replace
3275 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3276 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3277 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3278 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3279 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3284 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3285 CONSTRUCTORs, if any. */
3288 bool c
= TREE_CONSTANT (init
);
3289 bool s
= TREE_SIDE_EFFECTS (init
);
3291 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3294 TREE_CONSTANT (elt
) = false;
3296 TREE_SIDE_EFFECTS (elt
) = true;
3298 release_tree_vector (ctors
);
3300 if (*non_constant_p
)
3308 /* Evaluate a ++ or -- expression. */
3311 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3313 bool *non_constant_p
, bool *overflow_p
)
3315 enum tree_code code
= TREE_CODE (t
);
3316 tree type
= TREE_TYPE (t
);
3317 tree op
= TREE_OPERAND (t
, 0);
3318 tree offset
= TREE_OPERAND (t
, 1);
3319 gcc_assert (TREE_CONSTANT (offset
));
3321 /* The operand as an lvalue. */
3322 op
= cxx_eval_constant_expression (ctx
, op
, true,
3323 non_constant_p
, overflow_p
);
3325 /* The operand as an rvalue. */
3326 tree val
= rvalue (op
);
3327 val
= cxx_eval_constant_expression (ctx
, val
, false,
3328 non_constant_p
, overflow_p
);
3329 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3330 a local array in a constexpr function. */
3331 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3333 VERIFY_CONSTANT (val
);
3335 /* The modified value. */
3336 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3338 if (POINTER_TYPE_P (type
))
3340 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3341 offset
= convert_to_ptrofftype (offset
);
3343 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3344 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3347 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3349 VERIFY_CONSTANT (mod
);
3351 /* Storing the modified value. */
3352 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3353 cxx_eval_constant_expression (ctx
, store
,
3354 true, non_constant_p
, overflow_p
);
3356 /* And the value of the expression. */
3357 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3359 /* Prefix ops are lvalues. */
3363 /* But we optimize when the caller wants an rvalue. */
3367 /* Postfix ops are rvalues. */
3371 /* Predicates for the meaning of *jump_target. */
3374 returns (tree
*jump_target
)
3377 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
3381 breaks (tree
*jump_target
)
3384 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3385 && LABEL_DECL_BREAK (*jump_target
))
3386 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3390 continues (tree
*jump_target
)
3393 && TREE_CODE (*jump_target
) == LABEL_DECL
3394 && LABEL_DECL_CONTINUE (*jump_target
);
3398 switches (tree
*jump_target
)
3401 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3404 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3405 at I matches *jump_target. If we're looking for a case label and we see
3406 the default label, copy I into DEFAULT_LABEL. */
3409 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
3410 tree_stmt_iterator
& default_label
)
3412 tree stmt
= tsi_stmt (i
);
3413 switch (TREE_CODE (*jump_target
))
3416 if (TREE_CODE (stmt
) == LABEL_EXPR
3417 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3422 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3424 if (!CASE_LOW (stmt
))
3426 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3437 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3438 semantics, for switch, break, continue, and return. */
3441 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3442 bool *non_constant_p
, bool *overflow_p
,
3445 tree_stmt_iterator i
;
3446 tree_stmt_iterator default_label
= tree_stmt_iterator();
3448 /* In a statement-expression we want to return the last value. */
3452 local_target
= NULL_TREE
;
3453 jump_target
= &local_target
;
3455 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3458 tree stmt
= tsi_stmt (i
);
3461 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
3462 /* The label we want might be inside. */;
3463 else if (label_matches (jump_target
, i
, default_label
))
3465 *jump_target
= NULL_TREE
;
3469 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3470 non_constant_p
, overflow_p
,
3472 if (*non_constant_p
)
3474 if (returns (jump_target
) || breaks (jump_target
))
3477 if (switches (jump_target
) && !tsi_end_p (default_label
))
3480 *jump_target
= NULL_TREE
;
3486 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3487 semantics; continue semantics are covered by cxx_eval_statement_list. */
3490 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3491 bool *non_constant_p
, bool *overflow_p
,
3494 constexpr_ctx new_ctx
= *ctx
;
3496 tree body
= TREE_OPERAND (t
, 0);
3500 hash_set
<tree
> save_exprs
;
3501 new_ctx
.save_exprs
= &save_exprs
;
3503 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3504 non_constant_p
, overflow_p
, jump_target
);
3506 /* Forget saved values of SAVE_EXPRs. */
3507 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3508 iter
!= save_exprs
.end(); ++iter
)
3509 new_ctx
.values
->remove (*iter
);
3510 if (++count
>= constexpr_loop_limit
)
3513 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3514 "constexpr loop iteration count exceeds limit of %d "
3515 "(use -fconstexpr-loop-limit= to increase the limit)",
3516 constexpr_loop_limit
);
3517 *non_constant_p
= true;
3521 while (!returns (jump_target
) && !breaks (jump_target
) && !*non_constant_p
);
3523 if (breaks (jump_target
))
3524 *jump_target
= NULL_TREE
;
3529 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3533 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3534 bool *non_constant_p
, bool *overflow_p
,
3537 tree cond
= TREE_OPERAND (t
, 0);
3538 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3539 non_constant_p
, overflow_p
);
3540 VERIFY_CONSTANT (cond
);
3541 *jump_target
= cond
;
3543 tree body
= TREE_OPERAND (t
, 1);
3544 cxx_eval_statement_list (ctx
, body
,
3545 non_constant_p
, overflow_p
, jump_target
);
3546 if (breaks (jump_target
) || switches (jump_target
))
3547 *jump_target
= NULL_TREE
;
3551 /* Subroutine of cxx_eval_constant_expression.
3552 Attempt to reduce a POINTER_PLUS_EXPR expression T. */
3555 cxx_eval_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
3556 bool lval
, bool *non_constant_p
,
3559 tree orig_type
= TREE_TYPE (t
);
3560 tree op00
= TREE_OPERAND (t
, 0);
3561 tree op01
= TREE_OPERAND (t
, 1);
3562 location_t loc
= EXPR_LOCATION (t
);
3564 op00
= cxx_eval_constant_expression (ctx
, op00
, lval
,
3565 non_constant_p
, overflow_p
);
3568 if (TREE_CODE (op00
) != ADDR_EXPR
)
3571 op01
= cxx_eval_constant_expression (ctx
, op01
, lval
,
3572 non_constant_p
, overflow_p
);
3573 op00
= TREE_OPERAND (op00
, 0);
3575 /* &A[i] p+ j => &A[i + j] */
3576 if (TREE_CODE (op00
) == ARRAY_REF
3577 && TREE_CODE (TREE_OPERAND (op00
, 1)) == INTEGER_CST
3578 && TREE_CODE (op01
) == INTEGER_CST
3579 && TYPE_SIZE_UNIT (TREE_TYPE (op00
))
3580 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (op00
))) == INTEGER_CST
)
3582 tree type
= TREE_TYPE (op00
);
3583 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (op00
, 1));
3584 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (op00
, 0)));
3585 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
3587 if (*non_constant_p
)
3589 /* Don't fold an out-of-bound access. */
3590 if (!tree_int_cst_le (t
, nelts
))
3592 op01
= cp_fold_convert (ssizetype
, op01
);
3593 /* Don't fold if op01 can't be divided exactly by TYPE_SIZE_UNIT.
3594 constexpr int A[1]; ... (char *)&A[0] + 1 */
3595 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
3596 op01
, TYPE_SIZE_UNIT (type
))))
3598 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
3600 op01
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, op01
,
3601 TYPE_SIZE_UNIT (type
));
3602 t
= size_binop_loc (loc
, PLUS_EXPR
, op01
, t
);
3603 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (op00
, 0),
3604 t
, NULL_TREE
, NULL_TREE
);
3605 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
3606 t
= cp_fold_convert (orig_type
, t
);
3607 return cxx_eval_constant_expression (ctx
, t
, lval
, non_constant_p
,
3614 /* Attempt to reduce the expression T to a constant value.
3615 On failure, issue diagnostic and return error_mark_node. */
3616 /* FIXME unify with c_fully_fold */
3617 /* FIXME overflow_p is too global */
3620 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3622 bool *non_constant_p
, bool *overflow_p
,
3625 constexpr_ctx new_ctx
;
3628 if (t
== error_mark_node
)
3630 *non_constant_p
= true;
3633 if (CONSTANT_CLASS_P (t
))
3635 if (TREE_OVERFLOW (t
))
3638 permerror (input_location
, "overflow in constant expression");
3639 if (!flag_permissive
|| ctx
->quiet
)
3643 if (TREE_CODE (t
) == INTEGER_CST
3644 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
3645 && !integer_zerop (t
))
3648 error ("value %qE of type %qT is not a constant expression",
3650 *non_constant_p
= true;
3656 tree_code tcode
= TREE_CODE (t
);
3662 /* We ask for an rvalue for the RESULT_DECL when indirecting
3663 through an invisible reference, or in named return value
3665 return (*ctx
->values
->get (t
));
3669 /* We used to not check lval for CONST_DECL, but darwin.c uses
3670 CONST_DECL for aggregate constants. */
3674 r
= decl_really_constant_value (t
);
3676 r
= decl_constant_value (t
);
3677 if (TREE_CODE (r
) == TARGET_EXPR
3678 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3679 r
= TARGET_EXPR_INITIAL (r
);
3681 if (tree
*p
= ctx
->values
->get (r
))
3682 if (*p
!= NULL_TREE
)
3687 non_const_var_error (r
);
3688 *non_constant_p
= true;
3696 case CASE_LABEL_EXPR
:
3700 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
3702 else if (tree
*p
= ctx
->values
->get (r
))
3705 /* Defer in case this is only used for its type. */;
3706 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3707 /* Defer, there's no lvalue->rvalue conversion. */;
3708 else if (is_empty_class (TREE_TYPE (t
)))
3710 /* If the class is empty, we aren't actually loading anything. */
3711 r
= build_constructor (TREE_TYPE (t
), NULL
);
3712 TREE_CONSTANT (r
) = true;
3717 error ("%qE is not a constant expression", t
);
3718 *non_constant_p
= true;
3723 case AGGR_INIT_EXPR
:
3724 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3725 non_constant_p
, overflow_p
);
3730 r
= DECL_EXPR_DECL (t
);
3731 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3732 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3736 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3737 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3738 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3742 if (tree init
= DECL_INITIAL (r
))
3744 init
= cxx_eval_constant_expression (ctx
, init
,
3746 non_constant_p
, overflow_p
);
3747 /* Don't share a CONSTRUCTOR that might be changed. */
3748 init
= unshare_constructor (init
);
3749 ctx
->values
->put (r
, init
);
3751 else if (ctx
== &new_ctx
)
3752 /* We gave it a CONSTRUCTOR above. */;
3754 ctx
->values
->put (r
, NULL_TREE
);
3759 if (!literal_type_p (TREE_TYPE (t
)))
3763 error ("temporary of non-literal type %qT in a "
3764 "constant expression", TREE_TYPE (t
));
3765 explain_non_literal_class (TREE_TYPE (t
));
3767 *non_constant_p
= true;
3770 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3772 /* We're being expanded without an explicit target, so start
3773 initializing a new object; expansion with an explicit target
3774 strips the TARGET_EXPR before we get here. */
3776 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3777 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3778 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3779 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3782 /* Pass false for 'lval' because this indicates
3783 initialization of a temporary. */
3784 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3786 non_constant_p
, overflow_p
);
3787 if (!*non_constant_p
)
3788 /* Adjust the type of the result to the type of the temporary. */
3789 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3792 tree slot
= TARGET_EXPR_SLOT (t
);
3793 r
= unshare_constructor (r
);
3794 ctx
->values
->put (slot
, r
);
3801 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3802 non_constant_p
, overflow_p
);
3806 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3808 non_constant_p
, overflow_p
);
3812 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
3813 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3815 non_constant_p
, overflow_p
);
3820 /* Avoid evaluating a SAVE_EXPR more than once. */
3821 if (tree
*p
= ctx
->values
->get (t
))
3825 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3826 non_constant_p
, overflow_p
);
3827 ctx
->values
->put (t
, r
);
3828 if (ctx
->save_exprs
)
3829 ctx
->save_exprs
->add (t
);
3833 case NON_LVALUE_EXPR
:
3834 case TRY_CATCH_EXPR
:
3836 case CLEANUP_POINT_EXPR
:
3837 case MUST_NOT_THROW_EXPR
:
3840 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3842 non_constant_p
, overflow_p
,
3846 case TRY_FINALLY_EXPR
:
3847 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
3848 non_constant_p
, overflow_p
,
3850 if (!*non_constant_p
)
3851 /* Also evaluate the cleanup. */
3852 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
3853 non_constant_p
, overflow_p
,
3857 /* These differ from cxx_eval_unary_expression in that this doesn't
3858 check for a constant operand or result; an address can be
3859 constant without its operand being, and vice versa. */
3862 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3863 non_constant_p
, overflow_p
);
3868 tree oldop
= TREE_OPERAND (t
, 0);
3869 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3871 non_constant_p
, overflow_p
);
3872 /* Don't VERIFY_CONSTANT here. */
3873 if (*non_constant_p
)
3875 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3876 /* This function does more aggressive folding than fold itself. */
3877 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3878 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3887 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
3888 non_constant_p
, overflow_p
);
3889 if (r
== error_mark_node
)
3891 else if (r
== TREE_OPERAND (t
, 0))
3894 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
3899 case FIX_TRUNC_EXPR
:
3904 case TRUTH_NOT_EXPR
:
3905 case FIXED_CONVERT_EXPR
:
3906 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3907 non_constant_p
, overflow_p
);
3911 r
= fold_sizeof_expr (t
);
3912 VERIFY_CONSTANT (r
);
3917 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3918 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3919 introduced by build_call_a. */
3920 tree op0
= TREE_OPERAND (t
, 0);
3921 tree op1
= TREE_OPERAND (t
, 1);
3923 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3924 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3925 r
= cxx_eval_constant_expression (ctx
, op0
,
3926 lval
, non_constant_p
, overflow_p
,
3930 /* Check that the LHS is constant and then discard it. */
3931 cxx_eval_constant_expression (ctx
, op0
,
3932 true, non_constant_p
, overflow_p
,
3934 if (*non_constant_p
)
3936 op1
= TREE_OPERAND (t
, 1);
3937 r
= cxx_eval_constant_expression (ctx
, op1
,
3938 lval
, non_constant_p
, overflow_p
,
3944 case POINTER_PLUS_EXPR
:
3945 r
= cxx_eval_pointer_plus_expression (ctx
, t
, lval
, non_constant_p
,
3949 /* else fall through */
3954 case TRUNC_DIV_EXPR
:
3956 case FLOOR_DIV_EXPR
:
3957 case ROUND_DIV_EXPR
:
3958 case TRUNC_MOD_EXPR
:
3960 case ROUND_MOD_EXPR
:
3962 case EXACT_DIV_EXPR
:
3972 case TRUTH_XOR_EXPR
:
3979 case UNORDERED_EXPR
:
3989 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3990 non_constant_p
, overflow_p
);
3993 /* fold can introduce non-IF versions of these; still treat them as
3994 short-circuiting. */
3995 case TRUTH_AND_EXPR
:
3996 case TRUTH_ANDIF_EXPR
:
3997 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4000 non_constant_p
, overflow_p
);
4004 case TRUTH_ORIF_EXPR
:
4005 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4008 non_constant_p
, overflow_p
);
4012 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4013 non_constant_p
, overflow_p
);
4017 if (is_overloaded_fn (t
))
4019 /* We can only get here in checking mode via
4020 build_non_dependent_expr, because any expression that
4021 calls or takes the address of the function will have
4022 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4023 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4024 *non_constant_p
= true;
4027 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4028 non_constant_p
, overflow_p
);
4032 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4033 non_constant_p
, overflow_p
);
4038 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4039 non_constant_p
, overflow_p
,
4044 if (TREE_CONSTANT (t
))
4046 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4047 VECTOR_CST if applicable. */
4048 /* FIXME after GCC 6 branches, make the verify unconditional. */
4050 verify_constructor_flags (t
);
4052 recompute_constructor_flags (t
);
4053 if (TREE_CONSTANT (t
))
4056 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4057 non_constant_p
, overflow_p
);
4061 /* We can get this in a defaulted constructor for a class with a
4062 non-static data member of array type. Either the initializer will
4063 be NULL, meaning default-initialization, or it will be an lvalue
4064 or xvalue of the same type, meaning direct-initialization from the
4065 corresponding member. */
4066 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4067 non_constant_p
, overflow_p
);
4072 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4073 non_constant_p
, overflow_p
);
4077 case VIEW_CONVERT_EXPR
:
4079 case UNARY_PLUS_EXPR
:
4081 tree oldop
= TREE_OPERAND (t
, 0);
4083 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4085 non_constant_p
, overflow_p
);
4086 if (*non_constant_p
)
4088 tree type
= TREE_TYPE (t
);
4089 if (TREE_CODE (op
) == PTRMEM_CST
4090 && !TYPE_PTRMEM_P (type
))
4091 op
= cplus_expand_constant (op
);
4092 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4094 if (same_type_ignoring_top_level_qualifiers_p (type
,
4100 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4101 "a reinterpret_cast is not a constant-expression");
4102 *non_constant_p
= true;
4107 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4109 if (integer_zerop (op
))
4111 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4114 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4115 "dereferencing a null pointer");
4116 *non_constant_p
= true;
4119 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4121 tree from
= TREE_TYPE (op
);
4123 if (!can_convert (type
, from
, tf_none
))
4126 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4127 "conversion of %qT null pointer to %qT "
4128 "is not a constant expression",
4130 *non_constant_p
= true;
4137 /* This detects for example:
4138 reinterpret_cast<void*>(sizeof 0)
4141 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4142 "%<reinterpret_cast<%T>(%E)%> is not "
4143 "a constant-expression",
4145 *non_constant_p
= true;
4149 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4150 /* We didn't fold at the top so we could check for ptr-int
4153 if (tcode
== UNARY_PLUS_EXPR
)
4154 r
= fold_convert (TREE_TYPE (t
), op
);
4156 r
= fold_build1 (tcode
, type
, op
);
4157 /* Conversion of an out-of-range value has implementation-defined
4158 behavior; the language considers it different from arithmetic
4159 overflow, which is undefined. */
4160 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4161 TREE_OVERFLOW (r
) = false;
4165 case EMPTY_CLASS_EXPR
:
4166 /* This is good enough for a function argument that might not get
4167 used, and they can't do anything with it, so just return it. */
4170 case STATEMENT_LIST
:
4172 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4173 return cxx_eval_statement_list (&new_ctx
, t
,
4174 non_constant_p
, overflow_p
, jump_target
);
4177 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4179 non_constant_p
, overflow_p
,
4182 case PREINCREMENT_EXPR
:
4183 case POSTINCREMENT_EXPR
:
4184 case PREDECREMENT_EXPR
:
4185 case POSTDECREMENT_EXPR
:
4186 return cxx_eval_increment_expression (ctx
, t
,
4187 lval
, non_constant_p
, overflow_p
);
4193 case VEC_DELETE_EXPR
:
4196 /* GCC internal stuff. */
4199 case WITH_CLEANUP_EXPR
:
4200 case NON_DEPENDENT_EXPR
:
4204 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4205 "expression %qE is not a constant-expression", t
);
4206 *non_constant_p
= true;
4209 case PLACEHOLDER_EXPR
:
4210 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
)
4211 || !(same_type_ignoring_top_level_qualifiers_p
4212 (TREE_TYPE (t
), TREE_TYPE (ctx
->ctor
))))
4214 /* A placeholder without a referent. We can get here when
4215 checking whether NSDMIs are noexcept, or in massage_init_elt;
4216 just say it's non-constant for now. */
4217 gcc_assert (ctx
->quiet
);
4218 *non_constant_p
= true;
4223 /* Use of the value or address of the current object. We could
4224 use ctx->object unconditionally, but using ctx->ctor when we
4225 can is a minor optimization. */
4226 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
4227 return cxx_eval_constant_expression
4229 non_constant_p
, overflow_p
);
4235 tree cond
= TREE_OPERAND (t
, 0);
4236 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4237 non_constant_p
, overflow_p
);
4238 VERIFY_CONSTANT (cond
);
4239 if (integer_nonzerop (cond
))
4245 *jump_target
= TREE_OPERAND (t
, 0);
4246 gcc_assert (breaks (jump_target
) || continues (jump_target
));
4250 cxx_eval_loop_expr (ctx
, t
,
4251 non_constant_p
, overflow_p
, jump_target
);
4255 cxx_eval_switch_expr (ctx
, t
,
4256 non_constant_p
, overflow_p
, jump_target
);
4260 /* It's possible to get a requires-expression in a constant
4261 expression. For example:
4263 template<typename T> concept bool C() {
4264 return requires (T t) { t; };
4267 template<typename T> requires !C<T>() void f(T);
4269 Normalization leaves f with the associated constraint
4270 '!requires (T t) { ... }' which is not transformed into
4272 if (!processing_template_decl
)
4273 return evaluate_constraint_expression (t
, NULL_TREE
);
4275 *non_constant_p
= true;
4279 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4281 /* This function doesn't know how to deal with pre-genericize
4282 statements; this can only happen with statement-expressions,
4283 so for now just fail. */
4285 error_at (EXPR_LOCATION (t
),
4286 "statement is not a constant-expression");
4289 internal_error ("unexpected expression %qE of kind %s", t
,
4290 get_tree_code_name (TREE_CODE (t
)));
4291 *non_constant_p
= true;
4295 if (r
== error_mark_node
)
4296 *non_constant_p
= true;
4298 if (*non_constant_p
)
4305 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4306 bool strict
= true, tree object
= NULL_TREE
)
4308 bool non_constant_p
= false;
4309 bool overflow_p
= false;
4310 hash_map
<tree
,tree
> map
;
4312 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
,
4313 allow_non_constant
, strict
};
4315 tree type
= initialized_type (t
);
4317 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4319 /* In C++14 an NSDMI can participate in aggregate initialization,
4320 and can refer to the address of the object being initialized, so
4321 we need to pass in the relevant VAR_DECL if we want to do the
4322 evaluation in a single pass. The evaluation will dynamically
4323 update ctx.values for the VAR_DECL. We use the same strategy
4324 for C++11 constexpr constructors that refer to the object being
4326 ctx
.ctor
= build_constructor (type
, NULL
);
4327 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4330 if (TREE_CODE (t
) == TARGET_EXPR
)
4331 object
= TARGET_EXPR_SLOT (t
);
4332 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4333 object
= AGGR_INIT_EXPR_SLOT (t
);
4335 ctx
.object
= object
;
4337 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4338 (type
, TREE_TYPE (object
)));
4339 if (object
&& DECL_P (object
))
4340 map
.put (object
, ctx
.ctor
);
4341 if (TREE_CODE (r
) == TARGET_EXPR
)
4342 /* Avoid creating another CONSTRUCTOR when we expand the
4344 r
= TARGET_EXPR_INITIAL (r
);
4347 r
= cxx_eval_constant_expression (&ctx
, r
,
4348 false, &non_constant_p
, &overflow_p
);
4350 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4352 /* Mutable logic is a bit tricky: we want to allow initialization of
4353 constexpr variables with mutable members, but we can't copy those
4354 members to another constexpr variable. */
4355 if (TREE_CODE (r
) == CONSTRUCTOR
4356 && CONSTRUCTOR_MUTABLE_POISON (r
))
4358 if (!allow_non_constant
)
4359 error ("%qE is not a constant expression because it refers to "
4360 "mutable subobjects of %qT", t
, type
);
4361 non_constant_p
= true;
4364 /* Technically we should check this for all subexpressions, but that
4365 runs into problems with our internal representation of pointer
4366 subtraction and the 5.19 rules are still in flux. */
4367 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4368 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4369 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4371 if (!allow_non_constant
)
4372 error ("conversion from pointer type %qT "
4373 "to arithmetic type %qT in a constant-expression",
4374 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4375 non_constant_p
= true;
4378 if (!non_constant_p
&& overflow_p
)
4379 non_constant_p
= true;
4381 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4383 bool should_unshare
= true;
4384 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4385 should_unshare
= false;
4387 if (non_constant_p
&& !allow_non_constant
)
4388 return error_mark_node
;
4389 else if (non_constant_p
&& TREE_CONSTANT (r
))
4391 /* This isn't actually constant, so unset TREE_CONSTANT. */
4394 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4395 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4397 r
= build_nop (TREE_TYPE (r
), r
);
4398 TREE_CONSTANT (r
) = false;
4400 else if (non_constant_p
|| r
== t
)
4404 r
= unshare_expr (r
);
4406 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4408 if (TREE_CODE (t
) == TARGET_EXPR
4409 && TARGET_EXPR_INITIAL (t
) == r
)
4413 r
= get_target_expr (r
);
4414 TREE_CONSTANT (r
) = true;
4422 /* Returns true if T is a valid subexpression of a constant expression,
4423 even if it isn't itself a constant expression. */
4426 is_sub_constant_expr (tree t
)
4428 bool non_constant_p
= false;
4429 bool overflow_p
= false;
4430 hash_map
<tree
, tree
> map
;
4432 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, true, true };
4434 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4436 return !non_constant_p
&& !overflow_p
;
4439 /* If T represents a constant expression returns its reduced value.
4440 Otherwise return error_mark_node. If T is dependent, then
4444 cxx_constant_value (tree t
, tree decl
)
4446 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4449 /* Helper routine for fold_simple function. Either return simplified
4450 expression T, otherwise NULL_TREE.
4451 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4452 even if we are within template-declaration. So be careful on call, as in
4453 such case types can be undefined. */
4456 fold_simple_1 (tree t
)
4459 enum tree_code code
= TREE_CODE (t
);
4471 return fold_sizeof_expr (t
);
4479 case TRUTH_NOT_EXPR
:
4481 case VIEW_CONVERT_EXPR
:
4484 case FIX_TRUNC_EXPR
:
4485 case FIXED_CONVERT_EXPR
:
4486 case ADDR_SPACE_CONVERT_EXPR
:
4488 op1
= TREE_OPERAND (t
, 0);
4490 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4494 if (CONVERT_EXPR_CODE_P (code
)
4495 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4496 TREE_OVERFLOW (t
) = false;
4504 /* If T is a simple constant expression, returns its simplified value.
4505 Otherwise returns T. In contrast to maybe_constant_value do we
4506 simplify only few operations on constant-expressions, and we don't
4507 try to simplify constexpressions. */
4510 fold_simple (tree t
)
4513 if (processing_template_decl
)
4516 r
= fold_simple_1 (t
);
4523 /* If T is a constant expression, returns its reduced value.
4524 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4525 Otherwise, returns a version of T without TREE_CONSTANT. */
4528 maybe_constant_value_1 (tree t
, tree decl
)
4532 if (!potential_nondependent_constant_expression (t
))
4534 if (TREE_OVERFLOW_P (t
))
4536 t
= build_nop (TREE_TYPE (t
), t
);
4537 TREE_CONSTANT (t
) = false;
4542 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4543 gcc_checking_assert (r
== t
4544 || CONVERT_EXPR_P (t
)
4545 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4546 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4547 || !cp_tree_equal (r
, t
));
4551 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4553 /* If T is a constant expression, returns its reduced value.
4554 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4555 Otherwise, returns a version of T without TREE_CONSTANT. */
4558 maybe_constant_value (tree t
, tree decl
)
4560 if (cv_cache
== NULL
)
4561 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4563 if (tree
*cached
= cv_cache
->get (t
))
4566 tree ret
= maybe_constant_value_1 (t
, decl
);
4567 cv_cache
->put (t
, ret
);
4571 /* Dispose of the whole CV_CACHE. */
4574 clear_cv_cache (void)
4576 if (cv_cache
!= NULL
)
4580 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4583 clear_cv_and_fold_caches (void)
4586 clear_fold_cache ();
4589 /* Like maybe_constant_value but first fully instantiate the argument.
4591 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4592 (t, tf_none) followed by maybe_constant_value but is more efficient,
4593 because calls instantiation_dependent_expression_p and
4594 potential_constant_expression at most once. */
4597 fold_non_dependent_expr (tree t
)
4602 /* If we're in a template, but T isn't value dependent, simplify
4603 it. We're supposed to treat:
4605 template <typename T> void f(T[1 + 1]);
4606 template <typename T> void f(T[2]);
4608 as two declarations of the same function, for example. */
4609 if (processing_template_decl
)
4611 if (potential_nondependent_constant_expression (t
))
4613 processing_template_decl_sentinel s
;
4614 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4616 if (type_unknown_p (t
)
4617 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4619 if (TREE_OVERFLOW_P (t
))
4621 t
= build_nop (TREE_TYPE (t
), t
);
4622 TREE_CONSTANT (t
) = false;
4627 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4628 /* cp_tree_equal looks through NOPs, so allow them. */
4629 gcc_checking_assert (r
== t
4630 || CONVERT_EXPR_P (t
)
4631 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4632 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4633 || !cp_tree_equal (r
, t
));
4636 else if (TREE_OVERFLOW_P (t
))
4638 t
= build_nop (TREE_TYPE (t
), t
);
4639 TREE_CONSTANT (t
) = false;
4644 return maybe_constant_value (t
);
4647 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4648 than wrapped in a TARGET_EXPR. */
4651 maybe_constant_init (tree t
, tree decl
)
4655 if (TREE_CODE (t
) == EXPR_STMT
)
4656 t
= TREE_OPERAND (t
, 0);
4657 if (TREE_CODE (t
) == CONVERT_EXPR
4658 && VOID_TYPE_P (TREE_TYPE (t
)))
4659 t
= TREE_OPERAND (t
, 0);
4660 if (TREE_CODE (t
) == INIT_EXPR
)
4661 t
= TREE_OPERAND (t
, 1);
4662 if (!potential_nondependent_static_init_expression (t
))
4663 /* Don't try to evaluate it. */;
4665 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
4666 if (TREE_CODE (t
) == TARGET_EXPR
)
4668 tree init
= TARGET_EXPR_INITIAL (t
);
4669 if (TREE_CODE (init
) == CONSTRUCTOR
)
4676 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
4677 /* Return true if the object referred to by REF has automatic or thread
4680 enum { ck_ok
, ck_bad
, ck_unknown
};
4682 check_automatic_or_tls (tree ref
)
4685 HOST_WIDE_INT bitsize
, bitpos
;
4687 int volatilep
= 0, unsignedp
= 0;
4688 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
4689 &mode
, &unsignedp
, &volatilep
, false);
4692 /* If there isn't a decl in the middle, we don't know the linkage here,
4693 and this isn't a constant expression anyway. */
4696 dk
= decl_storage_duration (decl
);
4697 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
4701 /* Return true if T denotes a potentially constant expression. Issue
4702 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
4703 an lvalue-rvalue conversion is implied.
4705 C++0x [expr.const] used to say
4707 6 An expression is a potential constant expression if it is
4708 a constant expression where all occurrences of function
4709 parameters are replaced by arbitrary constant expressions
4710 of the appropriate type.
4712 2 A conditional expression is a constant expression unless it
4713 involves one of the following as a potentially evaluated
4714 subexpression (3.2), but subexpressions of logical AND (5.14),
4715 logical OR (5.15), and conditional (5.16) operations that are
4716 not evaluated are not considered. */
4719 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
4720 tsubst_flags_t flags
)
4722 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
4723 enum { any
= false, rval
= true };
4727 if (t
== error_mark_node
)
4731 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
4733 if (flags
& tf_error
)
4734 error ("expression %qE has side-effects", t
);
4737 if (CONSTANT_CLASS_P (t
))
4740 switch (TREE_CODE (t
))
4746 case TEMPLATE_ID_EXPR
:
4749 case CASE_LABEL_EXPR
:
4755 case TEMPLATE_PARM_INDEX
:
4757 case IDENTIFIER_NODE
:
4758 case USERDEF_LITERAL
:
4759 /* We can see a FIELD_DECL in a pointer-to-member expression. */
4765 case PLACEHOLDER_EXPR
:
4771 case AGGR_INIT_EXPR
:
4773 /* -- an invocation of a function other than a constexpr function
4774 or a constexpr constructor. */
4776 tree fun
= get_function_named_in_call (t
);
4777 const int nargs
= call_expr_nargs (t
);
4780 if (fun
== NULL_TREE
)
4782 /* Reset to allow the function to continue past the end
4783 of the block below. Otherwise return early. */
4786 if (TREE_CODE (t
) == CALL_EXPR
4787 && CALL_EXPR_FN (t
) == NULL_TREE
)
4788 switch (CALL_EXPR_IFN (t
))
4790 /* These should be ignored, they are optimized away from
4791 constexpr functions. */
4792 case IFN_UBSAN_NULL
:
4793 case IFN_UBSAN_BOUNDS
:
4794 case IFN_UBSAN_VPTR
:
4797 case IFN_ADD_OVERFLOW
:
4798 case IFN_SUB_OVERFLOW
:
4799 case IFN_MUL_OVERFLOW
:
4808 /* fold_call_expr can't do anything with IFN calls. */
4809 if (flags
& tf_error
)
4810 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4811 "call to internal function %qE", t
);
4816 if (fun
&& is_overloaded_fn (fun
))
4818 if (TREE_CODE (fun
) == FUNCTION_DECL
)
4820 if (builtin_valid_in_constant_expr_p (fun
))
4822 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
4823 /* Allow any built-in function; if the expansion
4824 isn't constant, we'll deal with that then. */
4825 && !is_builtin_fn (fun
))
4827 if (flags
& tf_error
)
4829 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4830 "call to non-constexpr function %qD", fun
);
4831 explain_invalid_constexpr_fn (fun
);
4835 /* A call to a non-static member function takes the address
4836 of the object as the first argument. But in a constant
4837 expression the address will be folded away, so look
4839 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
4840 && !DECL_CONSTRUCTOR_P (fun
))
4842 tree x
= get_nth_callarg (t
, 0);
4843 if (is_this_parameter (x
))
4845 else if (!RECUR (x
, rval
))
4852 if (!RECUR (fun
, true))
4854 fun
= get_first_fn (fun
);
4856 /* Skip initial arguments to base constructors. */
4857 if (DECL_BASE_CONSTRUCTOR_P (fun
))
4858 i
= num_artificial_parms_for (fun
);
4859 fun
= DECL_ORIGIN (fun
);
4863 if (RECUR (fun
, rval
))
4864 /* Might end up being a constant function pointer. */;
4868 for (; i
< nargs
; ++i
)
4870 tree x
= get_nth_callarg (t
, i
);
4871 /* In a template, reference arguments haven't been converted to
4872 REFERENCE_TYPE and we might not even know if the parameter
4873 is a reference, so accept lvalue constants too. */
4874 bool rv
= processing_template_decl
? any
: rval
;
4881 case NON_LVALUE_EXPR
:
4882 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
4883 -- an lvalue of integral type that refers to a non-volatile
4884 const variable or static data member initialized with
4885 constant expressions, or
4887 -- an lvalue of literal type that refers to non-volatile
4888 object defined with constexpr, or that refers to a
4889 sub-object of such an object; */
4890 return RECUR (TREE_OPERAND (t
, 0), rval
);
4894 && !decl_constant_var_p (t
)
4896 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
4897 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
4898 && !var_in_constexpr_fn (t
)
4899 && !type_dependent_expression_p (t
))
4901 if (flags
& tf_error
)
4902 non_const_var_error (t
);
4909 case VIEW_CONVERT_EXPR
:
4910 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4911 may change to something more specific to type-punning (DR 1312). */
4913 tree from
= TREE_OPERAND (t
, 0);
4914 if (POINTER_TYPE_P (TREE_TYPE (t
))
4915 && TREE_CODE (from
) == INTEGER_CST
4916 && !integer_zerop (from
))
4918 if (flags
& tf_error
)
4919 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4920 "reinterpret_cast from integer to pointer");
4923 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
4927 /* -- a unary operator & that is applied to an lvalue that
4928 designates an object with thread or automatic storage
4930 t
= TREE_OPERAND (t
, 0);
4932 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
4933 /* A pointer-to-member constant. */
4937 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4938 any checking here, as we might dereference the pointer later. If
4939 we remove this code, also remove check_automatic_or_tls. */
4940 i
= check_automatic_or_tls (t
);
4945 if (flags
& tf_error
)
4946 error ("address-of an object %qE with thread local or "
4947 "automatic storage is not a constant expression", t
);
4951 return RECUR (t
, any
);
4957 /* -- a class member access unless its postfix-expression is
4958 of literal type or of pointer to literal type. */
4959 /* This test would be redundant, as it follows from the
4960 postfix-expression being a potential constant expression. */
4961 if (type_unknown_p (t
))
4963 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4965 case EXPR_PACK_EXPANSION
:
4966 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
4970 tree x
= TREE_OPERAND (t
, 0);
4972 if (is_this_parameter (x
))
4974 if (DECL_CONTEXT (x
)
4975 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4977 if (flags
& tf_error
)
4978 error ("use of %<this%> in a constant expression");
4983 return RECUR (x
, rval
);
4986 case STATEMENT_LIST
:
4988 tree_stmt_iterator i
;
4989 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4991 if (!RECUR (tsi_stmt (i
), any
))
4999 if (cxx_dialect
< cxx14
)
5001 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5003 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5008 if (cxx_dialect
< cxx14
)
5010 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5012 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5017 if (!RECUR (DO_COND (t
), rval
))
5019 if (!RECUR (DO_BODY (t
), any
))
5024 if (!RECUR (FOR_INIT_STMT (t
), any
))
5026 if (!RECUR (FOR_COND (t
), rval
))
5028 if (!RECUR (FOR_EXPR (t
), any
))
5030 if (!RECUR (FOR_BODY (t
), any
))
5035 if (!RECUR (WHILE_COND (t
), rval
))
5037 if (!RECUR (WHILE_BODY (t
), any
))
5042 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5044 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5045 unreachable labels would be checked. */
5049 return RECUR (STMT_EXPR_STMT (t
), rval
);
5052 case DYNAMIC_CAST_EXPR
:
5053 case PSEUDO_DTOR_EXPR
:
5057 case VEC_DELETE_EXPR
:
5060 case OMP_ATOMIC_READ
:
5061 case OMP_ATOMIC_CAPTURE_OLD
:
5062 case OMP_ATOMIC_CAPTURE_NEW
:
5063 /* GCC internal stuff. */
5066 case TRANSACTION_EXPR
:
5068 case AT_ENCODE_EXPR
:
5070 if (flags
& tf_error
)
5071 error ("expression %qE is not a constant-expression", t
);
5075 /* -- a typeid expression whose operand is of polymorphic
5078 tree e
= TREE_OPERAND (t
, 0);
5079 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5080 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5082 if (flags
& tf_error
)
5083 error ("typeid-expression is not a constant expression "
5084 "because %qE is of polymorphic type", e
);
5103 case PREINCREMENT_EXPR
:
5104 case POSTINCREMENT_EXPR
:
5105 case PREDECREMENT_EXPR
:
5106 case POSTDECREMENT_EXPR
:
5107 if (cxx_dialect
< cxx14
)
5113 if (TYPE_P (TREE_OPERAND (t
, 0)))
5115 /* else fall through. */
5121 case FIX_TRUNC_EXPR
:
5125 case TRUTH_NOT_EXPR
:
5126 case FIXED_CONVERT_EXPR
:
5127 case UNARY_PLUS_EXPR
:
5128 case UNARY_LEFT_FOLD_EXPR
:
5129 case UNARY_RIGHT_FOLD_EXPR
:
5131 return RECUR (TREE_OPERAND (t
, 0), rval
);
5134 case CONST_CAST_EXPR
:
5135 case STATIC_CAST_EXPR
:
5136 case REINTERPRET_CAST_EXPR
:
5137 case IMPLICIT_CONV_EXPR
:
5138 if (cxx_dialect
< cxx11
5139 && !dependent_type_p (TREE_TYPE (t
))
5140 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5141 /* In C++98, a conversion to non-integral type can't be part of a
5142 constant expression. */
5144 if (flags
& tf_error
)
5145 error ("cast to non-integral type %qT in a constant expression",
5150 return (RECUR (TREE_OPERAND (t
, 0),
5151 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5154 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5156 case WITH_CLEANUP_EXPR
:
5157 case CLEANUP_POINT_EXPR
:
5158 case MUST_NOT_THROW_EXPR
:
5159 case TRY_CATCH_EXPR
:
5165 case NON_DEPENDENT_EXPR
:
5166 /* For convenience. */
5170 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5172 case TRY_FINALLY_EXPR
:
5173 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5174 && RECUR (TREE_OPERAND (t
, 1), any
));
5177 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5180 if (!literal_type_p (TREE_TYPE (t
)))
5182 if (flags
& tf_error
)
5184 error ("temporary of non-literal type %qT in a "
5185 "constant expression", TREE_TYPE (t
));
5186 explain_non_literal_class (TREE_TYPE (t
));
5191 return RECUR (TREE_OPERAND (t
, 1), rval
);
5195 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5196 constructor_elt
*ce
;
5197 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5198 if (!RECUR (ce
->value
, want_rval
))
5205 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5206 || DECL_P (TREE_PURPOSE (t
)));
5207 if (!RECUR (TREE_VALUE (t
), want_rval
))
5209 if (TREE_CHAIN (t
) == NULL_TREE
)
5211 return RECUR (TREE_CHAIN (t
), want_rval
);
5214 case TRUNC_DIV_EXPR
:
5216 case FLOOR_DIV_EXPR
:
5217 case ROUND_DIV_EXPR
:
5218 case TRUNC_MOD_EXPR
:
5220 case ROUND_MOD_EXPR
:
5222 tree denom
= TREE_OPERAND (t
, 1);
5223 if (!RECUR (denom
, rval
))
5225 /* We can't call cxx_eval_outermost_constant_expr on an expression
5226 that hasn't been through instantiate_non_dependent_expr yet. */
5227 if (!processing_template_decl
)
5228 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5229 if (integer_zerop (denom
))
5231 if (flags
& tf_error
)
5232 error ("division by zero is not a constant-expression");
5238 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5244 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5245 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5246 introduced by build_call_a. */
5247 tree op0
= TREE_OPERAND (t
, 0);
5248 tree op1
= TREE_OPERAND (t
, 1);
5250 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5251 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5252 return RECUR (op0
, want_rval
);
5257 /* If the first operand is the non-short-circuit constant, look at
5258 the second operand; otherwise we only care about the first one for
5260 case TRUTH_AND_EXPR
:
5261 case TRUTH_ANDIF_EXPR
:
5262 tmp
= boolean_true_node
;
5265 case TRUTH_ORIF_EXPR
:
5266 tmp
= boolean_false_node
;
5269 tree op
= TREE_OPERAND (t
, 0);
5270 if (!RECUR (op
, rval
))
5272 if (!processing_template_decl
)
5273 op
= cxx_eval_outermost_constant_expr (op
, true);
5274 if (tree_int_cst_equal (op
, tmp
))
5275 return RECUR (TREE_OPERAND (t
, 1), rval
);
5282 case POINTER_PLUS_EXPR
:
5284 case EXACT_DIV_EXPR
:
5294 case TRUTH_XOR_EXPR
:
5295 case UNORDERED_EXPR
:
5308 case ARRAY_RANGE_REF
:
5312 case BINARY_LEFT_FOLD_EXPR
:
5313 case BINARY_RIGHT_FOLD_EXPR
:
5315 for (i
= 0; i
< 2; ++i
)
5316 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5320 case CILK_SYNC_STMT
:
5321 case CILK_SPAWN_STMT
:
5322 case ARRAY_NOTATION_REF
:
5327 for (i
= 0; i
< 3; ++i
)
5328 if (!RECUR (TREE_OPERAND (t
, i
), true))
5333 if (COND_EXPR_IS_VEC_DELETE (t
))
5335 if (flags
& tf_error
)
5336 error_at (location_of (t
),
5337 "%<delete[]%> is not a constant-expression");
5343 /* If the condition is a known constant, we know which of the legs we
5344 care about; otherwise we only require that the condition and
5345 either of the legs be potentially constant. */
5346 tmp
= TREE_OPERAND (t
, 0);
5347 if (!RECUR (tmp
, rval
))
5349 if (!processing_template_decl
)
5350 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5351 if (integer_zerop (tmp
))
5352 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5353 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5354 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5355 for (i
= 1; i
< 3; ++i
)
5356 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5357 want_rval
, strict
, tf_none
))
5359 if (flags
& tf_error
)
5360 error ("expression %qE is not a constant-expression", t
);
5364 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5366 if (flags
& tf_error
)
5368 error ("non-constant array initialization");
5369 diagnose_non_constexpr_vec_init (t
);
5375 /* We can see these in statement-expressions. */
5378 case EMPTY_CLASS_EXPR
:
5383 tree
*target
= &TREE_OPERAND (t
, 0);
5384 /* Gotos representing break and continue are OK. */
5385 if (breaks (target
) || continues (target
))
5387 if (flags
& tf_error
)
5388 error ("%<goto%> is not a constant-expression");
5393 if (objc_is_property_ref (t
))
5396 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5403 /* The main entry point to the above. */
5406 potential_constant_expression (tree t
)
5408 return potential_constant_expression_1 (t
, false, true, tf_none
);
5412 potential_static_init_expression (tree t
)
5414 return potential_constant_expression_1 (t
, false, false, tf_none
);
5417 /* As above, but require a constant rvalue. */
5420 potential_rvalue_constant_expression (tree t
)
5422 return potential_constant_expression_1 (t
, true, true, tf_none
);
5425 /* Like above, but complain about non-constant expressions. */
5428 require_potential_constant_expression (tree t
)
5430 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
5433 /* Cross product of the above. */
5436 require_potential_rvalue_constant_expression (tree t
)
5438 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
5441 /* Returns true if T is a potential constant expression that is not
5442 instantiation-dependent, and therefore a candidate for constant folding even
5446 potential_nondependent_constant_expression (tree t
)
5448 return (!type_unknown_p (t
)
5449 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5450 && potential_constant_expression (t
)
5451 && !instantiation_dependent_expression_p (t
));
5454 /* Returns true if T is a potential static initializer expression that is not
5455 instantiation-dependent. */
5458 potential_nondependent_static_init_expression (tree t
)
5460 return (!type_unknown_p (t
)
5461 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5462 && potential_static_init_expression (t
)
5463 && !instantiation_dependent_expression_p (t
));
5466 /* Finalize constexpr processing after parsing. */
5469 fini_constexpr (void)
5471 /* The contexpr call and fundef copies tables are no longer needed. */
5472 constexpr_call_table
= NULL
;
5473 fundef_copies_table
= NULL
;
5476 #include "gt-cp-constexpr.h"