1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2015 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
32 #include "c-family/c-objc.h"
33 #include "tree-iterator.h"
36 #include "tree-inline.h"
39 static bool verify_constant (tree
, bool, bool *, bool *);
40 #define VERIFY_CONSTANT(X) \
42 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
46 /* Returns true iff FUN is an instantiation of a constexpr function
47 template or a defaulted constexpr function. */
50 is_instantiation_of_constexpr (tree fun
)
52 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
53 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
54 || (DECL_DEFAULTED_FN (fun
)
55 && DECL_DECLARED_CONSTEXPR_P (fun
)));
58 /* Return true if T is a literal type. */
61 literal_type_p (tree t
)
65 || TREE_CODE (t
) == REFERENCE_TYPE
66 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
70 t
= complete_type (t
);
71 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
72 return CLASSTYPE_LITERAL_P (t
);
74 if (TREE_CODE (t
) == ARRAY_TYPE
)
75 return literal_type_p (strip_array_types (t
));
79 /* If DECL is a variable declared `constexpr', require its type
80 be literal. Return the DECL if OK, otherwise NULL. */
83 ensure_literal_type_for_constexpr_object (tree decl
)
85 tree type
= TREE_TYPE (decl
);
87 && (DECL_DECLARED_CONSTEXPR_P (decl
)
88 || var_in_constexpr_fn (decl
))
89 && !processing_template_decl
)
91 tree stype
= strip_array_types (type
);
92 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
93 /* Don't complain here, we'll complain about incompleteness
94 when we try to initialize the variable. */;
95 else if (!literal_type_p (type
))
97 if (DECL_DECLARED_CONSTEXPR_P (decl
))
99 error ("the type %qT of constexpr variable %qD is not literal",
101 explain_non_literal_class (type
);
105 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
107 error ("variable %qD of non-literal type %qT in %<constexpr%> "
108 "function", decl
, type
);
109 explain_non_literal_class (type
);
111 cp_function_chain
->invalid_constexpr
= true;
119 /* Representation of entries in the constexpr function definition table. */
121 struct GTY((for_user
)) constexpr_fundef
{
126 struct constexpr_fundef_hasher
: ggc_ptr_hash
<constexpr_fundef
>
128 static hashval_t
hash (constexpr_fundef
*);
129 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
132 /* This table holds all constexpr function definitions seen in
133 the current translation unit. */
135 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
137 /* Utility function used for managing the constexpr function table.
138 Return true if the entries pointed to by P and Q are for the
139 same constexpr function. */
142 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
144 return lhs
->decl
== rhs
->decl
;
147 /* Utility function used for managing the constexpr function table.
148 Return a hash value for the entry pointed to by Q. */
151 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
153 return DECL_UID (fundef
->decl
);
156 /* Return a previously saved definition of function FUN. */
158 static constexpr_fundef
*
159 retrieve_constexpr_fundef (tree fun
)
161 constexpr_fundef fundef
= { NULL
, NULL
};
162 if (constexpr_fundef_table
== NULL
)
166 return constexpr_fundef_table
->find (&fundef
);
169 /* Check whether the parameter and return types of FUN are valid for a
170 constexpr function, and complain if COMPLAIN. */
173 is_valid_constexpr_fn (tree fun
, bool complain
)
177 if (DECL_INHERITED_CTOR_BASE (fun
)
178 && TREE_CODE (fun
) == TEMPLATE_DECL
)
182 error ("inherited constructor %qD is not constexpr",
183 get_inherited_ctor (fun
));
187 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
188 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
189 if (!literal_type_p (TREE_TYPE (parm
)))
194 error ("invalid type for parameter %d of constexpr "
195 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
196 explain_non_literal_class (TREE_TYPE (parm
));
201 if (!DECL_CONSTRUCTOR_P (fun
))
203 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
204 if (!literal_type_p (rettype
))
209 error ("invalid return type %qT of constexpr function %q+D",
211 explain_non_literal_class (rettype
);
215 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
216 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
221 error ("enclosing class of constexpr non-static member "
222 "function %q+#D is not a literal type", fun
);
223 explain_non_literal_class (DECL_CONTEXT (fun
));
227 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
231 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
237 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
238 for a member of an anonymous aggregate, INIT is the initializer for that
239 member, and VEC_OUTER is the vector of constructor elements for the class
240 whose constructor we are processing. Add the initializer to the vector
241 and return true to indicate success. */
244 build_anon_member_initialization (tree member
, tree init
,
245 vec
<constructor_elt
, va_gc
> **vec_outer
)
247 /* MEMBER presents the relevant fields from the inside out, but we need
248 to build up the initializer from the outside in so that we can reuse
249 previously built CONSTRUCTORs if this is, say, the second field in an
250 anonymous struct. So we use a vec as a stack. */
251 auto_vec
<tree
, 2> fields
;
254 fields
.safe_push (TREE_OPERAND (member
, 1));
255 member
= TREE_OPERAND (member
, 0);
257 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
258 && TREE_CODE (member
) == COMPONENT_REF
);
260 /* VEC has the constructor elements vector for the context of FIELD.
261 If FIELD is an anonymous aggregate, we will push inside it. */
262 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
264 while (field
= fields
.pop(),
265 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
268 /* If there is already an outer constructor entry for the anonymous
269 aggregate FIELD, use it; otherwise, insert one. */
270 if (vec_safe_is_empty (*vec
)
271 || (*vec
)->last().index
!= field
)
273 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
274 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
277 ctor
= (*vec
)->last().value
;
278 vec
= &CONSTRUCTOR_ELTS (ctor
);
281 /* Now we're at the innermost field, the one that isn't an anonymous
282 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
283 gcc_assert (fields
.is_empty());
284 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
289 /* Subroutine of build_constexpr_constructor_member_initializers.
290 The expression tree T represents a data member initialization
291 in a (constexpr) constructor definition. Build a pairing of
292 the data member with its initializer, and prepend that pair
293 to the existing initialization pair INITS. */
296 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
299 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
300 t
= TREE_OPERAND (t
, 0);
301 if (TREE_CODE (t
) == EXPR_STMT
)
302 t
= TREE_OPERAND (t
, 0);
303 if (t
== error_mark_node
)
305 if (TREE_CODE (t
) == STATEMENT_LIST
)
307 tree_stmt_iterator i
;
308 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
310 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
315 if (TREE_CODE (t
) == CLEANUP_STMT
)
317 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
318 but we can in a constexpr constructor for a non-literal class. Just
319 ignore it; either all the initialization will be constant, in which
320 case the cleanup can't run, or it can't be constexpr.
321 Still recurse into CLEANUP_BODY. */
322 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
324 if (TREE_CODE (t
) == CONVERT_EXPR
)
325 t
= TREE_OPERAND (t
, 0);
326 if (TREE_CODE (t
) == INIT_EXPR
327 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
328 use what this function builds for cx_check_missing_mem_inits, and
329 assignment in the ctor body doesn't count. */
330 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
332 member
= TREE_OPERAND (t
, 0);
333 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
335 else if (TREE_CODE (t
) == CALL_EXPR
)
337 tree fn
= get_callee_fndecl (t
);
338 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
339 /* We're only interested in calls to subobject constructors. */
341 member
= CALL_EXPR_ARG (t
, 0);
342 /* We don't use build_cplus_new here because it complains about
343 abstract bases. Leaving the call unwrapped means that it has the
344 wrong type, but cxx_eval_constant_expression doesn't care. */
345 init
= break_out_target_exprs (t
);
347 else if (TREE_CODE (t
) == BIND_EXPR
)
348 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
350 /* Don't add anything else to the CONSTRUCTOR. */
352 if (INDIRECT_REF_P (member
))
353 member
= TREE_OPERAND (member
, 0);
354 if (TREE_CODE (member
) == NOP_EXPR
)
358 if (TREE_CODE (op
) == ADDR_EXPR
)
360 gcc_assert (same_type_ignoring_top_level_qualifiers_p
361 (TREE_TYPE (TREE_TYPE (op
)),
362 TREE_TYPE (TREE_TYPE (member
))));
363 /* Initializing a cv-qualified member; we need to look through
367 else if (op
== current_class_ptr
368 && (same_type_ignoring_top_level_qualifiers_p
369 (TREE_TYPE (TREE_TYPE (member
)),
370 current_class_type
)))
371 /* Delegating constructor. */
375 /* This is an initializer for an empty base; keep it for now so
376 we can check it in cxx_eval_bare_aggregate. */
377 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
380 if (TREE_CODE (member
) == ADDR_EXPR
)
381 member
= TREE_OPERAND (member
, 0);
382 if (TREE_CODE (member
) == COMPONENT_REF
)
384 tree aggr
= TREE_OPERAND (member
, 0);
385 if (TREE_CODE (aggr
) != COMPONENT_REF
)
386 /* Normal member initialization. */
387 member
= TREE_OPERAND (member
, 1);
388 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
389 /* Initializing a member of an anonymous union. */
390 return build_anon_member_initialization (member
, init
, vec
);
392 /* We're initializing a vtable pointer in a base. Leave it as
393 COMPONENT_REF so we remember the path to get to the vfield. */
394 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
397 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
401 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
402 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
403 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
406 check_constexpr_bind_expr_vars (tree t
)
408 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
410 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
411 if (TREE_CODE (var
) == TYPE_DECL
412 && DECL_IMPLICIT_TYPEDEF_P (var
)
413 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
418 /* Subroutine of check_constexpr_ctor_body. */
421 check_constexpr_ctor_body_1 (tree last
, tree list
)
423 switch (TREE_CODE (list
))
426 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
)
430 case CLEANUP_POINT_EXPR
:
431 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
435 if (!check_constexpr_bind_expr_vars (list
)
436 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
450 /* Make sure that there are no statements after LAST in the constructor
451 body represented by LIST. */
454 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
456 /* C++14 doesn't require a constexpr ctor to have an empty body. */
457 if (cxx_dialect
>= cxx14
)
461 if (TREE_CODE (list
) == STATEMENT_LIST
)
463 tree_stmt_iterator i
= tsi_last (list
);
464 for (; !tsi_end_p (i
); tsi_prev (&i
))
466 tree t
= tsi_stmt (i
);
469 if (!check_constexpr_ctor_body_1 (last
, t
))
476 else if (list
!= last
477 && !check_constexpr_ctor_body_1 (last
, list
))
482 error ("constexpr constructor does not have empty body");
483 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
488 /* V is a vector of constructor elements built up for the base and member
489 initializers of a constructor for TYPE. They need to be in increasing
490 offset order, which they might not be yet if TYPE has a primary base
491 which is not first in the base-clause or a vptr and at least one base
492 all of which are non-primary. */
494 static vec
<constructor_elt
, va_gc
> *
495 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
497 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
503 field_type
= BINFO_TYPE (pri
);
504 else if (TYPE_CONTAINS_VPTR_P (type
))
505 field_type
= vtbl_ptr_type_node
;
509 /* Find the element for the primary base or vptr and move it to the
510 beginning of the vec. */
511 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
512 if (TREE_TYPE (ce
->index
) == field_type
)
515 if (i
> 0 && i
< vec_safe_length (v
))
517 vec
<constructor_elt
, va_gc
> &vref
= *v
;
518 constructor_elt elt
= vref
[i
];
527 /* Build compile-time evalable representations of member-initializer list
528 for a constexpr constructor. */
531 build_constexpr_constructor_member_initializers (tree type
, tree body
)
533 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
535 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
536 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
537 body
= TREE_OPERAND (body
, 0);
538 if (TREE_CODE (body
) == STATEMENT_LIST
)
540 for (tree_stmt_iterator i
= tsi_start (body
);
541 !tsi_end_p (i
); tsi_next (&i
))
544 if (TREE_CODE (body
) == BIND_EXPR
)
548 if (TREE_CODE (body
) == BIND_EXPR
)
549 body
= BIND_EXPR_BODY (body
);
550 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
552 body
= TREE_OPERAND (body
, 0);
553 if (TREE_CODE (body
) == EXPR_STMT
)
554 body
= TREE_OPERAND (body
, 0);
555 if (TREE_CODE (body
) == INIT_EXPR
556 && (same_type_ignoring_top_level_qualifiers_p
557 (TREE_TYPE (TREE_OPERAND (body
, 0)),
558 current_class_type
)))
561 return TREE_OPERAND (body
, 1);
563 ok
= build_data_member_initialization (body
, &vec
);
565 else if (TREE_CODE (body
) == STATEMENT_LIST
)
567 tree_stmt_iterator i
;
568 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
570 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
575 else if (TREE_CODE (body
) == TRY_BLOCK
)
577 error ("body of %<constexpr%> constructor cannot be "
578 "a function-try-block");
579 return error_mark_node
;
581 else if (EXPR_P (body
))
582 ok
= build_data_member_initialization (body
, &vec
);
584 gcc_assert (errorcount
> 0);
587 if (vec_safe_length (vec
) > 0)
589 /* In a delegating constructor, return the target. */
590 constructor_elt
*ce
= &(*vec
)[0];
591 if (ce
->index
== current_class_ptr
)
598 vec
= sort_constexpr_mem_initializers (type
, vec
);
599 return build_constructor (type
, vec
);
602 return error_mark_node
;
605 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
606 declared to be constexpr, or a sub-statement thereof. Returns the
607 return value if suitable, error_mark_node for a statement not allowed in
608 a constexpr function, or NULL_TREE if no return value was found. */
611 constexpr_fn_retval (tree body
)
613 switch (TREE_CODE (body
))
617 tree_stmt_iterator i
;
618 tree expr
= NULL_TREE
;
619 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
621 tree s
= constexpr_fn_retval (tsi_stmt (i
));
622 if (s
== error_mark_node
)
623 return error_mark_node
;
624 else if (s
== NULL_TREE
)
625 /* Keep iterating. */;
627 /* Multiple return statements. */
628 return error_mark_node
;
636 return break_out_target_exprs (TREE_OPERAND (body
, 0));
640 tree decl
= DECL_EXPR_DECL (body
);
641 if (TREE_CODE (decl
) == USING_DECL
642 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
643 || DECL_ARTIFICIAL (decl
))
645 return error_mark_node
;
648 case CLEANUP_POINT_EXPR
:
649 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
652 if (!check_constexpr_bind_expr_vars (body
))
653 return error_mark_node
;
654 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
660 return error_mark_node
;
664 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
665 FUN; do the necessary transformations to turn it into a single expression
666 that we can store in the hash table. */
669 massage_constexpr_body (tree fun
, tree body
)
671 if (DECL_CONSTRUCTOR_P (fun
))
672 body
= build_constexpr_constructor_member_initializers
673 (DECL_CONTEXT (fun
), body
);
674 else if (cxx_dialect
< cxx14
)
676 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
677 body
= EH_SPEC_STMTS (body
);
678 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
679 body
= TREE_OPERAND (body
, 0);
680 body
= constexpr_fn_retval (body
);
685 /* FUN is a constexpr constructor with massaged body BODY. Return true
686 if some bases/fields are uninitialized, and complain if COMPLAIN. */
689 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
696 if (TREE_CODE (body
) != CONSTRUCTOR
)
699 nelts
= CONSTRUCTOR_NELTS (body
);
700 ctype
= DECL_CONTEXT (fun
);
701 field
= TYPE_FIELDS (ctype
);
703 if (TREE_CODE (ctype
) == UNION_TYPE
)
705 if (nelts
== 0 && next_initializable_field (field
))
708 error ("%<constexpr%> constructor for union %qT must "
709 "initialize exactly one non-static data member", ctype
);
716 for (i
= 0; i
<= nelts
; ++i
)
723 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
724 /* Skip base and vtable inits. */
725 if (TREE_CODE (index
) != FIELD_DECL
726 || DECL_ARTIFICIAL (index
))
729 for (; field
!= index
; field
= DECL_CHAIN (field
))
732 if (TREE_CODE (field
) != FIELD_DECL
733 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
734 || DECL_ARTIFICIAL (field
))
736 ftype
= strip_array_types (TREE_TYPE (field
));
737 if (type_has_constexpr_default_constructor (ftype
))
739 /* It's OK to skip a member with a trivial constexpr ctor.
740 A constexpr ctor that isn't trivial should have been
742 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
748 error ("member %qD must be initialized by mem-initializer "
749 "in %<constexpr%> constructor", field
);
750 inform (DECL_SOURCE_LOCATION (field
), "declared here");
753 if (field
== NULL_TREE
)
755 field
= DECL_CHAIN (field
);
761 /* We are processing the definition of the constexpr function FUN.
762 Check that its BODY fulfills the propriate requirements and
763 enter it in the constexpr function definition table.
764 For constructor BODY is actually the TREE_LIST of the
765 member-initializer list. */
768 register_constexpr_fundef (tree fun
, tree body
)
770 constexpr_fundef entry
;
771 constexpr_fundef
**slot
;
773 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
776 body
= massage_constexpr_body (fun
, body
);
777 if (body
== NULL_TREE
|| body
== error_mark_node
)
779 if (!DECL_CONSTRUCTOR_P (fun
))
780 error ("body of constexpr function %qD not a return-statement", fun
);
784 if (!potential_rvalue_constant_expression (body
))
786 if (!DECL_GENERATED_P (fun
))
787 require_potential_rvalue_constant_expression (body
);
791 if (DECL_CONSTRUCTOR_P (fun
)
792 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
795 /* Create the constexpr function table if necessary. */
796 if (constexpr_fundef_table
== NULL
)
797 constexpr_fundef_table
798 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
802 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
804 gcc_assert (*slot
== NULL
);
805 *slot
= ggc_alloc
<constexpr_fundef
> ();
811 /* FUN is a non-constexpr function called in a context that requires a
812 constant expression. If it comes from a constexpr template, explain why
813 the instantiation isn't constexpr. */
816 explain_invalid_constexpr_fn (tree fun
)
818 static hash_set
<tree
> *diagnosed
;
821 /* Only diagnose defaulted functions or instantiations. */
822 if (!DECL_DEFAULTED_FN (fun
)
823 && !is_instantiation_of_constexpr (fun
))
825 if (diagnosed
== NULL
)
826 diagnosed
= new hash_set
<tree
>;
827 if (diagnosed
->add (fun
))
828 /* Already explained. */
831 save_loc
= input_location
;
832 input_location
= DECL_SOURCE_LOCATION (fun
);
833 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
834 /* First check the declaration. */
835 if (is_valid_constexpr_fn (fun
, true))
837 /* Then if it's OK, the body. */
838 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
839 explain_implicit_non_constexpr (fun
);
842 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
843 require_potential_rvalue_constant_expression (body
);
844 if (DECL_CONSTRUCTOR_P (fun
))
845 cx_check_missing_mem_inits (fun
, body
, true);
848 input_location
= save_loc
;
851 /* Objects of this type represent calls to constexpr functions
852 along with the bindings of parameters to their arguments, for
853 the purpose of compile time evaluation. */
855 struct GTY((for_user
)) constexpr_call
{
856 /* Description of the constexpr function definition. */
857 constexpr_fundef
*fundef
;
858 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
859 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
860 Note: This arrangement is made to accommodate the use of
861 iterative_hash_template_arg (see pt.c). If you change this
862 representation, also change the hash calculation in
863 cxx_eval_call_expression. */
865 /* Result of the call.
866 NULL means the call is being evaluated.
867 error_mark_node means that the evaluation was erroneous;
868 otherwise, the actuall value of the call. */
870 /* The hash of this call; we remember it here to avoid having to
871 recalculate it when expanding the hash table. */
875 struct constexpr_call_hasher
: ggc_ptr_hash
<constexpr_call
>
877 static hashval_t
hash (constexpr_call
*);
878 static bool equal (constexpr_call
*, constexpr_call
*);
881 /* The constexpr expansion context. CALL is the current function
882 expansion, CTOR is the current aggregate initializer, OBJECT is the
883 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
884 is a map of values of variables initialized within the expression. */
886 struct constexpr_ctx
{
887 /* The innermost call we're evaluating. */
888 constexpr_call
*call
;
889 /* Values for any temporaries or local variables within the
890 constant-expression. */
891 hash_map
<tree
,tree
> *values
;
892 /* The CONSTRUCTOR we're currently building up for an aggregate
895 /* The object we're building the CONSTRUCTOR for. */
897 /* Whether we should error on a non-constant expression or fail quietly. */
899 /* Whether we are strictly conforming to constant expression rules or
900 trying harder to get a constant value. */
904 /* A table of all constexpr calls that have been evaluated by the
905 compiler in this translation unit. */
907 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
909 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
910 bool, bool *, bool *, tree
* = NULL
);
912 /* Compute a hash value for a constexpr call representation. */
915 constexpr_call_hasher::hash (constexpr_call
*info
)
920 /* Return true if the objects pointed to by P and Q represent calls
921 to the same constexpr function with the same arguments.
922 Otherwise, return false. */
925 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
931 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
933 lhs_bindings
= lhs
->bindings
;
934 rhs_bindings
= rhs
->bindings
;
935 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
937 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
938 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
939 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
940 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
942 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
943 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
945 return lhs_bindings
== rhs_bindings
;
948 /* Initialize the constexpr call table, if needed. */
951 maybe_initialize_constexpr_call_table (void)
953 if (constexpr_call_table
== NULL
)
954 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
957 /* We have an expression tree T that represents a call, either CALL_EXPR
958 or AGGR_INIT_EXPR. If the call is lexically to a named function,
959 retrun the _DECL for that function. */
962 get_function_named_in_call (tree t
)
965 switch (TREE_CODE (t
))
968 fun
= CALL_EXPR_FN (t
);
972 fun
= AGGR_INIT_EXPR_FN (t
);
979 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
980 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
981 fun
= TREE_OPERAND (fun
, 0);
985 /* We have an expression tree T that represents a call, either CALL_EXPR
986 or AGGR_INIT_EXPR. Return the Nth argument. */
989 get_nth_callarg (tree t
, int n
)
991 switch (TREE_CODE (t
))
994 return CALL_EXPR_ARG (t
, n
);
997 return AGGR_INIT_EXPR_ARG (t
, n
);
1005 /* Attempt to evaluate T which represents a call to a builtin function.
1006 We assume here that all builtin functions evaluate to scalar types
1007 represented by _CST nodes. */
1010 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1012 bool *non_constant_p
, bool *overflow_p
)
1014 const int nargs
= call_expr_nargs (t
);
1015 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1019 /* Don't fold __builtin_constant_p within a constexpr function. */
1020 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
1021 && current_function_decl
1022 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1024 *non_constant_p
= true;
1028 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1029 return constant false for a non-constant argument. */
1030 constexpr_ctx new_ctx
= *ctx
;
1031 new_ctx
.quiet
= true;
1032 bool dummy1
= false, dummy2
= false;
1033 for (i
= 0; i
< nargs
; ++i
)
1034 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1035 lval
, &dummy1
, &dummy2
);
1037 bool save_ffbcp
= force_folding_builtin_constant_p
;
1038 force_folding_builtin_constant_p
= true;
1039 new_call
= fold_build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1040 CALL_EXPR_FN (t
), nargs
, args
);
1041 force_folding_builtin_constant_p
= save_ffbcp
;
1042 VERIFY_CONSTANT (new_call
);
1046 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1047 the type of the value to match. */
1050 adjust_temp_type (tree type
, tree temp
)
1052 if (TREE_TYPE (temp
) == type
)
1054 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1055 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1056 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1057 gcc_assert (scalarish_type_p (type
));
1058 return cp_fold_convert (type
, temp
);
1061 /* Subroutine of cxx_eval_call_expression.
1062 We are processing a call expression (either CALL_EXPR or
1063 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1064 all arguments and bind their values to correspondings
1065 parameters, making up the NEW_CALL context. */
1068 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1069 constexpr_call
*new_call
,
1070 bool *non_constant_p
, bool *overflow_p
,
1071 bool *non_constant_args
)
1073 const int nargs
= call_expr_nargs (t
);
1074 tree fun
= new_call
->fundef
->decl
;
1075 tree parms
= DECL_ARGUMENTS (fun
);
1077 tree
*p
= &new_call
->bindings
;
1078 for (i
= 0; i
< nargs
; ++i
)
1081 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1082 x
= get_nth_callarg (t
, i
);
1083 /* For member function, the first argument is a pointer to the implied
1084 object. For a constructor, it might still be a dummy object, in
1085 which case we get the real argument from ctx. */
1086 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1087 && is_dummy_object (x
))
1090 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1093 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1094 non_constant_p
, overflow_p
);
1095 /* Don't VERIFY_CONSTANT here. */
1096 if (*non_constant_p
&& ctx
->quiet
)
1098 /* Just discard ellipsis args after checking their constantitude. */
1101 if (*non_constant_p
)
1102 /* Don't try to adjust the type of non-constant args. */
1105 /* Make sure the binding has the same type as the parm. */
1106 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1107 arg
= adjust_temp_type (type
, arg
);
1108 if (!TREE_CONSTANT (arg
))
1109 *non_constant_args
= true;
1110 *p
= build_tree_list (parms
, arg
);
1111 p
= &TREE_CHAIN (*p
);
1113 parms
= TREE_CHAIN (parms
);
1117 /* Variables and functions to manage constexpr call expansion context.
1118 These do not need to be marked for PCH or GC. */
1120 /* FIXME remember and print actual constant arguments. */
1121 static vec
<tree
> call_stack
= vNULL
;
1122 static int call_stack_tick
;
1123 static int last_cx_error_tick
;
1126 push_cx_call_context (tree call
)
1129 if (!EXPR_HAS_LOCATION (call
))
1130 SET_EXPR_LOCATION (call
, input_location
);
1131 call_stack
.safe_push (call
);
1132 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1138 pop_cx_call_context (void)
1145 cx_error_context (void)
1147 vec
<tree
> r
= vNULL
;
1148 if (call_stack_tick
!= last_cx_error_tick
1149 && !call_stack
.is_empty ())
1151 last_cx_error_tick
= call_stack_tick
;
1155 /* Subroutine of cxx_eval_constant_expression.
1156 Evaluate the call expression tree T in the context of OLD_CALL expression
1160 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1162 bool *non_constant_p
, bool *overflow_p
)
1164 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1165 tree fun
= get_function_named_in_call (t
);
1166 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1169 if (fun
== NULL_TREE
)
1170 switch (CALL_EXPR_IFN (t
))
1172 case IFN_UBSAN_NULL
:
1173 case IFN_UBSAN_BOUNDS
:
1174 case IFN_UBSAN_VPTR
:
1178 error_at (loc
, "call to internal function");
1179 *non_constant_p
= true;
1183 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1185 /* Might be a constexpr function pointer. */
1186 fun
= cxx_eval_constant_expression (ctx
, fun
,
1187 /*lval*/false, non_constant_p
,
1190 if (TREE_CODE (fun
) == ADDR_EXPR
)
1191 fun
= TREE_OPERAND (fun
, 0);
1193 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1195 if (!ctx
->quiet
&& !*non_constant_p
)
1196 error_at (loc
, "expression %qE does not designate a constexpr "
1198 *non_constant_p
= true;
1201 if (DECL_CLONED_FUNCTION_P (fun
))
1202 fun
= DECL_CLONED_FUNCTION (fun
);
1204 if (is_ubsan_builtin_p (fun
))
1207 if (is_builtin_fn (fun
))
1208 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1209 lval
, non_constant_p
, overflow_p
);
1210 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1214 error_at (loc
, "call to non-constexpr function %qD", fun
);
1215 explain_invalid_constexpr_fn (fun
);
1217 *non_constant_p
= true;
1221 /* Shortcut trivial constructor/op=. */
1222 if (trivial_fn_p (fun
))
1224 if (call_expr_nargs (t
) == 2)
1226 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
1227 return cxx_eval_constant_expression (ctx
, arg
,
1228 lval
, non_constant_p
,
1231 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1232 && AGGR_INIT_ZERO_FIRST (t
))
1233 return build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1236 /* We can't defer instantiating the function any longer. */
1237 if (!DECL_INITIAL (fun
)
1238 && DECL_TEMPLOID_INSTANTIATION (fun
))
1241 instantiate_decl (fun
, /*defer_ok*/false, /*expl_inst*/false);
1245 /* If in direct recursive call, optimize definition search. */
1246 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1247 new_call
.fundef
= ctx
->call
->fundef
;
1250 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1251 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
1255 if (DECL_INITIAL (fun
))
1257 /* The definition of fun was somehow unsuitable. */
1258 error_at (loc
, "%qD called in a constant expression", fun
);
1259 explain_invalid_constexpr_fn (fun
);
1262 error_at (loc
, "%qD used before its definition", fun
);
1264 *non_constant_p
= true;
1269 constexpr_ctx new_ctx
= *ctx
;
1270 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1271 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1273 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1274 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1275 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1276 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1277 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1278 ctx
->values
->put (new_ctx
.object
, ctor
);
1282 bool non_constant_args
= false;
1283 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1284 non_constant_p
, overflow_p
, &non_constant_args
);
1285 if (*non_constant_p
)
1288 depth_ok
= push_cx_call_context (t
);
1290 tree result
= NULL_TREE
;
1292 constexpr_call
*entry
= NULL
;
1293 if (!non_constant_args
)
1295 new_call
.hash
= iterative_hash_template_arg
1296 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1298 /* If we have seen this call before, we are done. */
1299 maybe_initialize_constexpr_call_table ();
1300 constexpr_call
**slot
1301 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1305 /* We need to keep a pointer to the entry, not just the slot, as the
1306 slot can move in the call to cxx_eval_builtin_function_call. */
1307 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1310 /* Calls which are in progress have their result set to NULL
1311 so that we can detect circular dependencies. */
1312 else if (entry
->result
== NULL
)
1315 error ("call has circular dependency");
1316 *non_constant_p
= true;
1317 entry
->result
= result
= error_mark_node
;
1320 result
= entry
->result
;
1326 error ("constexpr evaluation depth exceeds maximum of %d (use "
1327 "-fconstexpr-depth= to increase the maximum)",
1328 max_constexpr_depth
);
1329 *non_constant_p
= true;
1330 result
= error_mark_node
;
1334 if (!result
|| result
== error_mark_node
)
1336 if (DECL_SAVED_TREE (fun
) == NULL_TREE
1337 && (DECL_CONSTRUCTOR_P (fun
) || DECL_DESTRUCTOR_P (fun
)))
1338 /* The maybe-in-charge 'tor had its DECL_SAVED_TREE
1339 cleared, try a clone. */
1340 for (fun
= DECL_CHAIN (fun
);
1341 fun
&& DECL_CLONED_FUNCTION_P (fun
);
1342 fun
= DECL_CHAIN (fun
))
1343 if (DECL_SAVED_TREE (fun
))
1345 gcc_assert (DECL_SAVED_TREE (fun
));
1348 /* Unshare the whole function body. */
1349 tree body
= copy_fn (fun
, parms
, res
);
1351 /* Associate the bindings with the remapped parms. */
1352 tree bound
= new_call
.bindings
;
1353 tree remapped
= parms
;
1356 tree oparm
= TREE_PURPOSE (bound
);
1357 tree arg
= TREE_VALUE (bound
);
1358 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1359 ctx
->values
->put (remapped
, arg
);
1360 bound
= TREE_CHAIN (bound
);
1361 remapped
= DECL_CHAIN (remapped
);
1363 /* Add the RESULT_DECL to the values map, too. */
1364 tree slot
= NULL_TREE
;
1365 if (DECL_BY_REFERENCE (res
))
1367 slot
= AGGR_INIT_EXPR_SLOT (t
);
1368 tree addr
= build_address (slot
);
1369 addr
= build_nop (TREE_TYPE (res
), addr
);
1370 ctx
->values
->put (res
, addr
);
1371 ctx
->values
->put (slot
, NULL_TREE
);
1374 ctx
->values
->put (res
, NULL_TREE
);
1376 tree jump_target
= NULL_TREE
;
1377 cxx_eval_constant_expression (ctx
, body
,
1378 lval
, non_constant_p
, overflow_p
,
1381 if (DECL_CONSTRUCTOR_P (fun
))
1382 /* This can be null for a subobject constructor call, in
1383 which case what we care about is the initialization
1384 side-effects rather than the value. We could get at the
1385 value by evaluating *this, but we don't bother; there's
1386 no need to put such a call in the hash table. */
1387 result
= lval
? ctx
->object
: ctx
->ctor
;
1388 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1392 result
= *ctx
->values
->get (slot
? slot
: res
);
1393 if (result
== NULL_TREE
&& !*non_constant_p
)
1396 error ("constexpr call flows off the end "
1398 *non_constant_p
= true;
1402 /* Remove the parms/result from the values map. Is it worth
1403 bothering to do this when the map itself is only live for
1404 one constexpr evaluation? If so, maybe also clear out
1405 other vars from call, maybe in BIND_EXPR handling? */
1406 ctx
->values
->remove (res
);
1408 ctx
->values
->remove (slot
);
1409 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1410 ctx
->values
->remove (parm
);
1413 if (result
== error_mark_node
)
1414 *non_constant_p
= true;
1415 if (*non_constant_p
)
1416 result
= error_mark_node
;
1420 entry
->result
= result
;
1423 pop_cx_call_context ();
1424 return unshare_expr (result
);
1427 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1430 reduced_constant_expression_p (tree t
)
1432 switch (TREE_CODE (t
))
1435 /* Even if we can't lower this yet, it's constant. */
1439 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1440 tree elt
; unsigned HOST_WIDE_INT idx
;
1441 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1442 if (!reduced_constant_expression_p (elt
))
1447 /* FIXME are we calling this too much? */
1448 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1452 /* Some expressions may have constant operands but are not constant
1453 themselves, such as 1/0. Call this function (or rather, the macro
1454 following it) to check for that condition.
1456 We only call this in places that require an arithmetic constant, not in
1457 places where we might have a non-constant expression that can be a
1458 component of a constant expression, such as the address of a constexpr
1459 variable that might be dereferenced later. */
1462 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1465 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1467 if (!allow_non_constant
)
1468 error ("%q+E is not a constant expression", t
);
1469 *non_constant_p
= true;
1471 if (TREE_OVERFLOW_P (t
))
1473 if (!allow_non_constant
)
1475 permerror (input_location
, "overflow in constant expression");
1476 /* If we're being permissive (and are in an enforcing
1477 context), ignore the overflow. */
1478 if (flag_permissive
)
1479 return *non_constant_p
;
1483 return *non_constant_p
;
1486 /* Check whether the shift operation with code CODE and type TYPE on LHS
1487 and RHS is undefined. If it is, give an error with an explanation,
1488 and return true; return false otherwise. */
1491 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1492 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1494 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1495 || TREE_CODE (lhs
) != INTEGER_CST
1496 || TREE_CODE (rhs
) != INTEGER_CST
)
1499 tree lhstype
= TREE_TYPE (lhs
);
1500 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1502 /* [expr.shift] The behavior is undefined if the right operand
1503 is negative, or greater than or equal to the length in bits
1504 of the promoted left operand. */
1505 if (tree_int_cst_sgn (rhs
) == -1)
1508 error_at (loc
, "right operand of shift expression %q+E is negative",
1509 build2_loc (loc
, code
, type
, lhs
, rhs
));
1512 if (compare_tree_int (rhs
, uprec
) >= 0)
1515 error_at (loc
, "right operand of shift expression %q+E is >= than "
1516 "the precision of the left operand",
1517 build2_loc (loc
, code
, type
, lhs
, rhs
));
1521 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1522 if E1 has a signed type and non-negative value, and E1x2^E2 is
1523 representable in the corresponding unsigned type of the result type,
1524 then that value, converted to the result type, is the resulting value;
1525 otherwise, the behavior is undefined. */
1526 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1527 && (cxx_dialect
>= cxx11
))
1529 if (tree_int_cst_sgn (lhs
) == -1)
1532 error_at (loc
, "left operand of shift expression %q+E is negative",
1533 build2_loc (loc
, code
, type
, lhs
, rhs
));
1536 /* For signed x << y the following:
1537 (unsigned) x >> ((prec (lhs) - 1) - y)
1538 if > 1, is undefined. The right-hand side of this formula
1539 is the highest bit of the LHS that can be set (starting from 0),
1540 so that the shift doesn't overflow. We then right-shift the LHS
1541 to see whether any other bit is set making the original shift
1542 undefined -- the result is not representable in the corresponding
1544 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1545 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1546 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1547 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1548 if (tree_int_cst_lt (integer_one_node
, t
))
1551 error_at (loc
, "shift expression %q+E overflows",
1552 build2_loc (loc
, code
, type
, lhs
, rhs
));
1559 /* Subroutine of cxx_eval_constant_expression.
1560 Attempt to reduce the unary expression tree T to a compile time value.
1561 If successful, return the value. Otherwise issue a diagnostic
1562 and return error_mark_node. */
1565 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1567 bool *non_constant_p
, bool *overflow_p
)
1570 tree orig_arg
= TREE_OPERAND (t
, 0);
1571 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1572 non_constant_p
, overflow_p
);
1573 VERIFY_CONSTANT (arg
);
1574 location_t loc
= EXPR_LOCATION (t
);
1575 enum tree_code code
= TREE_CODE (t
);
1576 tree type
= TREE_TYPE (t
);
1577 r
= fold_unary_loc (loc
, code
, type
, arg
);
1580 if (arg
== orig_arg
)
1583 r
= build1_loc (loc
, code
, type
, arg
);
1585 VERIFY_CONSTANT (r
);
1589 /* Subroutine of cxx_eval_constant_expression.
1590 Like cxx_eval_unary_expression, except for binary expressions. */
1593 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1595 bool *non_constant_p
, bool *overflow_p
)
1598 tree orig_lhs
= TREE_OPERAND (t
, 0);
1599 tree orig_rhs
= TREE_OPERAND (t
, 1);
1601 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1602 non_constant_p
, overflow_p
);
1603 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1604 a local array in a constexpr function. */
1605 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1607 VERIFY_CONSTANT (lhs
);
1608 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1609 non_constant_p
, overflow_p
);
1611 VERIFY_CONSTANT (rhs
);
1613 location_t loc
= EXPR_LOCATION (t
);
1614 enum tree_code code
= TREE_CODE (t
);
1615 tree type
= TREE_TYPE (t
);
1616 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1619 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1622 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1624 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1625 *non_constant_p
= true;
1627 VERIFY_CONSTANT (r
);
1631 /* Subroutine of cxx_eval_constant_expression.
1632 Attempt to evaluate condition expressions. Dead branches are not
1636 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1638 bool *non_constant_p
, bool *overflow_p
,
1641 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1643 non_constant_p
, overflow_p
);
1644 VERIFY_CONSTANT (val
);
1645 /* Don't VERIFY_CONSTANT the other operands. */
1646 if (integer_zerop (val
))
1647 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1649 non_constant_p
, overflow_p
,
1651 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1653 non_constant_p
, overflow_p
,
1657 /* Subroutine of cxx_eval_constant_expression.
1658 Attempt to reduce a reference to an array slot. */
1661 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
1663 bool *non_constant_p
, bool *overflow_p
)
1665 tree oldary
= TREE_OPERAND (t
, 0);
1666 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
1668 non_constant_p
, overflow_p
);
1672 unsigned len
, elem_nchars
= 1;
1673 if (*non_constant_p
)
1675 oldidx
= TREE_OPERAND (t
, 1);
1676 index
= cxx_eval_constant_expression (ctx
, oldidx
,
1678 non_constant_p
, overflow_p
);
1679 VERIFY_CONSTANT (index
);
1680 if (lval
&& ary
== oldary
&& index
== oldidx
)
1683 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
1684 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
1685 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1686 len
= CONSTRUCTOR_NELTS (ary
);
1687 else if (TREE_CODE (ary
) == STRING_CST
)
1689 elem_nchars
= (TYPE_PRECISION (elem_type
)
1690 / TYPE_PRECISION (char_type_node
));
1691 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
1695 /* We can't do anything with other tree codes, so use
1696 VERIFY_CONSTANT to complain and fail. */
1697 VERIFY_CONSTANT (ary
);
1700 if (compare_tree_int (index
, len
) >= 0)
1702 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
1704 /* If it's within the array bounds but doesn't have an explicit
1705 initializer, it's value-initialized. */
1706 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
1707 return cxx_eval_constant_expression (ctx
, val
,
1709 non_constant_p
, overflow_p
);
1713 error ("array subscript out of bound");
1714 *non_constant_p
= true;
1717 else if (tree_int_cst_lt (index
, integer_zero_node
))
1720 error ("negative array subscript");
1721 *non_constant_p
= true;
1724 i
= tree_to_shwi (index
);
1725 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1726 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
1727 else if (elem_nchars
== 1)
1728 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
1729 TREE_STRING_POINTER (ary
)[i
]);
1732 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
1733 return native_interpret_expr (type
, (const unsigned char *)
1734 TREE_STRING_POINTER (ary
)
1735 + i
* elem_nchars
, elem_nchars
);
1737 /* Don't VERIFY_CONSTANT here. */
1740 /* Subroutine of cxx_eval_constant_expression.
1741 Attempt to reduce a field access of a value of class type. */
1744 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
1746 bool *non_constant_p
, bool *overflow_p
)
1748 unsigned HOST_WIDE_INT i
;
1751 tree part
= TREE_OPERAND (t
, 1);
1752 tree orig_whole
= TREE_OPERAND (t
, 0);
1753 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1755 non_constant_p
, overflow_p
);
1756 if (whole
== orig_whole
)
1759 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
1760 whole
, part
, NULL_TREE
);
1761 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1763 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
1766 error ("%qE is not a constant expression", orig_whole
);
1767 *non_constant_p
= true;
1769 if (DECL_MUTABLE_P (part
))
1772 error ("mutable %qD is not usable in a constant expression", part
);
1773 *non_constant_p
= true;
1775 if (*non_constant_p
)
1777 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1784 /* We're in the middle of initializing it. */
1788 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
1789 && CONSTRUCTOR_NELTS (whole
) > 0)
1791 /* DR 1188 says we don't have to deal with this. */
1793 error ("accessing %qD member instead of initialized %qD member in "
1794 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
1795 *non_constant_p
= true;
1799 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
1801 /* 'whole' is part of the aggregate initializer we're currently
1802 building; if there's no initializer for this member yet, that's an
1805 error ("accessing uninitialized member %qD", part
);
1806 *non_constant_p
= true;
1810 /* If there's no explicit init for this field, it's value-initialized. */
1811 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
1812 return cxx_eval_constant_expression (ctx
, value
,
1814 non_constant_p
, overflow_p
);
1817 /* Subroutine of cxx_eval_constant_expression.
1818 Attempt to reduce a field access of a value of class type that is
1819 expressed as a BIT_FIELD_REF. */
1822 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
1824 bool *non_constant_p
, bool *overflow_p
)
1826 tree orig_whole
= TREE_OPERAND (t
, 0);
1827 tree retval
, fldval
, utype
, mask
;
1828 bool fld_seen
= false;
1829 HOST_WIDE_INT istart
, isize
;
1830 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1832 non_constant_p
, overflow_p
);
1833 tree start
, field
, value
;
1834 unsigned HOST_WIDE_INT i
;
1836 if (whole
== orig_whole
)
1838 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1840 if (!*non_constant_p
1841 && TREE_CODE (whole
) != VECTOR_CST
1842 && TREE_CODE (whole
) != CONSTRUCTOR
)
1845 error ("%qE is not a constant expression", orig_whole
);
1846 *non_constant_p
= true;
1848 if (*non_constant_p
)
1851 if (TREE_CODE (whole
) == VECTOR_CST
)
1852 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
1853 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
1855 start
= TREE_OPERAND (t
, 2);
1856 istart
= tree_to_shwi (start
);
1857 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
1858 utype
= TREE_TYPE (t
);
1859 if (!TYPE_UNSIGNED (utype
))
1860 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
1861 retval
= build_int_cst (utype
, 0);
1862 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1864 tree bitpos
= bit_position (field
);
1865 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
1867 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
1868 && TREE_CODE (value
) == INTEGER_CST
1869 && tree_fits_shwi_p (bitpos
)
1870 && tree_fits_shwi_p (DECL_SIZE (field
)))
1872 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
1873 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
1874 HOST_WIDE_INT shift
;
1875 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
1877 fldval
= fold_convert (utype
, value
);
1878 mask
= build_int_cst_type (utype
, -1);
1879 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
1880 size_int (TYPE_PRECISION (utype
) - sz
));
1881 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
1882 size_int (TYPE_PRECISION (utype
) - sz
));
1883 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
1884 shift
= bit
- istart
;
1885 if (BYTES_BIG_ENDIAN
)
1886 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
1887 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
1889 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
1895 return fold_convert (TREE_TYPE (t
), retval
);
1897 return error_mark_node
;
1900 /* Subroutine of cxx_eval_constant_expression.
1901 Evaluate a short-circuited logical expression T in the context
1902 of a given constexpr CALL. BAILOUT_VALUE is the value for
1903 early return. CONTINUE_VALUE is used here purely for
1904 sanity check purposes. */
1907 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
1908 tree bailout_value
, tree continue_value
,
1910 bool *non_constant_p
, bool *overflow_p
)
1913 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1915 non_constant_p
, overflow_p
);
1916 VERIFY_CONSTANT (lhs
);
1917 if (tree_int_cst_equal (lhs
, bailout_value
))
1919 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
1920 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1921 lval
, non_constant_p
,
1923 VERIFY_CONSTANT (r
);
1927 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
1928 CONSTRUCTOR elements to initialize (part of) an object containing that
1929 field. Return a pointer to the constructor_elt corresponding to the
1930 initialization of the field. */
1932 static constructor_elt
*
1933 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
1935 tree aggr
= TREE_OPERAND (ref
, 0);
1936 tree field
= TREE_OPERAND (ref
, 1);
1938 constructor_elt
*ce
;
1940 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
1942 if (TREE_CODE (aggr
) == COMPONENT_REF
)
1944 constructor_elt
*base_ce
1945 = base_field_constructor_elt (v
, aggr
);
1946 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
1949 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
1950 if (ce
->index
== field
)
1957 /* Some of the expressions fed to the constexpr mechanism are calls to
1958 constructors, which have type void. In that case, return the type being
1959 initialized by the constructor. */
1962 initialized_type (tree t
)
1966 tree type
= cv_unqualified (TREE_TYPE (t
));
1967 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
1969 /* A constructor call has void type, so we need to look deeper. */
1970 tree fn
= get_function_named_in_call (t
);
1971 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
1972 && DECL_CXX_CONSTRUCTOR_P (fn
))
1973 type
= DECL_CONTEXT (fn
);
1978 /* We're about to initialize element INDEX of an array or class from VALUE.
1979 Set up NEW_CTX appropriately by adjusting .object to refer to the
1980 subobject and creating a new CONSTRUCTOR if the element is itself
1981 a class or array. */
1984 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
1985 tree index
, tree
&value
)
1989 if (index
&& TREE_CODE (index
) != INTEGER_CST
1990 && TREE_CODE (index
) != FIELD_DECL
)
1991 /* This won't have an element in the new CONSTRUCTOR. */
1994 tree type
= initialized_type (value
);
1995 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
1996 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
1999 /* The sub-aggregate initializer might contain a placeholder;
2000 update object to refer to the subobject and ctor to refer to
2001 the (newly created) sub-initializer. */
2003 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2004 tree elt
= build_constructor (type
, NULL
);
2005 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2008 if (TREE_CODE (value
) == TARGET_EXPR
)
2009 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2010 value
= TARGET_EXPR_INITIAL (value
);
2013 /* We're about to process an initializer for a class or array TYPE. Make
2014 sure that CTX is set up appropriately. */
2017 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2019 /* We don't bother building a ctor for an empty base subobject. */
2020 if (is_empty_class (type
))
2023 /* We're in the middle of an initializer that might involve placeholders;
2024 our caller should have created a CONSTRUCTOR for us to put the
2025 initializer into. We will either return that constructor or T. */
2026 gcc_assert (ctx
->ctor
);
2027 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2028 (type
, TREE_TYPE (ctx
->ctor
)));
2029 gcc_assert (CONSTRUCTOR_NELTS (ctx
->ctor
) == 0);
2031 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2032 (type
, TREE_TYPE (ctx
->object
)));
2033 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2034 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2037 /* Subroutine of cxx_eval_constant_expression.
2038 The expression tree T denotes a C-style array or a C-style
2039 aggregate. Reduce it to a constant expression. */
2042 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2044 bool *non_constant_p
, bool *overflow_p
)
2046 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2047 bool changed
= false;
2048 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2050 verify_ctor_sanity (ctx
, TREE_TYPE (t
));
2051 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2052 vec_alloc (*p
, vec_safe_length (v
));
2054 unsigned i
; tree index
, value
;
2055 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2057 constexpr_ctx new_ctx
;
2058 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2059 if (new_ctx
.ctor
!= ctx
->ctor
)
2060 /* If we built a new CONSTRUCTOR, attach it now so that other
2061 initializers can refer to it. */
2062 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2063 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2065 non_constant_p
, overflow_p
);
2066 /* Don't VERIFY_CONSTANT here. */
2067 if (ctx
->quiet
&& *non_constant_p
)
2071 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2073 /* This is an initialization of a vfield inside a base
2074 subaggregate that we already initialized; push this
2075 initialization into the previous initialization. */
2076 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2081 && (TREE_CODE (index
) == NOP_EXPR
2082 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2084 /* This is an initializer for an empty base; now that we've
2085 checked that it's constant, we can ignore it. */
2086 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2089 else if (new_ctx
.ctor
!= ctx
->ctor
)
2091 /* We appended this element above; update the value. */
2092 gcc_assert ((*p
)->last().index
== index
);
2093 (*p
)->last().value
= elt
;
2096 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2098 if (*non_constant_p
|| !changed
)
2101 /* We're done building this CONSTRUCTOR, so now we can interpret an
2102 element without an explicit initializer as value-initialized. */
2103 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2104 if (VECTOR_TYPE_P (TREE_TYPE (t
)))
2109 /* Subroutine of cxx_eval_constant_expression.
2110 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2111 initialization of a non-static data member of array type. Reduce it to a
2114 Note that apart from value-initialization (when VALUE_INIT is true),
2115 this is only intended to support value-initialization and the
2116 initializations done by defaulted constructors for classes with
2117 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2118 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2119 for the copy/move constructor. */
2122 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2123 bool value_init
, bool lval
,
2124 bool *non_constant_p
, bool *overflow_p
)
2126 tree elttype
= TREE_TYPE (atype
);
2127 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2128 verify_ctor_sanity (ctx
, atype
);
2129 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2130 vec_alloc (*p
, max
+ 1);
2131 bool pre_init
= false;
2132 unsigned HOST_WIDE_INT i
;
2134 /* For the default constructor, build up a call to the default
2135 constructor of the element type. We only need to handle class types
2136 here, as for a constructor to be constexpr, all members must be
2137 initialized, which for a defaulted default constructor means they must
2138 be of a class type with a constexpr default constructor. */
2139 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2140 /* We only do this at the lowest level. */;
2141 else if (value_init
)
2143 init
= build_value_init (elttype
, tf_warning_or_error
);
2148 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2149 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2150 &argvec
, elttype
, LOOKUP_NORMAL
,
2151 tf_warning_or_error
);
2152 release_tree_vector (argvec
);
2153 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2157 for (i
= 0; i
< max
; ++i
)
2159 tree idx
= build_int_cst (size_type_node
, i
);
2161 constexpr_ctx new_ctx
;
2162 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2163 if (new_ctx
.ctor
!= ctx
->ctor
)
2164 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2165 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2167 /* A multidimensional array; recurse. */
2168 if (value_init
|| init
== NULL_TREE
)
2169 eltinit
= NULL_TREE
;
2171 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2172 tf_warning_or_error
);
2173 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2175 non_constant_p
, overflow_p
);
2179 /* Initializing an element using value or default initialization
2180 we just pre-built above. */
2181 eltinit
= (cxx_eval_constant_expression
2183 lval
, non_constant_p
, overflow_p
));
2187 /* Copying an element. */
2188 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2189 (atype
, TREE_TYPE (init
)));
2190 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2191 tf_warning_or_error
);
2192 if (!real_lvalue_p (init
))
2193 eltinit
= move (eltinit
);
2194 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2195 eltinit
= (cxx_eval_constant_expression
2196 (&new_ctx
, eltinit
, lval
,
2197 non_constant_p
, overflow_p
));
2199 if (*non_constant_p
&& !ctx
->quiet
)
2201 if (new_ctx
.ctor
!= ctx
->ctor
)
2203 /* We appended this element above; update the value. */
2204 gcc_assert ((*p
)->last().index
== idx
);
2205 (*p
)->last().value
= eltinit
;
2208 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2211 if (!*non_constant_p
)
2214 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2220 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2222 bool *non_constant_p
, bool *overflow_p
)
2224 tree atype
= TREE_TYPE (t
);
2225 tree init
= VEC_INIT_EXPR_INIT (t
);
2226 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2227 VEC_INIT_EXPR_VALUE_INIT (t
),
2228 lval
, non_constant_p
, overflow_p
);
2229 if (*non_constant_p
)
2235 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2236 match. We want to be less strict for simple *& folding; if we have a
2237 non-const temporary that we access through a const pointer, that should
2238 work. We handle this here rather than change fold_indirect_ref_1
2239 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2240 don't really make sense outside of constant expression evaluation. Also
2241 we want to allow folding to COMPONENT_REF, which could cause trouble
2242 with TBAA in fold_indirect_ref_1.
2244 Try to keep this function synced with fold_indirect_ref_1. */
2247 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2253 subtype
= TREE_TYPE (sub
);
2254 if (!POINTER_TYPE_P (subtype
))
2257 if (TREE_CODE (sub
) == ADDR_EXPR
)
2259 tree op
= TREE_OPERAND (sub
, 0);
2260 tree optype
= TREE_TYPE (op
);
2262 /* *&CONST_DECL -> to the value of the const decl. */
2263 if (TREE_CODE (op
) == CONST_DECL
)
2264 return DECL_INITIAL (op
);
2265 /* *&p => p; make sure to handle *&"str"[cst] here. */
2266 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
2268 tree fop
= fold_read_from_constant_string (op
);
2274 /* *(foo *)&fooarray => fooarray[0] */
2275 else if (TREE_CODE (optype
) == ARRAY_TYPE
2276 && (same_type_ignoring_top_level_qualifiers_p
2277 (type
, TREE_TYPE (optype
))))
2279 tree type_domain
= TYPE_DOMAIN (optype
);
2280 tree min_val
= size_zero_node
;
2281 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2282 min_val
= TYPE_MIN_VALUE (type_domain
);
2283 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2284 NULL_TREE
, NULL_TREE
);
2286 /* *(foo *)&complexfoo => __real__ complexfoo */
2287 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2288 && (same_type_ignoring_top_level_qualifiers_p
2289 (type
, TREE_TYPE (optype
))))
2290 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2291 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2292 else if (VECTOR_TYPE_P (optype
)
2293 && (same_type_ignoring_top_level_qualifiers_p
2294 (type
, TREE_TYPE (optype
))))
2296 tree part_width
= TYPE_SIZE (type
);
2297 tree index
= bitsize_int (0);
2298 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2300 /* Also handle conversion to an empty base class, which
2301 is represented with a NOP_EXPR. */
2302 else if (is_empty_class (type
)
2303 && CLASS_TYPE_P (optype
)
2304 && DERIVED_FROM_P (type
, optype
))
2309 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2310 else if (RECORD_OR_UNION_TYPE_P (optype
))
2312 tree field
= TYPE_FIELDS (optype
);
2313 for (; field
; field
= DECL_CHAIN (field
))
2314 if (TREE_CODE (field
) == FIELD_DECL
2315 && integer_zerop (byte_position (field
))
2316 && (same_type_ignoring_top_level_qualifiers_p
2317 (TREE_TYPE (field
), type
)))
2319 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2324 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2325 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2327 tree op00
= TREE_OPERAND (sub
, 0);
2328 tree op01
= TREE_OPERAND (sub
, 1);
2331 if (TREE_CODE (op00
) == ADDR_EXPR
)
2334 op00
= TREE_OPERAND (op00
, 0);
2335 op00type
= TREE_TYPE (op00
);
2337 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2338 if (VECTOR_TYPE_P (op00type
)
2339 && (same_type_ignoring_top_level_qualifiers_p
2340 (type
, TREE_TYPE (op00type
))))
2342 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2343 tree part_width
= TYPE_SIZE (type
);
2344 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2345 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2346 tree index
= bitsize_int (indexi
);
2348 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2349 return fold_build3_loc (loc
,
2350 BIT_FIELD_REF
, type
, op00
,
2354 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2355 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2356 && (same_type_ignoring_top_level_qualifiers_p
2357 (type
, TREE_TYPE (op00type
))))
2359 tree size
= TYPE_SIZE_UNIT (type
);
2360 if (tree_int_cst_equal (size
, op01
))
2361 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2363 /* ((foo *)&fooarray)[1] => fooarray[1] */
2364 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2365 && (same_type_ignoring_top_level_qualifiers_p
2366 (type
, TREE_TYPE (op00type
))))
2368 tree type_domain
= TYPE_DOMAIN (op00type
);
2369 tree min_val
= size_zero_node
;
2370 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2371 min_val
= TYPE_MIN_VALUE (type_domain
);
2372 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2373 TYPE_SIZE_UNIT (type
));
2374 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2375 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2376 NULL_TREE
, NULL_TREE
);
2378 /* Also handle conversion to an empty base class, which
2379 is represented with a NOP_EXPR. */
2380 else if (is_empty_class (type
)
2381 && CLASS_TYPE_P (op00type
)
2382 && DERIVED_FROM_P (type
, op00type
))
2387 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2388 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2390 tree field
= TYPE_FIELDS (op00type
);
2391 for (; field
; field
= DECL_CHAIN (field
))
2392 if (TREE_CODE (field
) == FIELD_DECL
2393 && tree_int_cst_equal (byte_position (field
), op01
)
2394 && (same_type_ignoring_top_level_qualifiers_p
2395 (TREE_TYPE (field
), type
)))
2397 return fold_build3 (COMPONENT_REF
, type
, op00
,
2404 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2405 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2406 && (same_type_ignoring_top_level_qualifiers_p
2407 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2410 tree min_val
= size_zero_node
;
2411 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2415 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2416 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2417 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2418 min_val
= TYPE_MIN_VALUE (type_domain
);
2419 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2427 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2429 bool *non_constant_p
, bool *overflow_p
)
2431 tree orig_op0
= TREE_OPERAND (t
, 0);
2432 bool empty_base
= false;
2434 /* First try to simplify it directly. */
2435 tree r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), orig_op0
,
2439 /* If that didn't work, evaluate the operand first. */
2440 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2441 /*lval*/false, non_constant_p
,
2443 /* Don't VERIFY_CONSTANT here. */
2444 if (*non_constant_p
)
2447 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2451 /* We couldn't fold to a constant value. Make sure it's not
2452 something we should have been able to fold. */
2455 if (TREE_CODE (sub
) == ADDR_EXPR
)
2457 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2458 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
2459 /* DR 1188 says we don't have to deal with this. */
2461 error ("accessing value of %qE through a %qT glvalue in a "
2462 "constant expression", build_fold_indirect_ref (sub
),
2464 *non_constant_p
= true;
2468 if (lval
&& op0
!= orig_op0
)
2469 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
2471 VERIFY_CONSTANT (t
);
2476 r
= cxx_eval_constant_expression (ctx
, r
,
2477 lval
, non_constant_p
, overflow_p
);
2478 if (*non_constant_p
)
2481 /* If we're pulling out the value of an empty base, make sure
2482 that the whole object is constant and then return an empty
2484 if (empty_base
&& !lval
)
2486 VERIFY_CONSTANT (r
);
2487 r
= build_constructor (TREE_TYPE (t
), NULL
);
2488 TREE_CONSTANT (r
) = true;
2494 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2495 Shared between potential_constant_expression and
2496 cxx_eval_constant_expression. */
2499 non_const_var_error (tree r
)
2501 tree type
= TREE_TYPE (r
);
2502 error ("the value of %qD is not usable in a constant "
2504 /* Avoid error cascade. */
2505 if (DECL_INITIAL (r
) == error_mark_node
)
2507 if (DECL_DECLARED_CONSTEXPR_P (r
))
2508 inform (DECL_SOURCE_LOCATION (r
),
2509 "%qD used in its own initializer", r
);
2510 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
2512 if (!CP_TYPE_CONST_P (type
))
2513 inform (DECL_SOURCE_LOCATION (r
),
2514 "%q#D is not const", r
);
2515 else if (CP_TYPE_VOLATILE_P (type
))
2516 inform (DECL_SOURCE_LOCATION (r
),
2517 "%q#D is volatile", r
);
2518 else if (!DECL_INITIAL (r
)
2519 || !TREE_CONSTANT (DECL_INITIAL (r
)))
2520 inform (DECL_SOURCE_LOCATION (r
),
2521 "%qD was not initialized with a constant "
2528 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
2529 inform (DECL_SOURCE_LOCATION (r
),
2530 "%qD was not declared %<constexpr%>", r
);
2532 inform (DECL_SOURCE_LOCATION (r
),
2533 "%qD does not have integral or enumeration type",
2538 /* Subroutine of cxx_eval_constant_expression.
2539 Like cxx_eval_unary_expression, except for trinary expressions. */
2542 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
2544 bool *non_constant_p
, bool *overflow_p
)
2550 for (i
= 0; i
< 3; i
++)
2552 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
2554 non_constant_p
, overflow_p
);
2555 VERIFY_CONSTANT (args
[i
]);
2558 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
2559 args
[0], args
[1], args
[2]);
2560 if (val
== NULL_TREE
)
2562 VERIFY_CONSTANT (val
);
2567 var_in_constexpr_fn (tree t
)
2569 tree ctx
= DECL_CONTEXT (t
);
2570 return (cxx_dialect
>= cxx14
&& ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
2571 && DECL_DECLARED_CONSTEXPR_P (ctx
));
2574 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
2577 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
2579 bool *non_constant_p
, bool *overflow_p
)
2581 constexpr_ctx new_ctx
= *ctx
;
2583 tree init
= TREE_OPERAND (t
, 1);
2584 if (TREE_CLOBBER_P (init
))
2585 /* Just ignore clobbers. */
2588 /* First we figure out where we're storing to. */
2589 tree target
= TREE_OPERAND (t
, 0);
2590 tree type
= TREE_TYPE (target
);
2591 target
= cxx_eval_constant_expression (ctx
, target
,
2593 non_constant_p
, overflow_p
);
2594 if (*non_constant_p
)
2597 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
2599 /* For initialization of an empty base, the original target will be
2600 *(base*)this, which the above evaluation resolves to the object
2601 argument, which has the derived type rather than the base type. In
2602 this situation, just evaluate the initializer and return, since
2603 there's no actual data to store. */
2604 gcc_assert (is_empty_class (type
));
2605 return cxx_eval_constant_expression (ctx
, init
, false,
2606 non_constant_p
, overflow_p
);
2609 /* And then find the underlying variable. */
2610 vec
<tree
,va_gc
> *refs
= make_tree_vector();
2611 tree object
= NULL_TREE
;
2612 for (tree probe
= target
; object
== NULL_TREE
; )
2614 switch (TREE_CODE (probe
))
2619 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
2620 vec_safe_push (refs
, TREE_TYPE (probe
));
2621 probe
= TREE_OPERAND (probe
, 0);
2629 /* And then find/build up our initializer for the path to the subobject
2630 we're initializing. */
2632 if (DECL_P (object
))
2633 valp
= ctx
->values
->get (object
);
2638 /* A constant-expression cannot modify objects from outside the
2639 constant-expression. */
2641 error ("modification of %qE is not a constant-expression", object
);
2642 *non_constant_p
= true;
2645 type
= TREE_TYPE (object
);
2646 while (!refs
->is_empty())
2648 if (*valp
== NULL_TREE
)
2650 *valp
= build_constructor (type
, NULL
);
2651 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = true;
2656 ce
.index
= refs
->pop();
2657 ce
.value
= NULL_TREE
;
2659 unsigned HOST_WIDE_INT idx
= 0;
2660 constructor_elt
*cep
= NULL
;
2662 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
2665 if (cp_tree_equal (ce
.index
, cep
->index
))
2668 cep
= vec_safe_push (CONSTRUCTOR_ELTS (*valp
), ce
);
2671 release_tree_vector (refs
);
2673 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
2675 /* Create a new CONSTRUCTOR in case evaluation of the initializer
2676 wants to modify it. */
2677 new_ctx
.ctor
= build_constructor (type
, NULL
);
2678 if (*valp
== NULL_TREE
)
2679 *valp
= new_ctx
.ctor
;
2680 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
2681 new_ctx
.object
= target
;
2684 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
2685 non_constant_p
, overflow_p
);
2686 if (target
== object
)
2688 /* The hash table might have moved since the get earlier. */
2689 valp
= ctx
->values
->get (object
);
2690 if (TREE_CODE (init
) == CONSTRUCTOR
)
2691 /* An outer ctx->ctor might be pointing to *valp, so just replace
2693 CONSTRUCTOR_ELTS (*valp
) = CONSTRUCTOR_ELTS (init
);
2700 if (*non_constant_p
)
2708 /* Evaluate a ++ or -- expression. */
2711 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
2713 bool *non_constant_p
, bool *overflow_p
)
2715 enum tree_code code
= TREE_CODE (t
);
2716 tree type
= TREE_TYPE (t
);
2717 tree op
= TREE_OPERAND (t
, 0);
2718 tree offset
= TREE_OPERAND (t
, 1);
2719 gcc_assert (TREE_CONSTANT (offset
));
2721 /* The operand as an lvalue. */
2722 op
= cxx_eval_constant_expression (ctx
, op
, true,
2723 non_constant_p
, overflow_p
);
2725 /* The operand as an rvalue. */
2726 tree val
= rvalue (op
);
2727 val
= cxx_eval_constant_expression (ctx
, val
, false,
2728 non_constant_p
, overflow_p
);
2729 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2730 a local array in a constexpr function. */
2731 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
2733 VERIFY_CONSTANT (val
);
2735 /* The modified value. */
2736 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
2738 if (POINTER_TYPE_P (type
))
2740 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
2741 offset
= convert_to_ptrofftype (offset
);
2743 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
2744 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
2747 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
2749 VERIFY_CONSTANT (mod
);
2751 /* Storing the modified value. */
2752 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
2753 cxx_eval_constant_expression (ctx
, store
,
2754 true, non_constant_p
, overflow_p
);
2756 /* And the value of the expression. */
2757 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
2759 /* Prefix ops are lvalues. */
2763 /* But we optimize when the caller wants an rvalue. */
2767 /* Postfix ops are rvalues. */
2771 /* Predicates for the meaning of *jump_target. */
2774 returns (tree
*jump_target
)
2777 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
2781 breaks (tree
*jump_target
)
2784 && TREE_CODE (*jump_target
) == LABEL_DECL
2785 && LABEL_DECL_BREAK (*jump_target
);
2789 continues (tree
*jump_target
)
2792 && TREE_CODE (*jump_target
) == LABEL_DECL
2793 && LABEL_DECL_CONTINUE (*jump_target
);
2797 switches (tree
*jump_target
)
2800 && TREE_CODE (*jump_target
) == INTEGER_CST
;
2803 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
2804 at I matches *jump_target. If we're looking for a case label and we see
2805 the default label, copy I into DEFAULT_LABEL. */
2808 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
2809 tree_stmt_iterator
& default_label
)
2811 tree stmt
= tsi_stmt (i
);
2812 switch (TREE_CODE (*jump_target
))
2815 if (TREE_CODE (stmt
) == LABEL_EXPR
2816 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
2821 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
2823 if (!CASE_LOW (stmt
))
2825 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
2836 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
2837 semantics, for switch, break, continue, and return. */
2840 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
2841 bool *non_constant_p
, bool *overflow_p
,
2844 tree_stmt_iterator i
;
2845 tree_stmt_iterator default_label
= tree_stmt_iterator();
2847 /* In a statement-expression we want to return the last value. */
2851 local_target
= NULL_TREE
;
2852 jump_target
= &local_target
;
2854 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
2857 tree stmt
= tsi_stmt (i
);
2860 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
2861 /* The label we want might be inside. */;
2862 else if (label_matches (jump_target
, i
, default_label
))
2864 *jump_target
= NULL_TREE
;
2868 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
2869 non_constant_p
, overflow_p
,
2871 if (*non_constant_p
)
2873 if (returns (jump_target
) || breaks (jump_target
))
2876 if (switches (jump_target
) && !tsi_end_p (default_label
))
2879 *jump_target
= NULL_TREE
;
2885 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
2886 semantics; continue semantics are covered by cxx_eval_statement_list. */
2889 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
2890 bool *non_constant_p
, bool *overflow_p
,
2893 tree body
= TREE_OPERAND (t
, 0);
2896 cxx_eval_statement_list (ctx
, body
,
2897 non_constant_p
, overflow_p
, jump_target
);
2898 if (returns (jump_target
) || breaks (jump_target
) || *non_constant_p
)
2901 if (breaks (jump_target
))
2902 *jump_target
= NULL_TREE
;
2906 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
2910 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
2911 bool *non_constant_p
, bool *overflow_p
,
2914 tree cond
= TREE_OPERAND (t
, 0);
2915 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
2916 non_constant_p
, overflow_p
);
2917 VERIFY_CONSTANT (cond
);
2918 *jump_target
= cond
;
2920 tree body
= TREE_OPERAND (t
, 1);
2921 cxx_eval_statement_list (ctx
, body
,
2922 non_constant_p
, overflow_p
, jump_target
);
2923 if (breaks (jump_target
) || switches (jump_target
))
2924 *jump_target
= NULL_TREE
;
2928 /* Subroutine of cxx_eval_constant_expression.
2929 Attempt to reduce a POINTER_PLUS_EXPR expression T. */
2932 cxx_eval_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
2933 bool lval
, bool *non_constant_p
,
2936 tree orig_type
= TREE_TYPE (t
);
2937 tree op00
= TREE_OPERAND (t
, 0);
2938 tree op01
= TREE_OPERAND (t
, 1);
2939 location_t loc
= EXPR_LOCATION (t
);
2941 op00
= cxx_eval_constant_expression (ctx
, op00
, lval
,
2942 non_constant_p
, overflow_p
);
2945 if (TREE_CODE (op00
) != ADDR_EXPR
)
2948 op00
= TREE_OPERAND (op00
, 0);
2950 /* &A[i] p+ j => &A[i + j] */
2951 if (TREE_CODE (op00
) == ARRAY_REF
2952 && TREE_CODE (TREE_OPERAND (op00
, 1)) == INTEGER_CST
2953 && TREE_CODE (op01
) == INTEGER_CST
2954 && TYPE_SIZE_UNIT (TREE_TYPE (op00
))
2955 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (op00
))) == INTEGER_CST
)
2957 tree type
= TREE_TYPE (op00
);
2958 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (op00
, 1));
2959 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (op00
, 0)));
2960 /* Don't fold an out-of-bound access. */
2961 if (!tree_int_cst_le (t
, nelts
))
2963 op01
= cp_fold_convert (ssizetype
, op01
);
2964 /* Don't fold if op01 can't be divided exactly by TYPE_SIZE_UNIT.
2965 constexpr int A[1]; ... (char *)&A[0] + 1 */
2966 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
2967 op01
, TYPE_SIZE_UNIT (type
))))
2969 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2971 op01
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, op01
,
2972 TYPE_SIZE_UNIT (type
));
2973 t
= size_binop_loc (loc
, PLUS_EXPR
, op01
, t
);
2974 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (op00
, 0),
2975 t
, NULL_TREE
, NULL_TREE
);
2976 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2977 t
= cp_fold_convert (orig_type
, t
);
2978 return cxx_eval_constant_expression (ctx
, t
, lval
, non_constant_p
,
2985 /* Attempt to reduce the expression T to a constant value.
2986 On failure, issue diagnostic and return error_mark_node. */
2987 /* FIXME unify with c_fully_fold */
2988 /* FIXME overflow_p is too global */
2991 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
2993 bool *non_constant_p
, bool *overflow_p
,
2996 constexpr_ctx new_ctx
;
2999 if (t
== error_mark_node
)
3001 *non_constant_p
= true;
3004 if (CONSTANT_CLASS_P (t
))
3006 if (TREE_CODE (t
) == PTRMEM_CST
)
3007 t
= cplus_expand_constant (t
);
3008 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| ctx
->quiet
))
3013 switch (TREE_CODE (t
))
3018 /* We ask for an rvalue for the RESULT_DECL when indirecting
3019 through an invisible reference, or in named return value
3021 return (*ctx
->values
->get (t
));
3025 /* We used to not check lval for CONST_DECL, but darwin.c uses
3026 CONST_DECL for aggregate constants. */
3030 r
= decl_really_constant_value (t
);
3032 r
= decl_constant_value (t
);
3033 if (TREE_CODE (r
) == TARGET_EXPR
3034 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3035 r
= TARGET_EXPR_INITIAL (r
);
3037 if (tree
*p
= ctx
->values
->get (r
))
3042 non_const_var_error (r
);
3043 *non_constant_p
= true;
3051 case CASE_LABEL_EXPR
:
3055 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
3057 else if (tree
*p
= ctx
->values
->get (r
))
3060 /* Defer in case this is only used for its type. */;
3061 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3062 /* Defer, there's no lvalue->rvalue conversion. */;
3063 else if (is_empty_class (TREE_TYPE (t
)))
3065 /* If the class is empty, we aren't actually loading anything. */
3066 r
= build_constructor (TREE_TYPE (t
), NULL
);
3067 TREE_CONSTANT (r
) = true;
3072 error ("%qE is not a constant expression", t
);
3073 *non_constant_p
= true;
3078 case AGGR_INIT_EXPR
:
3079 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3080 non_constant_p
, overflow_p
);
3085 r
= DECL_EXPR_DECL (t
);
3086 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3087 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3091 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3092 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3093 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3097 if (tree init
= DECL_INITIAL (r
))
3099 init
= cxx_eval_constant_expression (ctx
, init
,
3101 non_constant_p
, overflow_p
);
3102 ctx
->values
->put (r
, init
);
3104 else if (ctx
== &new_ctx
)
3105 /* We gave it a CONSTRUCTOR above. */;
3107 ctx
->values
->put (r
, NULL_TREE
);
3112 if (!literal_type_p (TREE_TYPE (t
)))
3116 error ("temporary of non-literal type %qT in a "
3117 "constant expression", TREE_TYPE (t
));
3118 explain_non_literal_class (TREE_TYPE (t
));
3120 *non_constant_p
= true;
3123 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3125 /* We're being expanded without an explicit target, so start
3126 initializing a new object; expansion with an explicit target
3127 strips the TARGET_EXPR before we get here. */
3129 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3130 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3131 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3132 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3135 /* Pass false for 'lval' because this indicates
3136 initialization of a temporary. */
3137 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3139 non_constant_p
, overflow_p
);
3140 if (!*non_constant_p
)
3141 /* Adjust the type of the result to the type of the temporary. */
3142 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3145 tree slot
= TARGET_EXPR_SLOT (t
);
3146 ctx
->values
->put (slot
, r
);
3153 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3154 non_constant_p
, overflow_p
);
3158 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3160 non_constant_p
, overflow_p
);
3164 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
3165 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3167 non_constant_p
, overflow_p
);
3172 /* Avoid evaluating a SAVE_EXPR more than once. */
3173 if (tree
*p
= ctx
->values
->get (t
))
3177 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3178 non_constant_p
, overflow_p
);
3179 ctx
->values
->put (t
, r
);
3183 case NON_LVALUE_EXPR
:
3184 case TRY_CATCH_EXPR
:
3186 case CLEANUP_POINT_EXPR
:
3187 case MUST_NOT_THROW_EXPR
:
3190 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3192 non_constant_p
, overflow_p
,
3196 case TRY_FINALLY_EXPR
:
3197 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), lval
,
3198 non_constant_p
, overflow_p
,
3200 if (!*non_constant_p
)
3201 /* Also evaluate the cleanup. */
3202 cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1), true,
3203 non_constant_p
, overflow_p
,
3207 /* These differ from cxx_eval_unary_expression in that this doesn't
3208 check for a constant operand or result; an address can be
3209 constant without its operand being, and vice versa. */
3211 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3212 non_constant_p
, overflow_p
);
3217 tree oldop
= TREE_OPERAND (t
, 0);
3218 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3220 non_constant_p
, overflow_p
);
3221 /* Don't VERIFY_CONSTANT here. */
3222 if (*non_constant_p
)
3224 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3225 /* This function does more aggressive folding than fold itself. */
3226 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3227 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3235 case FIX_TRUNC_EXPR
:
3240 case TRUTH_NOT_EXPR
:
3241 case FIXED_CONVERT_EXPR
:
3242 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3243 non_constant_p
, overflow_p
);
3247 if (SIZEOF_EXPR_TYPE_P (t
))
3248 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
3249 SIZEOF_EXPR
, false);
3250 else if (TYPE_P (TREE_OPERAND (t
, 0)))
3251 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3254 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3256 if (r
== error_mark_node
)
3258 VERIFY_CONSTANT (r
);
3263 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3264 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3265 introduced by build_call_a. */
3266 tree op0
= TREE_OPERAND (t
, 0);
3267 tree op1
= TREE_OPERAND (t
, 1);
3269 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3270 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3271 r
= cxx_eval_constant_expression (ctx
, op0
,
3272 lval
, non_constant_p
, overflow_p
,
3276 /* Check that the LHS is constant and then discard it. */
3277 cxx_eval_constant_expression (ctx
, op0
,
3278 true, non_constant_p
, overflow_p
,
3280 op1
= TREE_OPERAND (t
, 1);
3281 r
= cxx_eval_constant_expression (ctx
, op1
,
3282 lval
, non_constant_p
, overflow_p
,
3288 case POINTER_PLUS_EXPR
:
3289 r
= cxx_eval_pointer_plus_expression (ctx
, t
, lval
, non_constant_p
,
3293 /* else fall through */
3298 case TRUNC_DIV_EXPR
:
3300 case FLOOR_DIV_EXPR
:
3301 case ROUND_DIV_EXPR
:
3302 case TRUNC_MOD_EXPR
:
3304 case ROUND_MOD_EXPR
:
3306 case EXACT_DIV_EXPR
:
3316 case TRUTH_XOR_EXPR
:
3323 case UNORDERED_EXPR
:
3333 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3334 non_constant_p
, overflow_p
);
3337 /* fold can introduce non-IF versions of these; still treat them as
3338 short-circuiting. */
3339 case TRUTH_AND_EXPR
:
3340 case TRUTH_ANDIF_EXPR
:
3341 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
3344 non_constant_p
, overflow_p
);
3348 case TRUTH_ORIF_EXPR
:
3349 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
3352 non_constant_p
, overflow_p
);
3356 r
= cxx_eval_array_reference (ctx
, t
, lval
,
3357 non_constant_p
, overflow_p
);
3361 if (is_overloaded_fn (t
))
3363 /* We can only get here in checking mode via
3364 build_non_dependent_expr, because any expression that
3365 calls or takes the address of the function will have
3366 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3367 gcc_checking_assert (ctx
->quiet
|| errorcount
);
3368 *non_constant_p
= true;
3371 r
= cxx_eval_component_reference (ctx
, t
, lval
,
3372 non_constant_p
, overflow_p
);
3376 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
3377 non_constant_p
, overflow_p
);
3382 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
3383 non_constant_p
, overflow_p
,
3388 if (TREE_CONSTANT (t
))
3389 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3390 VECTOR_CST if applicable. */
3392 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
3393 non_constant_p
, overflow_p
);
3397 /* We can get this in a defaulted constructor for a class with a
3398 non-static data member of array type. Either the initializer will
3399 be NULL, meaning default-initialization, or it will be an lvalue
3400 or xvalue of the same type, meaning direct-initialization from the
3401 corresponding member. */
3402 r
= cxx_eval_vec_init (ctx
, t
, lval
,
3403 non_constant_p
, overflow_p
);
3408 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
3409 non_constant_p
, overflow_p
);
3413 case VIEW_CONVERT_EXPR
:
3416 tree oldop
= TREE_OPERAND (t
, 0);
3417 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3419 non_constant_p
, overflow_p
);
3420 if (*non_constant_p
)
3422 if (POINTER_TYPE_P (TREE_TYPE (t
))
3423 && TREE_CODE (op
) == INTEGER_CST
3424 && !integer_zerop (op
))
3427 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3428 "reinterpret_cast from integer to pointer");
3429 *non_constant_p
= true;
3433 /* We didn't fold at the top so we could check for ptr-int
3436 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
3437 /* Conversion of an out-of-range value has implementation-defined
3438 behavior; the language considers it different from arithmetic
3439 overflow, which is undefined. */
3440 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
3441 TREE_OVERFLOW (r
) = false;
3445 case EMPTY_CLASS_EXPR
:
3446 /* This is good enough for a function argument that might not get
3447 used, and they can't do anything with it, so just return it. */
3450 case STATEMENT_LIST
:
3452 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3453 return cxx_eval_statement_list (&new_ctx
, t
,
3454 non_constant_p
, overflow_p
, jump_target
);
3457 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
3459 non_constant_p
, overflow_p
,
3462 case PREINCREMENT_EXPR
:
3463 case POSTINCREMENT_EXPR
:
3464 case PREDECREMENT_EXPR
:
3465 case POSTDECREMENT_EXPR
:
3466 return cxx_eval_increment_expression (ctx
, t
,
3467 lval
, non_constant_p
, overflow_p
);
3473 case VEC_DELETE_EXPR
:
3476 /* GCC internal stuff. */
3479 case WITH_CLEANUP_EXPR
:
3480 case NON_DEPENDENT_EXPR
:
3484 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3485 "expression %qE is not a constant-expression", t
);
3486 *non_constant_p
= true;
3489 case PLACEHOLDER_EXPR
:
3490 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
)
3491 || !(same_type_ignoring_top_level_qualifiers_p
3492 (TREE_TYPE (t
), TREE_TYPE (ctx
->ctor
))))
3494 /* A placeholder without a referent. We can get here when
3495 checking whether NSDMIs are noexcept, or in massage_init_elt;
3496 just say it's non-constant for now. */
3497 gcc_assert (ctx
->quiet
);
3498 *non_constant_p
= true;
3503 /* Use of the value or address of the current object. We could
3504 use ctx->object unconditionally, but using ctx->ctor when we
3505 can is a minor optimization. */
3506 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
3507 return cxx_eval_constant_expression
3509 non_constant_p
, overflow_p
);
3514 *jump_target
= TREE_OPERAND (t
, 0);
3515 gcc_assert (breaks (jump_target
) || continues (jump_target
));
3519 cxx_eval_loop_expr (ctx
, t
,
3520 non_constant_p
, overflow_p
, jump_target
);
3524 cxx_eval_switch_expr (ctx
, t
,
3525 non_constant_p
, overflow_p
, jump_target
);
3529 if (STATEMENT_CODE_P (TREE_CODE (t
)))
3531 /* This function doesn't know how to deal with pre-genericize
3532 statements; this can only happen with statement-expressions,
3533 so for now just fail. */
3535 error_at (EXPR_LOCATION (t
),
3536 "statement is not a constant-expression");
3539 internal_error ("unexpected expression %qE of kind %s", t
,
3540 get_tree_code_name (TREE_CODE (t
)));
3541 *non_constant_p
= true;
3545 if (r
== error_mark_node
)
3546 *non_constant_p
= true;
3548 if (*non_constant_p
)
3555 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
3556 bool strict
= true, tree object
= NULL_TREE
)
3558 bool non_constant_p
= false;
3559 bool overflow_p
= false;
3560 hash_map
<tree
,tree
> map
;
3561 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, allow_non_constant
, strict
};
3562 tree type
= initialized_type (t
);
3564 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3566 /* In C++14 an NSDMI can participate in aggregate initialization,
3567 and can refer to the address of the object being initialized, so
3568 we need to pass in the relevant VAR_DECL if we want to do the
3569 evaluation in a single pass. The evaluation will dynamically
3570 update ctx.values for the VAR_DECL. We use the same strategy
3571 for C++11 constexpr constructors that refer to the object being
3573 ctx
.ctor
= build_constructor (type
, NULL
);
3574 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
3577 if (TREE_CODE (t
) == TARGET_EXPR
)
3578 object
= TARGET_EXPR_SLOT (t
);
3579 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3580 object
= AGGR_INIT_EXPR_SLOT (t
);
3582 ctx
.object
= object
;
3584 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3585 (type
, TREE_TYPE (object
)));
3586 if (object
&& DECL_P (object
))
3587 map
.put (object
, ctx
.ctor
);
3588 if (TREE_CODE (r
) == TARGET_EXPR
)
3589 /* Avoid creating another CONSTRUCTOR when we expand the
3591 r
= TARGET_EXPR_INITIAL (r
);
3594 r
= cxx_eval_constant_expression (&ctx
, r
,
3595 false, &non_constant_p
, &overflow_p
);
3597 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
3599 /* Mutable logic is a bit tricky: we want to allow initialization of
3600 constexpr variables with mutable members, but we can't copy those
3601 members to another constexpr variable. */
3602 if (TREE_CODE (r
) == CONSTRUCTOR
3603 && CONSTRUCTOR_MUTABLE_POISON (r
))
3605 if (!allow_non_constant
)
3606 error ("%qE is not a constant expression because it refers to "
3607 "mutable subobjects of %qT", t
, type
);
3608 non_constant_p
= true;
3611 /* Technically we should check this for all subexpressions, but that
3612 runs into problems with our internal representation of pointer
3613 subtraction and the 5.19 rules are still in flux. */
3614 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
3615 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
3616 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
3618 if (!allow_non_constant
)
3619 error ("conversion from pointer type %qT "
3620 "to arithmetic type %qT in a constant-expression",
3621 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
3622 non_constant_p
= true;
3625 if (!non_constant_p
&& overflow_p
)
3626 non_constant_p
= true;
3628 if (non_constant_p
&& !allow_non_constant
)
3629 return error_mark_node
;
3630 else if (non_constant_p
&& TREE_CONSTANT (r
))
3632 /* This isn't actually constant, so unset TREE_CONSTANT. */
3635 else if (TREE_CODE (r
) == CONSTRUCTOR
)
3636 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
3638 r
= build_nop (TREE_TYPE (r
), r
);
3639 TREE_CONSTANT (r
) = false;
3641 else if (non_constant_p
|| r
== t
)
3644 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
3646 if (TREE_CODE (t
) == TARGET_EXPR
3647 && TARGET_EXPR_INITIAL (t
) == r
)
3651 r
= get_target_expr (r
);
3652 TREE_CONSTANT (r
) = true;
3660 /* Returns true if T is a valid subexpression of a constant expression,
3661 even if it isn't itself a constant expression. */
3664 is_sub_constant_expr (tree t
)
3666 bool non_constant_p
= false;
3667 bool overflow_p
= false;
3668 hash_map
<tree
, tree
> map
;
3669 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, true, true };
3670 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
3672 return !non_constant_p
&& !overflow_p
;
3675 /* If T represents a constant expression returns its reduced value.
3676 Otherwise return error_mark_node. If T is dependent, then
3680 cxx_constant_value (tree t
, tree decl
)
3682 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
3685 /* If T is a constant expression, returns its reduced value.
3686 Otherwise, if T does not have TREE_CONSTANT set, returns T.
3687 Otherwise, returns a version of T without TREE_CONSTANT. */
3690 maybe_constant_value (tree t
, tree decl
)
3694 if (instantiation_dependent_expression_p (t
)
3695 || type_unknown_p (t
)
3696 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3697 || !potential_constant_expression (t
))
3699 if (TREE_OVERFLOW_P (t
))
3701 t
= build_nop (TREE_TYPE (t
), t
);
3702 TREE_CONSTANT (t
) = false;
3707 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
3708 #ifdef ENABLE_CHECKING
3710 || CONVERT_EXPR_P (t
)
3711 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3712 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3713 || !cp_tree_equal (r
, t
));
3718 /* Like maybe_constant_value but first fully instantiate the argument.
3720 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3721 (t, tf_none) followed by maybe_constant_value but is more efficient,
3722 because calls instantiation_dependent_expression_p and
3723 potential_constant_expression at most once. */
3726 fold_non_dependent_expr (tree t
)
3731 /* If we're in a template, but T isn't value dependent, simplify
3732 it. We're supposed to treat:
3734 template <typename T> void f(T[1 + 1]);
3735 template <typename T> void f(T[2]);
3737 as two declarations of the same function, for example. */
3738 if (processing_template_decl
)
3740 if (!instantiation_dependent_expression_p (t
)
3741 && potential_constant_expression (t
))
3743 processing_template_decl_sentinel s
;
3744 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
3746 if (type_unknown_p (t
)
3747 || BRACE_ENCLOSED_INITIALIZER_P (t
))
3749 if (TREE_OVERFLOW_P (t
))
3751 t
= build_nop (TREE_TYPE (t
), t
);
3752 TREE_CONSTANT (t
) = false;
3757 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
3758 #ifdef ENABLE_CHECKING
3759 /* cp_tree_equal looks through NOPs, so allow them. */
3761 || CONVERT_EXPR_P (t
)
3762 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3763 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3764 || !cp_tree_equal (r
, t
));
3768 else if (TREE_OVERFLOW_P (t
))
3770 t
= build_nop (TREE_TYPE (t
), t
);
3771 TREE_CONSTANT (t
) = false;
3776 return maybe_constant_value (t
);
3779 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3780 than wrapped in a TARGET_EXPR. */
3783 maybe_constant_init (tree t
, tree decl
)
3785 if (TREE_CODE (t
) == EXPR_STMT
)
3786 t
= TREE_OPERAND (t
, 0);
3787 if (TREE_CODE (t
) == CONVERT_EXPR
3788 && VOID_TYPE_P (TREE_TYPE (t
)))
3789 t
= TREE_OPERAND (t
, 0);
3790 if (TREE_CODE (t
) == INIT_EXPR
)
3791 t
= TREE_OPERAND (t
, 1);
3792 if (instantiation_dependent_expression_p (t
)
3793 || type_unknown_p (t
)
3794 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3795 || !potential_static_init_expression (t
))
3796 /* Don't try to evaluate it. */;
3798 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
3799 if (TREE_CODE (t
) == TARGET_EXPR
)
3801 tree init
= TARGET_EXPR_INITIAL (t
);
3802 if (TREE_CODE (init
) == CONSTRUCTOR
)
3809 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
3810 /* Return true if the object referred to by REF has automatic or thread
3813 enum { ck_ok
, ck_bad
, ck_unknown
};
3815 check_automatic_or_tls (tree ref
)
3818 HOST_WIDE_INT bitsize
, bitpos
;
3820 int volatilep
= 0, unsignedp
= 0;
3821 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
3822 &mode
, &unsignedp
, &volatilep
, false);
3825 /* If there isn't a decl in the middle, we don't know the linkage here,
3826 and this isn't a constant expression anyway. */
3829 dk
= decl_storage_duration (decl
);
3830 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
3834 /* Return true if T denotes a potentially constant expression. Issue
3835 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
3836 an lvalue-rvalue conversion is implied.
3838 C++0x [expr.const] used to say
3840 6 An expression is a potential constant expression if it is
3841 a constant expression where all occurrences of function
3842 parameters are replaced by arbitrary constant expressions
3843 of the appropriate type.
3845 2 A conditional expression is a constant expression unless it
3846 involves one of the following as a potentially evaluated
3847 subexpression (3.2), but subexpressions of logical AND (5.14),
3848 logical OR (5.15), and conditional (5.16) operations that are
3849 not evaluated are not considered. */
3852 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
3853 tsubst_flags_t flags
)
3855 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
3856 enum { any
= false, rval
= true };
3860 if (t
== error_mark_node
)
3864 if (TREE_THIS_VOLATILE (t
))
3866 if (flags
& tf_error
)
3867 error ("expression %qE has side-effects", t
);
3870 if (CONSTANT_CLASS_P (t
))
3873 switch (TREE_CODE (t
))
3879 case TEMPLATE_ID_EXPR
:
3882 case CASE_LABEL_EXPR
:
3888 case TEMPLATE_PARM_INDEX
:
3890 case IDENTIFIER_NODE
:
3891 case USERDEF_LITERAL
:
3892 /* We can see a FIELD_DECL in a pointer-to-member expression. */
3897 case PLACEHOLDER_EXPR
:
3902 case AGGR_INIT_EXPR
:
3904 /* -- an invocation of a function other than a constexpr function
3905 or a constexpr constructor. */
3907 tree fun
= get_function_named_in_call (t
);
3908 const int nargs
= call_expr_nargs (t
);
3911 if (fun
== NULL_TREE
)
3913 if (TREE_CODE (t
) == CALL_EXPR
3914 && CALL_EXPR_FN (t
) == NULL_TREE
)
3915 switch (CALL_EXPR_IFN (t
))
3917 /* These should be ignored, they are optimized away from
3918 constexpr functions. */
3919 case IFN_UBSAN_NULL
:
3920 case IFN_UBSAN_BOUNDS
:
3921 case IFN_UBSAN_VPTR
:
3926 /* fold_call_expr can't do anything with IFN calls. */
3927 if (flags
& tf_error
)
3928 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3929 "call to internal function");
3932 if (is_overloaded_fn (fun
))
3934 if (TREE_CODE (fun
) == FUNCTION_DECL
)
3936 if (builtin_valid_in_constant_expr_p (fun
))
3938 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
3939 /* Allow any built-in function; if the expansion
3940 isn't constant, we'll deal with that then. */
3941 && !is_builtin_fn (fun
))
3943 if (flags
& tf_error
)
3945 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3946 "call to non-constexpr function %qD", fun
);
3947 explain_invalid_constexpr_fn (fun
);
3951 /* A call to a non-static member function takes the address
3952 of the object as the first argument. But in a constant
3953 expression the address will be folded away, so look
3955 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
3956 && !DECL_CONSTRUCTOR_P (fun
))
3958 tree x
= get_nth_callarg (t
, 0);
3959 if (is_this_parameter (x
))
3961 else if (!RECUR (x
, rval
))
3968 if (!RECUR (fun
, true))
3970 fun
= get_first_fn (fun
);
3972 /* Skip initial arguments to base constructors. */
3973 if (DECL_BASE_CONSTRUCTOR_P (fun
))
3974 i
= num_artificial_parms_for (fun
);
3975 fun
= DECL_ORIGIN (fun
);
3979 if (RECUR (fun
, rval
))
3980 /* Might end up being a constant function pointer. */;
3984 for (; i
< nargs
; ++i
)
3986 tree x
= get_nth_callarg (t
, i
);
3987 /* In a template, reference arguments haven't been converted to
3988 REFERENCE_TYPE and we might not even know if the parameter
3989 is a reference, so accept lvalue constants too. */
3990 bool rv
= processing_template_decl
? any
: rval
;
3997 case NON_LVALUE_EXPR
:
3998 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
3999 -- an lvalue of integral type that refers to a non-volatile
4000 const variable or static data member initialized with
4001 constant expressions, or
4003 -- an lvalue of literal type that refers to non-volatile
4004 object defined with constexpr, or that refers to a
4005 sub-object of such an object; */
4006 return RECUR (TREE_OPERAND (t
, 0), rval
);
4010 && !decl_constant_var_p (t
)
4012 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
4013 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
4014 && !var_in_constexpr_fn (t
)
4015 && !type_dependent_expression_p (t
))
4017 if (flags
& tf_error
)
4018 non_const_var_error (t
);
4025 case VIEW_CONVERT_EXPR
:
4026 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4027 may change to something more specific to type-punning (DR 1312). */
4029 tree from
= TREE_OPERAND (t
, 0);
4030 if (POINTER_TYPE_P (TREE_TYPE (t
))
4031 && TREE_CODE (from
) == INTEGER_CST
4032 && !integer_zerop (from
))
4034 if (flags
& tf_error
)
4035 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4036 "reinterpret_cast from integer to pointer");
4039 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
4043 /* -- a unary operator & that is applied to an lvalue that
4044 designates an object with thread or automatic storage
4046 t
= TREE_OPERAND (t
, 0);
4048 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
4049 /* A pointer-to-member constant. */
4053 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4054 any checking here, as we might dereference the pointer later. If
4055 we remove this code, also remove check_automatic_or_tls. */
4056 i
= check_automatic_or_tls (t
);
4061 if (flags
& tf_error
)
4062 error ("address-of an object %qE with thread local or "
4063 "automatic storage is not a constant expression", t
);
4067 return RECUR (t
, any
);
4073 /* -- a class member access unless its postfix-expression is
4074 of literal type or of pointer to literal type. */
4075 /* This test would be redundant, as it follows from the
4076 postfix-expression being a potential constant expression. */
4077 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4079 case EXPR_PACK_EXPANSION
:
4080 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
4084 tree x
= TREE_OPERAND (t
, 0);
4086 if (is_this_parameter (x
))
4088 if (DECL_CONTEXT (x
)
4089 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4091 if (flags
& tf_error
)
4092 error ("use of %<this%> in a constant expression");
4097 return RECUR (x
, rval
);
4100 case STATEMENT_LIST
:
4102 tree_stmt_iterator i
;
4103 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4105 if (!RECUR (tsi_stmt (i
), any
))
4113 if (cxx_dialect
< cxx14
)
4115 if (!RECUR (TREE_OPERAND (t
, 0), any
))
4117 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
4122 if (cxx_dialect
< cxx14
)
4124 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
4126 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
4131 if (!RECUR (IF_COND (t
), rval
))
4133 if (!RECUR (THEN_CLAUSE (t
), any
))
4135 if (!RECUR (ELSE_CLAUSE (t
), any
))
4140 if (!RECUR (DO_COND (t
), rval
))
4142 if (!RECUR (DO_BODY (t
), any
))
4147 if (!RECUR (FOR_INIT_STMT (t
), any
))
4149 if (!RECUR (FOR_COND (t
), rval
))
4151 if (!RECUR (FOR_EXPR (t
), any
))
4153 if (!RECUR (FOR_BODY (t
), any
))
4158 if (!RECUR (WHILE_COND (t
), rval
))
4160 if (!RECUR (WHILE_BODY (t
), any
))
4165 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
4167 if (!RECUR (SWITCH_STMT_BODY (t
), any
))
4172 return RECUR (STMT_EXPR_STMT (t
), rval
);
4175 case DYNAMIC_CAST_EXPR
:
4176 case PSEUDO_DTOR_EXPR
:
4180 case VEC_DELETE_EXPR
:
4183 case OMP_ATOMIC_READ
:
4184 case OMP_ATOMIC_CAPTURE_OLD
:
4185 case OMP_ATOMIC_CAPTURE_NEW
:
4186 /* GCC internal stuff. */
4189 case TRANSACTION_EXPR
:
4191 case AT_ENCODE_EXPR
:
4193 if (flags
& tf_error
)
4194 error ("expression %qE is not a constant-expression", t
);
4198 /* -- a typeid expression whose operand is of polymorphic
4201 tree e
= TREE_OPERAND (t
, 0);
4202 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
4203 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
4205 if (flags
& tf_error
)
4206 error ("typeid-expression is not a constant expression "
4207 "because %qE is of polymorphic type", e
);
4226 case PREINCREMENT_EXPR
:
4227 case POSTINCREMENT_EXPR
:
4228 case PREDECREMENT_EXPR
:
4229 case POSTDECREMENT_EXPR
:
4230 if (cxx_dialect
< cxx14
)
4236 if (TYPE_P (TREE_OPERAND (t
, 0)))
4238 /* else fall through. */
4244 case FIX_TRUNC_EXPR
:
4248 case TRUTH_NOT_EXPR
:
4249 case FIXED_CONVERT_EXPR
:
4250 case UNARY_PLUS_EXPR
:
4252 return RECUR (TREE_OPERAND (t
, 0), rval
);
4255 case CONST_CAST_EXPR
:
4256 case STATIC_CAST_EXPR
:
4257 case REINTERPRET_CAST_EXPR
:
4258 case IMPLICIT_CONV_EXPR
:
4259 if (cxx_dialect
< cxx11
4260 && !dependent_type_p (TREE_TYPE (t
))
4261 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
4262 /* In C++98, a conversion to non-integral type can't be part of a
4263 constant expression. */
4265 if (flags
& tf_error
)
4266 error ("cast to non-integral type %qT in a constant expression",
4271 return (RECUR (TREE_OPERAND (t
, 0),
4272 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
4275 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
4277 case WITH_CLEANUP_EXPR
:
4278 case CLEANUP_POINT_EXPR
:
4279 case MUST_NOT_THROW_EXPR
:
4280 case TRY_CATCH_EXPR
:
4286 case NON_DEPENDENT_EXPR
:
4287 /* For convenience. */
4289 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4291 case TRY_FINALLY_EXPR
:
4292 return (RECUR (TREE_OPERAND (t
, 0), want_rval
)
4293 && RECUR (TREE_OPERAND (t
, 1), any
));
4296 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4299 if (!literal_type_p (TREE_TYPE (t
)))
4301 if (flags
& tf_error
)
4303 error ("temporary of non-literal type %qT in a "
4304 "constant expression", TREE_TYPE (t
));
4305 explain_non_literal_class (TREE_TYPE (t
));
4310 return RECUR (TREE_OPERAND (t
, 1), rval
);
4314 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4315 constructor_elt
*ce
;
4316 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4317 if (!RECUR (ce
->value
, want_rval
))
4324 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
4325 || DECL_P (TREE_PURPOSE (t
)));
4326 if (!RECUR (TREE_VALUE (t
), want_rval
))
4328 if (TREE_CHAIN (t
) == NULL_TREE
)
4330 return RECUR (TREE_CHAIN (t
), want_rval
);
4333 case TRUNC_DIV_EXPR
:
4335 case FLOOR_DIV_EXPR
:
4336 case ROUND_DIV_EXPR
:
4337 case TRUNC_MOD_EXPR
:
4339 case ROUND_MOD_EXPR
:
4341 tree denom
= TREE_OPERAND (t
, 1);
4342 if (!RECUR (denom
, rval
))
4344 /* We can't call cxx_eval_outermost_constant_expr on an expression
4345 that hasn't been through instantiate_non_dependent_expr yet. */
4346 if (!processing_template_decl
)
4347 denom
= cxx_eval_outermost_constant_expr (denom
, true);
4348 if (integer_zerop (denom
))
4350 if (flags
& tf_error
)
4351 error ("division by zero is not a constant-expression");
4357 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4363 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4364 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4365 introduced by build_call_a. */
4366 tree op0
= TREE_OPERAND (t
, 0);
4367 tree op1
= TREE_OPERAND (t
, 1);
4369 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4370 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4371 return RECUR (op0
, want_rval
);
4376 /* If the first operand is the non-short-circuit constant, look at
4377 the second operand; otherwise we only care about the first one for
4379 case TRUTH_AND_EXPR
:
4380 case TRUTH_ANDIF_EXPR
:
4381 tmp
= boolean_true_node
;
4384 case TRUTH_ORIF_EXPR
:
4385 tmp
= boolean_false_node
;
4388 tree op
= TREE_OPERAND (t
, 0);
4389 if (!RECUR (op
, rval
))
4391 if (!processing_template_decl
)
4392 op
= cxx_eval_outermost_constant_expr (op
, true);
4393 if (tree_int_cst_equal (op
, tmp
))
4394 return RECUR (TREE_OPERAND (t
, 1), rval
);
4401 case POINTER_PLUS_EXPR
:
4403 case EXACT_DIV_EXPR
:
4413 case TRUTH_XOR_EXPR
:
4414 case UNORDERED_EXPR
:
4427 case ARRAY_RANGE_REF
:
4432 for (i
= 0; i
< 2; ++i
)
4433 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
4437 case CILK_SYNC_STMT
:
4438 case CILK_SPAWN_STMT
:
4439 case ARRAY_NOTATION_REF
:
4444 for (i
= 0; i
< 3; ++i
)
4445 if (!RECUR (TREE_OPERAND (t
, i
), true))
4451 /* If the condition is a known constant, we know which of the legs we
4452 care about; otherwise we only require that the condition and
4453 either of the legs be potentially constant. */
4454 tmp
= TREE_OPERAND (t
, 0);
4455 if (!RECUR (tmp
, rval
))
4457 if (!processing_template_decl
)
4458 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
4459 if (integer_zerop (tmp
))
4460 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
4461 else if (TREE_CODE (tmp
) == INTEGER_CST
)
4462 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4463 for (i
= 1; i
< 3; ++i
)
4464 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
4465 want_rval
, strict
, tf_none
))
4467 if (flags
& tf_error
)
4468 error ("expression %qE is not a constant-expression", t
);
4472 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
4474 if (flags
& tf_error
)
4476 error ("non-constant array initialization");
4477 diagnose_non_constexpr_vec_init (t
);
4483 /* We can see these in statement-expressions. */
4487 if (objc_is_property_ref (t
))
4490 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
4497 /* The main entry point to the above. */
4500 potential_constant_expression (tree t
)
4502 return potential_constant_expression_1 (t
, false, true, tf_none
);
4506 potential_static_init_expression (tree t
)
4508 return potential_constant_expression_1 (t
, false, false, tf_none
);
4511 /* As above, but require a constant rvalue. */
4514 potential_rvalue_constant_expression (tree t
)
4516 return potential_constant_expression_1 (t
, true, true, tf_none
);
4519 /* Like above, but complain about non-constant expressions. */
4522 require_potential_constant_expression (tree t
)
4524 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
4527 /* Cross product of the above. */
4530 require_potential_rvalue_constant_expression (tree t
)
4532 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
4535 #include "gt-cp-constexpr.h"