1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2015 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "double-int.h"
39 #include "c-family/c-objc.h"
40 #include "tree-iterator.h"
43 #include "tree-inline.h"
46 static bool verify_constant (tree
, bool, bool *, bool *);
47 #define VERIFY_CONSTANT(X) \
49 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
53 /* Returns true iff FUN is an instantiation of a constexpr function
54 template or a defaulted constexpr function. */
57 is_instantiation_of_constexpr (tree fun
)
59 return ((DECL_TEMPLOID_INSTANTIATION (fun
)
60 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun
)))
61 || (DECL_DEFAULTED_FN (fun
)
62 && DECL_DECLARED_CONSTEXPR_P (fun
)));
65 /* Return true if T is a literal type. */
68 literal_type_p (tree t
)
71 || TREE_CODE (t
) == VECTOR_TYPE
72 || TREE_CODE (t
) == REFERENCE_TYPE
73 || (VOID_TYPE_P (t
) && cxx_dialect
>= cxx14
))
77 t
= complete_type (t
);
78 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
79 return CLASSTYPE_LITERAL_P (t
);
81 if (TREE_CODE (t
) == ARRAY_TYPE
)
82 return literal_type_p (strip_array_types (t
));
86 /* If DECL is a variable declared `constexpr', require its type
87 be literal. Return the DECL if OK, otherwise NULL. */
90 ensure_literal_type_for_constexpr_object (tree decl
)
92 tree type
= TREE_TYPE (decl
);
94 && (DECL_DECLARED_CONSTEXPR_P (decl
)
95 || var_in_constexpr_fn (decl
))
96 && !processing_template_decl
)
98 tree stype
= strip_array_types (type
);
99 if (CLASS_TYPE_P (stype
) && !COMPLETE_TYPE_P (complete_type (stype
)))
100 /* Don't complain here, we'll complain about incompleteness
101 when we try to initialize the variable. */;
102 else if (!literal_type_p (type
))
104 if (DECL_DECLARED_CONSTEXPR_P (decl
))
106 error ("the type %qT of constexpr variable %qD is not literal",
108 explain_non_literal_class (type
);
112 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
114 error ("variable %qD of non-literal type %qT in %<constexpr%> "
115 "function", decl
, type
);
116 explain_non_literal_class (type
);
118 cp_function_chain
->invalid_constexpr
= true;
126 /* Representation of entries in the constexpr function definition table. */
128 struct GTY((for_user
)) constexpr_fundef
{
133 struct constexpr_fundef_hasher
: ggc_hasher
<constexpr_fundef
*>
135 static hashval_t
hash (constexpr_fundef
*);
136 static bool equal (constexpr_fundef
*, constexpr_fundef
*);
139 /* This table holds all constexpr function definitions seen in
140 the current translation unit. */
142 static GTY (()) hash_table
<constexpr_fundef_hasher
> *constexpr_fundef_table
;
144 /* Utility function used for managing the constexpr function table.
145 Return true if the entries pointed to by P and Q are for the
146 same constexpr function. */
149 constexpr_fundef_hasher::equal (constexpr_fundef
*lhs
, constexpr_fundef
*rhs
)
151 return lhs
->decl
== rhs
->decl
;
154 /* Utility function used for managing the constexpr function table.
155 Return a hash value for the entry pointed to by Q. */
158 constexpr_fundef_hasher::hash (constexpr_fundef
*fundef
)
160 return DECL_UID (fundef
->decl
);
163 /* Return a previously saved definition of function FUN. */
165 static constexpr_fundef
*
166 retrieve_constexpr_fundef (tree fun
)
168 constexpr_fundef fundef
= { NULL
, NULL
};
169 if (constexpr_fundef_table
== NULL
)
173 return constexpr_fundef_table
->find (&fundef
);
176 /* Check whether the parameter and return types of FUN are valid for a
177 constexpr function, and complain if COMPLAIN. */
180 is_valid_constexpr_fn (tree fun
, bool complain
)
184 if (DECL_INHERITED_CTOR_BASE (fun
)
185 && TREE_CODE (fun
) == TEMPLATE_DECL
)
189 error ("inherited constructor %qD is not constexpr",
190 get_inherited_ctor (fun
));
194 for (tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
195 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
196 if (!literal_type_p (TREE_TYPE (parm
)))
201 error ("invalid type for parameter %d of constexpr "
202 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
203 explain_non_literal_class (TREE_TYPE (parm
));
208 if (!DECL_CONSTRUCTOR_P (fun
))
210 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
211 if (!literal_type_p (rettype
))
216 error ("invalid return type %qT of constexpr function %q+D",
218 explain_non_literal_class (rettype
);
222 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
223 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
228 error ("enclosing class of constexpr non-static member "
229 "function %q+#D is not a literal type", fun
);
230 explain_non_literal_class (DECL_CONTEXT (fun
));
234 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
238 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
244 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
245 for a member of an anonymous aggregate, INIT is the initializer for that
246 member, and VEC_OUTER is the vector of constructor elements for the class
247 whose constructor we are processing. Add the initializer to the vector
248 and return true to indicate success. */
251 build_anon_member_initialization (tree member
, tree init
,
252 vec
<constructor_elt
, va_gc
> **vec_outer
)
254 /* MEMBER presents the relevant fields from the inside out, but we need
255 to build up the initializer from the outside in so that we can reuse
256 previously built CONSTRUCTORs if this is, say, the second field in an
257 anonymous struct. So we use a vec as a stack. */
258 auto_vec
<tree
, 2> fields
;
261 fields
.safe_push (TREE_OPERAND (member
, 1));
262 member
= TREE_OPERAND (member
, 0);
264 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
))
265 && TREE_CODE (member
) == COMPONENT_REF
);
267 /* VEC has the constructor elements vector for the context of FIELD.
268 If FIELD is an anonymous aggregate, we will push inside it. */
269 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
271 while (field
= fields
.pop(),
272 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
275 /* If there is already an outer constructor entry for the anonymous
276 aggregate FIELD, use it; otherwise, insert one. */
277 if (vec_safe_is_empty (*vec
)
278 || (*vec
)->last().index
!= field
)
280 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
281 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
284 ctor
= (*vec
)->last().value
;
285 vec
= &CONSTRUCTOR_ELTS (ctor
);
288 /* Now we're at the innermost field, the one that isn't an anonymous
289 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
290 gcc_assert (fields
.is_empty());
291 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
296 /* Subroutine of build_constexpr_constructor_member_initializers.
297 The expression tree T represents a data member initialization
298 in a (constexpr) constructor definition. Build a pairing of
299 the data member with its initializer, and prepend that pair
300 to the existing initialization pair INITS. */
303 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
306 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
307 t
= TREE_OPERAND (t
, 0);
308 if (TREE_CODE (t
) == EXPR_STMT
)
309 t
= TREE_OPERAND (t
, 0);
310 if (t
== error_mark_node
)
312 if (TREE_CODE (t
) == STATEMENT_LIST
)
314 tree_stmt_iterator i
;
315 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
317 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
322 if (TREE_CODE (t
) == CLEANUP_STMT
)
324 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
325 but we can in a constexpr constructor for a non-literal class. Just
326 ignore it; either all the initialization will be constant, in which
327 case the cleanup can't run, or it can't be constexpr.
328 Still recurse into CLEANUP_BODY. */
329 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
331 if (TREE_CODE (t
) == CONVERT_EXPR
)
332 t
= TREE_OPERAND (t
, 0);
333 if (TREE_CODE (t
) == INIT_EXPR
334 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
335 use what this function builds for cx_check_missing_mem_inits, and
336 assignment in the ctor body doesn't count. */
337 || (cxx_dialect
< cxx14
&& TREE_CODE (t
) == MODIFY_EXPR
))
339 member
= TREE_OPERAND (t
, 0);
340 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
342 else if (TREE_CODE (t
) == CALL_EXPR
)
344 tree fn
= get_callee_fndecl (t
);
345 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
346 /* We're only interested in calls to subobject constructors. */
348 member
= CALL_EXPR_ARG (t
, 0);
349 /* We don't use build_cplus_new here because it complains about
350 abstract bases. Leaving the call unwrapped means that it has the
351 wrong type, but cxx_eval_constant_expression doesn't care. */
352 init
= break_out_target_exprs (t
);
354 else if (TREE_CODE (t
) == BIND_EXPR
)
355 return build_data_member_initialization (BIND_EXPR_BODY (t
), vec
);
357 /* Don't add anything else to the CONSTRUCTOR. */
359 if (INDIRECT_REF_P (member
))
360 member
= TREE_OPERAND (member
, 0);
361 if (TREE_CODE (member
) == NOP_EXPR
)
365 if (TREE_CODE (op
) == ADDR_EXPR
)
367 gcc_assert (same_type_ignoring_top_level_qualifiers_p
368 (TREE_TYPE (TREE_TYPE (op
)),
369 TREE_TYPE (TREE_TYPE (member
))));
370 /* Initializing a cv-qualified member; we need to look through
374 else if (op
== current_class_ptr
375 && (same_type_ignoring_top_level_qualifiers_p
376 (TREE_TYPE (TREE_TYPE (member
)),
377 current_class_type
)))
378 /* Delegating constructor. */
382 /* This is an initializer for an empty base; keep it for now so
383 we can check it in cxx_eval_bare_aggregate. */
384 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
387 if (TREE_CODE (member
) == ADDR_EXPR
)
388 member
= TREE_OPERAND (member
, 0);
389 if (TREE_CODE (member
) == COMPONENT_REF
)
391 tree aggr
= TREE_OPERAND (member
, 0);
392 if (TREE_CODE (aggr
) != COMPONENT_REF
)
393 /* Normal member initialization. */
394 member
= TREE_OPERAND (member
, 1);
395 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
396 /* Initializing a member of an anonymous union. */
397 return build_anon_member_initialization (member
, init
, vec
);
399 /* We're initializing a vtable pointer in a base. Leave it as
400 COMPONENT_REF so we remember the path to get to the vfield. */
401 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
404 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
408 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
409 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
410 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
413 check_constexpr_bind_expr_vars (tree t
)
415 gcc_assert (TREE_CODE (t
) == BIND_EXPR
);
417 for (tree var
= BIND_EXPR_VARS (t
); var
; var
= DECL_CHAIN (var
))
418 if (TREE_CODE (var
) == TYPE_DECL
419 && DECL_IMPLICIT_TYPEDEF_P (var
)
420 && !LAMBDA_TYPE_P (TREE_TYPE (var
)))
425 /* Subroutine of check_constexpr_ctor_body. */
428 check_constexpr_ctor_body_1 (tree last
, tree list
)
430 switch (TREE_CODE (list
))
433 if (TREE_CODE (DECL_EXPR_DECL (list
)) == USING_DECL
)
437 case CLEANUP_POINT_EXPR
:
438 return check_constexpr_ctor_body (last
, TREE_OPERAND (list
, 0),
442 if (!check_constexpr_bind_expr_vars (list
)
443 || !check_constexpr_ctor_body (last
, BIND_EXPR_BODY (list
),
457 /* Make sure that there are no statements after LAST in the constructor
458 body represented by LIST. */
461 check_constexpr_ctor_body (tree last
, tree list
, bool complain
)
463 /* C++14 doesn't require a constexpr ctor to have an empty body. */
464 if (cxx_dialect
>= cxx14
)
468 if (TREE_CODE (list
) == STATEMENT_LIST
)
470 tree_stmt_iterator i
= tsi_last (list
);
471 for (; !tsi_end_p (i
); tsi_prev (&i
))
473 tree t
= tsi_stmt (i
);
476 if (!check_constexpr_ctor_body_1 (last
, t
))
483 else if (list
!= last
484 && !check_constexpr_ctor_body_1 (last
, list
))
489 error ("constexpr constructor does not have empty body");
490 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
495 /* V is a vector of constructor elements built up for the base and member
496 initializers of a constructor for TYPE. They need to be in increasing
497 offset order, which they might not be yet if TYPE has a primary base
498 which is not first in the base-clause or a vptr and at least one base
499 all of which are non-primary. */
501 static vec
<constructor_elt
, va_gc
> *
502 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
504 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
510 field_type
= BINFO_TYPE (pri
);
511 else if (TYPE_CONTAINS_VPTR_P (type
))
512 field_type
= vtbl_ptr_type_node
;
516 /* Find the element for the primary base or vptr and move it to the
517 beginning of the vec. */
518 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
519 if (TREE_TYPE (ce
->index
) == field_type
)
522 if (i
> 0 && i
< vec_safe_length (v
))
524 vec
<constructor_elt
, va_gc
> &vref
= *v
;
525 constructor_elt elt
= vref
[i
];
534 /* Build compile-time evalable representations of member-initializer list
535 for a constexpr constructor. */
538 build_constexpr_constructor_member_initializers (tree type
, tree body
)
540 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
542 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
543 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
544 body
= TREE_OPERAND (body
, 0);
545 if (TREE_CODE (body
) == STATEMENT_LIST
)
547 tree_stmt_iterator i
= tsi_start (body
);
551 if (TREE_CODE (body
) == BIND_EXPR
)
556 body
= BIND_EXPR_BODY (body
);
557 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
559 body
= TREE_OPERAND (body
, 0);
560 if (TREE_CODE (body
) == EXPR_STMT
)
561 body
= TREE_OPERAND (body
, 0);
562 if (TREE_CODE (body
) == INIT_EXPR
563 && (same_type_ignoring_top_level_qualifiers_p
564 (TREE_TYPE (TREE_OPERAND (body
, 0)),
565 current_class_type
)))
568 return TREE_OPERAND (body
, 1);
570 ok
= build_data_member_initialization (body
, &vec
);
572 else if (TREE_CODE (body
) == STATEMENT_LIST
)
574 tree_stmt_iterator i
;
575 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
577 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
582 else if (TREE_CODE (body
) == TRY_BLOCK
)
584 error ("body of %<constexpr%> constructor cannot be "
585 "a function-try-block");
586 return error_mark_node
;
588 else if (EXPR_P (body
))
589 ok
= build_data_member_initialization (body
, &vec
);
591 gcc_assert (errorcount
> 0);
594 if (vec_safe_length (vec
) > 0)
596 /* In a delegating constructor, return the target. */
597 constructor_elt
*ce
= &(*vec
)[0];
598 if (ce
->index
== current_class_ptr
)
605 vec
= sort_constexpr_mem_initializers (type
, vec
);
606 return build_constructor (type
, vec
);
609 return error_mark_node
;
612 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
613 declared to be constexpr, or a sub-statement thereof. Returns the
614 return value if suitable, error_mark_node for a statement not allowed in
615 a constexpr function, or NULL_TREE if no return value was found. */
618 constexpr_fn_retval (tree body
)
620 switch (TREE_CODE (body
))
624 tree_stmt_iterator i
;
625 tree expr
= NULL_TREE
;
626 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
628 tree s
= constexpr_fn_retval (tsi_stmt (i
));
629 if (s
== error_mark_node
)
630 return error_mark_node
;
631 else if (s
== NULL_TREE
)
632 /* Keep iterating. */;
634 /* Multiple return statements. */
635 return error_mark_node
;
643 return break_out_target_exprs (TREE_OPERAND (body
, 0));
647 tree decl
= DECL_EXPR_DECL (body
);
648 if (TREE_CODE (decl
) == USING_DECL
649 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
650 || DECL_ARTIFICIAL (decl
))
652 return error_mark_node
;
655 case CLEANUP_POINT_EXPR
:
656 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
659 if (!check_constexpr_bind_expr_vars (body
))
660 return error_mark_node
;
661 return constexpr_fn_retval (BIND_EXPR_BODY (body
));
667 return error_mark_node
;
671 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
672 FUN; do the necessary transformations to turn it into a single expression
673 that we can store in the hash table. */
676 massage_constexpr_body (tree fun
, tree body
)
678 if (DECL_CONSTRUCTOR_P (fun
))
679 body
= build_constexpr_constructor_member_initializers
680 (DECL_CONTEXT (fun
), body
);
681 else if (cxx_dialect
< cxx14
)
683 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
684 body
= EH_SPEC_STMTS (body
);
685 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
686 body
= TREE_OPERAND (body
, 0);
687 body
= constexpr_fn_retval (body
);
692 /* FUN is a constexpr constructor with massaged body BODY. Return true
693 if some bases/fields are uninitialized, and complain if COMPLAIN. */
696 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
703 if (TREE_CODE (body
) != CONSTRUCTOR
)
706 nelts
= CONSTRUCTOR_NELTS (body
);
707 ctype
= DECL_CONTEXT (fun
);
708 field
= TYPE_FIELDS (ctype
);
710 if (TREE_CODE (ctype
) == UNION_TYPE
)
712 if (nelts
== 0 && next_initializable_field (field
))
715 error ("%<constexpr%> constructor for union %qT must "
716 "initialize exactly one non-static data member", ctype
);
723 for (i
= 0; i
<= nelts
; ++i
)
730 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
731 /* Skip base and vtable inits. */
732 if (TREE_CODE (index
) != FIELD_DECL
733 || DECL_ARTIFICIAL (index
))
736 for (; field
!= index
; field
= DECL_CHAIN (field
))
739 if (TREE_CODE (field
) != FIELD_DECL
740 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
741 || DECL_ARTIFICIAL (field
))
743 ftype
= strip_array_types (TREE_TYPE (field
));
744 if (type_has_constexpr_default_constructor (ftype
))
746 /* It's OK to skip a member with a trivial constexpr ctor.
747 A constexpr ctor that isn't trivial should have been
749 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
755 error ("member %qD must be initialized by mem-initializer "
756 "in %<constexpr%> constructor", field
);
757 inform (DECL_SOURCE_LOCATION (field
), "declared here");
760 if (field
== NULL_TREE
)
762 field
= DECL_CHAIN (field
);
768 /* We are processing the definition of the constexpr function FUN.
769 Check that its BODY fulfills the propriate requirements and
770 enter it in the constexpr function definition table.
771 For constructor BODY is actually the TREE_LIST of the
772 member-initializer list. */
775 register_constexpr_fundef (tree fun
, tree body
)
777 constexpr_fundef entry
;
778 constexpr_fundef
**slot
;
780 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
783 body
= massage_constexpr_body (fun
, body
);
784 if (body
== NULL_TREE
|| body
== error_mark_node
)
786 if (!DECL_CONSTRUCTOR_P (fun
))
787 error ("body of constexpr function %qD not a return-statement", fun
);
791 if (!potential_rvalue_constant_expression (body
))
793 if (!DECL_GENERATED_P (fun
))
794 require_potential_rvalue_constant_expression (body
);
798 if (DECL_CONSTRUCTOR_P (fun
)
799 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
802 /* Create the constexpr function table if necessary. */
803 if (constexpr_fundef_table
== NULL
)
804 constexpr_fundef_table
805 = hash_table
<constexpr_fundef_hasher
>::create_ggc (101);
809 slot
= constexpr_fundef_table
->find_slot (&entry
, INSERT
);
811 gcc_assert (*slot
== NULL
);
812 *slot
= ggc_alloc
<constexpr_fundef
> ();
818 /* FUN is a non-constexpr function called in a context that requires a
819 constant expression. If it comes from a constexpr template, explain why
820 the instantiation isn't constexpr. */
823 explain_invalid_constexpr_fn (tree fun
)
825 static hash_set
<tree
> *diagnosed
;
828 /* Only diagnose defaulted functions or instantiations. */
829 if (!DECL_DEFAULTED_FN (fun
)
830 && !is_instantiation_of_constexpr (fun
))
832 if (diagnosed
== NULL
)
833 diagnosed
= new hash_set
<tree
>;
834 if (diagnosed
->add (fun
))
835 /* Already explained. */
838 save_loc
= input_location
;
839 input_location
= DECL_SOURCE_LOCATION (fun
);
840 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
841 /* First check the declaration. */
842 if (is_valid_constexpr_fn (fun
, true))
844 /* Then if it's OK, the body. */
845 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
846 explain_implicit_non_constexpr (fun
);
849 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
850 require_potential_rvalue_constant_expression (body
);
851 if (DECL_CONSTRUCTOR_P (fun
))
852 cx_check_missing_mem_inits (fun
, body
, true);
855 input_location
= save_loc
;
858 /* Objects of this type represent calls to constexpr functions
859 along with the bindings of parameters to their arguments, for
860 the purpose of compile time evaluation. */
862 struct GTY((for_user
)) constexpr_call
{
863 /* Description of the constexpr function definition. */
864 constexpr_fundef
*fundef
;
865 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
866 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
867 Note: This arrangement is made to accommodate the use of
868 iterative_hash_template_arg (see pt.c). If you change this
869 representation, also change the hash calculation in
870 cxx_eval_call_expression. */
872 /* Result of the call.
873 NULL means the call is being evaluated.
874 error_mark_node means that the evaluation was erroneous;
875 otherwise, the actuall value of the call. */
877 /* The hash of this call; we remember it here to avoid having to
878 recalculate it when expanding the hash table. */
882 struct constexpr_call_hasher
: ggc_hasher
<constexpr_call
*>
884 static hashval_t
hash (constexpr_call
*);
885 static bool equal (constexpr_call
*, constexpr_call
*);
888 /* The constexpr expansion context. CALL is the current function
889 expansion, CTOR is the current aggregate initializer, OBJECT is the
890 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
891 is a map of values of variables initialized within the expression. */
893 struct constexpr_ctx
{
894 /* The innermost call we're evaluating. */
895 constexpr_call
*call
;
896 /* Values for any temporaries or local variables within the
897 constant-expression. */
898 hash_map
<tree
,tree
> *values
;
899 /* The CONSTRUCTOR we're currently building up for an aggregate
902 /* The object we're building the CONSTRUCTOR for. */
904 /* Whether we should error on a non-constant expression or fail quietly. */
906 /* Whether we are strictly conforming to constant expression rules or
907 trying harder to get a constant value. */
911 /* A table of all constexpr calls that have been evaluated by the
912 compiler in this translation unit. */
914 static GTY (()) hash_table
<constexpr_call_hasher
> *constexpr_call_table
;
916 static tree
cxx_eval_constant_expression (const constexpr_ctx
*, tree
,
917 bool, bool *, bool *, tree
* = NULL
);
919 /* Compute a hash value for a constexpr call representation. */
922 constexpr_call_hasher::hash (constexpr_call
*info
)
927 /* Return true if the objects pointed to by P and Q represent calls
928 to the same constexpr function with the same arguments.
929 Otherwise, return false. */
932 constexpr_call_hasher::equal (constexpr_call
*lhs
, constexpr_call
*rhs
)
938 if (!constexpr_fundef_hasher::equal (lhs
->fundef
, rhs
->fundef
))
940 lhs_bindings
= lhs
->bindings
;
941 rhs_bindings
= rhs
->bindings
;
942 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
944 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
945 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
946 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
947 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
949 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
950 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
952 return lhs_bindings
== rhs_bindings
;
955 /* Initialize the constexpr call table, if needed. */
958 maybe_initialize_constexpr_call_table (void)
960 if (constexpr_call_table
== NULL
)
961 constexpr_call_table
= hash_table
<constexpr_call_hasher
>::create_ggc (101);
964 /* We have an expression tree T that represents a call, either CALL_EXPR
965 or AGGR_INIT_EXPR. If the call is lexically to a named function,
966 retrun the _DECL for that function. */
969 get_function_named_in_call (tree t
)
972 switch (TREE_CODE (t
))
975 fun
= CALL_EXPR_FN (t
);
979 fun
= AGGR_INIT_EXPR_FN (t
);
986 if (fun
&& TREE_CODE (fun
) == ADDR_EXPR
987 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
988 fun
= TREE_OPERAND (fun
, 0);
992 /* We have an expression tree T that represents a call, either CALL_EXPR
993 or AGGR_INIT_EXPR. Return the Nth argument. */
996 get_nth_callarg (tree t
, int n
)
998 switch (TREE_CODE (t
))
1001 return CALL_EXPR_ARG (t
, n
);
1003 case AGGR_INIT_EXPR
:
1004 return AGGR_INIT_EXPR_ARG (t
, n
);
1012 /* Attempt to evaluate T which represents a call to a builtin function.
1013 We assume here that all builtin functions evaluate to scalar types
1014 represented by _CST nodes. */
1017 cxx_eval_builtin_function_call (const constexpr_ctx
*ctx
, tree t
, tree fun
,
1019 bool *non_constant_p
, bool *overflow_p
)
1021 const int nargs
= call_expr_nargs (t
);
1022 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
1026 /* Don't fold __builtin_constant_p within a constexpr function. */
1027 if (DECL_FUNCTION_CODE (fun
) == BUILT_IN_CONSTANT_P
1028 && current_function_decl
1029 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
1031 *non_constant_p
= true;
1035 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1036 return constant false for a non-constant argument. */
1037 constexpr_ctx new_ctx
= *ctx
;
1038 new_ctx
.quiet
= true;
1039 bool dummy1
= false, dummy2
= false;
1040 for (i
= 0; i
< nargs
; ++i
)
1041 args
[i
] = cxx_eval_constant_expression (&new_ctx
, CALL_EXPR_ARG (t
, i
),
1042 lval
, &dummy1
, &dummy2
);
1044 bool save_ffbcp
= force_folding_builtin_constant_p
;
1045 force_folding_builtin_constant_p
= true;
1046 new_call
= fold_build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
1047 CALL_EXPR_FN (t
), nargs
, args
);
1048 force_folding_builtin_constant_p
= save_ffbcp
;
1049 VERIFY_CONSTANT (new_call
);
1053 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1054 the type of the value to match. */
1057 adjust_temp_type (tree type
, tree temp
)
1059 if (TREE_TYPE (temp
) == type
)
1061 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1062 if (TREE_CODE (temp
) == CONSTRUCTOR
)
1063 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
1064 gcc_assert (scalarish_type_p (type
));
1065 return cp_fold_convert (type
, temp
);
1068 /* Subroutine of cxx_eval_call_expression.
1069 We are processing a call expression (either CALL_EXPR or
1070 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1071 all arguments and bind their values to correspondings
1072 parameters, making up the NEW_CALL context. */
1075 cxx_bind_parameters_in_call (const constexpr_ctx
*ctx
, tree t
,
1076 constexpr_call
*new_call
,
1077 bool *non_constant_p
, bool *overflow_p
,
1078 bool *non_constant_args
)
1080 const int nargs
= call_expr_nargs (t
);
1081 tree fun
= new_call
->fundef
->decl
;
1082 tree parms
= DECL_ARGUMENTS (fun
);
1084 tree
*p
= &new_call
->bindings
;
1085 for (i
= 0; i
< nargs
; ++i
)
1088 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
1089 x
= get_nth_callarg (t
, i
);
1090 /* For member function, the first argument is a pointer to the implied
1091 object. For a constructor, it might still be a dummy object, in
1092 which case we get the real argument from ctx. */
1093 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
)
1094 && is_dummy_object (x
))
1097 x
= cp_build_addr_expr (x
, tf_warning_or_error
);
1100 arg
= cxx_eval_constant_expression (ctx
, x
, lval
,
1101 non_constant_p
, overflow_p
);
1102 /* Don't VERIFY_CONSTANT here. */
1103 if (*non_constant_p
&& ctx
->quiet
)
1105 /* Just discard ellipsis args after checking their constantitude. */
1108 if (*non_constant_p
)
1109 /* Don't try to adjust the type of non-constant args. */
1112 /* Make sure the binding has the same type as the parm. */
1113 if (TREE_CODE (type
) != REFERENCE_TYPE
)
1114 arg
= adjust_temp_type (type
, arg
);
1115 if (!TREE_CONSTANT (arg
))
1116 *non_constant_args
= true;
1117 *p
= build_tree_list (parms
, arg
);
1118 p
= &TREE_CHAIN (*p
);
1120 parms
= TREE_CHAIN (parms
);
1124 /* Variables and functions to manage constexpr call expansion context.
1125 These do not need to be marked for PCH or GC. */
1127 /* FIXME remember and print actual constant arguments. */
1128 static vec
<tree
> call_stack
= vNULL
;
1129 static int call_stack_tick
;
1130 static int last_cx_error_tick
;
1133 push_cx_call_context (tree call
)
1136 if (!EXPR_HAS_LOCATION (call
))
1137 SET_EXPR_LOCATION (call
, input_location
);
1138 call_stack
.safe_push (call
);
1139 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
1145 pop_cx_call_context (void)
1152 cx_error_context (void)
1154 vec
<tree
> r
= vNULL
;
1155 if (call_stack_tick
!= last_cx_error_tick
1156 && !call_stack
.is_empty ())
1158 last_cx_error_tick
= call_stack_tick
;
1162 /* Subroutine of cxx_eval_constant_expression.
1163 Evaluate the call expression tree T in the context of OLD_CALL expression
1167 cxx_eval_call_expression (const constexpr_ctx
*ctx
, tree t
,
1169 bool *non_constant_p
, bool *overflow_p
)
1171 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
1172 tree fun
= get_function_named_in_call (t
);
1173 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
1176 if (fun
== NULL_TREE
)
1177 switch (CALL_EXPR_IFN (t
))
1179 case IFN_UBSAN_NULL
:
1180 case IFN_UBSAN_BOUNDS
:
1181 case IFN_UBSAN_VPTR
:
1185 error_at (loc
, "call to internal function");
1186 *non_constant_p
= true;
1190 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1192 /* Might be a constexpr function pointer. */
1193 fun
= cxx_eval_constant_expression (ctx
, fun
,
1194 /*lval*/false, non_constant_p
,
1197 if (TREE_CODE (fun
) == ADDR_EXPR
)
1198 fun
= TREE_OPERAND (fun
, 0);
1200 if (TREE_CODE (fun
) != FUNCTION_DECL
)
1202 if (!ctx
->quiet
&& !*non_constant_p
)
1203 error_at (loc
, "expression %qE does not designate a constexpr "
1205 *non_constant_p
= true;
1208 if (DECL_CLONED_FUNCTION_P (fun
))
1209 fun
= DECL_CLONED_FUNCTION (fun
);
1211 if (is_ubsan_builtin_p (fun
))
1214 if (is_builtin_fn (fun
))
1215 return cxx_eval_builtin_function_call (ctx
, t
, fun
,
1216 lval
, non_constant_p
, overflow_p
);
1217 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
1221 error_at (loc
, "call to non-constexpr function %qD", fun
);
1222 explain_invalid_constexpr_fn (fun
);
1224 *non_constant_p
= true;
1228 /* Shortcut trivial constructor/op=. */
1229 if (trivial_fn_p (fun
))
1231 if (call_expr_nargs (t
) == 2)
1233 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
1234 return cxx_eval_constant_expression (ctx
, arg
,
1235 lval
, non_constant_p
,
1238 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
1239 && AGGR_INIT_ZERO_FIRST (t
))
1240 return build_zero_init (DECL_CONTEXT (fun
), NULL_TREE
, false);
1243 /* If in direct recursive call, optimize definition search. */
1244 if (ctx
&& ctx
->call
&& ctx
->call
->fundef
->decl
== fun
)
1245 new_call
.fundef
= ctx
->call
->fundef
;
1248 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
1249 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
1253 if (DECL_INITIAL (fun
))
1255 /* The definition of fun was somehow unsuitable. */
1256 error_at (loc
, "%qD called in a constant expression", fun
);
1257 explain_invalid_constexpr_fn (fun
);
1260 error_at (loc
, "%qD used before its definition", fun
);
1262 *non_constant_p
= true;
1267 constexpr_ctx new_ctx
= *ctx
;
1268 if (DECL_CONSTRUCTOR_P (fun
) && !ctx
->object
1269 && TREE_CODE (t
) == AGGR_INIT_EXPR
)
1271 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1272 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1273 new_ctx
.object
= AGGR_INIT_EXPR_SLOT (t
);
1274 tree ctor
= new_ctx
.ctor
= build_constructor (DECL_CONTEXT (fun
), NULL
);
1275 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor
) = true;
1276 ctx
->values
->put (new_ctx
.object
, ctor
);
1280 bool non_constant_args
= false;
1281 cxx_bind_parameters_in_call (ctx
, t
, &new_call
,
1282 non_constant_p
, overflow_p
, &non_constant_args
);
1283 if (*non_constant_p
)
1286 depth_ok
= push_cx_call_context (t
);
1288 tree result
= NULL_TREE
;
1290 constexpr_call
*entry
= NULL
;
1291 if (!non_constant_args
)
1293 new_call
.hash
= iterative_hash_template_arg
1294 (new_call
.bindings
, constexpr_fundef_hasher::hash (new_call
.fundef
));
1296 /* If we have seen this call before, we are done. */
1297 maybe_initialize_constexpr_call_table ();
1298 constexpr_call
**slot
1299 = constexpr_call_table
->find_slot (&new_call
, INSERT
);
1303 /* We need to keep a pointer to the entry, not just the slot, as the
1304 slot can move in the call to cxx_eval_builtin_function_call. */
1305 *slot
= entry
= ggc_alloc
<constexpr_call
> ();
1308 /* Calls which are in progress have their result set to NULL
1309 so that we can detect circular dependencies. */
1310 else if (entry
->result
== NULL
)
1313 error ("call has circular dependency");
1314 *non_constant_p
= true;
1315 entry
->result
= result
= error_mark_node
;
1318 result
= entry
->result
;
1324 error ("constexpr evaluation depth exceeds maximum of %d (use "
1325 "-fconstexpr-depth= to increase the maximum)",
1326 max_constexpr_depth
);
1327 *non_constant_p
= true;
1328 result
= error_mark_node
;
1332 if (!result
|| result
== error_mark_node
)
1334 if (DECL_SAVED_TREE (fun
) == NULL_TREE
1335 && (DECL_CONSTRUCTOR_P (fun
) || DECL_DESTRUCTOR_P (fun
)))
1336 /* The maybe-in-charge 'tor had its DECL_SAVED_TREE
1337 cleared, try a clone. */
1338 for (fun
= DECL_CHAIN (fun
);
1339 fun
&& DECL_CLONED_FUNCTION_P (fun
);
1340 fun
= DECL_CHAIN (fun
))
1341 if (DECL_SAVED_TREE (fun
))
1343 gcc_assert (DECL_SAVED_TREE (fun
));
1346 /* Unshare the whole function body. */
1347 tree body
= copy_fn (fun
, parms
, res
);
1349 /* Associate the bindings with the remapped parms. */
1350 tree bound
= new_call
.bindings
;
1351 tree remapped
= parms
;
1354 tree oparm
= TREE_PURPOSE (bound
);
1355 tree arg
= TREE_VALUE (bound
);
1356 gcc_assert (DECL_NAME (remapped
) == DECL_NAME (oparm
));
1357 ctx
->values
->put (remapped
, arg
);
1358 bound
= TREE_CHAIN (bound
);
1359 remapped
= DECL_CHAIN (remapped
);
1361 /* Add the RESULT_DECL to the values map, too. */
1362 tree slot
= NULL_TREE
;
1363 if (DECL_BY_REFERENCE (res
))
1365 slot
= AGGR_INIT_EXPR_SLOT (t
);
1366 tree addr
= build_address (slot
);
1367 addr
= build_nop (TREE_TYPE (res
), addr
);
1368 ctx
->values
->put (res
, addr
);
1369 ctx
->values
->put (slot
, NULL_TREE
);
1372 ctx
->values
->put (res
, NULL_TREE
);
1374 tree jump_target
= NULL_TREE
;
1375 cxx_eval_constant_expression (ctx
, body
,
1376 lval
, non_constant_p
, overflow_p
,
1379 if (DECL_CONSTRUCTOR_P (fun
))
1380 /* This can be null for a subobject constructor call, in
1381 which case what we care about is the initialization
1382 side-effects rather than the value. We could get at the
1383 value by evaluating *this, but we don't bother; there's
1384 no need to put such a call in the hash table. */
1385 result
= lval
? ctx
->object
: ctx
->ctor
;
1386 else if (VOID_TYPE_P (TREE_TYPE (res
)))
1390 result
= *ctx
->values
->get (slot
? slot
: res
);
1391 if (result
== NULL_TREE
&& !*non_constant_p
)
1394 error ("constexpr call flows off the end "
1396 *non_constant_p
= true;
1400 /* Remove the parms/result from the values map. Is it worth
1401 bothering to do this when the map itself is only live for
1402 one constexpr evaluation? If so, maybe also clear out
1403 other vars from call, maybe in BIND_EXPR handling? */
1404 ctx
->values
->remove (res
);
1406 ctx
->values
->remove (slot
);
1407 for (tree parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1408 ctx
->values
->remove (parm
);
1411 if (result
== error_mark_node
)
1412 *non_constant_p
= true;
1413 if (*non_constant_p
)
1414 result
= error_mark_node
;
1418 entry
->result
= result
;
1421 pop_cx_call_context ();
1422 return unshare_expr (result
);
1425 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1428 reduced_constant_expression_p (tree t
)
1430 switch (TREE_CODE (t
))
1433 /* Even if we can't lower this yet, it's constant. */
1437 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1438 tree elt
; unsigned HOST_WIDE_INT idx
;
1439 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, elt
)
1440 if (!reduced_constant_expression_p (elt
))
1445 /* FIXME are we calling this too much? */
1446 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
1450 /* Some expressions may have constant operands but are not constant
1451 themselves, such as 1/0. Call this function (or rather, the macro
1452 following it) to check for that condition.
1454 We only call this in places that require an arithmetic constant, not in
1455 places where we might have a non-constant expression that can be a
1456 component of a constant expression, such as the address of a constexpr
1457 variable that might be dereferenced later. */
1460 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
1463 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
1465 if (!allow_non_constant
)
1466 error ("%q+E is not a constant expression", t
);
1467 *non_constant_p
= true;
1469 if (TREE_OVERFLOW_P (t
))
1471 if (!allow_non_constant
)
1473 permerror (input_location
, "overflow in constant expression");
1474 /* If we're being permissive (and are in an enforcing
1475 context), ignore the overflow. */
1476 if (flag_permissive
)
1477 return *non_constant_p
;
1481 return *non_constant_p
;
1484 /* Check whether the shift operation with code CODE and type TYPE on LHS
1485 and RHS is undefined. If it is, give an error with an explanation,
1486 and return true; return false otherwise. */
1489 cxx_eval_check_shift_p (location_t loc
, const constexpr_ctx
*ctx
,
1490 enum tree_code code
, tree type
, tree lhs
, tree rhs
)
1492 if ((code
!= LSHIFT_EXPR
&& code
!= RSHIFT_EXPR
)
1493 || TREE_CODE (lhs
) != INTEGER_CST
1494 || TREE_CODE (rhs
) != INTEGER_CST
)
1497 tree lhstype
= TREE_TYPE (lhs
);
1498 unsigned HOST_WIDE_INT uprec
= TYPE_PRECISION (TREE_TYPE (lhs
));
1500 /* [expr.shift] The behavior is undefined if the right operand
1501 is negative, or greater than or equal to the length in bits
1502 of the promoted left operand. */
1503 if (tree_int_cst_sgn (rhs
) == -1)
1506 error_at (loc
, "right operand of shift expression %q+E is negative",
1507 build2_loc (loc
, code
, type
, lhs
, rhs
));
1510 if (compare_tree_int (rhs
, uprec
) >= 0)
1513 error_at (loc
, "right operand of shift expression %q+E is >= than "
1514 "the precision of the left operand",
1515 build2_loc (loc
, code
, type
, lhs
, rhs
));
1519 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1520 if E1 has a signed type and non-negative value, and E1x2^E2 is
1521 representable in the corresponding unsigned type of the result type,
1522 then that value, converted to the result type, is the resulting value;
1523 otherwise, the behavior is undefined. */
1524 if (code
== LSHIFT_EXPR
&& !TYPE_UNSIGNED (lhstype
)
1525 && (cxx_dialect
>= cxx11
))
1527 if (tree_int_cst_sgn (lhs
) == -1)
1530 error_at (loc
, "left operand of shift expression %q+E is negative",
1531 build2_loc (loc
, code
, type
, lhs
, rhs
));
1534 /* For signed x << y the following:
1535 (unsigned) x >> ((prec (lhs) - 1) - y)
1536 if > 1, is undefined. The right-hand side of this formula
1537 is the highest bit of the LHS that can be set (starting from 0),
1538 so that the shift doesn't overflow. We then right-shift the LHS
1539 to see whether any other bit is set making the original shift
1540 undefined -- the result is not representable in the corresponding
1542 tree t
= build_int_cst (unsigned_type_node
, uprec
- 1);
1543 t
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, t
, rhs
);
1544 tree ulhs
= fold_convert (unsigned_type_for (lhstype
), lhs
);
1545 t
= fold_build2 (RSHIFT_EXPR
, TREE_TYPE (ulhs
), ulhs
, t
);
1546 if (tree_int_cst_lt (integer_one_node
, t
))
1549 error_at (loc
, "shift expression %q+E overflows",
1550 build2_loc (loc
, code
, type
, lhs
, rhs
));
1557 /* Subroutine of cxx_eval_constant_expression.
1558 Attempt to reduce the unary expression tree T to a compile time value.
1559 If successful, return the value. Otherwise issue a diagnostic
1560 and return error_mark_node. */
1563 cxx_eval_unary_expression (const constexpr_ctx
*ctx
, tree t
,
1565 bool *non_constant_p
, bool *overflow_p
)
1568 tree orig_arg
= TREE_OPERAND (t
, 0);
1569 tree arg
= cxx_eval_constant_expression (ctx
, orig_arg
, /*lval*/false,
1570 non_constant_p
, overflow_p
);
1571 VERIFY_CONSTANT (arg
);
1572 location_t loc
= EXPR_LOCATION (t
);
1573 enum tree_code code
= TREE_CODE (t
);
1574 tree type
= TREE_TYPE (t
);
1575 r
= fold_unary_loc (loc
, code
, type
, arg
);
1578 if (arg
== orig_arg
)
1581 r
= build1_loc (loc
, code
, type
, arg
);
1583 VERIFY_CONSTANT (r
);
1587 /* Subroutine of cxx_eval_constant_expression.
1588 Like cxx_eval_unary_expression, except for binary expressions. */
1591 cxx_eval_binary_expression (const constexpr_ctx
*ctx
, tree t
,
1593 bool *non_constant_p
, bool *overflow_p
)
1596 tree orig_lhs
= TREE_OPERAND (t
, 0);
1597 tree orig_rhs
= TREE_OPERAND (t
, 1);
1599 lhs
= cxx_eval_constant_expression (ctx
, orig_lhs
, /*lval*/false,
1600 non_constant_p
, overflow_p
);
1601 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1602 a local array in a constexpr function. */
1603 bool ptr
= POINTER_TYPE_P (TREE_TYPE (lhs
));
1605 VERIFY_CONSTANT (lhs
);
1606 rhs
= cxx_eval_constant_expression (ctx
, orig_rhs
, /*lval*/false,
1607 non_constant_p
, overflow_p
);
1609 VERIFY_CONSTANT (rhs
);
1611 location_t loc
= EXPR_LOCATION (t
);
1612 enum tree_code code
= TREE_CODE (t
);
1613 tree type
= TREE_TYPE (t
);
1614 r
= fold_binary_loc (loc
, code
, type
, lhs
, rhs
);
1617 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
1620 r
= build2_loc (loc
, code
, type
, lhs
, rhs
);
1622 else if (cxx_eval_check_shift_p (loc
, ctx
, code
, type
, lhs
, rhs
))
1623 *non_constant_p
= true;
1625 VERIFY_CONSTANT (r
);
1629 /* Subroutine of cxx_eval_constant_expression.
1630 Attempt to evaluate condition expressions. Dead branches are not
1634 cxx_eval_conditional_expression (const constexpr_ctx
*ctx
, tree t
,
1636 bool *non_constant_p
, bool *overflow_p
,
1639 tree val
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1641 non_constant_p
, overflow_p
);
1642 VERIFY_CONSTANT (val
);
1643 /* Don't VERIFY_CONSTANT the other operands. */
1644 if (integer_zerop (val
))
1645 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 2),
1647 non_constant_p
, overflow_p
,
1649 return cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1651 non_constant_p
, overflow_p
,
1655 /* Subroutine of cxx_eval_constant_expression.
1656 Attempt to reduce a reference to an array slot. */
1659 cxx_eval_array_reference (const constexpr_ctx
*ctx
, tree t
,
1661 bool *non_constant_p
, bool *overflow_p
)
1663 tree oldary
= TREE_OPERAND (t
, 0);
1664 tree ary
= cxx_eval_constant_expression (ctx
, oldary
,
1666 non_constant_p
, overflow_p
);
1670 unsigned len
, elem_nchars
= 1;
1671 if (*non_constant_p
)
1673 oldidx
= TREE_OPERAND (t
, 1);
1674 index
= cxx_eval_constant_expression (ctx
, oldidx
,
1676 non_constant_p
, overflow_p
);
1677 VERIFY_CONSTANT (index
);
1678 if (lval
&& ary
== oldary
&& index
== oldidx
)
1681 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
1682 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
1683 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1684 len
= CONSTRUCTOR_NELTS (ary
);
1685 else if (TREE_CODE (ary
) == STRING_CST
)
1687 elem_nchars
= (TYPE_PRECISION (elem_type
)
1688 / TYPE_PRECISION (char_type_node
));
1689 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
1693 /* We can't do anything with other tree codes, so use
1694 VERIFY_CONSTANT to complain and fail. */
1695 VERIFY_CONSTANT (ary
);
1698 if (compare_tree_int (index
, len
) >= 0)
1700 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
1702 /* If it's within the array bounds but doesn't have an explicit
1703 initializer, it's value-initialized. */
1704 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
1705 return cxx_eval_constant_expression (ctx
, val
,
1707 non_constant_p
, overflow_p
);
1711 error ("array subscript out of bound");
1712 *non_constant_p
= true;
1715 else if (tree_int_cst_lt (index
, integer_zero_node
))
1718 error ("negative array subscript");
1719 *non_constant_p
= true;
1722 i
= tree_to_shwi (index
);
1723 if (TREE_CODE (ary
) == CONSTRUCTOR
)
1724 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
1725 else if (elem_nchars
== 1)
1726 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
1727 TREE_STRING_POINTER (ary
)[i
]);
1730 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
1731 return native_interpret_expr (type
, (const unsigned char *)
1732 TREE_STRING_POINTER (ary
)
1733 + i
* elem_nchars
, elem_nchars
);
1735 /* Don't VERIFY_CONSTANT here. */
1738 /* Subroutine of cxx_eval_constant_expression.
1739 Attempt to reduce a field access of a value of class type. */
1742 cxx_eval_component_reference (const constexpr_ctx
*ctx
, tree t
,
1744 bool *non_constant_p
, bool *overflow_p
)
1746 unsigned HOST_WIDE_INT i
;
1749 tree part
= TREE_OPERAND (t
, 1);
1750 tree orig_whole
= TREE_OPERAND (t
, 0);
1751 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1753 non_constant_p
, overflow_p
);
1754 if (whole
== orig_whole
)
1757 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
1758 whole
, part
, NULL_TREE
);
1759 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1761 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
1764 error ("%qE is not a constant expression", orig_whole
);
1765 *non_constant_p
= true;
1767 if (DECL_MUTABLE_P (part
))
1770 error ("mutable %qD is not usable in a constant expression", part
);
1771 *non_constant_p
= true;
1773 if (*non_constant_p
)
1775 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1782 /* We're in the middle of initializing it. */
1786 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
1787 && CONSTRUCTOR_NELTS (whole
) > 0)
1789 /* DR 1188 says we don't have to deal with this. */
1791 error ("accessing %qD member instead of initialized %qD member in "
1792 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
1793 *non_constant_p
= true;
1797 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole
))
1799 /* 'whole' is part of the aggregate initializer we're currently
1800 building; if there's no initializer for this member yet, that's an
1803 error ("accessing uninitialized member %qD", part
);
1804 *non_constant_p
= true;
1808 /* If there's no explicit init for this field, it's value-initialized. */
1809 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
1810 return cxx_eval_constant_expression (ctx
, value
,
1812 non_constant_p
, overflow_p
);
1815 /* Subroutine of cxx_eval_constant_expression.
1816 Attempt to reduce a field access of a value of class type that is
1817 expressed as a BIT_FIELD_REF. */
1820 cxx_eval_bit_field_ref (const constexpr_ctx
*ctx
, tree t
,
1822 bool *non_constant_p
, bool *overflow_p
)
1824 tree orig_whole
= TREE_OPERAND (t
, 0);
1825 tree retval
, fldval
, utype
, mask
;
1826 bool fld_seen
= false;
1827 HOST_WIDE_INT istart
, isize
;
1828 tree whole
= cxx_eval_constant_expression (ctx
, orig_whole
,
1830 non_constant_p
, overflow_p
);
1831 tree start
, field
, value
;
1832 unsigned HOST_WIDE_INT i
;
1834 if (whole
== orig_whole
)
1836 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1838 if (!*non_constant_p
1839 && TREE_CODE (whole
) != VECTOR_CST
1840 && TREE_CODE (whole
) != CONSTRUCTOR
)
1843 error ("%qE is not a constant expression", orig_whole
);
1844 *non_constant_p
= true;
1846 if (*non_constant_p
)
1849 if (TREE_CODE (whole
) == VECTOR_CST
)
1850 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
1851 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
1853 start
= TREE_OPERAND (t
, 2);
1854 istart
= tree_to_shwi (start
);
1855 isize
= tree_to_shwi (TREE_OPERAND (t
, 1));
1856 utype
= TREE_TYPE (t
);
1857 if (!TYPE_UNSIGNED (utype
))
1858 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
1859 retval
= build_int_cst (utype
, 0);
1860 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
1862 tree bitpos
= bit_position (field
);
1863 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
1865 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
1866 && TREE_CODE (value
) == INTEGER_CST
1867 && tree_fits_shwi_p (bitpos
)
1868 && tree_fits_shwi_p (DECL_SIZE (field
)))
1870 HOST_WIDE_INT bit
= tree_to_shwi (bitpos
);
1871 HOST_WIDE_INT sz
= tree_to_shwi (DECL_SIZE (field
));
1872 HOST_WIDE_INT shift
;
1873 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
1875 fldval
= fold_convert (utype
, value
);
1876 mask
= build_int_cst_type (utype
, -1);
1877 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
1878 size_int (TYPE_PRECISION (utype
) - sz
));
1879 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
1880 size_int (TYPE_PRECISION (utype
) - sz
));
1881 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
1882 shift
= bit
- istart
;
1883 if (BYTES_BIG_ENDIAN
)
1884 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
1885 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
1887 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
1893 return fold_convert (TREE_TYPE (t
), retval
);
1895 return error_mark_node
;
1898 /* Subroutine of cxx_eval_constant_expression.
1899 Evaluate a short-circuited logical expression T in the context
1900 of a given constexpr CALL. BAILOUT_VALUE is the value for
1901 early return. CONTINUE_VALUE is used here purely for
1902 sanity check purposes. */
1905 cxx_eval_logical_expression (const constexpr_ctx
*ctx
, tree t
,
1906 tree bailout_value
, tree continue_value
,
1908 bool *non_constant_p
, bool *overflow_p
)
1911 tree lhs
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
1913 non_constant_p
, overflow_p
);
1914 VERIFY_CONSTANT (lhs
);
1915 if (tree_int_cst_equal (lhs
, bailout_value
))
1917 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
1918 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
1919 lval
, non_constant_p
,
1921 VERIFY_CONSTANT (r
);
1925 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
1926 CONSTRUCTOR elements to initialize (part of) an object containing that
1927 field. Return a pointer to the constructor_elt corresponding to the
1928 initialization of the field. */
1930 static constructor_elt
*
1931 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
1933 tree aggr
= TREE_OPERAND (ref
, 0);
1934 tree field
= TREE_OPERAND (ref
, 1);
1936 constructor_elt
*ce
;
1938 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
1940 if (TREE_CODE (aggr
) == COMPONENT_REF
)
1942 constructor_elt
*base_ce
1943 = base_field_constructor_elt (v
, aggr
);
1944 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
1947 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
1948 if (ce
->index
== field
)
1955 /* Some of the expressions fed to the constexpr mechanism are calls to
1956 constructors, which have type void. In that case, return the type being
1957 initialized by the constructor. */
1960 initialized_type (tree t
)
1964 tree type
= cv_unqualified (TREE_TYPE (t
));
1965 if (TREE_CODE (t
) == CALL_EXPR
|| TREE_CODE (t
) == AGGR_INIT_EXPR
)
1967 /* A constructor call has void type, so we need to look deeper. */
1968 tree fn
= get_function_named_in_call (t
);
1969 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
1970 && DECL_CXX_CONSTRUCTOR_P (fn
))
1971 type
= DECL_CONTEXT (fn
);
1976 /* We're about to initialize element INDEX of an array or class from VALUE.
1977 Set up NEW_CTX appropriately by adjusting .object to refer to the
1978 subobject and creating a new CONSTRUCTOR if the element is itself
1979 a class or array. */
1982 init_subob_ctx (const constexpr_ctx
*ctx
, constexpr_ctx
&new_ctx
,
1983 tree index
, tree
&value
)
1987 if (index
&& TREE_CODE (index
) != INTEGER_CST
1988 && TREE_CODE (index
) != FIELD_DECL
)
1989 /* This won't have an element in the new CONSTRUCTOR. */
1992 tree type
= initialized_type (value
);
1993 if (!AGGREGATE_TYPE_P (type
) && !VECTOR_TYPE_P (type
))
1994 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
1997 /* The sub-aggregate initializer might contain a placeholder;
1998 update object to refer to the subobject and ctor to refer to
1999 the (newly created) sub-initializer. */
2001 new_ctx
.object
= build_ctor_subob_ref (index
, type
, ctx
->object
);
2002 tree elt
= build_constructor (type
, NULL
);
2003 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt
) = true;
2006 if (TREE_CODE (value
) == TARGET_EXPR
)
2007 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2008 value
= TARGET_EXPR_INITIAL (value
);
2011 /* We're about to process an initializer for a class or array TYPE. Make
2012 sure that CTX is set up appropriately. */
2015 verify_ctor_sanity (const constexpr_ctx
*ctx
, tree type
)
2017 /* We don't bother building a ctor for an empty base subobject. */
2018 if (is_empty_class (type
))
2021 /* We're in the middle of an initializer that might involve placeholders;
2022 our caller should have created a CONSTRUCTOR for us to put the
2023 initializer into. We will either return that constructor or T. */
2024 gcc_assert (ctx
->ctor
);
2025 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2026 (type
, TREE_TYPE (ctx
->ctor
)));
2027 gcc_assert (CONSTRUCTOR_NELTS (ctx
->ctor
) == 0);
2029 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2030 (type
, TREE_TYPE (ctx
->object
)));
2031 gcc_assert (!ctx
->object
|| !DECL_P (ctx
->object
)
2032 || *(ctx
->values
->get (ctx
->object
)) == ctx
->ctor
);
2035 /* Subroutine of cxx_eval_constant_expression.
2036 The expression tree T denotes a C-style array or a C-style
2037 aggregate. Reduce it to a constant expression. */
2040 cxx_eval_bare_aggregate (const constexpr_ctx
*ctx
, tree t
,
2042 bool *non_constant_p
, bool *overflow_p
)
2044 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
2045 bool changed
= false;
2046 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
2048 verify_ctor_sanity (ctx
, TREE_TYPE (t
));
2049 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2050 vec_alloc (*p
, vec_safe_length (v
));
2052 unsigned i
; tree index
, value
;
2053 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, index
, value
)
2055 constexpr_ctx new_ctx
;
2056 init_subob_ctx (ctx
, new_ctx
, index
, value
);
2057 if (new_ctx
.ctor
!= ctx
->ctor
)
2058 /* If we built a new CONSTRUCTOR, attach it now so that other
2059 initializers can refer to it. */
2060 CONSTRUCTOR_APPEND_ELT (*p
, index
, new_ctx
.ctor
);
2061 tree elt
= cxx_eval_constant_expression (&new_ctx
, value
,
2063 non_constant_p
, overflow_p
);
2064 /* Don't VERIFY_CONSTANT here. */
2065 if (ctx
->quiet
&& *non_constant_p
)
2069 if (index
&& TREE_CODE (index
) == COMPONENT_REF
)
2071 /* This is an initialization of a vfield inside a base
2072 subaggregate that we already initialized; push this
2073 initialization into the previous initialization. */
2074 constructor_elt
*inner
= base_field_constructor_elt (*p
, index
);
2079 && (TREE_CODE (index
) == NOP_EXPR
2080 || TREE_CODE (index
) == POINTER_PLUS_EXPR
))
2082 /* This is an initializer for an empty base; now that we've
2083 checked that it's constant, we can ignore it. */
2084 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index
))));
2087 else if (new_ctx
.ctor
!= ctx
->ctor
)
2089 /* We appended this element above; update the value. */
2090 gcc_assert ((*p
)->last().index
== index
);
2091 (*p
)->last().value
= elt
;
2094 CONSTRUCTOR_APPEND_ELT (*p
, index
, elt
);
2096 if (*non_constant_p
|| !changed
)
2099 /* We're done building this CONSTRUCTOR, so now we can interpret an
2100 element without an explicit initializer as value-initialized. */
2101 CONSTRUCTOR_NO_IMPLICIT_ZERO (t
) = false;
2102 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2107 /* Subroutine of cxx_eval_constant_expression.
2108 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2109 initialization of a non-static data member of array type. Reduce it to a
2112 Note that apart from value-initialization (when VALUE_INIT is true),
2113 this is only intended to support value-initialization and the
2114 initializations done by defaulted constructors for classes with
2115 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2116 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2117 for the copy/move constructor. */
2120 cxx_eval_vec_init_1 (const constexpr_ctx
*ctx
, tree atype
, tree init
,
2121 bool value_init
, bool lval
,
2122 bool *non_constant_p
, bool *overflow_p
)
2124 tree elttype
= TREE_TYPE (atype
);
2125 unsigned HOST_WIDE_INT max
= tree_to_uhwi (array_type_nelts_top (atype
));
2126 verify_ctor_sanity (ctx
, atype
);
2127 vec
<constructor_elt
, va_gc
> **p
= &CONSTRUCTOR_ELTS (ctx
->ctor
);
2128 vec_alloc (*p
, max
+ 1);
2129 bool pre_init
= false;
2130 unsigned HOST_WIDE_INT i
;
2132 /* For the default constructor, build up a call to the default
2133 constructor of the element type. We only need to handle class types
2134 here, as for a constructor to be constexpr, all members must be
2135 initialized, which for a defaulted default constructor means they must
2136 be of a class type with a constexpr default constructor. */
2137 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2138 /* We only do this at the lowest level. */;
2139 else if (value_init
)
2141 init
= build_value_init (elttype
, tf_warning_or_error
);
2146 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
2147 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2148 &argvec
, elttype
, LOOKUP_NORMAL
,
2149 tf_warning_or_error
);
2150 release_tree_vector (argvec
);
2151 init
= build_aggr_init_expr (TREE_TYPE (init
), init
);
2155 for (i
= 0; i
< max
; ++i
)
2157 tree idx
= build_int_cst (size_type_node
, i
);
2159 constexpr_ctx new_ctx
;
2160 init_subob_ctx (ctx
, new_ctx
, idx
, pre_init
? init
: elttype
);
2161 if (new_ctx
.ctor
!= ctx
->ctor
)
2162 CONSTRUCTOR_APPEND_ELT (*p
, idx
, new_ctx
.ctor
);
2163 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
2165 /* A multidimensional array; recurse. */
2166 if (value_init
|| init
== NULL_TREE
)
2167 eltinit
= NULL_TREE
;
2169 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2170 tf_warning_or_error
);
2171 eltinit
= cxx_eval_vec_init_1 (&new_ctx
, elttype
, eltinit
, value_init
,
2173 non_constant_p
, overflow_p
);
2177 /* Initializing an element using value or default initialization
2178 we just pre-built above. */
2179 eltinit
= (cxx_eval_constant_expression
2181 lval
, non_constant_p
, overflow_p
));
2185 /* Copying an element. */
2186 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2187 (atype
, TREE_TYPE (init
)));
2188 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
2189 tf_warning_or_error
);
2190 if (!real_lvalue_p (init
))
2191 eltinit
= move (eltinit
);
2192 eltinit
= force_rvalue (eltinit
, tf_warning_or_error
);
2193 eltinit
= (cxx_eval_constant_expression
2194 (&new_ctx
, eltinit
, lval
,
2195 non_constant_p
, overflow_p
));
2197 if (*non_constant_p
&& !ctx
->quiet
)
2199 if (new_ctx
.ctor
!= ctx
->ctor
)
2201 /* We appended this element above; update the value. */
2202 gcc_assert ((*p
)->last().index
== idx
);
2203 (*p
)->last().value
= eltinit
;
2206 CONSTRUCTOR_APPEND_ELT (*p
, idx
, eltinit
);
2209 if (!*non_constant_p
)
2212 CONSTRUCTOR_NO_IMPLICIT_ZERO (init
) = false;
2218 cxx_eval_vec_init (const constexpr_ctx
*ctx
, tree t
,
2220 bool *non_constant_p
, bool *overflow_p
)
2222 tree atype
= TREE_TYPE (t
);
2223 tree init
= VEC_INIT_EXPR_INIT (t
);
2224 tree r
= cxx_eval_vec_init_1 (ctx
, atype
, init
,
2225 VEC_INIT_EXPR_VALUE_INIT (t
),
2226 lval
, non_constant_p
, overflow_p
);
2227 if (*non_constant_p
)
2233 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2234 match. We want to be less strict for simple *& folding; if we have a
2235 non-const temporary that we access through a const pointer, that should
2236 work. We handle this here rather than change fold_indirect_ref_1
2237 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2238 don't really make sense outside of constant expression evaluation. Also
2239 we want to allow folding to COMPONENT_REF, which could cause trouble
2240 with TBAA in fold_indirect_ref_1.
2242 Try to keep this function synced with fold_indirect_ref_1. */
2245 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
2251 subtype
= TREE_TYPE (sub
);
2252 if (!POINTER_TYPE_P (subtype
))
2255 if (TREE_CODE (sub
) == ADDR_EXPR
)
2257 tree op
= TREE_OPERAND (sub
, 0);
2258 tree optype
= TREE_TYPE (op
);
2260 /* *&CONST_DECL -> to the value of the const decl. */
2261 if (TREE_CODE (op
) == CONST_DECL
)
2262 return DECL_INITIAL (op
);
2263 /* *&p => p; make sure to handle *&"str"[cst] here. */
2264 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
2266 tree fop
= fold_read_from_constant_string (op
);
2272 /* *(foo *)&fooarray => fooarray[0] */
2273 else if (TREE_CODE (optype
) == ARRAY_TYPE
2274 && (same_type_ignoring_top_level_qualifiers_p
2275 (type
, TREE_TYPE (optype
))))
2277 tree type_domain
= TYPE_DOMAIN (optype
);
2278 tree min_val
= size_zero_node
;
2279 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2280 min_val
= TYPE_MIN_VALUE (type_domain
);
2281 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
2282 NULL_TREE
, NULL_TREE
);
2284 /* *(foo *)&complexfoo => __real__ complexfoo */
2285 else if (TREE_CODE (optype
) == COMPLEX_TYPE
2286 && (same_type_ignoring_top_level_qualifiers_p
2287 (type
, TREE_TYPE (optype
))))
2288 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
2289 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2290 else if (TREE_CODE (optype
) == VECTOR_TYPE
2291 && (same_type_ignoring_top_level_qualifiers_p
2292 (type
, TREE_TYPE (optype
))))
2294 tree part_width
= TYPE_SIZE (type
);
2295 tree index
= bitsize_int (0);
2296 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
2298 /* Also handle conversion to an empty base class, which
2299 is represented with a NOP_EXPR. */
2300 else if (is_empty_class (type
)
2301 && CLASS_TYPE_P (optype
)
2302 && DERIVED_FROM_P (type
, optype
))
2307 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2308 else if (RECORD_OR_UNION_TYPE_P (optype
))
2310 tree field
= TYPE_FIELDS (optype
);
2311 for (; field
; field
= DECL_CHAIN (field
))
2312 if (TREE_CODE (field
) == FIELD_DECL
2313 && integer_zerop (byte_position (field
))
2314 && (same_type_ignoring_top_level_qualifiers_p
2315 (TREE_TYPE (field
), type
)))
2317 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
2322 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
2323 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
2325 tree op00
= TREE_OPERAND (sub
, 0);
2326 tree op01
= TREE_OPERAND (sub
, 1);
2329 if (TREE_CODE (op00
) == ADDR_EXPR
)
2332 op00
= TREE_OPERAND (op00
, 0);
2333 op00type
= TREE_TYPE (op00
);
2335 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2336 if (TREE_CODE (op00type
) == VECTOR_TYPE
2337 && (same_type_ignoring_top_level_qualifiers_p
2338 (type
, TREE_TYPE (op00type
))))
2340 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
2341 tree part_width
= TYPE_SIZE (type
);
2342 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
2343 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
2344 tree index
= bitsize_int (indexi
);
2346 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
2347 return fold_build3_loc (loc
,
2348 BIT_FIELD_REF
, type
, op00
,
2352 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2353 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
2354 && (same_type_ignoring_top_level_qualifiers_p
2355 (type
, TREE_TYPE (op00type
))))
2357 tree size
= TYPE_SIZE_UNIT (type
);
2358 if (tree_int_cst_equal (size
, op01
))
2359 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
2361 /* ((foo *)&fooarray)[1] => fooarray[1] */
2362 else if (TREE_CODE (op00type
) == ARRAY_TYPE
2363 && (same_type_ignoring_top_level_qualifiers_p
2364 (type
, TREE_TYPE (op00type
))))
2366 tree type_domain
= TYPE_DOMAIN (op00type
);
2367 tree min_val
= size_zero_node
;
2368 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2369 min_val
= TYPE_MIN_VALUE (type_domain
);
2370 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
2371 TYPE_SIZE_UNIT (type
));
2372 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
2373 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
2374 NULL_TREE
, NULL_TREE
);
2376 /* Also handle conversion to an empty base class, which
2377 is represented with a NOP_EXPR. */
2378 else if (is_empty_class (type
)
2379 && CLASS_TYPE_P (op00type
)
2380 && DERIVED_FROM_P (type
, op00type
))
2385 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2386 else if (RECORD_OR_UNION_TYPE_P (op00type
))
2388 tree field
= TYPE_FIELDS (op00type
);
2389 for (; field
; field
= DECL_CHAIN (field
))
2390 if (TREE_CODE (field
) == FIELD_DECL
2391 && tree_int_cst_equal (byte_position (field
), op01
)
2392 && (same_type_ignoring_top_level_qualifiers_p
2393 (TREE_TYPE (field
), type
)))
2395 return fold_build3 (COMPONENT_REF
, type
, op00
,
2402 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2403 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
2404 && (same_type_ignoring_top_level_qualifiers_p
2405 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
2408 tree min_val
= size_zero_node
;
2409 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
2413 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
2414 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
2415 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
2416 min_val
= TYPE_MIN_VALUE (type_domain
);
2417 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
2425 cxx_eval_indirect_ref (const constexpr_ctx
*ctx
, tree t
,
2427 bool *non_constant_p
, bool *overflow_p
)
2429 tree orig_op0
= TREE_OPERAND (t
, 0);
2430 tree op0
= cxx_eval_constant_expression (ctx
, orig_op0
,
2431 /*lval*/false, non_constant_p
,
2433 bool empty_base
= false;
2436 /* Don't VERIFY_CONSTANT here. */
2437 if (*non_constant_p
)
2440 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
2444 r
= cxx_eval_constant_expression (ctx
, r
,
2445 lval
, non_constant_p
, overflow_p
);
2450 if (TREE_CODE (sub
) == ADDR_EXPR
)
2452 /* We couldn't fold to a constant value. Make sure it's not
2453 something we should have been able to fold. */
2454 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2455 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
2456 /* DR 1188 says we don't have to deal with this. */
2458 error ("accessing value of %qE through a %qT glvalue in a "
2459 "constant expression", build_fold_indirect_ref (sub
),
2461 *non_constant_p
= true;
2466 /* If we're pulling out the value of an empty base, make sure
2467 that the whole object is constant and then return an empty
2469 if (empty_base
&& !lval
)
2471 VERIFY_CONSTANT (r
);
2472 r
= build_constructor (TREE_TYPE (t
), NULL
);
2473 TREE_CONSTANT (r
) = true;
2478 if (lval
&& op0
!= orig_op0
)
2479 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
2481 VERIFY_CONSTANT (t
);
2487 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2488 Shared between potential_constant_expression and
2489 cxx_eval_constant_expression. */
2492 non_const_var_error (tree r
)
2494 tree type
= TREE_TYPE (r
);
2495 error ("the value of %qD is not usable in a constant "
2497 /* Avoid error cascade. */
2498 if (DECL_INITIAL (r
) == error_mark_node
)
2500 if (DECL_DECLARED_CONSTEXPR_P (r
))
2501 inform (DECL_SOURCE_LOCATION (r
),
2502 "%qD used in its own initializer", r
);
2503 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
2505 if (!CP_TYPE_CONST_P (type
))
2506 inform (DECL_SOURCE_LOCATION (r
),
2507 "%q#D is not const", r
);
2508 else if (CP_TYPE_VOLATILE_P (type
))
2509 inform (DECL_SOURCE_LOCATION (r
),
2510 "%q#D is volatile", r
);
2511 else if (!DECL_INITIAL (r
)
2512 || !TREE_CONSTANT (DECL_INITIAL (r
)))
2513 inform (DECL_SOURCE_LOCATION (r
),
2514 "%qD was not initialized with a constant "
2521 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
2522 inform (DECL_SOURCE_LOCATION (r
),
2523 "%qD was not declared %<constexpr%>", r
);
2525 inform (DECL_SOURCE_LOCATION (r
),
2526 "%qD does not have integral or enumeration type",
2531 /* Subroutine of cxx_eval_constant_expression.
2532 Like cxx_eval_unary_expression, except for trinary expressions. */
2535 cxx_eval_trinary_expression (const constexpr_ctx
*ctx
, tree t
,
2537 bool *non_constant_p
, bool *overflow_p
)
2543 for (i
= 0; i
< 3; i
++)
2545 args
[i
] = cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, i
),
2547 non_constant_p
, overflow_p
);
2548 VERIFY_CONSTANT (args
[i
]);
2551 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
2552 args
[0], args
[1], args
[2]);
2553 if (val
== NULL_TREE
)
2555 VERIFY_CONSTANT (val
);
2560 var_in_constexpr_fn (tree t
)
2562 tree ctx
= DECL_CONTEXT (t
);
2563 return (cxx_dialect
>= cxx14
&& ctx
&& TREE_CODE (ctx
) == FUNCTION_DECL
2564 && DECL_DECLARED_CONSTEXPR_P (ctx
));
2567 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
2570 cxx_eval_store_expression (const constexpr_ctx
*ctx
, tree t
,
2572 bool *non_constant_p
, bool *overflow_p
)
2574 constexpr_ctx new_ctx
= *ctx
;
2576 tree init
= TREE_OPERAND (t
, 1);
2577 if (TREE_CLOBBER_P (init
))
2578 /* Just ignore clobbers. */
2581 /* First we figure out where we're storing to. */
2582 tree target
= TREE_OPERAND (t
, 0);
2583 tree type
= TREE_TYPE (target
);
2584 target
= cxx_eval_constant_expression (ctx
, target
,
2586 non_constant_p
, overflow_p
);
2587 if (*non_constant_p
)
2590 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target
), type
))
2592 /* For initialization of an empty base, the original target will be
2593 *(base*)this, which the above evaluation resolves to the object
2594 argument, which has the derived type rather than the base type. In
2595 this situation, just evaluate the initializer and return, since
2596 there's no actual data to store. */
2597 gcc_assert (is_empty_class (type
));
2598 return cxx_eval_constant_expression (ctx
, init
, false,
2599 non_constant_p
, overflow_p
);
2602 /* And then find the underlying variable. */
2603 vec
<tree
,va_gc
> *refs
= make_tree_vector();
2604 tree object
= NULL_TREE
;
2605 for (tree probe
= target
; object
== NULL_TREE
; )
2607 switch (TREE_CODE (probe
))
2612 vec_safe_push (refs
, TREE_OPERAND (probe
, 1));
2613 vec_safe_push (refs
, TREE_TYPE (probe
));
2614 probe
= TREE_OPERAND (probe
, 0);
2622 /* And then find/build up our initializer for the path to the subobject
2623 we're initializing. */
2625 if (DECL_P (object
))
2626 valp
= ctx
->values
->get (object
);
2631 /* A constant-expression cannot modify objects from outside the
2632 constant-expression. */
2634 error ("modification of %qE is not a constant-expression", object
);
2635 *non_constant_p
= true;
2638 type
= TREE_TYPE (object
);
2639 while (!refs
->is_empty())
2641 if (*valp
== NULL_TREE
)
2643 *valp
= build_constructor (type
, NULL
);
2644 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp
) = true;
2649 ce
.index
= refs
->pop();
2650 ce
.value
= NULL_TREE
;
2652 unsigned HOST_WIDE_INT idx
= 0;
2653 constructor_elt
*cep
= NULL
;
2655 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp
), idx
, &cep
);
2658 if (cp_tree_equal (ce
.index
, cep
->index
))
2661 cep
= vec_safe_push (CONSTRUCTOR_ELTS (*valp
), ce
);
2664 release_tree_vector (refs
);
2666 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
2668 /* Create a new CONSTRUCTOR in case evaluation of the initializer
2669 wants to modify it. */
2670 *valp
= new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
2671 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
2672 new_ctx
.object
= target
;
2675 init
= cxx_eval_constant_expression (&new_ctx
, init
, false,
2676 non_constant_p
, overflow_p
);
2677 if (target
== object
)
2678 /* The hash table might have moved since the get earlier. */
2679 ctx
->values
->put (object
, init
);
2683 if (*non_constant_p
)
2691 /* Evaluate a ++ or -- expression. */
2694 cxx_eval_increment_expression (const constexpr_ctx
*ctx
, tree t
,
2696 bool *non_constant_p
, bool *overflow_p
)
2698 enum tree_code code
= TREE_CODE (t
);
2699 tree type
= TREE_TYPE (t
);
2700 tree op
= TREE_OPERAND (t
, 0);
2701 tree offset
= TREE_OPERAND (t
, 1);
2702 gcc_assert (TREE_CONSTANT (offset
));
2704 /* The operand as an lvalue. */
2705 op
= cxx_eval_constant_expression (ctx
, op
, true,
2706 non_constant_p
, overflow_p
);
2708 /* The operand as an rvalue. */
2709 tree val
= rvalue (op
);
2710 val
= cxx_eval_constant_expression (ctx
, val
, false,
2711 non_constant_p
, overflow_p
);
2712 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2713 a local array in a constexpr function. */
2714 bool ptr
= POINTER_TYPE_P (TREE_TYPE (val
));
2716 VERIFY_CONSTANT (val
);
2718 /* The modified value. */
2719 bool inc
= (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
);
2721 if (POINTER_TYPE_P (type
))
2723 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
2724 offset
= convert_to_ptrofftype (offset
);
2726 offset
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (offset
), offset
);
2727 mod
= fold_build2 (POINTER_PLUS_EXPR
, type
, val
, offset
);
2730 mod
= fold_build2 (inc
? PLUS_EXPR
: MINUS_EXPR
, type
, val
, offset
);
2732 VERIFY_CONSTANT (mod
);
2734 /* Storing the modified value. */
2735 tree store
= build2 (MODIFY_EXPR
, type
, op
, mod
);
2736 cxx_eval_constant_expression (ctx
, store
,
2737 true, non_constant_p
, overflow_p
);
2739 /* And the value of the expression. */
2740 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
2742 /* Prefix ops are lvalues. */
2746 /* But we optimize when the caller wants an rvalue. */
2750 /* Postfix ops are rvalues. */
2754 /* Predicates for the meaning of *jump_target. */
2757 returns (tree
*jump_target
)
2760 && TREE_CODE (*jump_target
) == RETURN_EXPR
;
2764 breaks (tree
*jump_target
)
2767 && TREE_CODE (*jump_target
) == LABEL_DECL
2768 && LABEL_DECL_BREAK (*jump_target
);
2772 continues (tree
*jump_target
)
2775 && TREE_CODE (*jump_target
) == LABEL_DECL
2776 && LABEL_DECL_CONTINUE (*jump_target
);
2780 switches (tree
*jump_target
)
2783 && TREE_CODE (*jump_target
) == INTEGER_CST
;
2786 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
2787 at I matches *jump_target. If we're looking for a case label and we see
2788 the default label, copy I into DEFAULT_LABEL. */
2791 label_matches (tree
*jump_target
, tree_stmt_iterator i
,
2792 tree_stmt_iterator
& default_label
)
2794 tree stmt
= tsi_stmt (i
);
2795 switch (TREE_CODE (*jump_target
))
2798 if (TREE_CODE (stmt
) == LABEL_EXPR
2799 && LABEL_EXPR_LABEL (stmt
) == *jump_target
)
2804 if (TREE_CODE (stmt
) == CASE_LABEL_EXPR
)
2806 if (!CASE_LOW (stmt
))
2808 else if (tree_int_cst_equal (*jump_target
, CASE_LOW (stmt
)))
2819 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
2820 semantics, for switch, break, continue, and return. */
2823 cxx_eval_statement_list (const constexpr_ctx
*ctx
, tree t
,
2824 bool *non_constant_p
, bool *overflow_p
,
2827 tree_stmt_iterator i
;
2828 tree_stmt_iterator default_label
= tree_stmt_iterator();
2830 /* In a statement-expression we want to return the last value. */
2834 local_target
= NULL_TREE
;
2835 jump_target
= &local_target
;
2837 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
2840 tree stmt
= tsi_stmt (i
);
2843 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
2844 /* The label we want might be inside. */;
2845 else if (label_matches (jump_target
, i
, default_label
))
2847 *jump_target
= NULL_TREE
;
2851 r
= cxx_eval_constant_expression (ctx
, stmt
, false,
2852 non_constant_p
, overflow_p
,
2854 if (*non_constant_p
)
2856 if (returns (jump_target
) || breaks (jump_target
))
2859 if (switches (jump_target
) && !tsi_end_p (default_label
))
2862 *jump_target
= NULL_TREE
;
2868 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
2869 semantics; continue semantics are covered by cxx_eval_statement_list. */
2872 cxx_eval_loop_expr (const constexpr_ctx
*ctx
, tree t
,
2873 bool *non_constant_p
, bool *overflow_p
,
2876 tree body
= TREE_OPERAND (t
, 0);
2879 cxx_eval_statement_list (ctx
, body
,
2880 non_constant_p
, overflow_p
, jump_target
);
2881 if (returns (jump_target
) || breaks (jump_target
) || *non_constant_p
)
2884 if (breaks (jump_target
))
2885 *jump_target
= NULL_TREE
;
2889 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
2893 cxx_eval_switch_expr (const constexpr_ctx
*ctx
, tree t
,
2894 bool *non_constant_p
, bool *overflow_p
,
2897 tree cond
= TREE_OPERAND (t
, 0);
2898 cond
= cxx_eval_constant_expression (ctx
, cond
, false,
2899 non_constant_p
, overflow_p
);
2900 VERIFY_CONSTANT (cond
);
2901 *jump_target
= cond
;
2903 tree body
= TREE_OPERAND (t
, 1);
2904 cxx_eval_statement_list (ctx
, body
,
2905 non_constant_p
, overflow_p
, jump_target
);
2906 if (breaks (jump_target
) || switches (jump_target
))
2907 *jump_target
= NULL_TREE
;
2911 /* Subroutine of cxx_eval_constant_expression.
2912 Attempt to reduce a POINTER_PLUS_EXPR expression T. */
2915 cxx_eval_pointer_plus_expression (const constexpr_ctx
*ctx
, tree t
,
2916 bool lval
, bool *non_constant_p
,
2919 tree orig_type
= TREE_TYPE (t
);
2920 tree op00
= TREE_OPERAND (t
, 0);
2921 tree op01
= TREE_OPERAND (t
, 1);
2922 location_t loc
= EXPR_LOCATION (t
);
2924 op00
= cxx_eval_constant_expression (ctx
, op00
, lval
,
2925 non_constant_p
, overflow_p
);
2928 if (TREE_CODE (op00
) != ADDR_EXPR
)
2931 op00
= TREE_OPERAND (op00
, 0);
2933 /* &A[i] p+ j => &A[i + j] */
2934 if (TREE_CODE (op00
) == ARRAY_REF
2935 && TREE_CODE (TREE_OPERAND (op00
, 1)) == INTEGER_CST
2936 && TREE_CODE (op01
) == INTEGER_CST
2937 && TYPE_SIZE_UNIT (TREE_TYPE (op00
))
2938 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (op00
))) == INTEGER_CST
)
2940 tree type
= TREE_TYPE (op00
);
2941 t
= fold_convert_loc (loc
, ssizetype
, TREE_OPERAND (op00
, 1));
2942 tree nelts
= array_type_nelts_top (TREE_TYPE (TREE_OPERAND (op00
, 0)));
2943 /* Don't fold an out-of-bound access. */
2944 if (!tree_int_cst_le (t
, nelts
))
2946 op01
= cp_fold_convert (ssizetype
, op01
);
2947 /* Don't fold if op01 can't be divided exactly by TYPE_SIZE_UNIT.
2948 constexpr int A[1]; ... (char *)&A[0] + 1 */
2949 if (!integer_zerop (fold_build2_loc (loc
, TRUNC_MOD_EXPR
, sizetype
,
2950 op01
, TYPE_SIZE_UNIT (type
))))
2952 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2954 op01
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, ssizetype
, op01
,
2955 TYPE_SIZE_UNIT (type
));
2956 t
= size_binop_loc (loc
, PLUS_EXPR
, op01
, t
);
2957 t
= build4_loc (loc
, ARRAY_REF
, type
, TREE_OPERAND (op00
, 0),
2958 t
, NULL_TREE
, NULL_TREE
);
2959 t
= cp_build_addr_expr (t
, tf_warning_or_error
);
2960 t
= cp_fold_convert (orig_type
, t
);
2961 return cxx_eval_constant_expression (ctx
, t
, lval
, non_constant_p
,
2968 /* Attempt to reduce the expression T to a constant value.
2969 On failure, issue diagnostic and return error_mark_node. */
2970 /* FIXME unify with c_fully_fold */
2971 /* FIXME overflow_p is too global */
2974 cxx_eval_constant_expression (const constexpr_ctx
*ctx
, tree t
,
2976 bool *non_constant_p
, bool *overflow_p
,
2979 constexpr_ctx new_ctx
;
2982 if (t
== error_mark_node
)
2984 *non_constant_p
= true;
2987 if (CONSTANT_CLASS_P (t
))
2989 if (TREE_CODE (t
) == PTRMEM_CST
)
2990 t
= cplus_expand_constant (t
);
2991 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| ctx
->quiet
))
2996 switch (TREE_CODE (t
))
3001 /* We ask for an rvalue for the RESULT_DECL when indirecting
3002 through an invisible reference, or in named return value
3004 return (*ctx
->values
->get (t
));
3008 /* We used to not check lval for CONST_DECL, but darwin.c uses
3009 CONST_DECL for aggregate constants. */
3013 r
= decl_really_constant_value (t
);
3015 r
= decl_constant_value (t
);
3016 if (TREE_CODE (r
) == TARGET_EXPR
3017 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
3018 r
= TARGET_EXPR_INITIAL (r
);
3019 if (TREE_CODE (r
) == VAR_DECL
)
3020 if (tree
*p
= ctx
->values
->get (r
))
3025 non_const_var_error (r
);
3026 *non_constant_p
= true;
3034 case CASE_LABEL_EXPR
:
3038 if (lval
&& TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
3040 else if (tree
*p
= ctx
->values
->get (r
))
3043 /* Defer in case this is only used for its type. */;
3044 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3045 /* Defer, there's no lvalue->rvalue conversion. */;
3046 else if (is_empty_class (TREE_TYPE (t
)))
3048 /* If the class is empty, we aren't actually loading anything. */
3049 r
= build_constructor (TREE_TYPE (t
), NULL
);
3050 TREE_CONSTANT (r
) = true;
3055 error ("%qE is not a constant expression", t
);
3056 *non_constant_p
= true;
3061 case AGGR_INIT_EXPR
:
3062 r
= cxx_eval_call_expression (ctx
, t
, lval
,
3063 non_constant_p
, overflow_p
);
3068 r
= DECL_EXPR_DECL (t
);
3069 if (AGGREGATE_TYPE_P (TREE_TYPE (r
))
3070 || VECTOR_TYPE_P (TREE_TYPE (r
)))
3074 new_ctx
.ctor
= build_constructor (TREE_TYPE (r
), NULL
);
3075 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3076 new_ctx
.values
->put (r
, new_ctx
.ctor
);
3080 if (tree init
= DECL_INITIAL (r
))
3082 init
= cxx_eval_constant_expression (ctx
, init
,
3084 non_constant_p
, overflow_p
);
3085 ctx
->values
->put (r
, init
);
3087 else if (ctx
== &new_ctx
)
3088 /* We gave it a CONSTRUCTOR above. */;
3090 ctx
->values
->put (r
, NULL_TREE
);
3095 if (!literal_type_p (TREE_TYPE (t
)))
3099 error ("temporary of non-literal type %qT in a "
3100 "constant expression", TREE_TYPE (t
));
3101 explain_non_literal_class (TREE_TYPE (t
));
3103 *non_constant_p
= true;
3106 if ((AGGREGATE_TYPE_P (TREE_TYPE (t
)) || VECTOR_TYPE_P (TREE_TYPE (t
))))
3108 /* We're being expanded without an explicit target, so start
3109 initializing a new object; expansion with an explicit target
3110 strips the TARGET_EXPR before we get here. */
3112 new_ctx
.ctor
= build_constructor (TREE_TYPE (t
), NULL
);
3113 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx
.ctor
) = true;
3114 new_ctx
.object
= TARGET_EXPR_SLOT (t
);
3115 ctx
->values
->put (new_ctx
.object
, new_ctx
.ctor
);
3118 /* Pass false for 'lval' because this indicates
3119 initialization of a temporary. */
3120 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3122 non_constant_p
, overflow_p
);
3123 if (!*non_constant_p
)
3124 /* Adjust the type of the result to the type of the temporary. */
3125 r
= adjust_temp_type (TREE_TYPE (t
), r
);
3128 tree slot
= TARGET_EXPR_SLOT (t
);
3129 ctx
->values
->put (slot
, r
);
3136 r
= cxx_eval_store_expression (ctx
, t
, lval
,
3137 non_constant_p
, overflow_p
);
3141 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 1),
3143 non_constant_p
, overflow_p
);
3147 if (TREE_OPERAND (t
, 0) != NULL_TREE
)
3148 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3150 non_constant_p
, overflow_p
);
3155 /* Avoid evaluating a SAVE_EXPR more than once. */
3156 if (tree
*p
= ctx
->values
->get (t
))
3160 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0), false,
3161 non_constant_p
, overflow_p
);
3162 ctx
->values
->put (t
, r
);
3166 case NON_LVALUE_EXPR
:
3167 case TRY_CATCH_EXPR
:
3168 case CLEANUP_POINT_EXPR
:
3169 case MUST_NOT_THROW_EXPR
:
3172 r
= cxx_eval_constant_expression (ctx
, TREE_OPERAND (t
, 0),
3174 non_constant_p
, overflow_p
,
3178 /* These differ from cxx_eval_unary_expression in that this doesn't
3179 check for a constant operand or result; an address can be
3180 constant without its operand being, and vice versa. */
3182 r
= cxx_eval_indirect_ref (ctx
, t
, lval
,
3183 non_constant_p
, overflow_p
);
3188 tree oldop
= TREE_OPERAND (t
, 0);
3189 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3191 non_constant_p
, overflow_p
);
3192 /* Don't VERIFY_CONSTANT here. */
3193 if (*non_constant_p
)
3195 gcc_checking_assert (TREE_CODE (op
) != CONSTRUCTOR
);
3196 /* This function does more aggressive folding than fold itself. */
3197 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
3198 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
3206 case FIX_TRUNC_EXPR
:
3211 case TRUTH_NOT_EXPR
:
3212 case FIXED_CONVERT_EXPR
:
3213 r
= cxx_eval_unary_expression (ctx
, t
, lval
,
3214 non_constant_p
, overflow_p
);
3218 if (SIZEOF_EXPR_TYPE_P (t
))
3219 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
3220 SIZEOF_EXPR
, false);
3221 else if (TYPE_P (TREE_OPERAND (t
, 0)))
3222 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3225 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
3227 if (r
== error_mark_node
)
3229 VERIFY_CONSTANT (r
);
3234 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3235 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3236 introduced by build_call_a. */
3237 tree op0
= TREE_OPERAND (t
, 0);
3238 tree op1
= TREE_OPERAND (t
, 1);
3240 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
3241 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
3242 r
= cxx_eval_constant_expression (ctx
, op0
,
3243 lval
, non_constant_p
, overflow_p
,
3247 /* Check that the LHS is constant and then discard it. */
3248 cxx_eval_constant_expression (ctx
, op0
,
3249 true, non_constant_p
, overflow_p
,
3251 op1
= TREE_OPERAND (t
, 1);
3252 r
= cxx_eval_constant_expression (ctx
, op1
,
3253 lval
, non_constant_p
, overflow_p
,
3259 case POINTER_PLUS_EXPR
:
3260 r
= cxx_eval_pointer_plus_expression (ctx
, t
, lval
, non_constant_p
,
3264 /* else fall through */
3269 case TRUNC_DIV_EXPR
:
3271 case FLOOR_DIV_EXPR
:
3272 case ROUND_DIV_EXPR
:
3273 case TRUNC_MOD_EXPR
:
3275 case ROUND_MOD_EXPR
:
3277 case EXACT_DIV_EXPR
:
3287 case TRUTH_XOR_EXPR
:
3294 case UNORDERED_EXPR
:
3304 r
= cxx_eval_binary_expression (ctx
, t
, lval
,
3305 non_constant_p
, overflow_p
);
3308 /* fold can introduce non-IF versions of these; still treat them as
3309 short-circuiting. */
3310 case TRUTH_AND_EXPR
:
3311 case TRUTH_ANDIF_EXPR
:
3312 r
= cxx_eval_logical_expression (ctx
, t
, boolean_false_node
,
3315 non_constant_p
, overflow_p
);
3319 case TRUTH_ORIF_EXPR
:
3320 r
= cxx_eval_logical_expression (ctx
, t
, boolean_true_node
,
3323 non_constant_p
, overflow_p
);
3327 r
= cxx_eval_array_reference (ctx
, t
, lval
,
3328 non_constant_p
, overflow_p
);
3332 if (is_overloaded_fn (t
))
3334 /* We can only get here in checking mode via
3335 build_non_dependent_expr, because any expression that
3336 calls or takes the address of the function will have
3337 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3338 gcc_checking_assert (ctx
->quiet
|| errorcount
);
3339 *non_constant_p
= true;
3342 r
= cxx_eval_component_reference (ctx
, t
, lval
,
3343 non_constant_p
, overflow_p
);
3347 r
= cxx_eval_bit_field_ref (ctx
, t
, lval
,
3348 non_constant_p
, overflow_p
);
3353 r
= cxx_eval_conditional_expression (ctx
, t
, lval
,
3354 non_constant_p
, overflow_p
,
3359 if (TREE_CONSTANT (t
))
3360 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3361 VECTOR_CST if applicable. */
3363 r
= cxx_eval_bare_aggregate (ctx
, t
, lval
,
3364 non_constant_p
, overflow_p
);
3368 /* We can get this in a defaulted constructor for a class with a
3369 non-static data member of array type. Either the initializer will
3370 be NULL, meaning default-initialization, or it will be an lvalue
3371 or xvalue of the same type, meaning direct-initialization from the
3372 corresponding member. */
3373 r
= cxx_eval_vec_init (ctx
, t
, lval
,
3374 non_constant_p
, overflow_p
);
3379 r
= cxx_eval_trinary_expression (ctx
, t
, lval
,
3380 non_constant_p
, overflow_p
);
3384 case VIEW_CONVERT_EXPR
:
3387 tree oldop
= TREE_OPERAND (t
, 0);
3388 tree op
= cxx_eval_constant_expression (ctx
, oldop
,
3390 non_constant_p
, overflow_p
);
3391 if (*non_constant_p
)
3393 if (POINTER_TYPE_P (TREE_TYPE (t
))
3394 && TREE_CODE (op
) == INTEGER_CST
3395 && !integer_zerop (op
))
3398 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3399 "reinterpret_cast from integer to pointer");
3400 *non_constant_p
= true;
3404 /* We didn't fold at the top so we could check for ptr-int
3407 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
3408 /* Conversion of an out-of-range value has implementation-defined
3409 behavior; the language considers it different from arithmetic
3410 overflow, which is undefined. */
3411 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
3412 TREE_OVERFLOW (r
) = false;
3416 case EMPTY_CLASS_EXPR
:
3417 /* This is good enough for a function argument that might not get
3418 used, and they can't do anything with it, so just return it. */
3421 case STATEMENT_LIST
:
3423 new_ctx
.ctor
= new_ctx
.object
= NULL_TREE
;
3424 return cxx_eval_statement_list (&new_ctx
, t
,
3425 non_constant_p
, overflow_p
, jump_target
);
3428 return cxx_eval_constant_expression (ctx
, BIND_EXPR_BODY (t
),
3430 non_constant_p
, overflow_p
,
3433 case PREINCREMENT_EXPR
:
3434 case POSTINCREMENT_EXPR
:
3435 case PREDECREMENT_EXPR
:
3436 case POSTDECREMENT_EXPR
:
3437 return cxx_eval_increment_expression (ctx
, t
,
3438 lval
, non_constant_p
, overflow_p
);
3444 case VEC_DELETE_EXPR
:
3447 /* GCC internal stuff. */
3450 case WITH_CLEANUP_EXPR
:
3451 case NON_DEPENDENT_EXPR
:
3455 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3456 "expression %qE is not a constant-expression", t
);
3457 *non_constant_p
= true;
3460 case PLACEHOLDER_EXPR
:
3461 if (!ctx
|| !ctx
->ctor
|| (lval
&& !ctx
->object
))
3463 /* A placeholder without a referent. We can get here when
3464 checking whether NSDMIs are noexcept, or in massage_init_elt;
3465 just say it's non-constant for now. */
3466 gcc_assert (ctx
->quiet
);
3467 *non_constant_p
= true;
3472 /* Use of the value or address of the current object. We could
3473 use ctx->object unconditionally, but using ctx->ctor when we
3474 can is a minor optimization. */
3475 tree ctor
= lval
? ctx
->object
: ctx
->ctor
;
3476 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3477 (TREE_TYPE (t
), TREE_TYPE (ctor
)));
3478 return cxx_eval_constant_expression
3480 non_constant_p
, overflow_p
);
3485 *jump_target
= TREE_OPERAND (t
, 0);
3486 gcc_assert (breaks (jump_target
) || continues (jump_target
));
3490 cxx_eval_loop_expr (ctx
, t
,
3491 non_constant_p
, overflow_p
, jump_target
);
3495 cxx_eval_switch_expr (ctx
, t
,
3496 non_constant_p
, overflow_p
, jump_target
);
3500 if (STATEMENT_CODE_P (TREE_CODE (t
)))
3502 /* This function doesn't know how to deal with pre-genericize
3503 statements; this can only happen with statement-expressions,
3504 so for now just fail. */
3506 error_at (EXPR_LOCATION (t
),
3507 "statement is not a constant-expression");
3510 internal_error ("unexpected expression %qE of kind %s", t
,
3511 get_tree_code_name (TREE_CODE (t
)));
3512 *non_constant_p
= true;
3516 if (r
== error_mark_node
)
3517 *non_constant_p
= true;
3519 if (*non_constant_p
)
3526 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
,
3527 bool strict
= true, tree object
= NULL_TREE
)
3529 bool non_constant_p
= false;
3530 bool overflow_p
= false;
3531 hash_map
<tree
,tree
> map
;
3532 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, allow_non_constant
, strict
};
3533 tree type
= initialized_type (t
);
3535 if (AGGREGATE_TYPE_P (type
) || VECTOR_TYPE_P (type
))
3537 /* In C++14 an NSDMI can participate in aggregate initialization,
3538 and can refer to the address of the object being initialized, so
3539 we need to pass in the relevant VAR_DECL if we want to do the
3540 evaluation in a single pass. The evaluation will dynamically
3541 update ctx.values for the VAR_DECL. We use the same strategy
3542 for C++11 constexpr constructors that refer to the object being
3544 ctx
.ctor
= build_constructor (type
, NULL
);
3545 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx
.ctor
) = true;
3548 if (TREE_CODE (t
) == TARGET_EXPR
)
3549 object
= TARGET_EXPR_SLOT (t
);
3550 else if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3551 object
= AGGR_INIT_EXPR_SLOT (t
);
3553 ctx
.object
= object
;
3555 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3556 (type
, TREE_TYPE (object
)));
3557 if (object
&& DECL_P (object
))
3558 map
.put (object
, ctx
.ctor
);
3559 if (TREE_CODE (r
) == TARGET_EXPR
)
3560 /* Avoid creating another CONSTRUCTOR when we expand the
3562 r
= TARGET_EXPR_INITIAL (r
);
3565 r
= cxx_eval_constant_expression (&ctx
, r
,
3566 false, &non_constant_p
, &overflow_p
);
3568 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
3570 /* Mutable logic is a bit tricky: we want to allow initialization of
3571 constexpr variables with mutable members, but we can't copy those
3572 members to another constexpr variable. */
3573 if (TREE_CODE (r
) == CONSTRUCTOR
3574 && CONSTRUCTOR_MUTABLE_POISON (r
))
3576 if (!allow_non_constant
)
3577 error ("%qE is not a constant expression because it refers to "
3578 "mutable subobjects of %qT", t
, type
);
3579 non_constant_p
= true;
3582 /* Technically we should check this for all subexpressions, but that
3583 runs into problems with our internal representation of pointer
3584 subtraction and the 5.19 rules are still in flux. */
3585 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
3586 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
3587 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
3589 if (!allow_non_constant
)
3590 error ("conversion from pointer type %qT "
3591 "to arithmetic type %qT in a constant-expression",
3592 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
3593 non_constant_p
= true;
3596 if (!non_constant_p
&& overflow_p
)
3597 non_constant_p
= true;
3599 if (non_constant_p
&& !allow_non_constant
)
3600 return error_mark_node
;
3601 else if (non_constant_p
&& TREE_CONSTANT (r
))
3603 /* This isn't actually constant, so unset TREE_CONSTANT. */
3606 else if (TREE_CODE (r
) == CONSTRUCTOR
)
3607 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
3609 r
= build_nop (TREE_TYPE (r
), r
);
3610 TREE_CONSTANT (r
) = false;
3612 else if (non_constant_p
|| r
== t
)
3615 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
3617 if (TREE_CODE (t
) == TARGET_EXPR
3618 && TARGET_EXPR_INITIAL (t
) == r
)
3622 r
= get_target_expr (r
);
3623 TREE_CONSTANT (r
) = true;
3631 /* Returns true if T is a valid subexpression of a constant expression,
3632 even if it isn't itself a constant expression. */
3635 is_sub_constant_expr (tree t
)
3637 bool non_constant_p
= false;
3638 bool overflow_p
= false;
3639 hash_map
<tree
, tree
> map
;
3640 constexpr_ctx ctx
= { NULL
, &map
, NULL
, NULL
, true, true };
3641 cxx_eval_constant_expression (&ctx
, t
, false, &non_constant_p
,
3643 return !non_constant_p
&& !overflow_p
;
3646 /* If T represents a constant expression returns its reduced value.
3647 Otherwise return error_mark_node. If T is dependent, then
3651 cxx_constant_value (tree t
, tree decl
)
3653 return cxx_eval_outermost_constant_expr (t
, false, true, decl
);
3656 /* If T is a constant expression, returns its reduced value.
3657 Otherwise, if T does not have TREE_CONSTANT set, returns T.
3658 Otherwise, returns a version of T without TREE_CONSTANT. */
3661 maybe_constant_value (tree t
, tree decl
)
3665 if (instantiation_dependent_expression_p (t
)
3666 || type_unknown_p (t
)
3667 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3668 || !potential_constant_expression (t
))
3670 if (TREE_OVERFLOW_P (t
))
3672 t
= build_nop (TREE_TYPE (t
), t
);
3673 TREE_CONSTANT (t
) = false;
3678 r
= cxx_eval_outermost_constant_expr (t
, true, true, decl
);
3679 #ifdef ENABLE_CHECKING
3681 || CONVERT_EXPR_P (t
)
3682 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3683 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3684 || !cp_tree_equal (r
, t
));
3689 /* Like maybe_constant_value but first fully instantiate the argument.
3691 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3692 (t, tf_none) followed by maybe_constant_value but is more efficient,
3693 because calls instantiation_dependent_expression_p and
3694 potential_constant_expression at most once. */
3697 fold_non_dependent_expr (tree t
)
3702 /* If we're in a template, but T isn't value dependent, simplify
3703 it. We're supposed to treat:
3705 template <typename T> void f(T[1 + 1]);
3706 template <typename T> void f(T[2]);
3708 as two declarations of the same function, for example. */
3709 if (processing_template_decl
)
3711 if (!instantiation_dependent_expression_p (t
)
3712 && potential_constant_expression (t
))
3714 processing_template_decl_sentinel s
;
3715 t
= instantiate_non_dependent_expr_internal (t
, tf_none
);
3717 if (type_unknown_p (t
)
3718 || BRACE_ENCLOSED_INITIALIZER_P (t
))
3720 if (TREE_OVERFLOW_P (t
))
3722 t
= build_nop (TREE_TYPE (t
), t
);
3723 TREE_CONSTANT (t
) = false;
3728 tree r
= cxx_eval_outermost_constant_expr (t
, true, true, NULL_TREE
);
3729 #ifdef ENABLE_CHECKING
3730 /* cp_tree_equal looks through NOPs, so allow them. */
3732 || CONVERT_EXPR_P (t
)
3733 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3734 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
3735 || !cp_tree_equal (r
, t
));
3739 else if (TREE_OVERFLOW_P (t
))
3741 t
= build_nop (TREE_TYPE (t
), t
);
3742 TREE_CONSTANT (t
) = false;
3747 return maybe_constant_value (t
);
3750 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3751 than wrapped in a TARGET_EXPR. */
3754 maybe_constant_init (tree t
, tree decl
)
3756 if (TREE_CODE (t
) == EXPR_STMT
)
3757 t
= TREE_OPERAND (t
, 0);
3758 if (TREE_CODE (t
) == CONVERT_EXPR
3759 && VOID_TYPE_P (TREE_TYPE (t
)))
3760 t
= TREE_OPERAND (t
, 0);
3761 if (TREE_CODE (t
) == INIT_EXPR
)
3762 t
= TREE_OPERAND (t
, 1);
3763 if (instantiation_dependent_expression_p (t
)
3764 || type_unknown_p (t
)
3765 || BRACE_ENCLOSED_INITIALIZER_P (t
)
3766 || !potential_static_init_expression (t
))
3767 /* Don't try to evaluate it. */;
3769 t
= cxx_eval_outermost_constant_expr (t
, true, false, decl
);
3770 if (TREE_CODE (t
) == TARGET_EXPR
)
3772 tree init
= TARGET_EXPR_INITIAL (t
);
3773 if (TREE_CODE (init
) == CONSTRUCTOR
)
3780 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
3781 /* Return true if the object referred to by REF has automatic or thread
3784 enum { ck_ok
, ck_bad
, ck_unknown
};
3786 check_automatic_or_tls (tree ref
)
3789 HOST_WIDE_INT bitsize
, bitpos
;
3791 int volatilep
= 0, unsignedp
= 0;
3792 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
3793 &mode
, &unsignedp
, &volatilep
, false);
3796 /* If there isn't a decl in the middle, we don't know the linkage here,
3797 and this isn't a constant expression anyway. */
3800 dk
= decl_storage_duration (decl
);
3801 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
3805 /* Return true if T denotes a potentially constant expression. Issue
3806 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
3807 an lvalue-rvalue conversion is implied.
3809 C++0x [expr.const] used to say
3811 6 An expression is a potential constant expression if it is
3812 a constant expression where all occurrences of function
3813 parameters are replaced by arbitrary constant expressions
3814 of the appropriate type.
3816 2 A conditional expression is a constant expression unless it
3817 involves one of the following as a potentially evaluated
3818 subexpression (3.2), but subexpressions of logical AND (5.14),
3819 logical OR (5.15), and conditional (5.16) operations that are
3820 not evaluated are not considered. */
3823 potential_constant_expression_1 (tree t
, bool want_rval
, bool strict
,
3824 tsubst_flags_t flags
)
3826 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
3827 enum { any
= false, rval
= true };
3831 if (t
== error_mark_node
)
3835 if (TREE_THIS_VOLATILE (t
))
3837 if (flags
& tf_error
)
3838 error ("expression %qE has side-effects", t
);
3841 if (CONSTANT_CLASS_P (t
))
3844 switch (TREE_CODE (t
))
3850 case TEMPLATE_ID_EXPR
:
3853 case CASE_LABEL_EXPR
:
3859 case TEMPLATE_PARM_INDEX
:
3861 case IDENTIFIER_NODE
:
3862 case USERDEF_LITERAL
:
3863 /* We can see a FIELD_DECL in a pointer-to-member expression. */
3868 case PLACEHOLDER_EXPR
:
3873 case AGGR_INIT_EXPR
:
3875 /* -- an invocation of a function other than a constexpr function
3876 or a constexpr constructor. */
3878 tree fun
= get_function_named_in_call (t
);
3879 const int nargs
= call_expr_nargs (t
);
3882 if (fun
== NULL_TREE
)
3884 if (TREE_CODE (t
) == CALL_EXPR
3885 && CALL_EXPR_FN (t
) == NULL_TREE
)
3886 switch (CALL_EXPR_IFN (t
))
3888 /* These should be ignored, they are optimized away from
3889 constexpr functions. */
3890 case IFN_UBSAN_NULL
:
3891 case IFN_UBSAN_BOUNDS
:
3892 case IFN_UBSAN_VPTR
:
3897 /* fold_call_expr can't do anything with IFN calls. */
3898 if (flags
& tf_error
)
3899 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3900 "call to internal function");
3903 if (is_overloaded_fn (fun
))
3905 if (TREE_CODE (fun
) == FUNCTION_DECL
)
3907 if (builtin_valid_in_constant_expr_p (fun
))
3909 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
3910 /* Allow any built-in function; if the expansion
3911 isn't constant, we'll deal with that then. */
3912 && !is_builtin_fn (fun
))
3914 if (flags
& tf_error
)
3916 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
3917 "call to non-constexpr function %qD", fun
);
3918 explain_invalid_constexpr_fn (fun
);
3922 /* A call to a non-static member function takes the address
3923 of the object as the first argument. But in a constant
3924 expression the address will be folded away, so look
3926 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
3927 && !DECL_CONSTRUCTOR_P (fun
))
3929 tree x
= get_nth_callarg (t
, 0);
3930 if (is_this_parameter (x
))
3932 else if (!RECUR (x
, rval
))
3939 if (!RECUR (fun
, true))
3941 fun
= get_first_fn (fun
);
3943 /* Skip initial arguments to base constructors. */
3944 if (DECL_BASE_CONSTRUCTOR_P (fun
))
3945 i
= num_artificial_parms_for (fun
);
3946 fun
= DECL_ORIGIN (fun
);
3950 if (RECUR (fun
, rval
))
3951 /* Might end up being a constant function pointer. */;
3955 for (; i
< nargs
; ++i
)
3957 tree x
= get_nth_callarg (t
, i
);
3958 /* In a template, reference arguments haven't been converted to
3959 REFERENCE_TYPE and we might not even know if the parameter
3960 is a reference, so accept lvalue constants too. */
3961 bool rv
= processing_template_decl
? any
: rval
;
3968 case NON_LVALUE_EXPR
:
3969 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
3970 -- an lvalue of integral type that refers to a non-volatile
3971 const variable or static data member initialized with
3972 constant expressions, or
3974 -- an lvalue of literal type that refers to non-volatile
3975 object defined with constexpr, or that refers to a
3976 sub-object of such an object; */
3977 return RECUR (TREE_OPERAND (t
, 0), rval
);
3981 && !decl_constant_var_p (t
)
3983 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t
))
3984 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
))
3985 && !var_in_constexpr_fn (t
)
3986 && !type_dependent_expression_p (t
))
3988 if (flags
& tf_error
)
3989 non_const_var_error (t
);
3996 case VIEW_CONVERT_EXPR
:
3997 /* -- a reinterpret_cast. FIXME not implemented, and this rule
3998 may change to something more specific to type-punning (DR 1312). */
4000 tree from
= TREE_OPERAND (t
, 0);
4001 if (POINTER_TYPE_P (TREE_TYPE (t
))
4002 && TREE_CODE (from
) == INTEGER_CST
4003 && !integer_zerop (from
))
4005 if (flags
& tf_error
)
4006 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
4007 "reinterpret_cast from integer to pointer");
4010 return (RECUR (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
));
4014 /* -- a unary operator & that is applied to an lvalue that
4015 designates an object with thread or automatic storage
4017 t
= TREE_OPERAND (t
, 0);
4019 if (TREE_CODE (t
) == OFFSET_REF
&& PTRMEM_OK_P (t
))
4020 /* A pointer-to-member constant. */
4024 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4025 any checking here, as we might dereference the pointer later. If
4026 we remove this code, also remove check_automatic_or_tls. */
4027 i
= check_automatic_or_tls (t
);
4032 if (flags
& tf_error
)
4033 error ("address-of an object %qE with thread local or "
4034 "automatic storage is not a constant expression", t
);
4038 return RECUR (t
, any
);
4044 /* -- a class member access unless its postfix-expression is
4045 of literal type or of pointer to literal type. */
4046 /* This test would be redundant, as it follows from the
4047 postfix-expression being a potential constant expression. */
4048 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4050 case EXPR_PACK_EXPANSION
:
4051 return RECUR (PACK_EXPANSION_PATTERN (t
), want_rval
);
4055 tree x
= TREE_OPERAND (t
, 0);
4057 if (is_this_parameter (x
))
4059 if (DECL_CONTEXT (x
)
4060 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
4062 if (flags
& tf_error
)
4063 error ("use of %<this%> in a constant expression");
4068 return RECUR (x
, rval
);
4071 case STATEMENT_LIST
:
4073 tree_stmt_iterator i
;
4074 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
4076 if (!RECUR (tsi_stmt (i
), any
))
4084 if (cxx_dialect
< cxx14
)
4086 if (!RECUR (TREE_OPERAND (t
, 0), any
))
4088 if (!RECUR (TREE_OPERAND (t
, 1), rval
))
4093 if (cxx_dialect
< cxx14
)
4095 if (!RECUR (TREE_OPERAND (t
, 0), rval
))
4097 if (!RECUR (TREE_OPERAND (t
, 2), rval
))
4102 if (!RECUR (IF_COND (t
), rval
))
4104 if (!RECUR (THEN_CLAUSE (t
), any
))
4106 if (!RECUR (ELSE_CLAUSE (t
), any
))
4111 if (!RECUR (DO_COND (t
), rval
))
4113 if (!RECUR (DO_BODY (t
), any
))
4118 if (!RECUR (FOR_INIT_STMT (t
), any
))
4120 if (!RECUR (FOR_COND (t
), rval
))
4122 if (!RECUR (FOR_EXPR (t
), any
))
4124 if (!RECUR (FOR_BODY (t
), any
))
4129 if (!RECUR (WHILE_COND (t
), rval
))
4131 if (!RECUR (WHILE_BODY (t
), any
))
4136 if (!RECUR (SWITCH_STMT_COND (t
), rval
))
4138 if (!RECUR (SWITCH_STMT_BODY (t
), any
))
4143 return RECUR (STMT_EXPR_STMT (t
), rval
);
4146 case DYNAMIC_CAST_EXPR
:
4147 case PSEUDO_DTOR_EXPR
:
4151 case VEC_DELETE_EXPR
:
4154 case OMP_ATOMIC_READ
:
4155 case OMP_ATOMIC_CAPTURE_OLD
:
4156 case OMP_ATOMIC_CAPTURE_NEW
:
4157 /* GCC internal stuff. */
4160 case TRANSACTION_EXPR
:
4162 case AT_ENCODE_EXPR
:
4164 if (flags
& tf_error
)
4165 error ("expression %qE is not a constant-expression", t
);
4169 /* -- a typeid expression whose operand is of polymorphic
4172 tree e
= TREE_OPERAND (t
, 0);
4173 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
4174 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
4176 if (flags
& tf_error
)
4177 error ("typeid-expression is not a constant expression "
4178 "because %qE is of polymorphic type", e
);
4197 case PREINCREMENT_EXPR
:
4198 case POSTINCREMENT_EXPR
:
4199 case PREDECREMENT_EXPR
:
4200 case POSTDECREMENT_EXPR
:
4201 if (cxx_dialect
< cxx14
)
4207 if (TYPE_P (TREE_OPERAND (t
, 0)))
4209 /* else fall through. */
4215 case FIX_TRUNC_EXPR
:
4219 case TRUTH_NOT_EXPR
:
4220 case FIXED_CONVERT_EXPR
:
4221 case UNARY_PLUS_EXPR
:
4223 return RECUR (TREE_OPERAND (t
, 0), rval
);
4226 case CONST_CAST_EXPR
:
4227 case STATIC_CAST_EXPR
:
4228 case REINTERPRET_CAST_EXPR
:
4229 case IMPLICIT_CONV_EXPR
:
4230 if (cxx_dialect
< cxx11
4231 && !dependent_type_p (TREE_TYPE (t
))
4232 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
4233 /* In C++98, a conversion to non-integral type can't be part of a
4234 constant expression. */
4236 if (flags
& tf_error
)
4237 error ("cast to non-integral type %qT in a constant expression",
4242 return (RECUR (TREE_OPERAND (t
, 0),
4243 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
));
4246 return RECUR (BIND_EXPR_BODY (t
), want_rval
);
4248 case WITH_CLEANUP_EXPR
:
4249 case CLEANUP_POINT_EXPR
:
4250 case MUST_NOT_THROW_EXPR
:
4251 case TRY_CATCH_EXPR
:
4256 case NON_DEPENDENT_EXPR
:
4257 /* For convenience. */
4259 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4262 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4265 if (!literal_type_p (TREE_TYPE (t
)))
4267 if (flags
& tf_error
)
4269 error ("temporary of non-literal type %qT in a "
4270 "constant expression", TREE_TYPE (t
));
4271 explain_non_literal_class (TREE_TYPE (t
));
4276 return RECUR (TREE_OPERAND (t
, 1), rval
);
4280 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4281 constructor_elt
*ce
;
4282 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4283 if (!RECUR (ce
->value
, want_rval
))
4290 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
4291 || DECL_P (TREE_PURPOSE (t
)));
4292 if (!RECUR (TREE_VALUE (t
), want_rval
))
4294 if (TREE_CHAIN (t
) == NULL_TREE
)
4296 return RECUR (TREE_CHAIN (t
), want_rval
);
4299 case TRUNC_DIV_EXPR
:
4301 case FLOOR_DIV_EXPR
:
4302 case ROUND_DIV_EXPR
:
4303 case TRUNC_MOD_EXPR
:
4305 case ROUND_MOD_EXPR
:
4307 tree denom
= TREE_OPERAND (t
, 1);
4308 if (!RECUR (denom
, rval
))
4310 /* We can't call cxx_eval_outermost_constant_expr on an expression
4311 that hasn't been through instantiate_non_dependent_expr yet. */
4312 if (!processing_template_decl
)
4313 denom
= cxx_eval_outermost_constant_expr (denom
, true);
4314 if (integer_zerop (denom
))
4316 if (flags
& tf_error
)
4317 error ("division by zero is not a constant-expression");
4323 return RECUR (TREE_OPERAND (t
, 0), want_rval
);
4329 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4330 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4331 introduced by build_call_a. */
4332 tree op0
= TREE_OPERAND (t
, 0);
4333 tree op1
= TREE_OPERAND (t
, 1);
4335 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
4336 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
4337 return RECUR (op0
, want_rval
);
4342 /* If the first operand is the non-short-circuit constant, look at
4343 the second operand; otherwise we only care about the first one for
4345 case TRUTH_AND_EXPR
:
4346 case TRUTH_ANDIF_EXPR
:
4347 tmp
= boolean_true_node
;
4350 case TRUTH_ORIF_EXPR
:
4351 tmp
= boolean_false_node
;
4354 tree op
= TREE_OPERAND (t
, 0);
4355 if (!RECUR (op
, rval
))
4357 if (!processing_template_decl
)
4358 op
= cxx_eval_outermost_constant_expr (op
, true);
4359 if (tree_int_cst_equal (op
, tmp
))
4360 return RECUR (TREE_OPERAND (t
, 1), rval
);
4367 case POINTER_PLUS_EXPR
:
4369 case EXACT_DIV_EXPR
:
4379 case TRUTH_XOR_EXPR
:
4380 case UNORDERED_EXPR
:
4393 case ARRAY_RANGE_REF
:
4398 for (i
= 0; i
< 2; ++i
)
4399 if (!RECUR (TREE_OPERAND (t
, i
), want_rval
))
4403 case CILK_SYNC_STMT
:
4404 case CILK_SPAWN_STMT
:
4405 case ARRAY_NOTATION_REF
:
4410 for (i
= 0; i
< 3; ++i
)
4411 if (!RECUR (TREE_OPERAND (t
, i
), true))
4417 /* If the condition is a known constant, we know which of the legs we
4418 care about; otherwise we only require that the condition and
4419 either of the legs be potentially constant. */
4420 tmp
= TREE_OPERAND (t
, 0);
4421 if (!RECUR (tmp
, rval
))
4423 if (!processing_template_decl
)
4424 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
4425 if (integer_zerop (tmp
))
4426 return RECUR (TREE_OPERAND (t
, 2), want_rval
);
4427 else if (TREE_CODE (tmp
) == INTEGER_CST
)
4428 return RECUR (TREE_OPERAND (t
, 1), want_rval
);
4429 for (i
= 1; i
< 3; ++i
)
4430 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
4431 want_rval
, strict
, tf_none
))
4433 if (flags
& tf_error
)
4434 error ("expression %qE is not a constant-expression", t
);
4438 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
4440 if (flags
& tf_error
)
4442 error ("non-constant array initialization");
4443 diagnose_non_constexpr_vec_init (t
);
4448 if (objc_is_property_ref (t
))
4451 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t
)));
4458 /* The main entry point to the above. */
4461 potential_constant_expression (tree t
)
4463 return potential_constant_expression_1 (t
, false, true, tf_none
);
4467 potential_static_init_expression (tree t
)
4469 return potential_constant_expression_1 (t
, false, false, tf_none
);
4472 /* As above, but require a constant rvalue. */
4475 potential_rvalue_constant_expression (tree t
)
4477 return potential_constant_expression_1 (t
, true, true, tf_none
);
4480 /* Like above, but complain about non-constant expressions. */
4483 require_potential_constant_expression (tree t
)
4485 return potential_constant_expression_1 (t
, false, true, tf_warning_or_error
);
4488 /* Cross product of the above. */
4491 require_potential_rvalue_constant_expression (tree t
)
4493 return potential_constant_expression_1 (t
, true, true, tf_warning_or_error
);
4496 #include "gt-cp-constexpr.h"