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, lambdas, or instantiations. */
836 if (!DECL_DEFAULTED_FN (fun
)
837 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
))
838 && !is_instantiation_of_constexpr (fun
))
840 if (diagnosed
== NULL
)
841 diagnosed
= new hash_set
<tree
>;
842 if (diagnosed
->add (fun
))
843 /* Already explained. */
846 save_loc
= input_location
;
847 if (!lambda_static_thunk_p (fun
))
849 /* Diagnostics should completely ignore the static thunk, so leave
850 input_location set to our caller's location. */
851 input_location
= DECL_SOURCE_LOCATION (fun
);
852 inform (input_location
,
853 "%qD is not usable as a constexpr function because:", fun
);
855 /* First check the declaration. */
856 if (is_valid_constexpr_fn (fun
, true))
858 /* Then if it's OK, the body. */
859 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
860 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun
)))
861 explain_implicit_non_constexpr (fun
);
864 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
865 require_potential_rvalue_constant_expression (body
);
866 if (DECL_CONSTRUCTOR_P (fun
))
867 cx_check_missing_mem_inits (fun
, body
, true);
870 input_location
= save_loc
;
873 /* Objects of this type represent calls to constexpr functions
874 along with the bindings of parameters to their arguments, for
875 the purpose of compile time evaluation. */
877 struct GTY((for_user
)) constexpr_call
{
878 /* Description of the constexpr function definition. */
879 constexpr_fundef
*fundef
;
880 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
881 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
882 Note: This arrangement is made to accommodate the use of
883 iterative_hash_template_arg (see pt.c). If you change this
884 representation, also change the hash calculation in
885 cxx_eval_call_expression. */
887 /* Result of the call.
888 NULL means the call is being evaluated.
889 error_mark_node means that the evaluation was erroneous;
890 otherwise, the actuall value of the call. */
892 /* The hash of this call; we remember it here to avoid having to
893 recalculate it when expanding the hash table. */
897 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
899 static hashval_t
hash (constexpr_call
*);
900 static bool equal (constexpr_call
*, constexpr_call
*);
903 /* The constexpr expansion context. CALL is the current function
904 expansion, CTOR is the current aggregate initializer, OBJECT is the
905 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
906 is a map of values of variables initialized within the expression. */
908 struct constexpr_ctx
{
909 /* The innermost call we're evaluating. */
910 constexpr_call
*call
;
911 /* Values for any temporaries or local variables within the
912 constant-expression. */
913 hash_map
<tree
,tree
> *values
;
914 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
915 aren't inside a loop. */
916 hash_set
<tree
> *save_exprs
;
917 /* The CONSTRUCTOR we're currently building up for an aggregate
920 /* The object we're building the CONSTRUCTOR for. */
922 /* Whether we should error on a non-constant expression or fail quietly. */
924 /* Whether we are strictly conforming to constant expression rules or
925 trying harder to get a constant value. */
929 /* A table of all constexpr calls that have been evaluated by the
930 compiler in this translation unit. */
932 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
934 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
935 bool, bool *, bool *, tree
* = NULL
);
937 /* Compute a hash value for a constexpr call representation. */
940 constexpr_call_hasher::hash (constexpr_call
*info
)
945 /* Return true if the objects pointed to by P and Q represent calls
946 to the same constexpr function with the same arguments.
947 Otherwise, return false. */
950 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
956 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
958 lhs_bindings
= lhs
->bindings
;
959 rhs_bindings
= rhs
->bindings
;
960 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
962 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
963 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
964 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
965 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
967 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
968 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
970 return lhs_bindings
== rhs_bindings
;
973 /* Initialize the constexpr call table, if needed. */
976 maybe_initialize_constexpr_call_table (void)
978 if (constexpr_call_table
== NULL
)
979 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
982 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
983 a function happens to get called recursively, we unshare the callee
984 function's body and evaluate this unshared copy instead of evaluating the
987 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
988 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
989 that's keyed off of the original FUNCTION_DECL and whose value is a
990 TREE_LIST of this function's unused copies awaiting reuse.
992 This is not GC-deletable to avoid GC affecting UID generation. */
994 static GTY(()) hash_map
<tree
, tree
> *fundef_copies_table
;
996 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
999 maybe_initialize_fundef_copies_table ()
1001 if (fundef_copies_table
== NULL
)
1002 fundef_copies_table
= hash_map
<tree
,tree
>::create_ggc (101);
1005 /* Reuse a copy or create a new unshared copy of the function FUN.
1006 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1007 is parms, TYPE is result. */
1010 get_fundef_copy (tree fun
)
1012 maybe_initialize_fundef_copies_table ();
1016 tree
*slot
= &fundef_copies_table
->get_or_insert (fun
, &existed
);
1020 /* There is no cached function available, or in use. We can use
1021 the function directly. That the slot is now created records
1022 that this function is now in use. */
1023 copy
= build_tree_list (DECL_SAVED_TREE (fun
), DECL_ARGUMENTS (fun
));
1024 TREE_TYPE (copy
) = DECL_RESULT (fun
);
1026 else if (*slot
== NULL_TREE
)
1028 /* We've already used the function itself, so make a copy. */
1029 copy
= build_tree_list (NULL
, NULL
);
1030 TREE_PURPOSE (copy
) = copy_fn (fun
, TREE_VALUE (copy
), TREE_TYPE (copy
));
1034 /* We have a cached function available. */
1036 *slot
= TREE_CHAIN (copy
);
1042 /* Save the copy COPY of function FUN for later reuse by
1043 get_fundef_copy(). By construction, there will always be an entry
1047 save_fundef_copy (tree fun
, tree copy
)
1049 tree
*slot
= fundef_copies_table
->get (fun
);
1050 TREE_CHAIN (copy
) = *slot
;
1054 /* We have an expression tree T that represents a call, either CALL_EXPR
1055 or AGGR_INIT_EXPR. If the call is lexically to a named function,
1056 retrun the _DECL for that function. */
1059 get_function_named_in_call (tree t
)
1061 tree fun
= cp_get_callee (t
);
1062 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
1063 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
1064 fun
= TREE_OPERAND (fun
, 0);
1068 /* We have an expression tree T that represents a call, either CALL_EXPR
1069 or AGGR_INIT_EXPR. Return the Nth argument. */
1072 get_nth_callarg (tree t
, int n
)
1074 switch (TREE_CODE (t
))
1077 return CALL_EXPR_ARG (t
, n
);
1079 case AGGR_INIT_EXPR
:
1080 return AGGR_INIT_EXPR_ARG (t
, n
);
1088 /* Attempt to evaluate T which represents a call to a builtin function.
1089 We assume here that all builtin functions evaluate to scalar types
1090 represented by _CST nodes. */
1093 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1095 bool *non_constant_p
, bool *overflow_p
)
1097 const int nargs
= call_expr_nargs (t
);
1098 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1102 /* Don't fold __builtin_constant_p within a constexpr function. */
1103 bool bi_const_p
= (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
);
1106 && current_function_decl
1107 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1109 *non_constant_p
= true;
1113 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1114 return constant false for a non-constant argument. */
1115 constexpr_ctx new_ctx
= *ctx
;
1116 new_ctx
.quiet
= true;
1117 bool dummy1
= false, dummy2
= false;
1118 for (i
= 0; i
< nargs
; ++i
)
1120 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1121 false, &dummy1
, &dummy2
);
1123 /* For __built_in_constant_p, fold all expressions with constant values
1124 even if they aren't C++ constant-expressions. */
1125 args
[i
] = cp_fully_fold (args
[i
]);
1128 bool save_ffbcp
= force_folding_builtin_constant_p
;
1129 force_folding_builtin_constant_p
= true;
1130 new_call
= fold_builtin_call_array (EXPR_LOCATION (t
), TREE_TYPE (t
),
1131 CALL_EXPR_FN (t
), nargs
, args
);
1132 force_folding_builtin_constant_p
= save_ffbcp
;
1133 if (new_call
== NULL
)
1135 if (!*non_constant_p
&& !ctx
->quiet
)
1137 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1138 CALL_EXPR_FN (t
), nargs
, args
);
1139 error ("%q+E is not a constant expression", new_call
);
1141 *non_constant_p
= true;
1145 if (!potential_constant_expression (new_call
))
1147 if (!*non_constant_p
&& !ctx
->quiet
)
1148 error ("%q+E is not a constant expression", new_call
);
1149 *non_constant_p
= true;
1153 return cxx_eval_constant_expression (&new_ctx
, new_call
, lval
,
1154 non_constant_p
, overflow_p
);
1157 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1158 the type of the value to match. */
1161 adjust_temp_type (tree type
, tree temp
)
1163 if (TREE_TYPE (temp
) == type
)
1165 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1166 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1167 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1168 gcc_assert (scalarish_type_p (type
));
1169 return cp_fold_convert (type
, temp
);
1172 /* Callback for walk_tree used by unshare_constructor. */
1175 find_constructor (tree
*tp
, int *walk_subtrees
, void *)
1179 if (TREE_CODE (*tp
) == CONSTRUCTOR
)
1184 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1185 subexpression, return an unshared copy of T. Otherwise return T. */
1188 unshare_constructor (tree t
)
1190 tree ctor
= walk_tree (&t
, find_constructor
, NULL
, NULL
);
1191 if (ctor
!= NULL_TREE
)
1192 return unshare_expr (t
);
1196 /* Subroutine of cxx_eval_call_expression.
1197 We are processing a call expression (either CALL_EXPR or
1198 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1199 all arguments and bind their values to correspondings
1200 parameters, making up the NEW_CALL context. */
1203 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1204 constexpr_call
*new_call
,
1205 bool *non_constant_p
, bool *overflow_p
,
1206 bool *non_constant_args
)
1208 const int nargs
= call_expr_nargs (t
);
1209 tree fun
= new_call
->fundef
->decl
;
1210 tree parms
= DECL_ARGUMENTS (fun
);
1212 tree
*p
= &new_call
->bindings
;
1213 for (i
= 0; i
< nargs
; ++i
)
1216 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1217 x
= get_nth_callarg (t
, i
);
1218 /* For member function, the first argument is a pointer to the implied
1219 object. For a constructor, it might still be a dummy object, in
1220 which case we get the real argument from ctx. */
1221 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1222 && is_dummy_object (x
))
1225 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1228 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1229 non_constant_p
, overflow_p
);
1230 /* Don't VERIFY_CONSTANT here. */
1231 if (*non_constant_p
&& ctx
->quiet
)
1233 /* Just discard ellipsis args after checking their constantitude. */
1237 if (!*non_constant_p
)
1239 /* Make sure the binding has the same type as the parm. But
1240 only for constant args. */
1241 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1242 arg
= adjust_temp_type (type
, arg
);
1243 if (!TREE_CONSTANT (arg
))
1244 *non_constant_args
= true;
1245 *p
= build_tree_list (parms
, arg
);
1246 p
= &TREE_CHAIN (*p
);
1248 parms
= TREE_CHAIN (parms
);
1252 /* Variables and functions to manage constexpr call expansion context.
1253 These do not need to be marked for PCH or GC. */
1255 /* FIXME remember and print actual constant arguments. */
1256 static vec
<tree
> call_stack
= vNULL
;
1257 static int call_stack_tick
;
1258 static int last_cx_error_tick
;
1261 push_cx_call_context (tree call
)
1264 if (!EXPR_HAS_LOCATION (call
))
1265 SET_EXPR_LOCATION (call
, input_location
);
1266 call_stack
.safe_push (call
);
1267 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1273 pop_cx_call_context (void)
1280 cx_error_context (void)
1282 vec
<tree
> r
= vNULL
;
1283 if (call_stack_tick
!= last_cx_error_tick
1284 && !call_stack
.is_empty ())
1286 last_cx_error_tick
= call_stack_tick
;
1290 /* Evaluate a call T to a GCC internal function when possible and return
1291 the evaluated result or, under the control of CTX, give an error, set
1292 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1295 cxx_eval_internal_function (const constexpr_ctx
*ctx
, tree t
,
1297 bool *non_constant_p
, bool *overflow_p
)
1299 enum tree_code opcode
= ERROR_MARK
;
1301 switch (CALL_EXPR_IFN (t
))
1303 case IFN_UBSAN_NULL
:
1304 case IFN_UBSAN_BOUNDS
:
1305 case IFN_UBSAN_VPTR
:
1308 case IFN_ADD_OVERFLOW
:
1311 case IFN_SUB_OVERFLOW
:
1312 opcode
= MINUS_EXPR
;
1314 case IFN_MUL_OVERFLOW
:
1320 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
1321 "call to internal function %qE", t
);
1322 *non_constant_p
= true;
1326 /* Evaluate constant arguments using OPCODE and return a complex
1327 number containing the result and the overflow bit. */
1328 tree arg0
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 0), lval
,
1329 non_constant_p
, overflow_p
);
1330 tree arg1
= cxx_eval_constant_expression (ctx
, CALL_EXPR_ARG (t
, 1), lval
,
1331 non_constant_p
, overflow_p
);
1333 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1335 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1336 tree type
= TREE_TYPE (TREE_TYPE (t
));
1337 tree result
= fold_binary_loc (loc
, opcode
, type
,
1338 fold_convert_loc (loc
, type
, arg0
),
1339 fold_convert_loc (loc
, type
, arg1
));
1341 = build_int_cst (type
, arith_overflowed_p (opcode
, type
, arg0
, arg1
));
1342 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1343 if (TREE_OVERFLOW (result
))
1344 TREE_OVERFLOW (result
) = 0;
1346 return build_complex (TREE_TYPE (t
), result
, ovf
);
1349 *non_constant_p
= true;
1353 /* Subroutine of cxx_eval_constant_expression.
1354 Evaluate the call expression tree T in the context of OLD_CALL expression
1358 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1360 bool *non_constant_p
, bool *overflow_p
)
1362 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1363 tree fun
= get_function_named_in_call (t
);
1364 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1367 if (fun
== NULL_TREE
)
1368 return cxx_eval_internal_function (ctx
, t
, lval
,
1369 non_constant_p
, overflow_p
);
1371 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1373 /* Might be a constexpr function pointer. */
1374 fun
= cxx_eval_constant_expression (ctx
, fun
,
1375 /*lval*/false, non_constant_p
,
1378 if (TREE_CODE (fun
) == ADDR_EXPR
)
1379 fun
= TREE_OPERAND (fun
, 0);
1381 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1383 if (!ctx
->quiet
&& !*non_constant_p
)
1384 error_at (loc
, "expression %qE does not designate a constexpr "
1386 *non_constant_p
= true;
1389 if (DECL_CLONED_FUNCTION_P (fun
))
1390 fun
= DECL_CLONED_FUNCTION (fun
);
1392 if (is_ubsan_builtin_p (fun
))
1395 if (is_builtin_fn (fun
))
1396 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1397 lval
, non_constant_p
, overflow_p
);
1398 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1402 error_at (loc
, "call to non-constexpr function %qD", fun
);
1403 explain_invalid_constexpr_fn (fun
);
1405 *non_constant_p
= true;
1409 constexpr_ctx new_ctx
= *ctx
;
1410 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1411 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1413 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1414 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1415 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1416 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1417 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1418 ctx
->values
->put (new_ctx
.object
, ctor
);
1422 /* Shortcut trivial constructor/op=. */
1423 if (trivial_fn_p (fun
))
1425 tree init
= NULL_TREE
;
1426 if (call_expr_nargs (t
) == 2)
1427 init
= convert_from_reference (get_nth_callarg (t
, 1));
1428 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1429 && AGGR_INIT_ZERO_FIRST (t
))
1430 init
= build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1433 tree op
= get_nth_callarg (t
, 0);
1434 if (is_dummy_object (op
))
1437 op
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (op
)), op
);
1438 tree set
= build2 (MODIFY_EXPR
, TREE_TYPE (op
), op
, init
);
1439 return cxx_eval_constant_expression (ctx
, set
, lval
,
1440 non_constant_p
, overflow_p
);
1444 /* We can't defer instantiating the function any longer. */
1445 if (!DECL_INITIAL (fun
)
1446 && DECL_TEMPLOID_INSTANTIATION (fun
))
1449 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1453 /* If in direct recursive call, optimize definition search. */
1454 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1455 new_call
.fundef
= ctx
->call
->fundef
;
1458 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1459 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
1460 || fun
== current_function_decl
)
1464 /* We need to check for current_function_decl here in case we're
1465 being called during cp_fold_function, because at that point
1466 DECL_INITIAL is set properly and we have a fundef but we
1467 haven't lowered invisirefs yet (c++/70344). */
1468 if (DECL_INITIAL (fun
) == error_mark_node
1469 || fun
== current_function_decl
)
1470 error_at (loc
, "%qD called in a constant expression before its "
1471 "definition is complete", fun
);
1472 else if (DECL_INITIAL (fun
))
1474 /* The definition of fun was somehow unsuitable. But pretend
1475 that lambda static thunks don't exist. */
1476 if (!lambda_static_thunk_p (fun
))
1477 error_at (loc
, "%qD called in a constant expression", fun
);
1478 explain_invalid_constexpr_fn (fun
);
1481 error_at (loc
, "%qD used before its definition", fun
);
1483 *non_constant_p
= true;
1488 bool non_constant_args
= false;
1489 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1490 non_constant_p
, overflow_p
, &non_constant_args
);
1491 if (*non_constant_p
)
1494 depth_ok
= push_cx_call_context (t
);
1496 tree result
= NULL_TREE
;
1498 constexpr_call
*entry
= NULL
;
1499 if (depth_ok
&& !non_constant_args
)
1501 new_call
.hash
= iterative_hash_template_arg
1502 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1504 /* If we have seen this call before, we are done. */
1505 maybe_initialize_constexpr_call_table ();
1506 constexpr_call
**slot
1507 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1511 /* We need to keep a pointer to the entry, not just the slot, as the
1512 slot can move in the call to cxx_eval_builtin_function_call. */
1513 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1516 /* Calls that are in progress have their result set to NULL,
1517 so that we can detect circular dependencies. */
1518 else if (entry
->result
== NULL
)
1521 error ("call has circular dependency");
1522 *non_constant_p
= true;
1523 entry
->result
= result
= error_mark_node
;
1526 result
= entry
->result
;
1532 error ("constexpr evaluation depth exceeds maximum of %d (use "
1533 "-fconstexpr-depth= to increase the maximum)",
1534 max_constexpr_depth
);
1535 *non_constant_p
= true;
1536 result
= error_mark_node
;
1540 if (result
&& result
!= error_mark_node
)
1542 else if (!DECL_SAVED_TREE (fun
))
1544 /* When at_eof >= 2, cgraph has started throwing away
1545 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1546 late code generation for VEC_INIT_EXPR, which needs to be
1547 completely reconsidered. */
1548 gcc_assert (at_eof
>= 2 && ctx
->quiet
);
1549 *non_constant_p
= true;
1553 tree body
, parms
, res
;
1555 /* Reuse or create a new unshared copy of this function's body. */
1556 tree copy
= get_fundef_copy (fun
);
1557 body
= TREE_PURPOSE (copy
);
1558 parms
= TREE_VALUE (copy
);
1559 res
= TREE_TYPE (copy
);
1561 /* Associate the bindings with the remapped parms. */
1562 tree bound
= new_call
.bindings
;
1563 tree remapped
= parms
;
1566 tree oparm
= TREE_PURPOSE (bound
);
1567 tree arg
= TREE_VALUE (bound
);
1568 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1569 /* Don't share a CONSTRUCTOR that might be changed. */
1570 arg
= unshare_constructor (arg
);
1571 ctx
->values
->put (remapped
, arg
);
1572 bound
= TREE_CHAIN (bound
);
1573 remapped
= DECL_CHAIN (remapped
);
1575 /* Add the RESULT_DECL to the values map, too. */
1576 tree slot
= NULL_TREE
;
1577 if (DECL_BY_REFERENCE (res
))
1579 slot
= AGGR_INIT_EXPR_SLOT (t
);
1580 tree addr
= build_address (slot
);
1581 addr
= build_nop (TREE_TYPE (res
), addr
);
1582 ctx
->values
->put (res
, addr
);
1583 ctx
->values
->put (slot
, NULL_TREE
);
1586 ctx
->values
->put (res
, NULL_TREE
);
1588 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1589 their values after the call. */
1590 constexpr_ctx ctx_with_save_exprs
= *ctx
;
1591 hash_set
<tree
> save_exprs
;
1592 ctx_with_save_exprs
.save_exprs
= &save_exprs
;
1594 tree jump_target
= NULL_TREE
;
1595 cxx_eval_constant_expression (&ctx_with_save_exprs
, body
,
1596 lval
, non_constant_p
, overflow_p
,
1599 if (DECL_CONSTRUCTOR_P (fun
))
1600 /* This can be null for a subobject constructor call, in
1601 which case what we care about is the initialization
1602 side-effects rather than the value. We could get at the
1603 value by evaluating *this, but we don't bother; there's
1604 no need to put such a call in the hash table. */
1605 result
= lval
? ctx
->object
: ctx
->ctor
;
1606 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1610 result
= *ctx
->values
->get (slot
? slot
: res
);
1611 if (result
== NULL_TREE
&& !*non_constant_p
)
1614 error ("constexpr call flows off the end "
1616 *non_constant_p
= true;
1620 /* Forget the saved values of the callee's SAVE_EXPRs. */
1621 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
1622 iter
!= save_exprs
.end(); ++iter
)
1623 ctx_with_save_exprs
.values
->remove (*iter
);
1625 /* Remove the parms/result from the values map. Is it worth
1626 bothering to do this when the map itself is only live for
1627 one constexpr evaluation? If so, maybe also clear out
1628 other vars from call, maybe in BIND_EXPR handling? */
1629 ctx
->values
->remove (res
);
1631 ctx
->values
->remove (slot
);
1632 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1633 ctx
->values
->remove (parm
);
1635 /* Make the unshared function copy we used available for re-use. */
1636 save_fundef_copy (fun
, copy
);
1639 if (result
== error_mark_node
)
1640 *non_constant_p
= true;
1641 if (*non_constant_p
|| *overflow_p
)
1642 result
= error_mark_node
;
1646 entry
->result
= result
;
1649 pop_cx_call_context ();
1650 return unshare_constructor (result
);
1653 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1656 reduced_constant_expression_p (tree t
)
1658 switch (TREE_CODE (t
))
1661 /* Even if we can't lower this yet, it's constant. */
1665 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1666 tree elt
; unsigned HOST_WIDE_INT idx
;
1667 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1668 if (!reduced_constant_expression_p (elt
))
1673 /* FIXME are we calling this too much? */
1674 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1678 /* Some expressions may have constant operands but are not constant
1679 themselves, such as 1/0. Call this function (or rather, the macro
1680 following it) to check for that condition.
1682 We only call this in places that require an arithmetic constant, not in
1683 places where we might have a non-constant expression that can be a
1684 component of a constant expression, such as the address of a constexpr
1685 variable that might be dereferenced later. */
1688 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1691 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1693 if (!allow_non_constant
)
1694 error ("%q+E is not a constant expression", t
);
1695 *non_constant_p
= true;
1697 if (TREE_OVERFLOW_P (t
))
1699 if (!allow_non_constant
)
1701 permerror (input_location
, "overflow in constant expression");
1702 /* If we're being permissive (and are in an enforcing
1703 context), ignore the overflow. */
1704 if (flag_permissive
)
1705 return *non_constant_p
;
1709 return *non_constant_p
;
1712 /* Check whether the shift operation with code CODE and type TYPE on LHS
1713 and RHS is undefined. If it is, give an error with an explanation,
1714 and return true; return false otherwise. */
1717 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1718 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1720 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1721 || TREE_CODE (lhs
) != INTEGER_CST
1722 || TREE_CODE (rhs
) != INTEGER_CST
)
1725 tree lhstype
= TREE_TYPE (lhs
);
1726 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1728 /* [expr.shift] The behavior is undefined if the right operand
1729 is negative, or greater than or equal to the length in bits
1730 of the promoted left operand. */
1731 if (tree_int_cst_sgn (rhs
) == -1)
1734 permerror (loc
, "right operand of shift expression %q+E is negative",
1735 build2_loc (loc
, code
, type
, lhs
, rhs
));
1736 return (!flag_permissive
|| ctx
->quiet
);
1738 if (compare_tree_int (rhs
, uprec
) >= 0)
1741 permerror (loc
, "right operand of shift expression %q+E is >= than "
1742 "the precision of the left operand",
1743 build2_loc (loc
, code
, type
, lhs
, rhs
));
1744 return (!flag_permissive
|| ctx
->quiet
);
1747 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1748 if E1 has a signed type and non-negative value, and E1x2^E2 is
1749 representable in the corresponding unsigned type of the result type,
1750 then that value, converted to the result type, is the resulting value;
1751 otherwise, the behavior is undefined. */
1752 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1753 && (cxx_dialect
>= cxx11
))
1755 if (tree_int_cst_sgn (lhs
) == -1)
1759 "left operand of shift expression %q+E is negative",
1760 build2_loc (loc
, code
, type
, lhs
, rhs
));
1761 return (!flag_permissive
|| ctx
->quiet
);
1763 /* For signed x << y the following:
1764 (unsigned) x >> ((prec (lhs) - 1) - y)
1765 if > 1, is undefined. The right-hand side of this formula
1766 is the highest bit of the LHS that can be set (starting from 0),
1767 so that the shift doesn't overflow. We then right-shift the LHS
1768 to see whether any other bit is set making the original shift
1769 undefined -- the result is not representable in the corresponding
1771 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1772 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1773 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1774 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1775 if (tree_int_cst_lt (integer_one_node
, t
))
1778 permerror (loc
, "shift expression %q+E overflows",
1779 build2_loc (loc
, code
, type
, lhs
, rhs
));
1780 return (!flag_permissive
|| ctx
->quiet
);
1786 /* Subroutine of cxx_eval_constant_expression.
1787 Attempt to reduce the unary expression tree T to a compile time value.
1788 If successful, return the value. Otherwise issue a diagnostic
1789 and return error_mark_node. */
1792 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1794 bool *non_constant_p
, bool *overflow_p
)
1797 tree orig_arg
= TREE_OPERAND (t
, 0);
1798 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1799 non_constant_p
, overflow_p
);
1800 VERIFY_CONSTANT (arg
);
1801 location_t loc
= EXPR_LOCATION (t
);
1802 enum tree_code code
= TREE_CODE (t
);
1803 tree type
= TREE_TYPE (t
);
1804 r
= fold_unary_loc (loc
, code
, type
, arg
);
1807 if (arg
== orig_arg
)
1810 r
= build1_loc (loc
, code
, type
, arg
);
1812 VERIFY_CONSTANT (r
);
1816 /* Subroutine of cxx_eval_constant_expression.
1817 Like cxx_eval_unary_expression, except for binary expressions. */
1820 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1822 bool *non_constant_p
, bool *overflow_p
)
1825 tree orig_lhs
= TREE_OPERAND (t
, 0);
1826 tree orig_rhs
= TREE_OPERAND (t
, 1);
1828 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1829 non_constant_p
, overflow_p
);
1830 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
1832 if (*non_constant_p
)
1834 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1835 non_constant_p
, overflow_p
);
1836 if (*non_constant_p
)
1839 location_t loc
= EXPR_LOCATION (t
);
1840 enum tree_code code
= TREE_CODE (t
);
1841 tree type
= TREE_TYPE (t
);
1843 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
1845 bool is_code_eq
= (code
== EQ_EXPR
);
1847 if (TREE_CODE (lhs
) == PTRMEM_CST
1848 && TREE_CODE (rhs
) == PTRMEM_CST
)
1849 r
= constant_boolean_node (cp_tree_equal (lhs
, rhs
) == is_code_eq
,
1851 else if ((TREE_CODE (lhs
) == PTRMEM_CST
1852 || TREE_CODE (rhs
) == PTRMEM_CST
)
1853 && (null_member_pointer_value_p (lhs
)
1854 || null_member_pointer_value_p (rhs
)))
1855 r
= constant_boolean_node (!is_code_eq
, type
);
1856 else if (TREE_CODE (lhs
) == PTRMEM_CST
)
1857 lhs
= cplus_expand_constant (lhs
);
1858 else if (TREE_CODE (rhs
) == PTRMEM_CST
)
1859 rhs
= cplus_expand_constant (rhs
);
1861 if (code
== POINTER_PLUS_EXPR
&& !*non_constant_p
1862 && integer_zerop (lhs
) && !integer_zerop (rhs
))
1865 error ("arithmetic involving a null pointer in %qE", lhs
);
1870 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1874 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1877 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1879 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1880 *non_constant_p
= true;
1881 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1882 a local array in a constexpr function. */
1883 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1885 VERIFY_CONSTANT (r
);
1889 /* Subroutine of cxx_eval_constant_expression.
1890 Attempt to evaluate condition expressions. Dead branches are not
1894 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1896 bool *non_constant_p
, bool *overflow_p
,
1899 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1901 non_constant_p
, overflow_p
);
1902 VERIFY_CONSTANT (val
);
1903 /* Don't VERIFY_CONSTANT the other operands. */
1904 if (integer_zerop (val
))
1905 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1907 non_constant_p
, overflow_p
,
1909 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1911 non_constant_p
, overflow_p
,
1915 /* Returns less than, equal to, or greater than zero if KEY is found to be
1916 less than, to match, or to be greater than the constructor_elt's INDEX. */
1919 array_index_cmp (tree key
, tree index
)
1921 gcc_assert (TREE_CODE (key
) == INTEGER_CST
);
1923 switch (TREE_CODE (index
))
1926 return tree_int_cst_compare (key
, index
);
1929 tree lo
= TREE_OPERAND (index
, 0);
1930 tree hi
= TREE_OPERAND (index
, 1);
1931 if (tree_int_cst_lt (key
, lo
))
1933 else if (tree_int_cst_lt (hi
, key
))
1943 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
1944 if none. If INSERT is true, insert a matching element rather than fail. */
1946 static HOST_WIDE_INT
1947 find_array_ctor_elt (tree ary
, tree dindex
, bool insert
= false)
1949 if (tree_int_cst_sgn (dindex
) < 0)
1952 unsigned HOST_WIDE_INT i
= tree_to_uhwi (dindex
);
1953 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ary
);
1954 unsigned HOST_WIDE_INT len
= vec_safe_length (elts
);
1956 unsigned HOST_WIDE_INT end
= len
;
1957 unsigned HOST_WIDE_INT begin
= 0;
1959 /* If the last element of the CONSTRUCTOR has its own index, we can assume
1960 that the same is true of the other elements and index directly. */
1963 tree cindex
= (*elts
)[end
-1].index
;
1964 if (TREE_CODE (cindex
) == INTEGER_CST
1965 && compare_tree_int (cindex
, end
-1) == 0)
1974 /* Otherwise, find a matching index by means of a binary search. */
1975 while (begin
!= end
)
1977 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
1978 constructor_elt
&elt
= (*elts
)[middle
];
1979 tree idx
= elt
.index
;
1981 int cmp
= array_index_cmp (dindex
, idx
);
1988 if (insert
&& TREE_CODE (idx
) == RANGE_EXPR
)
1990 /* We need to split the range. */
1992 tree lo
= TREE_OPERAND (idx
, 0);
1993 tree hi
= TREE_OPERAND (idx
, 1);
1994 if (tree_int_cst_lt (lo
, dindex
))
1996 /* There are still some lower elts; shorten the range. */
1997 tree new_hi
= int_const_binop (MINUS_EXPR
, dindex
,
1999 if (tree_int_cst_equal (lo
, new_hi
))
2000 /* Only one element left, no longer a range. */
2003 TREE_OPERAND (idx
, 1) = new_hi
;
2004 /* Append the element we want to insert. */
2007 e
.value
= unshare_constructor (elt
.value
);
2008 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
, e
);
2011 /* No lower elts, the range elt is now ours. */
2014 if (tree_int_cst_lt (dindex
, hi
))
2016 /* There are still some higher elts; append a range. */
2017 tree new_lo
= int_const_binop (PLUS_EXPR
, dindex
,
2019 if (tree_int_cst_equal (new_lo
, hi
))
2022 e
.index
= build2 (RANGE_EXPR
, sizetype
, new_lo
, hi
);
2023 e
.value
= unshare_constructor (elt
.value
);
2024 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), middle
+1, e
);
2033 constructor_elt e
= { dindex
, NULL_TREE
};
2034 vec_safe_insert (CONSTRUCTOR_ELTS (ary
), end
, e
);
2041 /* Under the control of CTX, issue a detailed diagnostic for
2042 an out-of-bounds subscript INDEX into the expression ARRAY. */
2045 diag_array_subscript (const constexpr_ctx
*ctx
, tree array
, tree index
)
2049 tree arraytype
= TREE_TYPE (array
);
2051 /* Convert the unsigned array subscript to a signed integer to avoid
2052 printing huge numbers for small negative values. */
2053 tree sidx
= fold_convert (ssizetype
, index
);
2056 error ("array subscript value %qE is outside the bounds "
2057 "of array %qD of type %qT", sidx
, array
, arraytype
);
2058 inform (DECL_SOURCE_LOCATION (array
), "declared here");
2061 error ("array subscript value %qE is outside the bounds "
2062 "of array type %qT", sidx
, arraytype
);
2066 /* Subroutine of cxx_eval_constant_expression.
2067 Attempt to reduce a reference to an array slot. */
2070 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
2072 bool *non_constant_p
, bool *overflow_p
)
2074 tree oldary
= TREE_OPERAND (t
, 0);
2075 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
2077 non_constant_p
, overflow_p
);
2081 unsigned len
, elem_nchars
= 1;
2082 if (*non_constant_p
)
2084 oldidx
= TREE_OPERAND (t
, 1);
2085 index
= cxx_eval_constant_expression (ctx
, oldidx
,
2087 non_constant_p
, overflow_p
);
2088 VERIFY_CONSTANT (index
);
2089 if (lval
&& ary
== oldary
&& index
== oldidx
)
2092 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
2093 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
2094 if (TREE_CODE (ary
) == VIEW_CONVERT_EXPR
2095 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary
, 0)))
2096 && TREE_TYPE (t
) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary
, 0))))
2097 ary
= TREE_OPERAND (ary
, 0);
2098 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2099 len
= CONSTRUCTOR_NELTS (ary
);
2100 else if (TREE_CODE (ary
) == STRING_CST
)
2102 elem_nchars
= (TYPE_PRECISION (elem_type
)
2103 / TYPE_PRECISION (char_type_node
));
2104 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
2106 else if (TREE_CODE (ary
) == VECTOR_CST
)
2107 len
= VECTOR_CST_NELTS (ary
);
2110 /* We can't do anything with other tree codes, so use
2111 VERIFY_CONSTANT to complain and fail. */
2112 VERIFY_CONSTANT (ary
);
2116 if (!tree_fits_shwi_p (index
)
2117 || (i
= tree_to_shwi (index
)) < 0)
2119 diag_array_subscript (ctx
, ary
, index
);
2120 *non_constant_p
= true;
2125 if (TREE_CODE (TREE_TYPE (ary
)) == ARRAY_TYPE
)
2126 nelts
= array_type_nelts_top (TREE_TYPE (ary
));
2127 else if (VECTOR_TYPE_P (TREE_TYPE (ary
)))
2128 nelts
= size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary
)));
2132 /* For VLAs, the number of elements won't be an integer constant. */
2133 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
2135 VERIFY_CONSTANT (nelts
);
2136 if (!tree_int_cst_lt (index
, nelts
))
2138 diag_array_subscript (ctx
, ary
, index
);
2139 *non_constant_p
= true;
2144 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2146 HOST_WIDE_INT ix
= find_array_ctor_elt (ary
, index
);
2157 if (TREE_CODE (ary
) == CONSTRUCTOR
)
2158 r
= (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
2159 else if (TREE_CODE (ary
) == VECTOR_CST
)
2160 r
= VECTOR_CST_ELT (ary
, i
);
2161 else if (elem_nchars
== 1)
2162 r
= build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
2163 TREE_STRING_POINTER (ary
)[i
]);
2166 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
2167 r
= native_interpret_expr (type
, (const unsigned char *)
2168 TREE_STRING_POINTER (ary
)
2169 + i
* elem_nchars
, elem_nchars
);
2172 /* Don't VERIFY_CONSTANT here. */
2175 /* Otherwise the element doesn't have a value yet. */
2180 if (TREE_CODE (ary
) == CONSTRUCTOR
2181 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary
))
2183 /* 'ary' is part of the aggregate initializer we're currently
2184 building; if there's no initializer for this element yet,
2187 error ("accessing uninitialized array element");
2188 *non_constant_p
= true;
2192 /* If it's within the array bounds but doesn't have an explicit
2193 initializer, it's value-initialized. */
2194 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
2195 return cxx_eval_constant_expression (ctx
, val
, lval
, non_constant_p
,
2199 /* Subroutine of cxx_eval_constant_expression.
2200 Attempt to reduce a field access of a value of class type. */
2203 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
2205 bool *non_constant_p
, bool *overflow_p
)
2207 unsigned HOST_WIDE_INT i
;
2210 tree part
= TREE_OPERAND (t
, 1);
2211 tree orig_whole
= TREE_OPERAND (t
, 0);
2212 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2214 non_constant_p
, overflow_p
);
2215 if (TREE_CODE (whole
) == INDIRECT_REF
2216 && integer_zerop (TREE_OPERAND (whole
, 0))
2218 error ("dereferencing a null pointer in %qE", orig_whole
);
2220 if (TREE_CODE (whole
) == PTRMEM_CST
)
2221 whole
= cplus_expand_constant (whole
);
2222 if (whole
== orig_whole
)
2225 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
2226 whole
, part
, NULL_TREE
);
2227 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2229 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
2232 error ("%qE is not a constant expression", orig_whole
);
2233 *non_constant_p
= true;
2235 if (DECL_MUTABLE_P (part
))
2238 error ("mutable %qD is not usable in a constant expression", part
);
2239 *non_constant_p
= true;
2241 if (*non_constant_p
)
2243 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2250 /* We're in the middle of initializing it. */
2254 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
2255 && CONSTRUCTOR_NELTS (whole
) > 0)
2257 /* DR 1188 says we don't have to deal with this. */
2259 error ("accessing %qD member instead of initialized %qD member in "
2260 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
2261 *non_constant_p
= true;
2265 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2266 classes never get represented; throw together a value now. */
2267 if (is_really_empty_class (TREE_TYPE (t
)))
2268 return build_constructor (TREE_TYPE (t
), NULL
);
2270 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
2272 /* 'whole' is part of the aggregate initializer we're currently
2273 building; if there's no initializer for this member yet, that's an
2276 error ("accessing uninitialized member %qD", part
);
2277 *non_constant_p
= true;
2281 /* If there's no explicit init for this field, it's value-initialized. */
2282 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
2283 return cxx_eval_constant_expression (ctx
, value
,
2285 non_constant_p
, overflow_p
);
2288 /* Subroutine of cxx_eval_constant_expression.
2289 Attempt to reduce a field access of a value of class type that is
2290 expressed as a BIT_FIELD_REF. */
2293 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
2295 bool *non_constant_p
, bool *overflow_p
)
2297 tree orig_whole
= TREE_OPERAND (t
, 0);
2298 tree retval
, fldval
, utype
, mask
;
2299 bool fld_seen
= false;
2300 HOST_WIDE_INT istart
, isize
;
2301 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
2303 non_constant_p
, overflow_p
);
2304 tree start
, field
, value
;
2305 unsigned HOST_WIDE_INT i
;
2307 if (whole
== orig_whole
)
2309 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2311 if (!*non_constant_p
2312 && TREE_CODE (whole
) != VECTOR_CST
2313 && TREE_CODE (whole
) != CONSTRUCTOR
)
2316 error ("%qE is not a constant expression", orig_whole
);
2317 *non_constant_p
= true;
2319 if (*non_constant_p
)
2322 if (TREE_CODE (whole
) == VECTOR_CST
)
2323 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
2324 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
2326 start
= TREE_OPERAND (t
, 2);
2327 istart
= tree_to_shwi (start
);
2328 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
2329 utype
= TREE_TYPE (t
);
2330 if (!TYPE_UNSIGNED (utype
))
2331 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
2332 retval
= build_int_cst (utype
, 0);
2333 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
2335 tree bitpos
= bit_position (field
);
2336 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
2338 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
2339 && TREE_CODE (value
) == INTEGER_CST
2340 && tree_fits_shwi_p (bitpos
)
2341 && tree_fits_shwi_p (DECL_SIZE (field
)))
2343 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
2344 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
2345 HOST_WIDE_INT shift
;
2346 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
2348 fldval
= fold_convert (utype
, value
);
2349 mask
= build_int_cst_type (utype
, -1);
2350 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
2351 size_int (TYPE_PRECISION (utype
) - sz
));
2352 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
2353 size_int (TYPE_PRECISION (utype
) - sz
));
2354 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
2355 shift
= bit
- istart
;
2356 if (BYTES_BIG_ENDIAN
)
2357 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
2358 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
2360 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
2366 return fold_convert (TREE_TYPE (t
), retval
);
2368 return error_mark_node
;
2371 /* Subroutine of cxx_eval_constant_expression.
2372 Evaluate a short-circuited logical expression T in the context
2373 of a given constexpr CALL. BAILOUT_VALUE is the value for
2374 early return. CONTINUE_VALUE is used here purely for
2375 sanity check purposes. */
2378 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
2379 tree bailout_value
, tree continue_value
,
2381 bool *non_constant_p
, bool *overflow_p
)
2384 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
2386 non_constant_p
, overflow_p
);
2387 VERIFY_CONSTANT (lhs
);
2388 if (tree_int_cst_equal (lhs
, bailout_value
))
2390 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
2391 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
2392 lval
, non_constant_p
,
2394 VERIFY_CONSTANT (r
);
2398 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2399 CONSTRUCTOR elements to initialize (part of) an object containing that
2400 field. Return a pointer to the constructor_elt corresponding to the
2401 initialization of the field. */
2403 static constructor_elt
*
2404 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
2406 tree aggr
= TREE_OPERAND (ref
, 0);
2407 tree field
= TREE_OPERAND (ref
, 1);
2409 constructor_elt
*ce
;
2411 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
2413 if (TREE_CODE (aggr
) == COMPONENT_REF
)
2415 constructor_elt
*base_ce
2416 = base_field_constructor_elt (v
, aggr
);
2417 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
2420 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2421 if (ce
->index
== field
)
2428 /* Some of the expressions fed to the constexpr mechanism are calls to
2429 constructors, which have type void. In that case, return the type being
2430 initialized by the constructor. */
2433 initialized_type (tree t
)
2437 tree type
= cv_unqualified (TREE_TYPE (t
));
2438 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
2440 /* A constructor call has void type, so we need to look deeper. */
2441 tree fn
= get_function_named_in_call (t
);
2442 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2443 && DECL_CXX_CONSTRUCTOR_P (fn
))
2444 type
= DECL_CONTEXT (fn
);
2449 /* We're about to initialize element INDEX of an array or class from VALUE.
2450 Set up NEW_CTX appropriately by adjusting .object to refer to the
2451 subobject and creating a new CONSTRUCTOR if the element is itself
2452 a class or array. */
2455 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
2456 tree index
, tree
&value
)
2460 if (index
&& TREE_CODE (index
) != INTEGER_CST
2461 && TREE_CODE (index
) != FIELD_DECL
)
2462 /* This won't have an element in the new CONSTRUCTOR. */
2465 tree type
= initialized_type (value
);
2466 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
2467 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2470 /* The sub-aggregate initializer might contain a placeholder;
2471 update object to refer to the subobject and ctor to refer to
2472 the (newly created) sub-initializer. */
2474 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2475 tree elt
= build_constructor (type
, NULL
);
2476 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2479 if (TREE_CODE (value
) == TARGET_EXPR
)
2480 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2481 value
= TARGET_EXPR_INITIAL (value
);
2484 /* We're about to process an initializer for a class or array TYPE. Make
2485 sure that CTX is set up appropriately. */
2488 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2490 /* We don't bother building a ctor for an empty base subobject. */
2491 if (is_empty_class (type
))
2494 /* We're in the middle of an initializer that might involve placeholders;
2495 our caller should have created a CONSTRUCTOR for us to put the
2496 initializer into. We will either return that constructor or T. */
2497 gcc_assert (ctx
->ctor
);
2498 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2499 (type
, TREE_TYPE (ctx
->ctor
)));
2500 /* We used to check that ctx->ctor was empty, but that isn't the case when
2501 the object is zero-initialized before calling the constructor. */
2503 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2504 (type
, TREE_TYPE (ctx
->object
)));
2505 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2506 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2509 /* Subroutine of cxx_eval_constant_expression.
2510 The expression tree T denotes a C-style array or a C-style
2511 aggregate. Reduce it to a constant expression. */
2514 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2516 bool *non_constant_p
, bool *overflow_p
)
2518 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2519 bool changed
= false;
2520 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2521 tree type
= TREE_TYPE (t
);
2523 constexpr_ctx new_ctx
;
2524 if (TYPE_PTRMEMFUNC_P (type
) || VECTOR_TYPE_P (type
))
2526 /* We don't really need the ctx->ctor business for a PMF or
2527 vector, but it's simpler to use the same code. */
2529 new_ctx
.ctor
= build_constructor (type
, NULL
);
2530 new_ctx
.object
= NULL_TREE
;
2533 verify_ctor_sanity (ctx
, type
);
2534 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2535 vec_alloc (*p
, vec_safe_length (v
));
2539 bool constant_p
= true;
2540 bool side_effects_p
= false;
2541 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2543 tree orig_value
= value
;
2544 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2545 if (new_ctx
.ctor
!= ctx
->ctor
)
2546 /* If we built a new CONSTRUCTOR, attach it now so that other
2547 initializers can refer to it. */
2548 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2549 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2551 non_constant_p
, overflow_p
);
2552 /* Don't VERIFY_CONSTANT here. */
2553 if (ctx
->quiet
&& *non_constant_p
)
2555 if (elt
!= orig_value
)
2558 if (!TREE_CONSTANT (elt
))
2560 if (TREE_SIDE_EFFECTS (elt
))
2561 side_effects_p
= true;
2562 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2564 /* This is an initialization of a vfield inside a base
2565 subaggregate that we already initialized; push this
2566 initialization into the previous initialization. */
2567 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2572 && (TREE_CODE (index
) == NOP_EXPR
2573 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2575 /* This is an initializer for an empty base; now that we've
2576 checked that it's constant, we can ignore it. */
2577 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2580 else if (new_ctx
.ctor
!= ctx
->ctor
)
2582 /* We appended this element above; update the value. */
2583 gcc_assert ((*p
)->last().index
== index
);
2584 (*p
)->last().value
= elt
;
2587 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2589 if (*non_constant_p
|| !changed
)
2592 /* We're done building this CONSTRUCTOR, so now we can interpret an
2593 element without an explicit initializer as value-initialized. */
2594 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2595 TREE_CONSTANT (t
) = constant_p
;
2596 TREE_SIDE_EFFECTS (t
) = side_effects_p
;
2597 if (VECTOR_TYPE_P (type
))
2602 /* Subroutine of cxx_eval_constant_expression.
2603 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2604 initialization of a non-static data member of array type. Reduce it to a
2607 Note that apart from value-initialization (when VALUE_INIT is true),
2608 this is only intended to support value-initialization and the
2609 initializations done by defaulted constructors for classes with
2610 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2611 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2612 for the copy/move constructor. */
2615 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2616 bool value_init
, bool lval
,
2617 bool *non_constant_p
, bool *overflow_p
)
2619 tree elttype
= TREE_TYPE (atype
);
2620 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2621 verify_ctor_sanity (ctx
, atype
);
2622 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2623 vec_alloc (*p
, max
+ 1);
2624 bool pre_init
= false;
2625 unsigned HOST_WIDE_INT i
;
2627 /* For the default constructor, build up a call to the default
2628 constructor of the element type. We only need to handle class types
2629 here, as for a constructor to be constexpr, all members must be
2630 initialized, which for a defaulted default constructor means they must
2631 be of a class type with a constexpr default constructor. */
2632 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2633 /* We only do this at the lowest level. */;
2634 else if (value_init
)
2636 init
= build_value_init (elttype
, tf_warning_or_error
);
2641 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2642 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2643 &argvec
, elttype
, LOOKUP_NORMAL
,
2644 tf_warning_or_error
);
2645 release_tree_vector (argvec
);
2646 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2650 for (i
= 0; i
< max
; ++i
)
2652 tree idx
= build_int_cst (size_type_node
, i
);
2655 constexpr_ctx new_ctx
;
2656 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2657 if (new_ctx
.ctor
!= ctx
->ctor
)
2658 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2659 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2661 /* A multidimensional array; recurse. */
2662 if (value_init
|| init
== NULL_TREE
)
2664 eltinit
= NULL_TREE
;
2668 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2669 tf_warning_or_error
);
2670 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2672 non_constant_p
, overflow_p
);
2676 /* Initializing an element using value or default initialization
2677 we just pre-built above. */
2678 eltinit
= cxx_eval_constant_expression (&new_ctx
, init
, lval
,
2679 non_constant_p
, overflow_p
);
2684 /* Copying an element. */
2685 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2686 (atype
, TREE_TYPE (init
)));
2687 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2688 tf_warning_or_error
);
2689 if (!lvalue_p (init
))
2690 eltinit
= move (eltinit
);
2691 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2692 eltinit
= (cxx_eval_constant_expression
2693 (&new_ctx
, eltinit
, lval
,
2694 non_constant_p
, overflow_p
));
2696 if (*non_constant_p
&& !ctx
->quiet
)
2698 if (new_ctx
.ctor
!= ctx
->ctor
)
2700 /* We appended this element above; update the value. */
2701 gcc_assert ((*p
)->last().index
== idx
);
2702 (*p
)->last().value
= eltinit
;
2705 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2706 /* Reuse the result of cxx_eval_constant_expression call
2707 from the first iteration to all others if it is a constant
2708 initializer that doesn't require relocations. */
2711 && (initializer_constant_valid_p (eltinit
, TREE_TYPE (eltinit
))
2712 == null_pointer_node
))
2714 if (new_ctx
.ctor
!= ctx
->ctor
)
2715 eltinit
= new_ctx
.ctor
;
2716 for (i
= 1; i
< max
; ++i
)
2718 idx
= build_int_cst (size_type_node
, i
);
2719 CONSTRUCTOR_APPEND_ELT (*p
, idx
, unshare_constructor (eltinit
));
2725 if (!*non_constant_p
)
2728 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2734 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2736 bool *non_constant_p
, bool *overflow_p
)
2738 tree atype
= TREE_TYPE (t
);
2739 tree init
= VEC_INIT_EXPR_INIT (t
);
2740 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2741 VEC_INIT_EXPR_VALUE_INIT (t
),
2742 lval
, non_constant_p
, overflow_p
);
2743 if (*non_constant_p
)
2749 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2750 match. We want to be less strict for simple *& folding; if we have a
2751 non-const temporary that we access through a const pointer, that should
2752 work. We handle this here rather than change fold_indirect_ref_1
2753 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2754 don't really make sense outside of constant expression evaluation. Also
2755 we want to allow folding to COMPONENT_REF, which could cause trouble
2756 with TBAA in fold_indirect_ref_1.
2758 Try to keep this function synced with fold_indirect_ref_1. */
2761 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2767 subtype
= TREE_TYPE (sub
);
2768 if (!POINTER_TYPE_P (subtype
))
2771 if (TREE_CODE (sub
) == ADDR_EXPR
)
2773 tree op
= TREE_OPERAND (sub
, 0);
2774 tree optype
= TREE_TYPE (op
);
2776 /* *&CONST_DECL -> to the value of the const decl. */
2777 if (TREE_CODE (op
) == CONST_DECL
)
2778 return DECL_INITIAL (op
);
2779 /* *&p => p; make sure to handle *&"str"[cst] here. */
2780 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
)
2781 /* Also handle the case where the desired type is an array of unknown
2782 bounds because the variable has had its bounds deduced since the
2783 ADDR_EXPR was created. */
2784 || (TREE_CODE (type
) == ARRAY_TYPE
2785 && TREE_CODE (optype
) == ARRAY_TYPE
2786 && TYPE_DOMAIN (type
) == NULL_TREE
2787 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype
),
2790 tree fop
= fold_read_from_constant_string (op
);
2796 /* *(foo *)&fooarray => fooarray[0] */
2797 else if (TREE_CODE (optype
) == ARRAY_TYPE
2798 && (same_type_ignoring_top_level_qualifiers_p
2799 (type
, TREE_TYPE (optype
))))
2801 tree type_domain
= TYPE_DOMAIN (optype
);
2802 tree min_val
= size_zero_node
;
2803 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2804 min_val
= TYPE_MIN_VALUE (type_domain
);
2805 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2806 NULL_TREE
, NULL_TREE
);
2808 /* *(foo *)&complexfoo => __real__ complexfoo */
2809 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2810 && (same_type_ignoring_top_level_qualifiers_p
2811 (type
, TREE_TYPE (optype
))))
2812 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2813 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2814 else if (VECTOR_TYPE_P (optype
)
2815 && (same_type_ignoring_top_level_qualifiers_p
2816 (type
, TREE_TYPE (optype
))))
2818 tree part_width
= TYPE_SIZE (type
);
2819 tree index
= bitsize_int (0);
2820 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2822 /* Also handle conversion to an empty base class, which
2823 is represented with a NOP_EXPR. */
2824 else if (is_empty_class (type
)
2825 && CLASS_TYPE_P (optype
)
2826 && DERIVED_FROM_P (type
, optype
))
2831 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2832 else if (RECORD_OR_UNION_TYPE_P (optype
))
2834 tree field
= TYPE_FIELDS (optype
);
2835 for (; field
; field
= DECL_CHAIN (field
))
2836 if (TREE_CODE (field
) == FIELD_DECL
2837 && integer_zerop (byte_position (field
))
2838 && (same_type_ignoring_top_level_qualifiers_p
2839 (TREE_TYPE (field
), type
)))
2841 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2846 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2847 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2849 tree op00
= TREE_OPERAND (sub
, 0);
2850 tree op01
= TREE_OPERAND (sub
, 1);
2853 if (TREE_CODE (op00
) == ADDR_EXPR
)
2856 op00
= TREE_OPERAND (op00
, 0);
2857 op00type
= TREE_TYPE (op00
);
2859 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2860 if (VECTOR_TYPE_P (op00type
)
2861 && (same_type_ignoring_top_level_qualifiers_p
2862 (type
, TREE_TYPE (op00type
))))
2864 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2865 tree part_width
= TYPE_SIZE (type
);
2866 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2867 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2868 tree index
= bitsize_int (indexi
);
2870 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2871 return fold_build3_loc (loc
,
2872 BIT_FIELD_REF
, type
, op00
,
2876 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2877 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2878 && (same_type_ignoring_top_level_qualifiers_p
2879 (type
, TREE_TYPE (op00type
))))
2881 tree size
= TYPE_SIZE_UNIT (type
);
2882 if (tree_int_cst_equal (size
, op01
))
2883 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2885 /* ((foo *)&fooarray)[1] => fooarray[1] */
2886 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2887 && (same_type_ignoring_top_level_qualifiers_p
2888 (type
, TREE_TYPE (op00type
))))
2890 tree type_domain
= TYPE_DOMAIN (op00type
);
2891 tree min_val
= size_zero_node
;
2892 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2893 min_val
= TYPE_MIN_VALUE (type_domain
);
2894 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2895 TYPE_SIZE_UNIT (type
));
2896 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2897 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2898 NULL_TREE
, NULL_TREE
);
2900 /* Also handle conversion to an empty base class, which
2901 is represented with a NOP_EXPR. */
2902 else if (is_empty_class (type
)
2903 && CLASS_TYPE_P (op00type
)
2904 && DERIVED_FROM_P (type
, op00type
))
2909 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2910 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2912 tree field
= TYPE_FIELDS (op00type
);
2913 for (; field
; field
= DECL_CHAIN (field
))
2914 if (TREE_CODE (field
) == FIELD_DECL
2915 && tree_int_cst_equal (byte_position (field
), op01
)
2916 && (same_type_ignoring_top_level_qualifiers_p
2917 (TREE_TYPE (field
), type
)))
2919 return fold_build3 (COMPONENT_REF
, type
, op00
,
2926 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2927 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2928 && (same_type_ignoring_top_level_qualifiers_p
2929 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2932 tree min_val
= size_zero_node
;
2933 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2937 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2938 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2939 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2940 min_val
= TYPE_MIN_VALUE (type_domain
);
2941 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2949 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2951 bool *non_constant_p
, bool *overflow_p
)
2953 tree orig_op0
= TREE_OPERAND (t
, 0);
2954 bool empty_base
= false;
2956 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
2957 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
2959 if (TREE_CODE (t
) == MEM_REF
2960 && (!TREE_OPERAND (t
, 1) || !integer_zerop (TREE_OPERAND (t
, 1))))
2962 gcc_assert (ctx
->quiet
);
2963 *non_constant_p
= true;
2967 /* First try to simplify it directly. */
2968 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
2972 /* If that didn't work, evaluate the operand first. */
2973 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2974 /*lval*/false, non_constant_p
,
2976 /* Don't VERIFY_CONSTANT here. */
2977 if (*non_constant_p
)
2980 if (!lval
&& integer_zerop (op0
))
2983 error ("dereferencing a null pointer");
2984 *non_constant_p
= true;
2988 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2992 /* We couldn't fold to a constant value. Make sure it's not
2993 something we should have been able to fold. */
2996 if (TREE_CODE (sub
) == ADDR_EXPR
)
2998 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2999 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
3000 /* DR 1188 says we don't have to deal with this. */
3002 error ("accessing value of %qE through a %qT glvalue in a "
3003 "constant expression", build_fold_indirect_ref (sub
),
3005 *non_constant_p
= true;
3009 if (lval
&& op0
!= orig_op0
)
3010 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
3012 VERIFY_CONSTANT (t
);
3017 r
= cxx_eval_constant_expression (ctx
, r
,
3018 lval
, non_constant_p
, overflow_p
);
3019 if (*non_constant_p
)
3022 /* If we're pulling out the value of an empty base, make sure
3023 that the whole object is constant and then return an empty
3025 if (empty_base
&& !lval
)
3027 VERIFY_CONSTANT (r
);
3028 r
= build_constructor (TREE_TYPE (t
), NULL
);
3029 TREE_CONSTANT (r
) = true;
3035 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3036 Shared between potential_constant_expression and
3037 cxx_eval_constant_expression. */
3040 non_const_var_error (tree r
)
3042 tree type
= TREE_TYPE (r
);
3043 error ("the value of %qD is not usable in a constant "
3045 /* Avoid error cascade. */
3046 if (DECL_INITIAL (r
) == error_mark_node
)
3048 if (DECL_DECLARED_CONSTEXPR_P (r
))
3049 inform (DECL_SOURCE_LOCATION (r
),
3050 "%qD used in its own initializer", r
);
3051 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3053 if (!CP_TYPE_CONST_P (type
))
3054 inform (DECL_SOURCE_LOCATION (r
),
3055 "%q#D is not const", r
);
3056 else if (CP_TYPE_VOLATILE_P (type
))
3057 inform (DECL_SOURCE_LOCATION (r
),
3058 "%q#D is volatile", r
);
3059 else if (!DECL_INITIAL (r
)
3060 || !TREE_CONSTANT (DECL_INITIAL (r
))
3061 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
))
3062 inform (DECL_SOURCE_LOCATION (r
),
3063 "%qD was not initialized with a constant "
3070 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
3071 inform (DECL_SOURCE_LOCATION (r
),
3072 "%qD was not declared %<constexpr%>", r
);
3074 inform (DECL_SOURCE_LOCATION (r
),
3075 "%qD does not have integral or enumeration type",
3080 /* Subroutine of cxx_eval_constant_expression.
3081 Like cxx_eval_unary_expression, except for trinary expressions. */
3084 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
3086 bool *non_constant_p
, bool *overflow_p
)
3092 for (i
= 0; i
< 3; i
++)
3094 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
3096 non_constant_p
, overflow_p
);
3097 VERIFY_CONSTANT (args
[i
]);
3100 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
3101 args
[0], args
[1], args
[2]);
3102 if (val
== NULL_TREE
)
3104 VERIFY_CONSTANT (val
);
3108 /* True if T was declared in a function declared to be constexpr, and
3109 therefore potentially constant in C++14. */
3112 var_in_constexpr_fn (tree t
)
3114 tree ctx
= DECL_CONTEXT (t
);
3115 return (ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
3116 && DECL_DECLARED_CONSTEXPR_P (ctx
));
3119 /* True if T was declared in a function that might be constexpr: either a
3120 function that was declared constexpr, or a C++17 lambda op(). */
3123 var_in_maybe_constexpr_fn (tree t
)
3125 if (cxx_dialect
>= cxx1z
3126 && DECL_FUNCTION_SCOPE_P (t
)
3127 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t
)))
3129 return var_in_constexpr_fn (t
);
3132 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3135 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
3137 bool *non_constant_p
, bool *overflow_p
)
3139 constexpr_ctx new_ctx
= *ctx
;
3141 tree init
= TREE_OPERAND (t
, 1);
3142 if (TREE_CLOBBER_P (init
))
3143 /* Just ignore clobbers. */
3146 /* First we figure out where we're storing to. */
3147 tree target
= TREE_OPERAND (t
, 0);
3148 tree type
= TREE_TYPE (target
);
3149 target
= cxx_eval_constant_expression (ctx
, target
,
3151 non_constant_p
, overflow_p
);
3152 if (*non_constant_p
)
3155 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
3157 /* For initialization of an empty base, the original target will be
3158 *(base*)this, which the above evaluation resolves to the object
3159 argument, which has the derived type rather than the base type. In
3160 this situation, just evaluate the initializer and return, since
3161 there's no actual data to store. */
3162 gcc_assert (is_empty_class (type
));
3163 return cxx_eval_constant_expression (ctx
, init
, false,
3164 non_constant_p
, overflow_p
);
3167 /* And then find the underlying variable. */
3168 vec
<tree
,va_gc
> *refs
= make_tree_vector();
3169 tree object
= NULL_TREE
;
3170 for (tree probe
= target
; object
== NULL_TREE
; )
3172 switch (TREE_CODE (probe
))
3177 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
3178 vec_safe_push (refs
, TREE_TYPE (probe
));
3179 probe
= TREE_OPERAND (probe
, 0);
3187 /* And then find/build up our initializer for the path to the subobject
3188 we're initializing. */
3190 if (DECL_P (object
))
3191 valp
= ctx
->values
->get (object
);
3196 /* A constant-expression cannot modify objects from outside the
3197 constant-expression. */
3199 error ("modification of %qE is not a constant expression", object
);
3200 *non_constant_p
= true;
3203 type
= TREE_TYPE (object
);
3204 bool no_zero_init
= true;
3206 vec
<tree
,va_gc
> *ctors
= make_tree_vector ();
3207 while (!refs
->is_empty())
3209 if (*valp
== NULL_TREE
)
3211 *valp
= build_constructor (type
, NULL
);
3212 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = no_zero_init
;
3214 /* If the value of object is already zero-initialized, any new ctors for
3215 subobjects will also be zero-initialized. */
3216 no_zero_init
= CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
);
3218 vec_safe_push (ctors
, *valp
);
3220 enum tree_code code
= TREE_CODE (type
);
3222 tree index
= refs
->pop();
3224 constructor_elt
*cep
= NULL
;
3225 if (code
== ARRAY_TYPE
)
3228 = find_array_ctor_elt (*valp
, index
, /*insert*/true);
3229 gcc_assert (i
>= 0);
3230 cep
= CONSTRUCTOR_ELT (*valp
, i
);
3231 gcc_assert (TREE_CODE (cep
->index
) != RANGE_EXPR
);
3235 gcc_assert (TREE_CODE (index
) == FIELD_DECL
);
3237 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3238 Usually we meet initializers in that order, but it is
3239 possible for base types to be placed not in program
3241 tree fields
= TYPE_FIELDS (DECL_CONTEXT (index
));
3242 unsigned HOST_WIDE_INT idx
;
3245 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
3246 idx
++, fields
= DECL_CHAIN (fields
))
3248 if (index
== cep
->index
)
3251 /* The field we're initializing must be on the field
3252 list. Look to see if it is present before the
3253 field the current ELT initializes. */
3254 for (; fields
!= cep
->index
; fields
= DECL_CHAIN (fields
))
3255 if (index
== fields
)
3259 /* We fell off the end of the CONSTRUCTOR, so insert a new
3260 entry at the end. */
3263 constructor_elt ce
= { index
, NULL_TREE
};
3265 vec_safe_insert (CONSTRUCTOR_ELTS (*valp
), idx
, ce
);
3266 cep
= CONSTRUCTOR_ELT (*valp
, idx
);
3272 release_tree_vector (refs
);
3274 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3276 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3277 wants to modify it. */
3278 if (*valp
== NULL_TREE
)
3280 *valp
= new_ctx
.ctor
= build_constructor (type
, NULL
);
3281 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = no_zero_init
;
3284 new_ctx
.ctor
= *valp
;
3285 new_ctx
.object
= target
;
3288 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
3289 non_constant_p
, overflow_p
);
3290 /* Don't share a CONSTRUCTOR that might be changed later. */
3291 init
= unshare_constructor (init
);
3292 if (target
== object
)
3293 /* The hash table might have moved since the get earlier. */
3294 valp
= ctx
->values
->get (object
);
3296 if (TREE_CODE (init
) == CONSTRUCTOR
)
3298 /* An outer ctx->ctor might be pointing to *valp, so replace
3300 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
3301 TREE_CONSTANT (*valp
) = TREE_CONSTANT (init
);
3302 TREE_SIDE_EFFECTS (*valp
) = TREE_SIDE_EFFECTS (init
);
3303 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
)
3304 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init
);
3309 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3310 CONSTRUCTORs, if any. */
3313 bool c
= TREE_CONSTANT (init
);
3314 bool s
= TREE_SIDE_EFFECTS (init
);
3316 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
3319 TREE_CONSTANT (elt
) = false;
3321 TREE_SIDE_EFFECTS (elt
) = true;
3323 release_tree_vector (ctors
);
3325 if (*non_constant_p
)
3333 /* Evaluate a ++ or -- expression. */
3336 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
3338 bool *non_constant_p
, bool *overflow_p
)
3340 enum tree_code code
= TREE_CODE (t
);
3341 tree type
= TREE_TYPE (t
);
3342 tree op
= TREE_OPERAND (t
, 0);
3343 tree offset
= TREE_OPERAND (t
, 1);
3344 gcc_assert (TREE_CONSTANT (offset
));
3346 /* The operand as an lvalue. */
3347 op
= cxx_eval_constant_expression (ctx
, op
, true,
3348 non_constant_p
, overflow_p
);
3350 /* The operand as an rvalue. */
3351 tree val
= rvalue (op
);
3352 val
= cxx_eval_constant_expression (ctx
, val
, false,
3353 non_constant_p
, overflow_p
);
3354 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3355 a local array in a constexpr function. */
3356 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
3358 VERIFY_CONSTANT (val
);
3360 /* The modified value. */
3361 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
3363 if (POINTER_TYPE_P (type
))
3365 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3366 offset
= convert_to_ptrofftype (offset
);
3368 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
3369 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
3372 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
3374 VERIFY_CONSTANT (mod
);
3376 /* Storing the modified value. */
3377 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
3378 cxx_eval_constant_expression (ctx
, store
,
3379 true, non_constant_p
, overflow_p
);
3381 /* And the value of the expression. */
3382 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3384 /* Prefix ops are lvalues. */
3388 /* But we optimize when the caller wants an rvalue. */
3392 /* Postfix ops are rvalues. */
3396 /* Predicates for the meaning of *jump_target. */
3399 returns (tree
*jump_target
)
3402 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
3406 breaks (tree
*jump_target
)
3409 && ((TREE_CODE (*jump_target
) == LABEL_DECL
3410 && LABEL_DECL_BREAK (*jump_target
))
3411 || TREE_CODE (*jump_target
) == EXIT_EXPR
);
3415 continues (tree
*jump_target
)
3418 && TREE_CODE (*jump_target
) == LABEL_DECL
3419 && LABEL_DECL_CONTINUE (*jump_target
);
3423 switches (tree
*jump_target
)
3426 && TREE_CODE (*jump_target
) == INTEGER_CST
;
3429 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3430 at I matches *jump_target. If we're looking for a case label and we see
3431 the default label, copy I into DEFAULT_LABEL. */
3434 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
3435 tree_stmt_iterator
& default_label
)
3437 tree stmt
= tsi_stmt (i
);
3438 switch (TREE_CODE (*jump_target
))
3441 if (TREE_CODE (stmt
) == LABEL_EXPR
3442 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
3447 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
3449 if (!CASE_LOW (stmt
))
3451 else if (CASE_HIGH (stmt
))
3453 if (tree_int_cst_le (CASE_LOW (stmt
), *jump_target
)
3454 && tree_int_cst_le (*jump_target
, CASE_HIGH (stmt
)))
3457 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
3468 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3469 semantics, for switch, break, continue, and return. */
3472 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
3473 bool *non_constant_p
, bool *overflow_p
,
3476 tree_stmt_iterator i
;
3477 tree_stmt_iterator default_label
= tree_stmt_iterator();
3479 /* In a statement-expression we want to return the last value. */
3483 local_target
= NULL_TREE
;
3484 jump_target
= &local_target
;
3486 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
3489 tree stmt
= tsi_stmt (i
);
3492 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
3493 /* The label we want might be inside. */;
3494 else if (label_matches (jump_target
, i
, default_label
))
3496 *jump_target
= NULL_TREE
;
3500 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
3501 non_constant_p
, overflow_p
,
3503 if (*non_constant_p
)
3505 if (returns (jump_target
) || breaks (jump_target
))
3508 if (switches (jump_target
) && !tsi_end_p (default_label
))
3511 *jump_target
= NULL_TREE
;
3517 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3518 semantics; continue semantics are covered by cxx_eval_statement_list. */
3521 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
3522 bool *non_constant_p
, bool *overflow_p
,
3525 constexpr_ctx new_ctx
= *ctx
;
3527 tree body
= TREE_OPERAND (t
, 0);
3531 hash_set
<tree
> save_exprs
;
3532 new_ctx
.save_exprs
= &save_exprs
;
3534 cxx_eval_constant_expression (&new_ctx
, body
, /*lval*/false,
3535 non_constant_p
, overflow_p
, jump_target
);
3537 /* Forget saved values of SAVE_EXPRs. */
3538 for (hash_set
<tree
>::iterator iter
= save_exprs
.begin();
3539 iter
!= save_exprs
.end(); ++iter
)
3540 new_ctx
.values
->remove (*iter
);
3541 if (++count
>= constexpr_loop_limit
)
3544 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3545 "constexpr loop iteration count exceeds limit of %d "
3546 "(use -fconstexpr-loop-limit= to increase the limit)",
3547 constexpr_loop_limit
);
3548 *non_constant_p
= true;
3552 while (!returns (jump_target
) && !breaks (jump_target
) && !*non_constant_p
);
3554 if (breaks (jump_target
))
3555 *jump_target
= NULL_TREE
;
3560 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3564 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
3565 bool *non_constant_p
, bool *overflow_p
,
3568 tree cond
= TREE_OPERAND (t
, 0);
3569 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
3570 non_constant_p
, overflow_p
);
3571 VERIFY_CONSTANT (cond
);
3572 *jump_target
= cond
;
3574 tree body
= TREE_OPERAND (t
, 1);
3575 cxx_eval_statement_list (ctx
, body
,
3576 non_constant_p
, overflow_p
, jump_target
);
3577 if (breaks (jump_target
) || switches (jump_target
))
3578 *jump_target
= NULL_TREE
;
3582 /* Subroutine of cxx_eval_constant_expression.
3583 Attempt to reduce a POINTER_PLUS_EXPR expression T. */
3586 cxx_eval_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
3587 bool lval
, bool *non_constant_p
,
3590 tree orig_type
= TREE_TYPE (t
);
3591 tree op00
= TREE_OPERAND (t
, 0);
3592 tree op01
= TREE_OPERAND (t
, 1);
3593 location_t loc
= EXPR_LOCATION (t
);
3595 op00
= cxx_eval_constant_expression (ctx
, op00
, lval
,
3596 non_constant_p
, overflow_p
);
3599 if (TREE_CODE (op00
) != ADDR_EXPR
)
3602 op01
= cxx_eval_constant_expression (ctx
, op01
, lval
,
3603 non_constant_p
, overflow_p
);
3604 op00
= TREE_OPERAND (op00
, 0);
3606 /* &A[i] p+ j => &A[i + j] */
3607 if (TREE_CODE (op00
) == ARRAY_REF
3608 && TREE_CODE (TREE_OPERAND (op00
, 1)) == INTEGER_CST
3609 && TREE_CODE (op01
) == INTEGER_CST
3610 && TYPE_SIZE_UNIT (TREE_TYPE (op00
))
3611 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (op00
))) == INTEGER_CST
)
3613 tree type
= TREE_TYPE (op00
);
3614 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (op00
, 1));
3615 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (op00
, 0)));
3616 nelts
= cxx_eval_constant_expression (ctx
, nelts
, false, non_constant_p
,
3618 if (*non_constant_p
)
3620 /* Don't fold an out-of-bound access. */
3621 if (!tree_int_cst_le (t
, nelts
))
3623 op01
= cp_fold_convert (ssizetype
, op01
);
3624 /* Don't fold if op01 can't be divided exactly by TYPE_SIZE_UNIT.
3625 constexpr int A[1]; ... (char *)&A[0] + 1 */
3626 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
3627 op01
, TYPE_SIZE_UNIT (type
))))
3629 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
3631 op01
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, op01
,
3632 TYPE_SIZE_UNIT (type
));
3633 t
= size_binop_loc (loc
, PLUS_EXPR
, op01
, t
);
3634 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (op00
, 0),
3635 t
, NULL_TREE
, NULL_TREE
);
3636 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
3637 t
= cp_fold_convert (orig_type
, t
);
3638 return cxx_eval_constant_expression (ctx
, t
, lval
, non_constant_p
,
3645 /* Attempt to reduce the expression T to a constant value.
3646 On failure, issue diagnostic and return error_mark_node. */
3647 /* FIXME unify with c_fully_fold */
3648 /* FIXME overflow_p is too global */
3651 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
3653 bool *non_constant_p
, bool *overflow_p
,
3656 constexpr_ctx new_ctx
;
3659 if (t
== error_mark_node
)
3661 *non_constant_p
= true;
3664 if (CONSTANT_CLASS_P (t
))
3666 if (TREE_OVERFLOW (t
))
3669 permerror (input_location
, "overflow in constant expression");
3670 if (!flag_permissive
|| ctx
->quiet
)
3674 if (TREE_CODE (t
) == INTEGER_CST
3675 && TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
3676 && !integer_zerop (t
))
3679 error ("value %qE of type %qT is not a constant expression",
3681 *non_constant_p
= true;
3687 tree_code tcode
= TREE_CODE (t
);
3693 /* We ask for an rvalue for the RESULT_DECL when indirecting
3694 through an invisible reference, or in named return value
3696 return (*ctx
->values
->get (t
));
3699 if (is_capture_proxy (t
))
3700 return cxx_eval_constant_expression (ctx
, DECL_VALUE_EXPR (t
),
3701 lval
, non_constant_p
, overflow_p
);
3704 /* We used to not check lval for CONST_DECL, but darwin.c uses
3705 CONST_DECL for aggregate constants. */
3708 if (COMPLETE_TYPE_P (TREE_TYPE (t
))
3709 && is_really_empty_class (TREE_TYPE (t
)))
3711 /* If the class is empty, we aren't actually loading anything. */
3712 r
= build_constructor (TREE_TYPE (t
), NULL
);
3713 TREE_CONSTANT (r
) = true;
3715 else if (ctx
->strict
)
3716 r
= decl_really_constant_value (t
);
3718 r
= decl_constant_value (t
);
3719 if (TREE_CODE (r
) == TARGET_EXPR
3720 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3721 r
= TARGET_EXPR_INITIAL (r
);
3723 if (tree
*p
= ctx
->values
->get (r
))
3724 if (*p
!= NULL_TREE
)
3729 non_const_var_error (r
);
3730 *non_constant_p
= true;
3738 case CASE_LABEL_EXPR
:
3742 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
3744 else if (tree
*p
= ctx
->values
->get (r
))
3747 /* Defer in case this is only used for its type. */;
3748 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3749 /* Defer, there's no lvalue->rvalue conversion. */;
3750 else if (is_really_empty_class (TREE_TYPE (t
)))
3752 /* If the class is empty, we aren't actually loading anything. */
3753 r
= build_constructor (TREE_TYPE (t
), NULL
);
3754 TREE_CONSTANT (r
) = true;
3759 error ("%qE is not a constant expression", t
);
3760 *non_constant_p
= true;
3765 case AGGR_INIT_EXPR
:
3766 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3767 non_constant_p
, overflow_p
);
3772 r
= DECL_EXPR_DECL (t
);
3773 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3774 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3778 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3779 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3780 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3784 if (tree init
= DECL_INITIAL (r
))
3786 init
= cxx_eval_constant_expression (ctx
, init
,
3788 non_constant_p
, overflow_p
);
3789 /* Don't share a CONSTRUCTOR that might be changed. */
3790 init
= unshare_constructor (init
);
3791 ctx
->values
->put (r
, init
);
3793 else if (ctx
== &new_ctx
)
3794 /* We gave it a CONSTRUCTOR above. */;
3796 ctx
->values
->put (r
, NULL_TREE
);
3801 if (!literal_type_p (TREE_TYPE (t
)))
3805 error ("temporary of non-literal type %qT in a "
3806 "constant expression", TREE_TYPE (t
));
3807 explain_non_literal_class (TREE_TYPE (t
));
3809 *non_constant_p
= true;
3812 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3814 /* We're being expanded without an explicit target, so start
3815 initializing a new object; expansion with an explicit target
3816 strips the TARGET_EXPR before we get here. */
3818 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3819 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3820 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3821 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3824 /* Pass false for 'lval' because this indicates
3825 initialization of a temporary. */
3826 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3828 non_constant_p
, overflow_p
);
3829 if (!*non_constant_p
)
3830 /* Adjust the type of the result to the type of the temporary. */
3831 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3834 tree slot
= TARGET_EXPR_SLOT (t
);
3835 r
= unshare_constructor (r
);
3836 ctx
->values
->put (slot
, r
);
3843 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3844 non_constant_p
, overflow_p
);
3848 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3850 non_constant_p
, overflow_p
);
3854 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
3855 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3857 non_constant_p
, overflow_p
);
3862 /* Avoid evaluating a SAVE_EXPR more than once. */
3863 if (tree
*p
= ctx
->values
->get (t
))
3867 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3868 non_constant_p
, overflow_p
);
3869 ctx
->values
->put (t
, r
);
3870 if (ctx
->save_exprs
)
3871 ctx
->save_exprs
->add (t
);
3875 case NON_LVALUE_EXPR
:
3876 case TRY_CATCH_EXPR
:
3878 case CLEANUP_POINT_EXPR
:
3879 case MUST_NOT_THROW_EXPR
:
3882 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3884 non_constant_p
, overflow_p
,
3888 case TRY_FINALLY_EXPR
:
3889 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
3890 non_constant_p
, overflow_p
,
3892 if (!*non_constant_p
)
3893 /* Also evaluate the cleanup. */
3894 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
3895 non_constant_p
, overflow_p
,
3899 /* These differ from cxx_eval_unary_expression in that this doesn't
3900 check for a constant operand or result; an address can be
3901 constant without its operand being, and vice versa. */
3904 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3905 non_constant_p
, overflow_p
);
3910 tree oldop
= TREE_OPERAND (t
, 0);
3911 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3913 non_constant_p
, overflow_p
);
3914 /* Don't VERIFY_CONSTANT here. */
3915 if (*non_constant_p
)
3917 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3918 /* This function does more aggressive folding than fold itself. */
3919 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3920 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3929 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
3930 non_constant_p
, overflow_p
);
3931 if (r
== error_mark_node
)
3933 else if (r
== TREE_OPERAND (t
, 0))
3936 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), r
);
3941 case FIX_TRUNC_EXPR
:
3946 case TRUTH_NOT_EXPR
:
3947 case FIXED_CONVERT_EXPR
:
3948 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3949 non_constant_p
, overflow_p
);
3953 r
= fold_sizeof_expr (t
);
3954 VERIFY_CONSTANT (r
);
3959 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3960 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3961 introduced by build_call_a. */
3962 tree op0
= TREE_OPERAND (t
, 0);
3963 tree op1
= TREE_OPERAND (t
, 1);
3965 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3966 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3967 r
= cxx_eval_constant_expression (ctx
, op0
,
3968 lval
, non_constant_p
, overflow_p
,
3972 /* Check that the LHS is constant and then discard it. */
3973 cxx_eval_constant_expression (ctx
, op0
,
3974 true, non_constant_p
, overflow_p
,
3976 if (*non_constant_p
)
3978 op1
= TREE_OPERAND (t
, 1);
3979 r
= cxx_eval_constant_expression (ctx
, op1
,
3980 lval
, non_constant_p
, overflow_p
,
3986 case POINTER_PLUS_EXPR
:
3987 r
= cxx_eval_pointer_plus_expression (ctx
, t
, lval
, non_constant_p
,
3996 case TRUNC_DIV_EXPR
:
3998 case FLOOR_DIV_EXPR
:
3999 case ROUND_DIV_EXPR
:
4000 case TRUNC_MOD_EXPR
:
4002 case ROUND_MOD_EXPR
:
4004 case EXACT_DIV_EXPR
:
4014 case TRUTH_XOR_EXPR
:
4021 case UNORDERED_EXPR
:
4031 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
4032 non_constant_p
, overflow_p
);
4035 /* fold can introduce non-IF versions of these; still treat them as
4036 short-circuiting. */
4037 case TRUTH_AND_EXPR
:
4038 case TRUTH_ANDIF_EXPR
:
4039 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
4042 non_constant_p
, overflow_p
);
4046 case TRUTH_ORIF_EXPR
:
4047 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
4050 non_constant_p
, overflow_p
);
4054 r
= cxx_eval_array_reference (ctx
, t
, lval
,
4055 non_constant_p
, overflow_p
);
4059 if (is_overloaded_fn (t
))
4061 /* We can only get here in checking mode via
4062 build_non_dependent_expr, because any expression that
4063 calls or takes the address of the function will have
4064 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4065 gcc_checking_assert (ctx
->quiet
|| errorcount
);
4066 *non_constant_p
= true;
4069 r
= cxx_eval_component_reference (ctx
, t
, lval
,
4070 non_constant_p
, overflow_p
);
4074 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
4075 non_constant_p
, overflow_p
);
4080 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
4081 non_constant_p
, overflow_p
,
4086 if (TREE_CONSTANT (t
))
4088 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4089 VECTOR_CST if applicable. */
4090 /* FIXME after GCC 6 branches, make the verify unconditional. */
4092 verify_constructor_flags (t
);
4094 recompute_constructor_flags (t
);
4095 if (TREE_CONSTANT (t
))
4098 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
4099 non_constant_p
, overflow_p
);
4103 /* We can get this in a defaulted constructor for a class with a
4104 non-static data member of array type. Either the initializer will
4105 be NULL, meaning default-initialization, or it will be an lvalue
4106 or xvalue of the same type, meaning direct-initialization from the
4107 corresponding member. */
4108 r
= cxx_eval_vec_init (ctx
, t
, lval
,
4109 non_constant_p
, overflow_p
);
4114 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
4115 non_constant_p
, overflow_p
);
4119 case VIEW_CONVERT_EXPR
:
4121 case UNARY_PLUS_EXPR
:
4123 tree oldop
= TREE_OPERAND (t
, 0);
4125 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
4127 non_constant_p
, overflow_p
);
4128 if (*non_constant_p
)
4130 tree type
= TREE_TYPE (t
);
4131 if (TREE_CODE (op
) == PTRMEM_CST
4132 && !TYPE_PTRMEM_P (type
))
4133 op
= cplus_expand_constant (op
);
4134 if (TREE_CODE (op
) == PTRMEM_CST
&& tcode
== NOP_EXPR
)
4136 if (same_type_ignoring_top_level_qualifiers_p (type
,
4142 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4143 "a reinterpret_cast is not a constant expression");
4144 *non_constant_p
= true;
4149 if (POINTER_TYPE_P (type
) && TREE_CODE (op
) == INTEGER_CST
)
4151 if (integer_zerop (op
))
4153 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4156 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4157 "dereferencing a null pointer");
4158 *non_constant_p
= true;
4161 else if (TREE_CODE (TREE_TYPE (op
)) == POINTER_TYPE
)
4163 tree from
= TREE_TYPE (op
);
4165 if (!can_convert (type
, from
, tf_none
))
4168 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4169 "conversion of %qT null pointer to %qT "
4170 "is not a constant expression",
4172 *non_constant_p
= true;
4179 /* This detects for example:
4180 reinterpret_cast<void*>(sizeof 0)
4183 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4184 "%<reinterpret_cast<%T>(%E)%> is not "
4185 "a constant expression",
4187 *non_constant_p
= true;
4191 if (op
== oldop
&& tcode
!= UNARY_PLUS_EXPR
)
4192 /* We didn't fold at the top so we could check for ptr-int
4195 if (tcode
== UNARY_PLUS_EXPR
)
4196 r
= fold_convert (TREE_TYPE (t
), op
);
4198 r
= fold_build1 (tcode
, type
, op
);
4199 /* Conversion of an out-of-range value has implementation-defined
4200 behavior; the language considers it different from arithmetic
4201 overflow, which is undefined. */
4202 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
4203 TREE_OVERFLOW (r
) = false;
4207 case EMPTY_CLASS_EXPR
:
4208 /* This is good enough for a function argument that might not get
4209 used, and they can't do anything with it, so just return it. */
4212 case STATEMENT_LIST
:
4214 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
4215 return cxx_eval_statement_list (&new_ctx
, t
,
4216 non_constant_p
, overflow_p
, jump_target
);
4219 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
4221 non_constant_p
, overflow_p
,
4224 case PREINCREMENT_EXPR
:
4225 case POSTINCREMENT_EXPR
:
4226 case PREDECREMENT_EXPR
:
4227 case POSTDECREMENT_EXPR
:
4228 return cxx_eval_increment_expression (ctx
, t
,
4229 lval
, non_constant_p
, overflow_p
);
4235 case VEC_DELETE_EXPR
:
4238 /* GCC internal stuff. */
4241 case WITH_CLEANUP_EXPR
:
4242 case NON_DEPENDENT_EXPR
:
4246 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4247 "expression %qE is not a constant expression", t
);
4248 *non_constant_p
= true;
4251 case PLACEHOLDER_EXPR
:
4252 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
)
4253 || !(same_type_ignoring_top_level_qualifiers_p
4254 (TREE_TYPE (t
), TREE_TYPE (ctx
->ctor
))))
4256 /* A placeholder without a referent. We can get here when
4257 checking whether NSDMIs are noexcept, or in massage_init_elt;
4258 just say it's non-constant for now. */
4259 gcc_assert (ctx
->quiet
);
4260 *non_constant_p
= true;
4265 /* Use of the value or address of the current object. We could
4266 use ctx->object unconditionally, but using ctx->ctor when we
4267 can is a minor optimization. */
4268 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
4269 return cxx_eval_constant_expression
4271 non_constant_p
, overflow_p
);
4277 tree cond
= TREE_OPERAND (t
, 0);
4278 cond
= cxx_eval_constant_expression (ctx
, cond
, /*lval*/false,
4279 non_constant_p
, overflow_p
);
4280 VERIFY_CONSTANT (cond
);
4281 if (integer_nonzerop (cond
))
4287 *jump_target
= TREE_OPERAND (t
, 0);
4288 gcc_assert (breaks (jump_target
) || continues (jump_target
));
4292 cxx_eval_loop_expr (ctx
, t
,
4293 non_constant_p
, overflow_p
, jump_target
);
4297 cxx_eval_switch_expr (ctx
, t
,
4298 non_constant_p
, overflow_p
, jump_target
);
4302 /* It's possible to get a requires-expression in a constant
4303 expression. For example:
4305 template<typename T> concept bool C() {
4306 return requires (T t) { t; };
4309 template<typename T> requires !C<T>() void f(T);
4311 Normalization leaves f with the associated constraint
4312 '!requires (T t) { ... }' which is not transformed into
4314 if (!processing_template_decl
)
4315 return evaluate_constraint_expression (t
, NULL_TREE
);
4317 *non_constant_p
= true;
4321 if (STATEMENT_CODE_P (TREE_CODE (t
)))
4323 /* This function doesn't know how to deal with pre-genericize
4324 statements; this can only happen with statement-expressions,
4325 so for now just fail. */
4327 error_at (EXPR_LOCATION (t
),
4328 "statement is not a constant expression");
4331 internal_error ("unexpected expression %qE of kind %s", t
,
4332 get_tree_code_name (TREE_CODE (t
)));
4333 *non_constant_p
= true;
4337 if (r
== error_mark_node
)
4338 *non_constant_p
= true;
4340 if (*non_constant_p
)
4347 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
4348 bool strict
= true, tree object
= NULL_TREE
)
4350 bool non_constant_p
= false;
4351 bool overflow_p
= false;
4352 hash_map
<tree
,tree
> map
;
4354 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
,
4355 allow_non_constant
, strict
};
4357 tree type
= initialized_type (t
);
4359 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
4361 /* In C++14 an NSDMI can participate in aggregate initialization,
4362 and can refer to the address of the object being initialized, so
4363 we need to pass in the relevant VAR_DECL if we want to do the
4364 evaluation in a single pass. The evaluation will dynamically
4365 update ctx.values for the VAR_DECL. We use the same strategy
4366 for C++11 constexpr constructors that refer to the object being
4368 ctx
.ctor
= build_constructor (type
, NULL
);
4369 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
4372 if (TREE_CODE (t
) == TARGET_EXPR
)
4373 object
= TARGET_EXPR_SLOT (t
);
4374 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4375 object
= AGGR_INIT_EXPR_SLOT (t
);
4377 ctx
.object
= object
;
4379 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4380 (type
, TREE_TYPE (object
)));
4381 if (object
&& DECL_P (object
))
4382 map
.put (object
, ctx
.ctor
);
4383 if (TREE_CODE (r
) == TARGET_EXPR
)
4384 /* Avoid creating another CONSTRUCTOR when we expand the
4386 r
= TARGET_EXPR_INITIAL (r
);
4389 r
= cxx_eval_constant_expression (&ctx
, r
,
4390 false, &non_constant_p
, &overflow_p
);
4392 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
4394 /* Mutable logic is a bit tricky: we want to allow initialization of
4395 constexpr variables with mutable members, but we can't copy those
4396 members to another constexpr variable. */
4397 if (TREE_CODE (r
) == CONSTRUCTOR
4398 && CONSTRUCTOR_MUTABLE_POISON (r
))
4400 if (!allow_non_constant
)
4401 error ("%qE is not a constant expression because it refers to "
4402 "mutable subobjects of %qT", t
, type
);
4403 non_constant_p
= true;
4406 /* Technically we should check this for all subexpressions, but that
4407 runs into problems with our internal representation of pointer
4408 subtraction and the 5.19 rules are still in flux. */
4409 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
4410 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
4411 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
4413 if (!allow_non_constant
)
4414 error ("conversion from pointer type %qT "
4415 "to arithmetic type %qT in a constant expression",
4416 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
4417 non_constant_p
= true;
4420 if (!non_constant_p
&& overflow_p
)
4421 non_constant_p
= true;
4423 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4425 bool should_unshare
= true;
4426 if (r
== t
|| TREE_CODE (r
) == CONSTRUCTOR
)
4427 should_unshare
= false;
4429 if (non_constant_p
&& !allow_non_constant
)
4430 return error_mark_node
;
4431 else if (non_constant_p
&& TREE_CONSTANT (r
))
4433 /* This isn't actually constant, so unset TREE_CONSTANT. */
4436 else if (TREE_CODE (r
) == CONSTRUCTOR
)
4437 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
4439 r
= build_nop (TREE_TYPE (r
), r
);
4440 TREE_CONSTANT (r
) = false;
4442 else if (non_constant_p
|| r
== t
)
4446 r
= unshare_expr (r
);
4448 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
4450 if (TREE_CODE (t
) == TARGET_EXPR
4451 && TARGET_EXPR_INITIAL (t
) == r
)
4455 r
= get_target_expr (r
);
4456 TREE_CONSTANT (r
) = true;
4464 /* Returns true if T is a valid subexpression of a constant expression,
4465 even if it isn't itself a constant expression. */
4468 is_sub_constant_expr (tree t
)
4470 bool non_constant_p
= false;
4471 bool overflow_p
= false;
4472 hash_map
<tree
, tree
> map
;
4474 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, NULL
, true, true };
4476 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
4478 return !non_constant_p
&& !overflow_p
;
4481 /* If T represents a constant expression returns its reduced value.
4482 Otherwise return error_mark_node. If T is dependent, then
4486 cxx_constant_value (tree t
, tree decl
)
4488 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
4491 /* Helper routine for fold_simple function. Either return simplified
4492 expression T, otherwise NULL_TREE.
4493 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4494 even if we are within template-declaration. So be careful on call, as in
4495 such case types can be undefined. */
4498 fold_simple_1 (tree t
)
4501 enum tree_code code
= TREE_CODE (t
);
4513 return fold_sizeof_expr (t
);
4521 case TRUTH_NOT_EXPR
:
4523 case VIEW_CONVERT_EXPR
:
4526 case FIX_TRUNC_EXPR
:
4527 case FIXED_CONVERT_EXPR
:
4528 case ADDR_SPACE_CONVERT_EXPR
:
4530 op1
= TREE_OPERAND (t
, 0);
4532 t
= const_unop (code
, TREE_TYPE (t
), op1
);
4536 if (CONVERT_EXPR_CODE_P (code
)
4537 && TREE_OVERFLOW_P (t
) && !TREE_OVERFLOW_P (op1
))
4538 TREE_OVERFLOW (t
) = false;
4546 /* If T is a simple constant expression, returns its simplified value.
4547 Otherwise returns T. In contrast to maybe_constant_value do we
4548 simplify only few operations on constant-expressions, and we don't
4549 try to simplify constexpressions. */
4552 fold_simple (tree t
)
4555 if (processing_template_decl
)
4558 r
= fold_simple_1 (t
);
4565 /* If T is a constant expression, returns its reduced value.
4566 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4567 Otherwise, returns a version of T without TREE_CONSTANT. */
4570 maybe_constant_value_1 (tree t
, tree decl
)
4574 if (!potential_nondependent_constant_expression (t
))
4576 if (TREE_OVERFLOW_P (t
))
4578 t
= build_nop (TREE_TYPE (t
), t
);
4579 TREE_CONSTANT (t
) = false;
4584 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
4585 gcc_checking_assert (r
== t
4586 || CONVERT_EXPR_P (t
)
4587 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4588 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4589 || !cp_tree_equal (r
, t
));
4593 static GTY((deletable
)) hash_map
<tree
, tree
> *cv_cache
;
4595 /* If T is a constant expression, returns its reduced value.
4596 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4597 Otherwise, returns a version of T without TREE_CONSTANT. */
4600 maybe_constant_value (tree t
, tree decl
)
4602 if (cv_cache
== NULL
)
4603 cv_cache
= hash_map
<tree
, tree
>::create_ggc (101);
4605 if (tree
*cached
= cv_cache
->get (t
))
4608 tree ret
= maybe_constant_value_1 (t
, decl
);
4609 cv_cache
->put (t
, ret
);
4613 /* Dispose of the whole CV_CACHE. */
4616 clear_cv_cache (void)
4618 if (cv_cache
!= NULL
)
4622 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4625 clear_cv_and_fold_caches (void)
4628 clear_fold_cache ();
4631 /* Like maybe_constant_value but first fully instantiate the argument.
4633 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4634 (t, tf_none) followed by maybe_constant_value but is more efficient,
4635 because calls instantiation_dependent_expression_p and
4636 potential_constant_expression at most once. */
4639 fold_non_dependent_expr (tree t
)
4644 /* If we're in a template, but T isn't value dependent, simplify
4645 it. We're supposed to treat:
4647 template <typename T> void f(T[1 + 1]);
4648 template <typename T> void f(T[2]);
4650 as two declarations of the same function, for example. */
4651 if (processing_template_decl
)
4653 if (potential_nondependent_constant_expression (t
))
4655 processing_template_decl_sentinel s
;
4656 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
4658 if (type_unknown_p (t
)
4659 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4661 if (TREE_OVERFLOW_P (t
))
4663 t
= build_nop (TREE_TYPE (t
), t
);
4664 TREE_CONSTANT (t
) = false;
4669 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
4670 /* cp_tree_equal looks through NOPs, so allow them. */
4671 gcc_checking_assert (r
== t
4672 || CONVERT_EXPR_P (t
)
4673 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4674 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
4675 || !cp_tree_equal (r
, t
));
4678 else if (TREE_OVERFLOW_P (t
))
4680 t
= build_nop (TREE_TYPE (t
), t
);
4681 TREE_CONSTANT (t
) = false;
4686 return maybe_constant_value (t
);
4689 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4690 than wrapped in a TARGET_EXPR. */
4693 maybe_constant_init (tree t
, tree decl
)
4697 if (TREE_CODE (t
) == EXPR_STMT
)
4698 t
= TREE_OPERAND (t
, 0);
4699 if (TREE_CODE (t
) == CONVERT_EXPR
4700 && VOID_TYPE_P (TREE_TYPE (t
)))
4701 t
= TREE_OPERAND (t
, 0);
4702 if (TREE_CODE (t
) == INIT_EXPR
)
4703 t
= TREE_OPERAND (t
, 1);
4704 if (!potential_nondependent_static_init_expression (t
))
4705 /* Don't try to evaluate it. */;
4707 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
4708 if (TREE_CODE (t
) == TARGET_EXPR
)
4710 tree init
= TARGET_EXPR_INITIAL (t
);
4711 if (TREE_CODE (init
) == CONSTRUCTOR
)
4718 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
4719 /* Return true if the object referred to by REF has automatic or thread
4722 enum { ck_ok
, ck_bad
, ck_unknown
};
4724 check_automatic_or_tls (tree ref
)
4727 HOST_WIDE_INT bitsize
, bitpos
;
4729 int volatilep
= 0, unsignedp
= 0;
4730 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
4731 &mode
, &unsignedp
, &volatilep
, false);
4734 /* If there isn't a decl in the middle, we don't know the linkage here,
4735 and this isn't a constant expression anyway. */
4738 dk
= decl_storage_duration (decl
);
4739 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
4743 /* Return true if T denotes a potentially constant expression. Issue
4744 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
4745 an lvalue-rvalue conversion is implied.
4747 C++0x [expr.const] used to say
4749 6 An expression is a potential constant expression if it is
4750 a constant expression where all occurrences of function
4751 parameters are replaced by arbitrary constant expressions
4752 of the appropriate type.
4754 2 A conditional expression is a constant expression unless it
4755 involves one of the following as a potentially evaluated
4756 subexpression (3.2), but subexpressions of logical AND (5.14),
4757 logical OR (5.15), and conditional (5.16) operations that are
4758 not evaluated are not considered. */
4761 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
4762 tsubst_flags_t flags
)
4764 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
4765 enum { any
= false, rval
= true };
4769 if (t
== error_mark_node
)
4773 if (TREE_THIS_VOLATILE (t
) && !DECL_P (t
))
4775 if (flags
& tf_error
)
4776 error ("expression %qE has side-effects", t
);
4779 if (CONSTANT_CLASS_P (t
))
4781 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_TYPED
)
4782 && TREE_TYPE (t
) == error_mark_node
)
4785 switch (TREE_CODE (t
))
4791 case TEMPLATE_ID_EXPR
:
4794 case CASE_LABEL_EXPR
:
4800 case TEMPLATE_PARM_INDEX
:
4802 case IDENTIFIER_NODE
:
4803 case USERDEF_LITERAL
:
4804 /* We can see a FIELD_DECL in a pointer-to-member expression. */
4810 case PLACEHOLDER_EXPR
:
4817 case AGGR_INIT_EXPR
:
4819 /* -- an invocation of a function other than a constexpr function
4820 or a constexpr constructor. */
4822 tree fun
= get_function_named_in_call (t
);
4823 const int nargs
= call_expr_nargs (t
);
4826 if (fun
== NULL_TREE
)
4828 /* Reset to allow the function to continue past the end
4829 of the block below. Otherwise return early. */
4832 if (TREE_CODE (t
) == CALL_EXPR
4833 && CALL_EXPR_FN (t
) == NULL_TREE
)
4834 switch (CALL_EXPR_IFN (t
))
4836 /* These should be ignored, they are optimized away from
4837 constexpr functions. */
4838 case IFN_UBSAN_NULL
:
4839 case IFN_UBSAN_BOUNDS
:
4840 case IFN_UBSAN_VPTR
:
4843 case IFN_ADD_OVERFLOW
:
4844 case IFN_SUB_OVERFLOW
:
4845 case IFN_MUL_OVERFLOW
:
4854 /* fold_call_expr can't do anything with IFN calls. */
4855 if (flags
& tf_error
)
4856 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4857 "call to internal function %qE", t
);
4862 if (fun
&& is_overloaded_fn (fun
))
4864 if (TREE_CODE (fun
) == FUNCTION_DECL
)
4866 if (builtin_valid_in_constant_expr_p (fun
))
4868 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
4869 /* Allow any built-in function; if the expansion
4870 isn't constant, we'll deal with that then. */
4871 && !is_builtin_fn (fun
))
4873 if (flags
& tf_error
)
4875 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4876 "call to non-constexpr function %qD", fun
);
4877 explain_invalid_constexpr_fn (fun
);
4881 /* A call to a non-static member function takes the address
4882 of the object as the first argument. But in a constant
4883 expression the address will be folded away, so look
4885 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
4886 && !DECL_CONSTRUCTOR_P (fun
))
4888 tree x
= get_nth_callarg (t
, 0);
4889 if (is_this_parameter (x
))
4891 else if (!RECUR (x
, rval
))
4898 if (!RECUR (fun
, true))
4900 fun
= get_first_fn (fun
);
4902 /* Skip initial arguments to base constructors. */
4903 if (DECL_BASE_CONSTRUCTOR_P (fun
))
4904 i
= num_artificial_parms_for (fun
);
4905 fun
= DECL_ORIGIN (fun
);
4909 if (RECUR (fun
, rval
))
4910 /* Might end up being a constant function pointer. */;
4914 for (; i
< nargs
; ++i
)
4916 tree x
= get_nth_callarg (t
, i
);
4917 /* In a template, reference arguments haven't been converted to
4918 REFERENCE_TYPE and we might not even know if the parameter
4919 is a reference, so accept lvalue constants too. */
4920 bool rv
= processing_template_decl
? any
: rval
;
4927 case NON_LVALUE_EXPR
:
4928 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
4929 -- an lvalue of integral type that refers to a non-volatile
4930 const variable or static data member initialized with
4931 constant expressions, or
4933 -- an lvalue of literal type that refers to non-volatile
4934 object defined with constexpr, or that refers to a
4935 sub-object of such an object; */
4936 return RECUR (TREE_OPERAND (t
, 0), rval
);
4940 && !var_in_maybe_constexpr_fn (t
)
4941 && !type_dependent_expression_p (t
)
4942 && !decl_constant_var_p (t
)
4944 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
4945 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
4946 && COMPLETE_TYPE_P (TREE_TYPE (t
))
4947 && !is_really_empty_class (TREE_TYPE (t
)))
4949 if (flags
& tf_error
)
4950 non_const_var_error (t
);
4957 case VIEW_CONVERT_EXPR
:
4958 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4959 may change to something more specific to type-punning (DR 1312). */
4961 tree from
= TREE_OPERAND (t
, 0);
4962 if (POINTER_TYPE_P (TREE_TYPE (t
))
4963 && TREE_CODE (from
) == INTEGER_CST
4964 && !integer_zerop (from
))
4966 if (flags
& tf_error
)
4967 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4968 "reinterpret_cast from integer to pointer");
4971 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
4975 /* -- a unary operator & that is applied to an lvalue that
4976 designates an object with thread or automatic storage
4978 t
= TREE_OPERAND (t
, 0);
4980 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
4981 /* A pointer-to-member constant. */
4985 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4986 any checking here, as we might dereference the pointer later. If
4987 we remove this code, also remove check_automatic_or_tls. */
4988 i
= check_automatic_or_tls (t
);
4993 if (flags
& tf_error
)
4994 error ("address-of an object %qE with thread local or "
4995 "automatic storage is not a constant expression", t
);
4999 return RECUR (t
, any
);
5005 /* -- a class member access unless its postfix-expression is
5006 of literal type or of pointer to literal type. */
5007 /* This test would be redundant, as it follows from the
5008 postfix-expression being a potential constant expression. */
5009 if (type_unknown_p (t
))
5011 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5013 case EXPR_PACK_EXPANSION
:
5014 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
5018 tree x
= TREE_OPERAND (t
, 0);
5020 if (is_this_parameter (x
))
5022 if (DECL_CONTEXT (x
)
5023 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
5025 if (flags
& tf_error
)
5026 error ("use of %<this%> in a constant expression");
5031 return RECUR (x
, rval
);
5034 case STATEMENT_LIST
:
5036 tree_stmt_iterator i
;
5037 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5039 if (!RECUR (tsi_stmt (i
), any
))
5047 if (cxx_dialect
< cxx14
)
5049 if (!RECUR (TREE_OPERAND (t
, 0), any
))
5051 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
5056 if (cxx_dialect
< cxx14
)
5058 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
5060 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
5065 if (!RECUR (DO_COND (t
), rval
))
5067 if (!RECUR (DO_BODY (t
), any
))
5072 if (!RECUR (FOR_INIT_STMT (t
), any
))
5074 if (!RECUR (FOR_COND (t
), rval
))
5076 if (!RECUR (FOR_EXPR (t
), any
))
5078 if (!RECUR (FOR_BODY (t
), any
))
5082 case RANGE_FOR_STMT
:
5083 if (!RECUR (RANGE_FOR_EXPR (t
), any
))
5085 if (!RECUR (RANGE_FOR_BODY (t
), any
))
5090 if (!RECUR (WHILE_COND (t
), rval
))
5092 if (!RECUR (WHILE_BODY (t
), any
))
5097 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
5099 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5100 unreachable labels would be checked. */
5104 return RECUR (STMT_EXPR_STMT (t
), rval
);
5107 case DYNAMIC_CAST_EXPR
:
5108 case PSEUDO_DTOR_EXPR
:
5112 case VEC_DELETE_EXPR
:
5115 case OMP_ATOMIC_READ
:
5116 case OMP_ATOMIC_CAPTURE_OLD
:
5117 case OMP_ATOMIC_CAPTURE_NEW
:
5118 /* GCC internal stuff. */
5121 case TRANSACTION_EXPR
:
5123 case AT_ENCODE_EXPR
:
5125 if (flags
& tf_error
)
5126 error ("expression %qE is not a constant expression", t
);
5130 /* -- a typeid expression whose operand is of polymorphic
5133 tree e
= TREE_OPERAND (t
, 0);
5134 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
5135 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
5137 if (flags
& tf_error
)
5138 error ("typeid-expression is not a constant expression "
5139 "because %qE is of polymorphic type", e
);
5158 case PREINCREMENT_EXPR
:
5159 case POSTINCREMENT_EXPR
:
5160 case PREDECREMENT_EXPR
:
5161 case POSTDECREMENT_EXPR
:
5162 if (cxx_dialect
< cxx14
)
5168 if (TYPE_P (TREE_OPERAND (t
, 0)))
5176 case FIX_TRUNC_EXPR
:
5180 case TRUTH_NOT_EXPR
:
5181 case FIXED_CONVERT_EXPR
:
5182 case UNARY_PLUS_EXPR
:
5183 case UNARY_LEFT_FOLD_EXPR
:
5184 case UNARY_RIGHT_FOLD_EXPR
:
5186 return RECUR (TREE_OPERAND (t
, 0), rval
);
5189 case CONST_CAST_EXPR
:
5190 case STATIC_CAST_EXPR
:
5191 case REINTERPRET_CAST_EXPR
:
5192 case IMPLICIT_CONV_EXPR
:
5193 if (cxx_dialect
< cxx11
5194 && !dependent_type_p (TREE_TYPE (t
))
5195 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
5196 /* In C++98, a conversion to non-integral type can't be part of a
5197 constant expression. */
5199 if (flags
& tf_error
)
5200 error ("cast to non-integral type %qT in a constant expression",
5205 return (RECUR (TREE_OPERAND (t
, 0),
5206 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
5209 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
5211 case WITH_CLEANUP_EXPR
:
5212 case CLEANUP_POINT_EXPR
:
5213 case MUST_NOT_THROW_EXPR
:
5214 case TRY_CATCH_EXPR
:
5219 case NON_DEPENDENT_EXPR
:
5220 /* For convenience. */
5224 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5227 tmp
= DECL_EXPR_DECL (t
);
5228 if (VAR_P (tmp
) && !DECL_ARTIFICIAL (tmp
))
5230 if (TREE_STATIC (tmp
))
5232 if (flags
& tf_error
)
5233 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5234 "%<static%> in %<constexpr%> function", tmp
);
5237 else if (CP_DECL_THREAD_LOCAL_P (tmp
))
5239 if (flags
& tf_error
)
5240 error_at (DECL_SOURCE_LOCATION (tmp
), "%qD declared "
5241 "%<thread_local%> in %<constexpr%> function", tmp
);
5244 else if (!DECL_NONTRIVIALLY_INITIALIZED_P (tmp
))
5246 if (flags
& tf_error
)
5247 error_at (DECL_SOURCE_LOCATION (tmp
), "uninitialized "
5248 "variable %qD in %<constexpr%> function", tmp
);
5252 return RECUR (tmp
, want_rval
);
5254 case TRY_FINALLY_EXPR
:
5255 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
5256 && RECUR (TREE_OPERAND (t
, 1), any
));
5259 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5262 if (!literal_type_p (TREE_TYPE (t
)))
5264 if (flags
& tf_error
)
5266 error ("temporary of non-literal type %qT in a "
5267 "constant expression", TREE_TYPE (t
));
5268 explain_non_literal_class (TREE_TYPE (t
));
5274 return RECUR (TREE_OPERAND (t
, 1), rval
);
5278 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5279 constructor_elt
*ce
;
5280 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5281 if (!RECUR (ce
->value
, want_rval
))
5288 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
5289 || DECL_P (TREE_PURPOSE (t
)));
5290 if (!RECUR (TREE_VALUE (t
), want_rval
))
5292 if (TREE_CHAIN (t
) == NULL_TREE
)
5294 return RECUR (TREE_CHAIN (t
), want_rval
);
5297 case TRUNC_DIV_EXPR
:
5299 case FLOOR_DIV_EXPR
:
5300 case ROUND_DIV_EXPR
:
5301 case TRUNC_MOD_EXPR
:
5303 case ROUND_MOD_EXPR
:
5305 tree denom
= TREE_OPERAND (t
, 1);
5306 if (!RECUR (denom
, rval
))
5308 /* We can't call cxx_eval_outermost_constant_expr on an expression
5309 that hasn't been through instantiate_non_dependent_expr yet. */
5310 if (!processing_template_decl
)
5311 denom
= cxx_eval_outermost_constant_expr (denom
, true);
5312 if (integer_zerop (denom
))
5314 if (flags
& tf_error
)
5315 error ("division by zero is not a constant expression");
5321 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
5327 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5328 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5329 introduced by build_call_a. */
5330 tree op0
= TREE_OPERAND (t
, 0);
5331 tree op1
= TREE_OPERAND (t
, 1);
5333 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
5334 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
5335 return RECUR (op0
, want_rval
);
5340 /* If the first operand is the non-short-circuit constant, look at
5341 the second operand; otherwise we only care about the first one for
5343 case TRUTH_AND_EXPR
:
5344 case TRUTH_ANDIF_EXPR
:
5345 tmp
= boolean_true_node
;
5348 case TRUTH_ORIF_EXPR
:
5349 tmp
= boolean_false_node
;
5352 tree op
= TREE_OPERAND (t
, 0);
5353 if (!RECUR (op
, rval
))
5355 if (!processing_template_decl
)
5356 op
= cxx_eval_outermost_constant_expr (op
, true);
5357 if (tree_int_cst_equal (op
, tmp
))
5358 return RECUR (TREE_OPERAND (t
, 1), rval
);
5365 case POINTER_PLUS_EXPR
:
5367 case EXACT_DIV_EXPR
:
5377 case TRUTH_XOR_EXPR
:
5378 case UNORDERED_EXPR
:
5391 case ARRAY_RANGE_REF
:
5395 case BINARY_LEFT_FOLD_EXPR
:
5396 case BINARY_RIGHT_FOLD_EXPR
:
5398 for (i
= 0; i
< 2; ++i
)
5399 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
5403 case CILK_SYNC_STMT
:
5404 case CILK_SPAWN_STMT
:
5405 case ARRAY_NOTATION_REF
:
5410 for (i
= 0; i
< 3; ++i
)
5411 if (!RECUR (TREE_OPERAND (t
, i
), true))
5416 if (COND_EXPR_IS_VEC_DELETE (t
))
5418 if (flags
& tf_error
)
5419 error_at (location_of (t
),
5420 "%<delete[]%> is not a constant expression");
5426 /* If the condition is a known constant, we know which of the legs we
5427 care about; otherwise we only require that the condition and
5428 either of the legs be potentially constant. */
5429 tmp
= TREE_OPERAND (t
, 0);
5430 if (!RECUR (tmp
, rval
))
5432 if (!processing_template_decl
)
5433 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
5434 if (integer_zerop (tmp
))
5435 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
5436 else if (TREE_CODE (tmp
) == INTEGER_CST
)
5437 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
5438 for (i
= 1; i
< 3; ++i
)
5439 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
5440 want_rval
, strict
, tf_none
))
5442 if (flags
& tf_error
)
5443 error ("expression %qE is not a constant expression", t
);
5447 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
5449 if (flags
& tf_error
)
5451 error ("non-constant array initialization");
5452 diagnose_non_constexpr_vec_init (t
);
5458 /* We can see these in statement-expressions. */
5461 case EMPTY_CLASS_EXPR
:
5466 tree
*target
= &TREE_OPERAND (t
, 0);
5467 /* Gotos representing break and continue are OK. */
5468 if (breaks (target
) || continues (target
))
5470 if (flags
& tf_error
)
5471 error ("%<goto%> is not a constant expression");
5476 if (objc_is_property_ref (t
))
5479 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
5486 /* The main entry point to the above. */
5489 potential_constant_expression (tree t
)
5491 return potential_constant_expression_1 (t
, false, true, tf_none
);
5495 potential_static_init_expression (tree t
)
5497 return potential_constant_expression_1 (t
, false, false, tf_none
);
5500 /* As above, but require a constant rvalue. */
5503 potential_rvalue_constant_expression (tree t
)
5505 return potential_constant_expression_1 (t
, true, true, tf_none
);
5508 /* Like above, but complain about non-constant expressions. */
5511 require_potential_constant_expression (tree t
)
5513 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
5516 /* Cross product of the above. */
5519 require_potential_rvalue_constant_expression (tree t
)
5521 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
5524 /* Returns true if T is a potential constant expression that is not
5525 instantiation-dependent, and therefore a candidate for constant folding even
5529 potential_nondependent_constant_expression (tree t
)
5531 return (!type_unknown_p (t
)
5532 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5533 && potential_constant_expression (t
)
5534 && !instantiation_dependent_expression_p (t
));
5537 /* Returns true if T is a potential static initializer expression that is not
5538 instantiation-dependent. */
5541 potential_nondependent_static_init_expression (tree t
)
5543 return (!type_unknown_p (t
)
5544 && !BRACE_ENCLOSED_INITIALIZER_P (t
)
5545 && potential_static_init_expression (t
)
5546 && !instantiation_dependent_expression_p (t
));
5549 /* Finalize constexpr processing after parsing. */
5552 fini_constexpr (void)
5554 /* The contexpr call and fundef copies tables are no longer needed. */
5555 constexpr_call_table
= NULL
;
5556 fundef_copies_table
= NULL
;
5559 #include "gt-cp-constexpr.h"