1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2016 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
35 static bool verify_constant (tree, bool, bool *, bool *);
36 #define VERIFY_CONSTANT(X) \
38 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
42 /* Returns true iff FUN is an instantiation of a constexpr function
43 template or a defaulted constexpr function. */
46 is_instantiation_of_constexpr (tree fun)
48 return ((DECL_TEMPLOID_INSTANTIATION (fun)
49 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun)))
50 || (DECL_DEFAULTED_FN (fun)
51 && DECL_DECLARED_CONSTEXPR_P (fun)));
54 /* Return true if T is a literal type. */
57 literal_type_p (tree t)
61 || TREE_CODE (t) == REFERENCE_TYPE
62 || (VOID_TYPE_P (t) && cxx_dialect >= cxx14))
66 t = complete_type (t);
67 gcc_assert (COMPLETE_TYPE_P (t) || errorcount);
68 return CLASSTYPE_LITERAL_P (t);
70 if (TREE_CODE (t) == ARRAY_TYPE)
71 return literal_type_p (strip_array_types (t));
75 /* If DECL is a variable declared `constexpr', require its type
76 be literal. Return the DECL if OK, otherwise NULL. */
79 ensure_literal_type_for_constexpr_object (tree decl)
81 tree type = TREE_TYPE (decl);
83 && (DECL_DECLARED_CONSTEXPR_P (decl)
84 || var_in_constexpr_fn (decl))
85 && !processing_template_decl)
87 tree stype = strip_array_types (type);
88 if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype)))
89 /* Don't complain here, we'll complain about incompleteness
90 when we try to initialize the variable. */;
91 else if (!literal_type_p (type))
93 if (DECL_DECLARED_CONSTEXPR_P (decl))
95 error ("the type %qT of constexpr variable %qD is not literal",
97 explain_non_literal_class (type);
101 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))
103 error ("variable %qD of non-literal type %qT in %<constexpr%> "
104 "function", decl, type);
105 explain_non_literal_class (type);
107 cp_function_chain->invalid_constexpr = true;
115 /* Representation of entries in the constexpr function definition table. */
117 struct GTY((for_user)) constexpr_fundef {
122 struct constexpr_fundef_hasher : ggc_ptr_hash<constexpr_fundef>
124 static hashval_t hash (constexpr_fundef *);
125 static bool equal (constexpr_fundef *, constexpr_fundef *);
128 /* This table holds all constexpr function definitions seen in
129 the current translation unit. */
131 static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table;
133 /* Utility function used for managing the constexpr function table.
134 Return true if the entries pointed to by P and Q are for the
135 same constexpr function. */
138 constexpr_fundef_hasher::equal (constexpr_fundef *lhs, constexpr_fundef *rhs)
140 return lhs->decl == rhs->decl;
143 /* Utility function used for managing the constexpr function table.
144 Return a hash value for the entry pointed to by Q. */
147 constexpr_fundef_hasher::hash (constexpr_fundef *fundef)
149 return DECL_UID (fundef->decl);
152 /* Return a previously saved definition of function FUN. */
154 static constexpr_fundef *
155 retrieve_constexpr_fundef (tree fun)
157 constexpr_fundef fundef = { NULL, NULL };
158 if (constexpr_fundef_table == NULL)
162 return constexpr_fundef_table->find (&fundef);
165 /* Check whether the parameter and return types of FUN are valid for a
166 constexpr function, and complain if COMPLAIN. */
169 is_valid_constexpr_fn (tree fun, bool complain)
173 if (DECL_INHERITED_CTOR_BASE (fun)
174 && TREE_CODE (fun) == TEMPLATE_DECL)
178 error ("inherited constructor %qD is not constexpr",
179 get_inherited_ctor (fun));
183 for (tree parm = FUNCTION_FIRST_USER_PARM (fun);
184 parm != NULL_TREE; parm = TREE_CHAIN (parm))
185 if (!literal_type_p (TREE_TYPE (parm)))
190 error ("invalid type for parameter %d of constexpr "
191 "function %q+#D", DECL_PARM_INDEX (parm), fun);
192 explain_non_literal_class (TREE_TYPE (parm));
197 if (!DECL_CONSTRUCTOR_P (fun))
199 tree rettype = TREE_TYPE (TREE_TYPE (fun));
200 if (!literal_type_p (rettype))
205 error ("invalid return type %qT of constexpr function %q+D",
207 explain_non_literal_class (rettype);
211 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
212 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
217 error ("enclosing class of constexpr non-static member "
218 "function %q+#D is not a literal type", fun);
219 explain_non_literal_class (DECL_CONTEXT (fun));
223 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
227 error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
233 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
234 for a member of an anonymous aggregate, INIT is the initializer for that
235 member, and VEC_OUTER is the vector of constructor elements for the class
236 whose constructor we are processing. Add the initializer to the vector
237 and return true to indicate success. */
240 build_anon_member_initialization (tree member, tree init,
241 vec<constructor_elt, va_gc> **vec_outer)
243 /* MEMBER presents the relevant fields from the inside out, but we need
244 to build up the initializer from the outside in so that we can reuse
245 previously built CONSTRUCTORs if this is, say, the second field in an
246 anonymous struct. So we use a vec as a stack. */
247 auto_vec<tree, 2> fields;
250 fields.safe_push (TREE_OPERAND (member, 1));
251 member = TREE_OPERAND (member, 0);
253 while (ANON_AGGR_TYPE_P (TREE_TYPE (member))
254 && TREE_CODE (member) == COMPONENT_REF);
256 /* VEC has the constructor elements vector for the context of FIELD.
257 If FIELD is an anonymous aggregate, we will push inside it. */
258 vec<constructor_elt, va_gc> **vec = vec_outer;
260 while (field = fields.pop(),
261 ANON_AGGR_TYPE_P (TREE_TYPE (field)))
264 /* If there is already an outer constructor entry for the anonymous
265 aggregate FIELD, use it; otherwise, insert one. */
266 if (vec_safe_is_empty (*vec)
267 || (*vec)->last().index != field)
269 ctor = build_constructor (TREE_TYPE (field), NULL);
270 CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
273 ctor = (*vec)->last().value;
274 vec = &CONSTRUCTOR_ELTS (ctor);
277 /* Now we're at the innermost field, the one that isn't an anonymous
278 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
279 gcc_assert (fields.is_empty());
280 CONSTRUCTOR_APPEND_ELT (*vec, field, init);
285 /* Subroutine of build_constexpr_constructor_member_initializers.
286 The expression tree T represents a data member initialization
287 in a (constexpr) constructor definition. Build a pairing of
288 the data member with its initializer, and prepend that pair
289 to the existing initialization pair INITS. */
292 build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
295 if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
296 t = TREE_OPERAND (t, 0);
297 if (TREE_CODE (t) == EXPR_STMT)
298 t = TREE_OPERAND (t, 0);
299 if (t == error_mark_node)
301 if (TREE_CODE (t) == STATEMENT_LIST)
303 tree_stmt_iterator i;
304 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
306 if (! build_data_member_initialization (tsi_stmt (i), vec))
311 if (TREE_CODE (t) == CLEANUP_STMT)
313 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
314 but we can in a constexpr constructor for a non-literal class. Just
315 ignore it; either all the initialization will be constant, in which
316 case the cleanup can't run, or it can't be constexpr.
317 Still recurse into CLEANUP_BODY. */
318 return build_data_member_initialization (CLEANUP_BODY (t), vec);
320 if (TREE_CODE (t) == CONVERT_EXPR)
321 t = TREE_OPERAND (t, 0);
322 if (TREE_CODE (t) == INIT_EXPR
323 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
324 use what this function builds for cx_check_missing_mem_inits, and
325 assignment in the ctor body doesn't count. */
326 || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR))
328 member = TREE_OPERAND (t, 0);
329 init = break_out_target_exprs (TREE_OPERAND (t, 1));
331 else if (TREE_CODE (t) == CALL_EXPR)
333 tree fn = get_callee_fndecl (t);
334 if (!fn || !DECL_CONSTRUCTOR_P (fn))
335 /* We're only interested in calls to subobject constructors. */
337 member = CALL_EXPR_ARG (t, 0);
338 /* We don't use build_cplus_new here because it complains about
339 abstract bases. Leaving the call unwrapped means that it has the
340 wrong type, but cxx_eval_constant_expression doesn't care. */
341 init = break_out_target_exprs (t);
343 else if (TREE_CODE (t) == BIND_EXPR)
344 return build_data_member_initialization (BIND_EXPR_BODY (t), vec);
346 /* Don't add anything else to the CONSTRUCTOR. */
348 if (INDIRECT_REF_P (member))
349 member = TREE_OPERAND (member, 0);
350 if (TREE_CODE (member) == NOP_EXPR)
354 if (TREE_CODE (op) == ADDR_EXPR)
356 gcc_assert (same_type_ignoring_top_level_qualifiers_p
357 (TREE_TYPE (TREE_TYPE (op)),
358 TREE_TYPE (TREE_TYPE (member))));
359 /* Initializing a cv-qualified member; we need to look through
363 else if (op == current_class_ptr
364 && (same_type_ignoring_top_level_qualifiers_p
365 (TREE_TYPE (TREE_TYPE (member)),
366 current_class_type)))
367 /* Delegating constructor. */
371 /* This is an initializer for an empty base; keep it for now so
372 we can check it in cxx_eval_bare_aggregate. */
373 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
376 if (TREE_CODE (member) == ADDR_EXPR)
377 member = TREE_OPERAND (member, 0);
378 if (TREE_CODE (member) == COMPONENT_REF)
380 tree aggr = TREE_OPERAND (member, 0);
381 if (TREE_CODE (aggr) != COMPONENT_REF)
382 /* Normal member initialization. */
383 member = TREE_OPERAND (member, 1);
384 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
385 /* Initializing a member of an anonymous union. */
386 return build_anon_member_initialization (member, init, vec);
388 /* We're initializing a vtable pointer in a base. Leave it as
389 COMPONENT_REF so we remember the path to get to the vfield. */
390 gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
393 /* Value-initialization can produce multiple initializers for the
394 same field; use the last one. */
395 if (!vec_safe_is_empty (*vec) && (*vec)->last().index == member)
396 (*vec)->last().value = init;
398 CONSTRUCTOR_APPEND_ELT (*vec, member, init);
402 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
403 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
404 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
407 check_constexpr_bind_expr_vars (tree t)
409 gcc_assert (TREE_CODE (t) == BIND_EXPR);
411 for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var))
412 if (TREE_CODE (var) == TYPE_DECL
413 && DECL_IMPLICIT_TYPEDEF_P (var)
414 && !LAMBDA_TYPE_P (TREE_TYPE (var)))
419 /* Subroutine of check_constexpr_ctor_body. */
422 check_constexpr_ctor_body_1 (tree last, tree list)
424 switch (TREE_CODE (list))
427 if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL)
431 case CLEANUP_POINT_EXPR:
432 return check_constexpr_ctor_body (last, TREE_OPERAND (list, 0),
436 if (!check_constexpr_bind_expr_vars (list)
437 || !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list),
451 /* Make sure that there are no statements after LAST in the constructor
452 body represented by LIST. */
455 check_constexpr_ctor_body (tree last, tree list, bool complain)
457 /* C++14 doesn't require a constexpr ctor to have an empty body. */
458 if (cxx_dialect >= cxx14)
462 if (TREE_CODE (list) == STATEMENT_LIST)
464 tree_stmt_iterator i = tsi_last (list);
465 for (; !tsi_end_p (i); tsi_prev (&i))
467 tree t = tsi_stmt (i);
470 if (!check_constexpr_ctor_body_1 (last, t))
477 else if (list != last
478 && !check_constexpr_ctor_body_1 (last, list))
483 error ("constexpr constructor does not have empty body");
484 DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
489 /* V is a vector of constructor elements built up for the base and member
490 initializers of a constructor for TYPE. They need to be in increasing
491 offset order, which they might not be yet if TYPE has a primary base
492 which is not first in the base-clause or a vptr and at least one base
493 all of which are non-primary. */
495 static vec<constructor_elt, va_gc> *
496 sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
498 tree pri = CLASSTYPE_PRIMARY_BINFO (type);
504 field_type = BINFO_TYPE (pri);
505 else if (TYPE_CONTAINS_VPTR_P (type))
506 field_type = vtbl_ptr_type_node;
510 /* Find the element for the primary base or vptr and move it to the
511 beginning of the vec. */
512 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
513 if (TREE_TYPE (ce->index) == field_type)
516 if (i > 0 && i < vec_safe_length (v))
518 vec<constructor_elt, va_gc> &vref = *v;
519 constructor_elt elt = vref[i];
528 /* Build compile-time evalable representations of member-initializer list
529 for a constexpr constructor. */
532 build_constexpr_constructor_member_initializers (tree type, tree body)
534 vec<constructor_elt, va_gc> *vec = NULL;
537 switch (TREE_CODE (body))
539 case MUST_NOT_THROW_EXPR:
541 body = TREE_OPERAND (body, 0);
545 for (tree_stmt_iterator i = tsi_start (body);
546 !tsi_end_p (i); tsi_next (&i))
549 if (TREE_CODE (body) == BIND_EXPR)
555 body = BIND_EXPR_BODY (body);
562 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
564 body = TREE_OPERAND (body, 0);
565 if (TREE_CODE (body) == EXPR_STMT)
566 body = TREE_OPERAND (body, 0);
567 if (TREE_CODE (body) == INIT_EXPR
568 && (same_type_ignoring_top_level_qualifiers_p
569 (TREE_TYPE (TREE_OPERAND (body, 0)),
570 current_class_type)))
573 return TREE_OPERAND (body, 1);
575 ok = build_data_member_initialization (body, &vec);
577 else if (TREE_CODE (body) == STATEMENT_LIST)
579 tree_stmt_iterator i;
580 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
582 ok = build_data_member_initialization (tsi_stmt (i), &vec);
587 else if (TREE_CODE (body) == TRY_BLOCK)
589 error ("body of %<constexpr%> constructor cannot be "
590 "a function-try-block");
591 return error_mark_node;
593 else if (EXPR_P (body))
594 ok = build_data_member_initialization (body, &vec);
596 gcc_assert (errorcount > 0);
599 if (vec_safe_length (vec) > 0)
601 /* In a delegating constructor, return the target. */
602 constructor_elt *ce = &(*vec)[0];
603 if (ce->index == current_class_ptr)
610 vec = sort_constexpr_mem_initializers (type, vec);
611 return build_constructor (type, vec);
614 return error_mark_node;
617 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
618 declared to be constexpr, or a sub-statement thereof. Returns the
619 return value if suitable, error_mark_node for a statement not allowed in
620 a constexpr function, or NULL_TREE if no return value was found. */
623 constexpr_fn_retval (tree body)
625 switch (TREE_CODE (body))
629 tree_stmt_iterator i;
630 tree expr = NULL_TREE;
631 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
633 tree s = constexpr_fn_retval (tsi_stmt (i));
634 if (s == error_mark_node)
635 return error_mark_node;
636 else if (s == NULL_TREE)
637 /* Keep iterating. */;
639 /* Multiple return statements. */
640 return error_mark_node;
648 return break_out_target_exprs (TREE_OPERAND (body, 0));
652 tree decl = DECL_EXPR_DECL (body);
653 if (TREE_CODE (decl) == USING_DECL
654 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
655 || DECL_ARTIFICIAL (decl))
657 return error_mark_node;
660 case CLEANUP_POINT_EXPR:
661 return constexpr_fn_retval (TREE_OPERAND (body, 0));
664 if (!check_constexpr_bind_expr_vars (body))
665 return error_mark_node;
666 return constexpr_fn_retval (BIND_EXPR_BODY (body));
672 return error_mark_node;
676 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
677 FUN; do the necessary transformations to turn it into a single expression
678 that we can store in the hash table. */
681 massage_constexpr_body (tree fun, tree body)
683 if (DECL_CONSTRUCTOR_P (fun))
684 body = build_constexpr_constructor_member_initializers
685 (DECL_CONTEXT (fun), body);
686 else if (cxx_dialect < cxx14)
688 if (TREE_CODE (body) == EH_SPEC_BLOCK)
689 body = EH_SPEC_STMTS (body);
690 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
691 body = TREE_OPERAND (body, 0);
692 body = constexpr_fn_retval (body);
697 /* FUN is a constexpr constructor with massaged body BODY. Return true
698 if some bases/fields are uninitialized, and complain if COMPLAIN. */
701 cx_check_missing_mem_inits (tree fun, tree body, bool complain)
708 if (TREE_CODE (body) != CONSTRUCTOR)
711 nelts = CONSTRUCTOR_NELTS (body);
712 ctype = DECL_CONTEXT (fun);
713 field = TYPE_FIELDS (ctype);
715 if (TREE_CODE (ctype) == UNION_TYPE)
717 if (nelts == 0 && next_initializable_field (field))
720 error ("%<constexpr%> constructor for union %qT must "
721 "initialize exactly one non-static data member", ctype);
728 for (i = 0; i <= nelts; ++i)
735 index = CONSTRUCTOR_ELT (body, i)->index;
736 /* Skip base and vtable inits. */
737 if (TREE_CODE (index) != FIELD_DECL
738 || DECL_ARTIFICIAL (index))
741 for (; field != index; field = DECL_CHAIN (field))
744 if (TREE_CODE (field) != FIELD_DECL
745 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
746 || DECL_ARTIFICIAL (field))
748 ftype = strip_array_types (TREE_TYPE (field));
749 if (type_has_constexpr_default_constructor (ftype))
751 /* It's OK to skip a member with a trivial constexpr ctor.
752 A constexpr ctor that isn't trivial should have been
754 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
760 error ("member %qD must be initialized by mem-initializer "
761 "in %<constexpr%> constructor", field);
762 inform (DECL_SOURCE_LOCATION (field), "declared here");
765 if (field == NULL_TREE)
767 field = DECL_CHAIN (field);
773 /* We are processing the definition of the constexpr function FUN.
774 Check that its BODY fulfills the propriate requirements and
775 enter it in the constexpr function definition table.
776 For constructor BODY is actually the TREE_LIST of the
777 member-initializer list. */
780 register_constexpr_fundef (tree fun, tree body)
782 constexpr_fundef entry;
783 constexpr_fundef **slot;
785 if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
788 tree massaged = massage_constexpr_body (fun, body);
789 if (massaged == NULL_TREE || massaged == error_mark_node)
791 if (!DECL_CONSTRUCTOR_P (fun))
792 error ("body of constexpr function %qD not a return-statement", fun);
796 if (!potential_rvalue_constant_expression (massaged))
798 if (!DECL_GENERATED_P (fun))
799 require_potential_rvalue_constant_expression (massaged);
803 if (DECL_CONSTRUCTOR_P (fun)
804 && cx_check_missing_mem_inits (fun, massaged, !DECL_GENERATED_P (fun)))
807 /* Create the constexpr function table if necessary. */
808 if (constexpr_fundef_table == NULL)
809 constexpr_fundef_table
810 = hash_table<constexpr_fundef_hasher>::create_ggc (101);
814 slot = constexpr_fundef_table->find_slot (&entry, INSERT);
816 gcc_assert (*slot == NULL);
817 *slot = ggc_alloc<constexpr_fundef> ();
823 /* FUN is a non-constexpr function called in a context that requires a
824 constant expression. If it comes from a constexpr template, explain why
825 the instantiation isn't constexpr. */
828 explain_invalid_constexpr_fn (tree fun)
830 static hash_set<tree> *diagnosed;
833 /* Only diagnose defaulted functions or instantiations. */
834 if (!DECL_DEFAULTED_FN (fun)
835 && !is_instantiation_of_constexpr (fun))
837 if (diagnosed == NULL)
838 diagnosed = new hash_set<tree>;
839 if (diagnosed->add (fun))
840 /* Already explained. */
843 save_loc = input_location;
844 input_location = DECL_SOURCE_LOCATION (fun);
845 inform (input_location,
846 "%qD is not usable as a constexpr function because:", fun);
847 /* First check the declaration. */
848 if (is_valid_constexpr_fn (fun, true))
850 /* Then if it's OK, the body. */
851 if (!DECL_DECLARED_CONSTEXPR_P (fun))
852 explain_implicit_non_constexpr (fun);
855 body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
856 require_potential_rvalue_constant_expression (body);
857 if (DECL_CONSTRUCTOR_P (fun))
858 cx_check_missing_mem_inits (fun, body, true);
861 input_location = save_loc;
864 /* Objects of this type represent calls to constexpr functions
865 along with the bindings of parameters to their arguments, for
866 the purpose of compile time evaluation. */
868 struct GTY((for_user)) constexpr_call {
869 /* Description of the constexpr function definition. */
870 constexpr_fundef *fundef;
871 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
872 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
873 Note: This arrangement is made to accommodate the use of
874 iterative_hash_template_arg (see pt.c). If you change this
875 representation, also change the hash calculation in
876 cxx_eval_call_expression. */
878 /* Result of the call.
879 NULL means the call is being evaluated.
880 error_mark_node means that the evaluation was erroneous;
881 otherwise, the actuall value of the call. */
883 /* The hash of this call; we remember it here to avoid having to
884 recalculate it when expanding the hash table. */
888 struct constexpr_call_hasher : ggc_ptr_hash<constexpr_call>
890 static hashval_t hash (constexpr_call *);
891 static bool equal (constexpr_call *, constexpr_call *);
894 enum constexpr_switch_state {
895 /* Used when processing a switch for the first time by cxx_eval_switch_expr
896 and default: label for that switch has not been seen yet. */
897 css_default_not_seen,
898 /* Used when processing a switch for the first time by cxx_eval_switch_expr
899 and default: label for that switch has been seen already. */
901 /* Used when processing a switch for the second time by
902 cxx_eval_switch_expr, where default: label should match. */
903 css_default_processing
906 /* The constexpr expansion context. CALL is the current function
907 expansion, CTOR is the current aggregate initializer, OBJECT is the
908 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
909 is a map of values of variables initialized within the expression. */
911 struct constexpr_ctx {
912 /* The innermost call we're evaluating. */
913 constexpr_call *call;
914 /* Values for any temporaries or local variables within the
915 constant-expression. */
916 hash_map<tree,tree> *values;
917 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
918 aren't inside a loop. */
919 hash_set<tree> *save_exprs;
920 /* The CONSTRUCTOR we're currently building up for an aggregate
923 /* The object we're building the CONSTRUCTOR for. */
925 /* If inside SWITCH_EXPR. */
926 constexpr_switch_state *css_state;
927 /* Whether we should error on a non-constant expression or fail quietly. */
929 /* Whether we are strictly conforming to constant expression rules or
930 trying harder to get a constant value. */
934 /* A table of all constexpr calls that have been evaluated by the
935 compiler in this translation unit. */
937 static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
939 static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
940 bool, bool *, bool *, tree * = NULL);
942 /* Compute a hash value for a constexpr call representation. */
945 constexpr_call_hasher::hash (constexpr_call *info)
950 /* Return true if the objects pointed to by P and Q represent calls
951 to the same constexpr function with the same arguments.
952 Otherwise, return false. */
955 constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs)
961 if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef))
963 lhs_bindings = lhs->bindings;
964 rhs_bindings = rhs->bindings;
965 while (lhs_bindings != NULL && rhs_bindings != NULL)
967 tree lhs_arg = TREE_VALUE (lhs_bindings);
968 tree rhs_arg = TREE_VALUE (rhs_bindings);
969 gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
970 if (!cp_tree_equal (lhs_arg, rhs_arg))
972 lhs_bindings = TREE_CHAIN (lhs_bindings);
973 rhs_bindings = TREE_CHAIN (rhs_bindings);
975 return lhs_bindings == rhs_bindings;
978 /* Initialize the constexpr call table, if needed. */
981 maybe_initialize_constexpr_call_table (void)
983 if (constexpr_call_table == NULL)
984 constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101);
987 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
988 a function happens to get called recursively, we unshare the callee
989 function's body and evaluate this unshared copy instead of evaluating the
992 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
993 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
994 that's keyed off of the original FUNCTION_DECL and whose value is a
995 TREE_LIST of this function's unused copies awaiting reuse.
997 This is not GC-deletable to avoid GC affecting UID generation. */
999 static GTY(()) hash_map<tree, tree> *fundef_copies_table;
1001 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1004 maybe_initialize_fundef_copies_table ()
1006 if (fundef_copies_table == NULL)
1007 fundef_copies_table = hash_map<tree,tree>::create_ggc (101);
1010 /* Reuse a copy or create a new unshared copy of the function FUN.
1011 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1012 is parms, TYPE is result. */
1015 get_fundef_copy (tree fun)
1017 maybe_initialize_fundef_copies_table ();
1021 tree *slot = &fundef_copies_table->get_or_insert (fun, &existed);
1025 /* There is no cached function available, or in use. We can use
1026 the function directly. That the slot is now created records
1027 that this function is now in use. */
1028 copy = build_tree_list (DECL_SAVED_TREE (fun), DECL_ARGUMENTS (fun));
1029 TREE_TYPE (copy) = DECL_RESULT (fun);
1031 else if (*slot == NULL_TREE)
1033 /* We've already used the function itself, so make a copy. */
1034 copy = build_tree_list (NULL, NULL);
1035 TREE_PURPOSE (copy) = copy_fn (fun, TREE_VALUE (copy), TREE_TYPE (copy));
1039 /* We have a cached function available. */
1041 *slot = TREE_CHAIN (copy);
1047 /* Save the copy COPY of function FUN for later reuse by
1048 get_fundef_copy(). By construction, there will always be an entry
1052 save_fundef_copy (tree fun, tree copy)
1054 tree *slot = fundef_copies_table->get (fun);
1055 TREE_CHAIN (copy) = *slot;
1059 /* We have an expression tree T that represents a call, either CALL_EXPR
1060 or AGGR_INIT_EXPR. If the call is lexically to a named function,
1061 retrun the _DECL for that function. */
1064 get_function_named_in_call (tree t)
1067 switch (TREE_CODE (t))
1070 fun = CALL_EXPR_FN (t);
1073 case AGGR_INIT_EXPR:
1074 fun = AGGR_INIT_EXPR_FN (t);
1081 if (fun && TREE_CODE (fun) == ADDR_EXPR
1082 && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
1083 fun = TREE_OPERAND (fun, 0);
1087 /* We have an expression tree T that represents a call, either CALL_EXPR
1088 or AGGR_INIT_EXPR. Return the Nth argument. */
1091 get_nth_callarg (tree t, int n)
1093 switch (TREE_CODE (t))
1096 return CALL_EXPR_ARG (t, n);
1098 case AGGR_INIT_EXPR:
1099 return AGGR_INIT_EXPR_ARG (t, n);
1107 /* Attempt to evaluate T which represents a call to a builtin function.
1108 We assume here that all builtin functions evaluate to scalar types
1109 represented by _CST nodes. */
1112 cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,
1114 bool *non_constant_p, bool *overflow_p)
1116 const int nargs = call_expr_nargs (t);
1117 tree *args = (tree *) alloca (nargs * sizeof (tree));
1121 /* Don't fold __builtin_constant_p within a constexpr function. */
1122 bool bi_const_p = (DECL_FUNCTION_CODE (fun) == BUILT_IN_CONSTANT_P);
1125 && current_function_decl
1126 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
1128 *non_constant_p = true;
1132 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1133 return constant false for a non-constant argument. */
1134 constexpr_ctx new_ctx = *ctx;
1135 new_ctx.quiet = true;
1136 bool dummy1 = false, dummy2 = false;
1137 for (i = 0; i < nargs; ++i)
1139 args[i] = cxx_eval_constant_expression (&new_ctx, CALL_EXPR_ARG (t, i),
1140 lval, &dummy1, &dummy2);
1142 /* For __built_in_constant_p, fold all expressions with constant values
1143 even if they aren't C++ constant-expressions. */
1144 args[i] = cp_fully_fold (args[i]);
1147 bool save_ffbcp = force_folding_builtin_constant_p;
1148 force_folding_builtin_constant_p = true;
1149 new_call = fold_build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
1150 CALL_EXPR_FN (t), nargs, args);
1151 /* Fold away the NOP_EXPR from fold_builtin_n. */
1152 new_call = fold (new_call);
1153 force_folding_builtin_constant_p = save_ffbcp;
1154 VERIFY_CONSTANT (new_call);
1158 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1159 the type of the value to match. */
1162 adjust_temp_type (tree type, tree temp)
1164 if (TREE_TYPE (temp) == type)
1166 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1167 if (TREE_CODE (temp) == CONSTRUCTOR)
1168 return build_constructor (type, CONSTRUCTOR_ELTS (temp));
1169 gcc_assert (scalarish_type_p (type));
1170 return cp_fold_convert (type, temp);
1173 /* Callback for walk_tree used by unshare_constructor. */
1176 find_constructor (tree *tp, int *walk_subtrees, void *)
1180 if (TREE_CODE (*tp) == CONSTRUCTOR)
1185 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1186 subexpression, return an unshared copy of T. Otherwise return T. */
1189 unshare_constructor (tree t)
1191 tree ctor = walk_tree (&t, find_constructor, NULL, NULL);
1192 if (ctor != NULL_TREE)
1193 return unshare_expr (t);
1197 /* Subroutine of cxx_eval_call_expression.
1198 We are processing a call expression (either CALL_EXPR or
1199 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1200 all arguments and bind their values to correspondings
1201 parameters, making up the NEW_CALL context. */
1204 cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
1205 constexpr_call *new_call,
1206 bool *non_constant_p, bool *overflow_p,
1207 bool *non_constant_args)
1209 const int nargs = call_expr_nargs (t);
1210 tree fun = new_call->fundef->decl;
1211 tree parms = DECL_ARGUMENTS (fun);
1213 tree *p = &new_call->bindings;
1214 for (i = 0; i < nargs; ++i)
1217 tree type = parms ? TREE_TYPE (parms) : void_type_node;
1218 x = get_nth_callarg (t, i);
1219 /* For member function, the first argument is a pointer to the implied
1220 object. For a constructor, it might still be a dummy object, in
1221 which case we get the real argument from ctx. */
1222 if (i == 0 && DECL_CONSTRUCTOR_P (fun)
1223 && is_dummy_object (x))
1226 x = cp_build_addr_expr (x, tf_warning_or_error);
1229 arg = cxx_eval_constant_expression (ctx, x, lval,
1230 non_constant_p, overflow_p);
1231 /* Don't VERIFY_CONSTANT here. */
1232 if (*non_constant_p && ctx->quiet)
1234 /* Just discard ellipsis args after checking their constantitude. */
1237 if (*non_constant_p)
1238 /* Don't try to adjust the type of non-constant args. */
1241 /* Make sure the binding has the same type as the parm. */
1242 if (TREE_CODE (type) != REFERENCE_TYPE)
1243 arg = adjust_temp_type (type, arg);
1244 if (!TREE_CONSTANT (arg))
1245 *non_constant_args = true;
1246 *p = build_tree_list (parms, arg);
1247 p = &TREE_CHAIN (*p);
1249 parms = TREE_CHAIN (parms);
1253 /* Variables and functions to manage constexpr call expansion context.
1254 These do not need to be marked for PCH or GC. */
1256 /* FIXME remember and print actual constant arguments. */
1257 static vec<tree> call_stack = vNULL;
1258 static int call_stack_tick;
1259 static int last_cx_error_tick;
1262 push_cx_call_context (tree call)
1265 if (!EXPR_HAS_LOCATION (call))
1266 SET_EXPR_LOCATION (call, input_location);
1267 call_stack.safe_push (call);
1268 if (call_stack.length () > (unsigned) max_constexpr_depth)
1274 pop_cx_call_context (void)
1281 cx_error_context (void)
1283 vec<tree> r = vNULL;
1284 if (call_stack_tick != last_cx_error_tick
1285 && !call_stack.is_empty ())
1287 last_cx_error_tick = call_stack_tick;
1291 /* Subroutine of cxx_eval_constant_expression.
1292 Evaluate the call expression tree T in the context of OLD_CALL expression
1296 cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
1298 bool *non_constant_p, bool *overflow_p)
1300 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1301 tree fun = get_function_named_in_call (t);
1302 constexpr_call new_call = { NULL, NULL, NULL, 0 };
1305 if (fun == NULL_TREE)
1306 switch (CALL_EXPR_IFN (t))
1308 case IFN_UBSAN_NULL:
1309 case IFN_UBSAN_BOUNDS:
1310 case IFN_UBSAN_VPTR:
1314 error_at (loc, "call to internal function");
1315 *non_constant_p = true;
1319 if (TREE_CODE (fun) != FUNCTION_DECL)
1321 /* Might be a constexpr function pointer. */
1322 fun = cxx_eval_constant_expression (ctx, fun,
1323 /*lval*/false, non_constant_p,
1326 if (TREE_CODE (fun) == ADDR_EXPR)
1327 fun = TREE_OPERAND (fun, 0);
1329 if (TREE_CODE (fun) != FUNCTION_DECL)
1331 if (!ctx->quiet && !*non_constant_p)
1332 error_at (loc, "expression %qE does not designate a constexpr "
1334 *non_constant_p = true;
1337 if (DECL_CLONED_FUNCTION_P (fun))
1338 fun = DECL_CLONED_FUNCTION (fun);
1340 if (is_ubsan_builtin_p (fun))
1343 if (is_builtin_fn (fun))
1344 return cxx_eval_builtin_function_call (ctx, t, fun,
1345 lval, non_constant_p, overflow_p);
1346 if (!DECL_DECLARED_CONSTEXPR_P (fun))
1350 error_at (loc, "call to non-constexpr function %qD", fun);
1351 explain_invalid_constexpr_fn (fun);
1353 *non_constant_p = true;
1357 constexpr_ctx new_ctx = *ctx;
1358 if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
1359 && TREE_CODE (t) == AGGR_INIT_EXPR)
1361 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1362 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1363 new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
1364 tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
1365 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true;
1366 ctx->values->put (new_ctx.object, ctor);
1370 /* Shortcut trivial constructor/op=. */
1371 if (trivial_fn_p (fun))
1373 tree init = NULL_TREE;
1374 if (call_expr_nargs (t) == 2)
1375 init = convert_from_reference (get_nth_callarg (t, 1));
1376 else if (TREE_CODE (t) == AGGR_INIT_EXPR
1377 && AGGR_INIT_ZERO_FIRST (t))
1378 init = build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false);
1381 tree op = get_nth_callarg (t, 0);
1382 if (is_dummy_object (op))
1385 op = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (op)), op);
1386 tree set = build2 (MODIFY_EXPR, TREE_TYPE (op), op, init);
1387 return cxx_eval_constant_expression (ctx, set, lval,
1388 non_constant_p, overflow_p);
1392 /* We can't defer instantiating the function any longer. */
1393 if (!DECL_INITIAL (fun)
1394 && DECL_TEMPLOID_INSTANTIATION (fun))
1397 instantiate_decl (fun, /*defer_ok*/false, /*expl_inst*/false);
1401 /* If in direct recursive call, optimize definition search. */
1402 if (ctx && ctx->call && ctx->call->fundef->decl == fun)
1403 new_call.fundef = ctx->call->fundef;
1406 new_call.fundef = retrieve_constexpr_fundef (fun);
1407 if (new_call.fundef == NULL || new_call.fundef->body == NULL
1408 || fun == current_function_decl)
1412 /* We need to check for current_function_decl here in case we're
1413 being called during cp_fold_function, because at that point
1414 DECL_INITIAL is set properly and we have a fundef but we
1415 haven't lowered invisirefs yet (c++/70344). */
1416 if (DECL_INITIAL (fun) == error_mark_node
1417 || fun == current_function_decl)
1418 error_at (loc, "%qD called in a constant expression before its "
1419 "definition is complete", fun);
1420 else if (DECL_INITIAL (fun))
1422 /* The definition of fun was somehow unsuitable. */
1423 error_at (loc, "%qD called in a constant expression", fun);
1424 explain_invalid_constexpr_fn (fun);
1427 error_at (loc, "%qD used before its definition", fun);
1429 *non_constant_p = true;
1434 bool non_constant_args = false;
1435 cxx_bind_parameters_in_call (ctx, t, &new_call,
1436 non_constant_p, overflow_p, &non_constant_args);
1437 if (*non_constant_p)
1440 depth_ok = push_cx_call_context (t);
1442 tree result = NULL_TREE;
1444 constexpr_call *entry = NULL;
1445 if (depth_ok && !non_constant_args)
1447 new_call.hash = iterative_hash_template_arg
1448 (new_call.bindings, constexpr_fundef_hasher::hash (new_call.fundef));
1450 /* If we have seen this call before, we are done. */
1451 maybe_initialize_constexpr_call_table ();
1452 constexpr_call **slot
1453 = constexpr_call_table->find_slot (&new_call, INSERT);
1457 /* We need to keep a pointer to the entry, not just the slot, as the
1458 slot can move in the call to cxx_eval_builtin_function_call. */
1459 *slot = entry = ggc_alloc<constexpr_call> ();
1462 /* Calls which are in progress have their result set to NULL
1463 so that we can detect circular dependencies. */
1464 else if (entry->result == NULL)
1467 error ("call has circular dependency");
1468 *non_constant_p = true;
1469 entry->result = result = error_mark_node;
1472 result = entry->result;
1478 error ("constexpr evaluation depth exceeds maximum of %d (use "
1479 "-fconstexpr-depth= to increase the maximum)",
1480 max_constexpr_depth);
1481 *non_constant_p = true;
1482 result = error_mark_node;
1486 if (result && result != error_mark_node)
1488 else if (!DECL_SAVED_TREE (fun))
1490 /* When at_eof >= 2, cgraph has started throwing away
1491 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1492 late code generation for VEC_INIT_EXPR, which needs to be
1493 completely reconsidered. */
1494 gcc_assert (at_eof >= 2 && ctx->quiet);
1495 *non_constant_p = true;
1499 tree body, parms, res;
1501 /* Reuse or create a new unshared copy of this function's body. */
1502 tree copy = get_fundef_copy (fun);
1503 body = TREE_PURPOSE (copy);
1504 parms = TREE_VALUE (copy);
1505 res = TREE_TYPE (copy);
1507 /* Associate the bindings with the remapped parms. */
1508 tree bound = new_call.bindings;
1509 tree remapped = parms;
1512 tree oparm = TREE_PURPOSE (bound);
1513 tree arg = TREE_VALUE (bound);
1514 gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm));
1515 /* Don't share a CONSTRUCTOR that might be changed. */
1516 arg = unshare_constructor (arg);
1517 ctx->values->put (remapped, arg);
1518 bound = TREE_CHAIN (bound);
1519 remapped = DECL_CHAIN (remapped);
1521 /* Add the RESULT_DECL to the values map, too. */
1522 tree slot = NULL_TREE;
1523 if (DECL_BY_REFERENCE (res))
1525 slot = AGGR_INIT_EXPR_SLOT (t);
1526 tree addr = build_address (slot);
1527 addr = build_nop (TREE_TYPE (res), addr);
1528 ctx->values->put (res, addr);
1529 ctx->values->put (slot, NULL_TREE);
1532 ctx->values->put (res, NULL_TREE);
1534 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1535 their values after the call. */
1536 constexpr_ctx ctx_with_save_exprs = *ctx;
1537 hash_set<tree> save_exprs;
1538 ctx_with_save_exprs.save_exprs = &save_exprs;
1540 tree jump_target = NULL_TREE;
1541 cxx_eval_constant_expression (&ctx_with_save_exprs, body,
1542 lval, non_constant_p, overflow_p,
1545 if (DECL_CONSTRUCTOR_P (fun))
1546 /* This can be null for a subobject constructor call, in
1547 which case what we care about is the initialization
1548 side-effects rather than the value. We could get at the
1549 value by evaluating *this, but we don't bother; there's
1550 no need to put such a call in the hash table. */
1551 result = lval ? ctx->object : ctx->ctor;
1552 else if (VOID_TYPE_P (TREE_TYPE (res)))
1556 result = *ctx->values->get (slot ? slot : res);
1557 if (result == NULL_TREE && !*non_constant_p)
1560 error ("constexpr call flows off the end "
1562 *non_constant_p = true;
1566 /* Forget the saved values of the callee's SAVE_EXPRs. */
1567 for (hash_set<tree>::iterator iter = save_exprs.begin();
1568 iter != save_exprs.end(); ++iter)
1569 ctx_with_save_exprs.values->remove (*iter);
1571 /* Remove the parms/result from the values map. Is it worth
1572 bothering to do this when the map itself is only live for
1573 one constexpr evaluation? If so, maybe also clear out
1574 other vars from call, maybe in BIND_EXPR handling? */
1575 ctx->values->remove (res);
1577 ctx->values->remove (slot);
1578 for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
1579 ctx->values->remove (parm);
1581 /* Make the unshared function copy we used available for re-use. */
1582 save_fundef_copy (fun, copy);
1585 if (result == error_mark_node)
1586 *non_constant_p = true;
1587 if (*non_constant_p || *overflow_p)
1588 result = error_mark_node;
1592 entry->result = result;
1595 pop_cx_call_context ();
1596 return unshare_constructor (result);
1599 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1602 reduced_constant_expression_p (tree t)
1604 switch (TREE_CODE (t))
1607 /* Even if we can't lower this yet, it's constant. */
1611 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1612 tree elt; unsigned HOST_WIDE_INT idx;
1613 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, elt)
1614 if (!reduced_constant_expression_p (elt))
1619 /* FIXME are we calling this too much? */
1620 return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
1624 /* Some expressions may have constant operands but are not constant
1625 themselves, such as 1/0. Call this function (or rather, the macro
1626 following it) to check for that condition.
1628 We only call this in places that require an arithmetic constant, not in
1629 places where we might have a non-constant expression that can be a
1630 component of a constant expression, such as the address of a constexpr
1631 variable that might be dereferenced later. */
1634 verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
1637 if (!*non_constant_p && !reduced_constant_expression_p (t))
1639 if (!allow_non_constant)
1640 error ("%q+E is not a constant expression", t);
1641 *non_constant_p = true;
1643 if (TREE_OVERFLOW_P (t))
1645 if (!allow_non_constant)
1647 permerror (input_location, "overflow in constant expression");
1648 /* If we're being permissive (and are in an enforcing
1649 context), ignore the overflow. */
1650 if (flag_permissive)
1651 return *non_constant_p;
1655 return *non_constant_p;
1658 /* Check whether the shift operation with code CODE and type TYPE on LHS
1659 and RHS is undefined. If it is, give an error with an explanation,
1660 and return true; return false otherwise. */
1663 cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx,
1664 enum tree_code code, tree type, tree lhs, tree rhs)
1666 if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR)
1667 || TREE_CODE (lhs) != INTEGER_CST
1668 || TREE_CODE (rhs) != INTEGER_CST)
1671 tree lhstype = TREE_TYPE (lhs);
1672 unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs));
1674 /* [expr.shift] The behavior is undefined if the right operand
1675 is negative, or greater than or equal to the length in bits
1676 of the promoted left operand. */
1677 if (tree_int_cst_sgn (rhs) == -1)
1680 permerror (loc, "right operand of shift expression %q+E is negative",
1681 build2_loc (loc, code, type, lhs, rhs));
1682 return (!flag_permissive || ctx->quiet);
1684 if (compare_tree_int (rhs, uprec) >= 0)
1687 permerror (loc, "right operand of shift expression %q+E is >= than "
1688 "the precision of the left operand",
1689 build2_loc (loc, code, type, lhs, rhs));
1690 return (!flag_permissive || ctx->quiet);
1693 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1694 if E1 has a signed type and non-negative value, and E1x2^E2 is
1695 representable in the corresponding unsigned type of the result type,
1696 then that value, converted to the result type, is the resulting value;
1697 otherwise, the behavior is undefined. */
1698 if (code == LSHIFT_EXPR && !TYPE_UNSIGNED (lhstype)
1699 && (cxx_dialect >= cxx11))
1701 if (tree_int_cst_sgn (lhs) == -1)
1705 "left operand of shift expression %q+E is negative",
1706 build2_loc (loc, code, type, lhs, rhs));
1707 return (!flag_permissive || ctx->quiet);
1709 /* For signed x << y the following:
1710 (unsigned) x >> ((prec (lhs) - 1) - y)
1711 if > 1, is undefined. The right-hand side of this formula
1712 is the highest bit of the LHS that can be set (starting from 0),
1713 so that the shift doesn't overflow. We then right-shift the LHS
1714 to see whether any other bit is set making the original shift
1715 undefined -- the result is not representable in the corresponding
1717 tree t = build_int_cst (unsigned_type_node, uprec - 1);
1718 t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs);
1719 tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs);
1720 t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t);
1721 if (tree_int_cst_lt (integer_one_node, t))
1724 permerror (loc, "shift expression %q+E overflows",
1725 build2_loc (loc, code, type, lhs, rhs));
1726 return (!flag_permissive || ctx->quiet);
1732 /* Subroutine of cxx_eval_constant_expression.
1733 Attempt to reduce the unary expression tree T to a compile time value.
1734 If successful, return the value. Otherwise issue a diagnostic
1735 and return error_mark_node. */
1738 cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
1740 bool *non_constant_p, bool *overflow_p)
1743 tree orig_arg = TREE_OPERAND (t, 0);
1744 tree arg = cxx_eval_constant_expression (ctx, orig_arg, /*lval*/false,
1745 non_constant_p, overflow_p);
1746 VERIFY_CONSTANT (arg);
1747 location_t loc = EXPR_LOCATION (t);
1748 enum tree_code code = TREE_CODE (t);
1749 tree type = TREE_TYPE (t);
1750 r = fold_unary_loc (loc, code, type, arg);
1753 if (arg == orig_arg)
1756 r = build1_loc (loc, code, type, arg);
1758 VERIFY_CONSTANT (r);
1762 /* Helper function for cxx_eval_binary_expression. Try to optimize
1763 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1764 generic folding should be used. */
1767 cxx_fold_pointer_plus_expression (const constexpr_ctx *ctx, tree t,
1768 tree lhs, tree rhs, bool *non_constant_p,
1772 if (TREE_CODE (lhs) != ADDR_EXPR)
1775 lhs = TREE_OPERAND (lhs, 0);
1777 /* &A[i] p+ j => &A[i + j] */
1778 if (TREE_CODE (lhs) == ARRAY_REF
1779 && TREE_CODE (TREE_OPERAND (lhs, 1)) == INTEGER_CST
1780 && TREE_CODE (rhs) == INTEGER_CST
1781 && TYPE_SIZE_UNIT (TREE_TYPE (lhs))
1782 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST)
1784 tree orig_type = TREE_TYPE (t);
1785 location_t loc = EXPR_LOCATION (t);
1786 tree type = TREE_TYPE (lhs);
1788 t = fold_convert_loc (loc, ssizetype, TREE_OPERAND (lhs, 1));
1789 tree nelts = array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs, 0)));
1790 nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
1792 if (*non_constant_p)
1794 /* Don't fold an out-of-bound access. */
1795 if (!tree_int_cst_le (t, nelts))
1797 rhs = cp_fold_convert (ssizetype, rhs);
1798 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1799 constexpr int A[1]; ... (char *)&A[0] + 1 */
1800 if (!integer_zerop (fold_build2_loc (loc, TRUNC_MOD_EXPR, sizetype,
1801 rhs, TYPE_SIZE_UNIT (type))))
1803 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1805 rhs = fold_build2_loc (loc, EXACT_DIV_EXPR, ssizetype, rhs,
1806 TYPE_SIZE_UNIT (type));
1807 t = size_binop_loc (loc, PLUS_EXPR, rhs, t);
1808 t = build4_loc (loc, ARRAY_REF, type, TREE_OPERAND (lhs, 0),
1809 t, NULL_TREE, NULL_TREE);
1810 t = cp_build_addr_expr (t, tf_warning_or_error);
1811 t = cp_fold_convert (orig_type, t);
1812 return cxx_eval_constant_expression (ctx, t, /*lval*/false,
1813 non_constant_p, overflow_p);
1819 /* Subroutine of cxx_eval_constant_expression.
1820 Like cxx_eval_unary_expression, except for binary expressions. */
1823 cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
1825 bool *non_constant_p, bool *overflow_p)
1828 tree orig_lhs = TREE_OPERAND (t, 0);
1829 tree orig_rhs = TREE_OPERAND (t, 1);
1831 lhs = cxx_eval_constant_expression (ctx, orig_lhs, /*lval*/false,
1832 non_constant_p, overflow_p);
1833 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
1835 if (*non_constant_p)
1837 rhs = cxx_eval_constant_expression (ctx, orig_rhs, /*lval*/false,
1838 non_constant_p, overflow_p);
1839 if (*non_constant_p)
1842 location_t loc = EXPR_LOCATION (t);
1843 enum tree_code code = TREE_CODE (t);
1844 tree type = TREE_TYPE (t);
1846 if (code == EQ_EXPR || code == NE_EXPR)
1848 bool is_code_eq = (code == EQ_EXPR);
1850 if (TREE_CODE (lhs) == PTRMEM_CST
1851 && TREE_CODE (rhs) == PTRMEM_CST)
1852 r = constant_boolean_node (cp_tree_equal (lhs, rhs) == is_code_eq,
1854 else if ((TREE_CODE (lhs) == PTRMEM_CST
1855 || TREE_CODE (rhs) == PTRMEM_CST)
1856 && (null_member_pointer_value_p (lhs)
1857 || null_member_pointer_value_p (rhs)))
1858 r = constant_boolean_node (!is_code_eq, type);
1859 else if (TREE_CODE (lhs) == PTRMEM_CST)
1860 lhs = cplus_expand_constant (lhs);
1861 else if (TREE_CODE (rhs) == PTRMEM_CST)
1862 rhs = cplus_expand_constant (rhs);
1864 else if (code == POINTER_PLUS_EXPR)
1865 r = cxx_fold_pointer_plus_expression (ctx, t, lhs, rhs, non_constant_p,
1869 r = fold_binary_loc (loc, code, type, lhs, rhs);
1873 if (lhs == orig_lhs && rhs == orig_rhs)
1876 r = build2_loc (loc, code, type, lhs, rhs);
1878 else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs))
1879 *non_constant_p = true;
1880 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1881 a local array in a constexpr function. */
1882 bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs));
1884 VERIFY_CONSTANT (r);
1888 /* Subroutine of cxx_eval_constant_expression.
1889 Attempt to evaluate condition expressions. Dead branches are not
1893 cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
1895 bool *non_constant_p, bool *overflow_p,
1898 tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
1900 non_constant_p, overflow_p);
1901 VERIFY_CONSTANT (val);
1902 /* Don't VERIFY_CONSTANT the other operands. */
1903 if (integer_zerop (val))
1904 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
1906 non_constant_p, overflow_p,
1908 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
1910 non_constant_p, overflow_p,
1914 /* Returns less than, equal to, or greater than zero if KEY is found to be
1915 less than, to match, or to be greater than the constructor_elt's INDEX. */
1918 array_index_cmp (tree key, tree index)
1920 gcc_assert (TREE_CODE (key) == INTEGER_CST);
1922 switch (TREE_CODE (index))
1925 return tree_int_cst_compare (key, index);
1928 tree lo = TREE_OPERAND (index, 0);
1929 tree hi = TREE_OPERAND (index, 1);
1930 if (tree_int_cst_lt (key, lo))
1932 else if (tree_int_cst_lt (hi, key))
1942 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
1943 if none. If INSERT is true, insert a matching element rather than fail. */
1945 static HOST_WIDE_INT
1946 find_array_ctor_elt (tree ary, tree dindex, bool insert = false)
1948 if (tree_int_cst_sgn (dindex) < 0)
1951 unsigned HOST_WIDE_INT i = tree_to_uhwi (dindex);
1952 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ary);
1953 unsigned HOST_WIDE_INT len = vec_safe_length (elts);
1955 unsigned HOST_WIDE_INT end = len;
1956 unsigned HOST_WIDE_INT begin = 0;
1958 /* If the last element of the CONSTRUCTOR has its own index, we can assume
1959 that the same is true of the other elements and index directly. */
1962 tree cindex = (*elts)[end-1].index;
1963 if (TREE_CODE (cindex) == INTEGER_CST
1964 && compare_tree_int (cindex, end-1) == 0)
1973 /* Otherwise, find a matching index by means of a binary search. */
1974 while (begin != end)
1976 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
1977 constructor_elt &elt = (*elts)[middle];
1978 tree idx = elt.index;
1980 int cmp = array_index_cmp (dindex, idx);
1987 if (insert && TREE_CODE (idx) == RANGE_EXPR)
1989 /* We need to split the range. */
1991 tree lo = TREE_OPERAND (idx, 0);
1992 tree hi = TREE_OPERAND (idx, 1);
1993 if (tree_int_cst_lt (lo, dindex))
1995 /* There are still some lower elts; shorten the range. */
1996 tree new_hi = int_const_binop (MINUS_EXPR, dindex,
1998 if (tree_int_cst_equal (lo, new_hi))
1999 /* Only one element left, no longer a range. */
2002 TREE_OPERAND (idx, 1) = new_hi;
2003 /* Append the element we want to insert. */
2006 e.value = unshare_constructor (elt.value);
2007 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle, e);
2010 /* No lower elts, the range elt is now ours. */
2013 if (tree_int_cst_lt (dindex, hi))
2015 /* There are still some higher elts; append a range. */
2016 tree new_lo = int_const_binop (PLUS_EXPR, dindex,
2018 if (tree_int_cst_equal (new_lo, hi))
2021 e.index = build2 (RANGE_EXPR, sizetype, new_lo, hi);
2022 e.value = unshare_constructor (elt.value);
2023 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle+1, e);
2032 constructor_elt e = { dindex, NULL_TREE };
2033 vec_safe_insert (CONSTRUCTOR_ELTS (ary), end, e);
2040 /* Under the control of CTX, issue a detailed diagnostic for
2041 an out-of-bounds subscript INDEX into the expression ARRAY. */
2044 diag_array_subscript (const constexpr_ctx *ctx, tree array, tree index)
2048 tree arraytype = TREE_TYPE (array);
2050 /* Convert the unsigned array subscript to a signed integer to avoid
2051 printing huge numbers for small negative values. */
2052 tree sidx = fold_convert (ssizetype, index);
2055 error ("array subscript value %qE is outside the bounds "
2056 "of array %qD of type %qT", sidx, array, arraytype);
2057 inform (DECL_SOURCE_LOCATION (array), "declared here");
2060 error ("array subscript value %qE is outside the bounds "
2061 "of array type %qT", sidx, arraytype);
2065 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2066 STRING_CST STRING. */
2069 extract_string_elt (tree string, unsigned chars_per_elt, unsigned index)
2071 tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (string)));
2074 if (chars_per_elt == 1)
2075 r = build_int_cst (type, TREE_STRING_POINTER (string)[index]);
2078 const unsigned char *ptr
2079 = ((const unsigned char *)TREE_STRING_POINTER (string)
2080 + index * chars_per_elt);
2081 r = native_interpret_expr (type, ptr, chars_per_elt);
2086 /* Subroutine of cxx_eval_constant_expression.
2087 Attempt to reduce a reference to an array slot. */
2090 cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
2092 bool *non_constant_p, bool *overflow_p)
2094 tree oldary = TREE_OPERAND (t, 0);
2095 tree ary = cxx_eval_constant_expression (ctx, oldary,
2097 non_constant_p, overflow_p);
2101 unsigned len, elem_nchars = 1;
2102 if (*non_constant_p)
2104 oldidx = TREE_OPERAND (t, 1);
2105 index = cxx_eval_constant_expression (ctx, oldidx,
2107 non_constant_p, overflow_p);
2108 VERIFY_CONSTANT (index);
2109 if (lval && ary == oldary && index == oldidx)
2112 return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
2113 elem_type = TREE_TYPE (TREE_TYPE (ary));
2114 if (TREE_CODE (ary) == CONSTRUCTOR)
2115 len = CONSTRUCTOR_NELTS (ary);
2116 else if (TREE_CODE (ary) == STRING_CST)
2118 elem_nchars = (TYPE_PRECISION (elem_type)
2119 / TYPE_PRECISION (char_type_node));
2120 len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
2124 /* We can't do anything with other tree codes, so use
2125 VERIFY_CONSTANT to complain and fail. */
2126 VERIFY_CONSTANT (ary);
2130 if (!tree_fits_shwi_p (index)
2131 || (i = tree_to_shwi (index)) < 0)
2133 diag_array_subscript (ctx, ary, index);
2134 *non_constant_p = true;
2138 tree nelts = array_type_nelts_top (TREE_TYPE (ary));
2139 /* For VLAs, the number of elements won't be an integer constant. */
2140 nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
2142 VERIFY_CONSTANT (nelts);
2143 if (!tree_int_cst_lt (index, nelts))
2145 diag_array_subscript (ctx, ary, index);
2146 *non_constant_p = true;
2151 if (TREE_CODE (ary) == CONSTRUCTOR)
2153 HOST_WIDE_INT ix = find_array_ctor_elt (ary, index);
2164 if (TREE_CODE (ary) == CONSTRUCTOR)
2165 r = (*CONSTRUCTOR_ELTS (ary))[i].value;
2167 r = extract_string_elt (ary, elem_nchars, i);
2170 /* Don't VERIFY_CONSTANT here. */
2173 /* Otherwise the element doesn't have a value yet. */
2178 if (TREE_CODE (ary) == CONSTRUCTOR
2179 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary))
2181 /* 'ary' is part of the aggregate initializer we're currently
2182 building; if there's no initializer for this element yet,
2185 error ("accessing uninitialized array element");
2186 *non_constant_p = true;
2190 /* If it's within the array bounds but doesn't have an explicit
2191 initializer, it's value-initialized. */
2192 tree val = build_value_init (elem_type, tf_warning_or_error);
2193 return cxx_eval_constant_expression (ctx, val, lval, non_constant_p,
2197 /* Subroutine of cxx_eval_constant_expression.
2198 Attempt to reduce a field access of a value of class type. */
2201 cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
2203 bool *non_constant_p, bool *overflow_p)
2205 unsigned HOST_WIDE_INT i;
2208 tree part = TREE_OPERAND (t, 1);
2209 tree orig_whole = TREE_OPERAND (t, 0);
2210 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2212 non_constant_p, overflow_p);
2213 if (TREE_CODE (whole) == PTRMEM_CST)
2214 whole = cplus_expand_constant (whole);
2215 if (whole == orig_whole)
2218 return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
2219 whole, part, NULL_TREE);
2220 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2222 if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
2225 error ("%qE is not a constant expression", orig_whole);
2226 *non_constant_p = true;
2228 if (DECL_MUTABLE_P (part))
2231 error ("mutable %qD is not usable in a constant expression", part);
2232 *non_constant_p = true;
2234 if (*non_constant_p)
2236 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2243 /* We're in the middle of initializing it. */
2247 if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
2248 && CONSTRUCTOR_NELTS (whole) > 0)
2250 /* DR 1188 says we don't have to deal with this. */
2252 error ("accessing %qD member instead of initialized %qD member in "
2253 "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
2254 *non_constant_p = true;
2258 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2259 classes never get represented; throw together a value now. */
2260 if (is_really_empty_class (TREE_TYPE (t)))
2261 return build_constructor (TREE_TYPE (t), NULL);
2263 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole))
2265 /* 'whole' is part of the aggregate initializer we're currently
2266 building; if there's no initializer for this member yet, that's an
2269 error ("accessing uninitialized member %qD", part);
2270 *non_constant_p = true;
2274 /* If there's no explicit init for this field, it's value-initialized. */
2275 value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
2276 return cxx_eval_constant_expression (ctx, value,
2278 non_constant_p, overflow_p);
2281 /* Subroutine of cxx_eval_constant_expression.
2282 Attempt to reduce a field access of a value of class type that is
2283 expressed as a BIT_FIELD_REF. */
2286 cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
2288 bool *non_constant_p, bool *overflow_p)
2290 tree orig_whole = TREE_OPERAND (t, 0);
2291 tree retval, fldval, utype, mask;
2292 bool fld_seen = false;
2293 HOST_WIDE_INT istart, isize;
2294 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2296 non_constant_p, overflow_p);
2297 tree start, field, value;
2298 unsigned HOST_WIDE_INT i;
2300 if (whole == orig_whole)
2302 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2304 if (!*non_constant_p
2305 && TREE_CODE (whole) != VECTOR_CST
2306 && TREE_CODE (whole) != CONSTRUCTOR)
2309 error ("%qE is not a constant expression", orig_whole);
2310 *non_constant_p = true;
2312 if (*non_constant_p)
2315 if (TREE_CODE (whole) == VECTOR_CST)
2316 return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
2317 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
2319 start = TREE_OPERAND (t, 2);
2320 istart = tree_to_shwi (start);
2321 isize = tree_to_shwi (TREE_OPERAND (t, 1));
2322 utype = TREE_TYPE (t);
2323 if (!TYPE_UNSIGNED (utype))
2324 utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
2325 retval = build_int_cst (utype, 0);
2326 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2328 tree bitpos = bit_position (field);
2329 if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
2331 if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
2332 && TREE_CODE (value) == INTEGER_CST
2333 && tree_fits_shwi_p (bitpos)
2334 && tree_fits_shwi_p (DECL_SIZE (field)))
2336 HOST_WIDE_INT bit = tree_to_shwi (bitpos);
2337 HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field));
2338 HOST_WIDE_INT shift;
2339 if (bit >= istart && bit + sz <= istart + isize)
2341 fldval = fold_convert (utype, value);
2342 mask = build_int_cst_type (utype, -1);
2343 mask = fold_build2 (LSHIFT_EXPR, utype, mask,
2344 size_int (TYPE_PRECISION (utype) - sz));
2345 mask = fold_build2 (RSHIFT_EXPR, utype, mask,
2346 size_int (TYPE_PRECISION (utype) - sz));
2347 fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
2348 shift = bit - istart;
2349 if (BYTES_BIG_ENDIAN)
2350 shift = TYPE_PRECISION (utype) - shift - sz;
2351 fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
2353 retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
2359 return fold_convert (TREE_TYPE (t), retval);
2361 return error_mark_node;
2364 /* Subroutine of cxx_eval_constant_expression.
2365 Evaluate a short-circuited logical expression T in the context
2366 of a given constexpr CALL. BAILOUT_VALUE is the value for
2367 early return. CONTINUE_VALUE is used here purely for
2368 sanity check purposes. */
2371 cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
2372 tree bailout_value, tree continue_value,
2374 bool *non_constant_p, bool *overflow_p)
2377 tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
2379 non_constant_p, overflow_p);
2380 VERIFY_CONSTANT (lhs);
2381 if (tree_int_cst_equal (lhs, bailout_value))
2383 gcc_assert (tree_int_cst_equal (lhs, continue_value));
2384 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
2385 lval, non_constant_p,
2387 VERIFY_CONSTANT (r);
2391 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2392 CONSTRUCTOR elements to initialize (part of) an object containing that
2393 field. Return a pointer to the constructor_elt corresponding to the
2394 initialization of the field. */
2396 static constructor_elt *
2397 base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
2399 tree aggr = TREE_OPERAND (ref, 0);
2400 tree field = TREE_OPERAND (ref, 1);
2402 constructor_elt *ce;
2404 gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
2406 if (TREE_CODE (aggr) == COMPONENT_REF)
2408 constructor_elt *base_ce
2409 = base_field_constructor_elt (v, aggr);
2410 v = CONSTRUCTOR_ELTS (base_ce->value);
2413 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
2414 if (ce->index == field)
2421 /* Some of the expressions fed to the constexpr mechanism are calls to
2422 constructors, which have type void. In that case, return the type being
2423 initialized by the constructor. */
2426 initialized_type (tree t)
2430 tree type = cv_unqualified (TREE_TYPE (t));
2431 if (TREE_CODE (t) == CALL_EXPR || TREE_CODE (t) == AGGR_INIT_EXPR)
2433 /* A constructor call has void type, so we need to look deeper. */
2434 tree fn = get_function_named_in_call (t);
2435 if (fn && TREE_CODE (fn) == FUNCTION_DECL
2436 && DECL_CXX_CONSTRUCTOR_P (fn))
2437 type = DECL_CONTEXT (fn);
2442 /* We're about to initialize element INDEX of an array or class from VALUE.
2443 Set up NEW_CTX appropriately by adjusting .object to refer to the
2444 subobject and creating a new CONSTRUCTOR if the element is itself
2445 a class or array. */
2448 init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
2449 tree index, tree &value)
2453 if (index && TREE_CODE (index) != INTEGER_CST
2454 && TREE_CODE (index) != FIELD_DECL)
2455 /* This won't have an element in the new CONSTRUCTOR. */
2458 tree type = initialized_type (value);
2459 if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type))
2460 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2463 /* The sub-aggregate initializer might contain a placeholder;
2464 update object to refer to the subobject and ctor to refer to
2465 the (newly created) sub-initializer. */
2467 new_ctx.object = build_ctor_subob_ref (index, type, ctx->object);
2468 tree elt = build_constructor (type, NULL);
2469 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt) = true;
2472 if (TREE_CODE (value) == TARGET_EXPR)
2473 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2474 value = TARGET_EXPR_INITIAL (value);
2477 /* We're about to process an initializer for a class or array TYPE. Make
2478 sure that CTX is set up appropriately. */
2481 verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
2483 /* We don't bother building a ctor for an empty base subobject. */
2484 if (is_empty_class (type))
2487 /* We're in the middle of an initializer that might involve placeholders;
2488 our caller should have created a CONSTRUCTOR for us to put the
2489 initializer into. We will either return that constructor or T. */
2490 gcc_assert (ctx->ctor);
2491 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2492 (type, TREE_TYPE (ctx->ctor)));
2493 /* We used to check that ctx->ctor was empty, but that isn't the case when
2494 the object is zero-initialized before calling the constructor. */
2496 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2497 (type, TREE_TYPE (ctx->object)));
2498 gcc_assert (!ctx->object || !DECL_P (ctx->object)
2499 || *(ctx->values->get (ctx->object)) == ctx->ctor);
2502 /* Subroutine of cxx_eval_constant_expression.
2503 The expression tree T denotes a C-style array or a C-style
2504 aggregate. Reduce it to a constant expression. */
2507 cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
2509 bool *non_constant_p, bool *overflow_p)
2511 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
2512 bool changed = false;
2513 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
2514 tree type = TREE_TYPE (t);
2516 constexpr_ctx new_ctx;
2517 if (TYPE_PTRMEMFUNC_P (type) || VECTOR_TYPE_P (type))
2519 /* We don't really need the ctx->ctor business for a PMF or
2520 vector, but it's simpler to use the same code. */
2522 new_ctx.ctor = build_constructor (type, NULL);
2523 new_ctx.object = NULL_TREE;
2526 verify_ctor_sanity (ctx, type);
2527 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2528 vec_alloc (*p, vec_safe_length (v));
2532 bool constant_p = true;
2533 bool side_effects_p = false;
2534 FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value)
2536 tree orig_value = value;
2537 init_subob_ctx (ctx, new_ctx, index, value);
2538 if (new_ctx.ctor != ctx->ctor)
2539 /* If we built a new CONSTRUCTOR, attach it now so that other
2540 initializers can refer to it. */
2541 CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor);
2542 tree elt = cxx_eval_constant_expression (&new_ctx, value,
2544 non_constant_p, overflow_p);
2545 /* Don't VERIFY_CONSTANT here. */
2546 if (ctx->quiet && *non_constant_p)
2548 if (elt != orig_value)
2551 if (!TREE_CONSTANT (elt))
2553 if (TREE_SIDE_EFFECTS (elt))
2554 side_effects_p = true;
2555 if (index && TREE_CODE (index) == COMPONENT_REF)
2557 /* This is an initialization of a vfield inside a base
2558 subaggregate that we already initialized; push this
2559 initialization into the previous initialization. */
2560 constructor_elt *inner = base_field_constructor_elt (*p, index);
2565 && (TREE_CODE (index) == NOP_EXPR
2566 || TREE_CODE (index) == POINTER_PLUS_EXPR))
2568 /* This is an initializer for an empty base; now that we've
2569 checked that it's constant, we can ignore it. */
2570 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index))));
2573 else if (new_ctx.ctor != ctx->ctor)
2575 /* We appended this element above; update the value. */
2576 gcc_assert ((*p)->last().index == index);
2577 (*p)->last().value = elt;
2580 CONSTRUCTOR_APPEND_ELT (*p, index, elt);
2582 if (*non_constant_p || !changed)
2585 /* We're done building this CONSTRUCTOR, so now we can interpret an
2586 element without an explicit initializer as value-initialized. */
2587 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
2588 TREE_CONSTANT (t) = constant_p;
2589 TREE_SIDE_EFFECTS (t) = side_effects_p;
2590 if (VECTOR_TYPE_P (type))
2595 /* Subroutine of cxx_eval_constant_expression.
2596 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2597 initialization of a non-static data member of array type. Reduce it to a
2600 Note that apart from value-initialization (when VALUE_INIT is true),
2601 this is only intended to support value-initialization and the
2602 initializations done by defaulted constructors for classes with
2603 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2604 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2605 for the copy/move constructor. */
2608 cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
2609 bool value_init, bool lval,
2610 bool *non_constant_p, bool *overflow_p)
2612 tree elttype = TREE_TYPE (atype);
2613 unsigned HOST_WIDE_INT max = tree_to_uhwi (array_type_nelts_top (atype));
2614 verify_ctor_sanity (ctx, atype);
2615 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2616 vec_alloc (*p, max + 1);
2617 bool pre_init = false;
2618 unsigned HOST_WIDE_INT i;
2620 /* For the default constructor, build up a call to the default
2621 constructor of the element type. We only need to handle class types
2622 here, as for a constructor to be constexpr, all members must be
2623 initialized, which for a defaulted default constructor means they must
2624 be of a class type with a constexpr default constructor. */
2625 if (TREE_CODE (elttype) == ARRAY_TYPE)
2626 /* We only do this at the lowest level. */;
2627 else if (value_init)
2629 init = build_value_init (elttype, tf_warning_or_error);
2634 vec<tree, va_gc> *argvec = make_tree_vector ();
2635 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
2636 &argvec, elttype, LOOKUP_NORMAL,
2637 tf_warning_or_error);
2638 release_tree_vector (argvec);
2639 init = build_aggr_init_expr (TREE_TYPE (init), init);
2643 for (i = 0; i < max; ++i)
2645 tree idx = build_int_cst (size_type_node, i);
2648 constexpr_ctx new_ctx;
2649 init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype);
2650 if (new_ctx.ctor != ctx->ctor)
2651 CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor);
2652 if (TREE_CODE (elttype) == ARRAY_TYPE)
2654 /* A multidimensional array; recurse. */
2655 if (value_init || init == NULL_TREE)
2657 eltinit = NULL_TREE;
2661 eltinit = cp_build_array_ref (input_location, init, idx,
2662 tf_warning_or_error);
2663 eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
2665 non_constant_p, overflow_p);
2669 /* Initializing an element using value or default initialization
2670 we just pre-built above. */
2671 eltinit = cxx_eval_constant_expression (&new_ctx, init, lval,
2672 non_constant_p, overflow_p);
2677 /* Copying an element. */
2678 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2679 (atype, TREE_TYPE (init)));
2680 eltinit = cp_build_array_ref (input_location, init, idx,
2681 tf_warning_or_error);
2682 if (!real_lvalue_p (init))
2683 eltinit = move (eltinit);
2684 eltinit = force_rvalue (eltinit, tf_warning_or_error);
2685 eltinit = (cxx_eval_constant_expression
2686 (&new_ctx, eltinit, lval,
2687 non_constant_p, overflow_p));
2689 if (*non_constant_p && !ctx->quiet)
2691 if (new_ctx.ctor != ctx->ctor)
2693 /* We appended this element above; update the value. */
2694 gcc_assert ((*p)->last().index == idx);
2695 (*p)->last().value = eltinit;
2698 CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit);
2699 /* Reuse the result of cxx_eval_constant_expression call
2700 from the first iteration to all others if it is a constant
2701 initializer that doesn't require relocations. */
2704 && (initializer_constant_valid_p (eltinit, TREE_TYPE (eltinit))
2705 == null_pointer_node))
2707 if (new_ctx.ctor != ctx->ctor)
2708 eltinit = new_ctx.ctor;
2709 for (i = 1; i < max; ++i)
2711 idx = build_int_cst (size_type_node, i);
2712 CONSTRUCTOR_APPEND_ELT (*p, idx, unshare_constructor (eltinit));
2718 if (!*non_constant_p)
2721 CONSTRUCTOR_NO_IMPLICIT_ZERO (init) = false;
2727 cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
2729 bool *non_constant_p, bool *overflow_p)
2731 tree atype = TREE_TYPE (t);
2732 tree init = VEC_INIT_EXPR_INIT (t);
2733 tree r = cxx_eval_vec_init_1 (ctx, atype, init,
2734 VEC_INIT_EXPR_VALUE_INIT (t),
2735 lval, non_constant_p, overflow_p);
2736 if (*non_constant_p)
2742 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2743 match. We want to be less strict for simple *& folding; if we have a
2744 non-const temporary that we access through a const pointer, that should
2745 work. We handle this here rather than change fold_indirect_ref_1
2746 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2747 don't really make sense outside of constant expression evaluation. Also
2748 we want to allow folding to COMPONENT_REF, which could cause trouble
2749 with TBAA in fold_indirect_ref_1.
2751 Try to keep this function synced with fold_indirect_ref_1. */
2754 cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
2760 subtype = TREE_TYPE (sub);
2761 if (!POINTER_TYPE_P (subtype))
2764 if (TREE_CODE (sub) == ADDR_EXPR)
2766 tree op = TREE_OPERAND (sub, 0);
2767 tree optype = TREE_TYPE (op);
2769 /* *&CONST_DECL -> to the value of the const decl. */
2770 if (TREE_CODE (op) == CONST_DECL)
2771 return DECL_INITIAL (op);
2772 /* *&p => p; make sure to handle *&"str"[cst] here. */
2773 if (same_type_ignoring_top_level_qualifiers_p (optype, type)
2774 /* Also handle the case where the desired type is an array of unknown
2775 bounds because the variable has had its bounds deduced since the
2776 ADDR_EXPR was created. */
2777 || (TREE_CODE (type) == ARRAY_TYPE
2778 && TREE_CODE (optype) == ARRAY_TYPE
2779 && TYPE_DOMAIN (type) == NULL_TREE
2780 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype),
2783 tree fop = fold_read_from_constant_string (op);
2789 /* *(foo *)&fooarray => fooarray[0] */
2790 else if (TREE_CODE (optype) == ARRAY_TYPE
2791 && (same_type_ignoring_top_level_qualifiers_p
2792 (type, TREE_TYPE (optype))))
2794 tree type_domain = TYPE_DOMAIN (optype);
2795 tree min_val = size_zero_node;
2796 if (type_domain && TYPE_MIN_VALUE (type_domain))
2797 min_val = TYPE_MIN_VALUE (type_domain);
2798 return build4_loc (loc, ARRAY_REF, type, op, min_val,
2799 NULL_TREE, NULL_TREE);
2801 /* *(foo *)&complexfoo => __real__ complexfoo */
2802 else if (TREE_CODE (optype) == COMPLEX_TYPE
2803 && (same_type_ignoring_top_level_qualifiers_p
2804 (type, TREE_TYPE (optype))))
2805 return fold_build1_loc (loc, REALPART_EXPR, type, op);
2806 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2807 else if (VECTOR_TYPE_P (optype)
2808 && (same_type_ignoring_top_level_qualifiers_p
2809 (type, TREE_TYPE (optype))))
2811 tree part_width = TYPE_SIZE (type);
2812 tree index = bitsize_int (0);
2813 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
2815 /* Also handle conversion to an empty base class, which
2816 is represented with a NOP_EXPR. */
2817 else if (is_empty_class (type)
2818 && CLASS_TYPE_P (optype)
2819 && DERIVED_FROM_P (type, optype))
2824 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2825 else if (RECORD_OR_UNION_TYPE_P (optype))
2827 tree field = TYPE_FIELDS (optype);
2828 for (; field; field = DECL_CHAIN (field))
2829 if (TREE_CODE (field) == FIELD_DECL
2830 && integer_zerop (byte_position (field))
2831 && (same_type_ignoring_top_level_qualifiers_p
2832 (TREE_TYPE (field), type)))
2834 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
2839 else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
2840 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
2842 tree op00 = TREE_OPERAND (sub, 0);
2843 tree op01 = TREE_OPERAND (sub, 1);
2846 if (TREE_CODE (op00) == ADDR_EXPR)
2849 op00 = TREE_OPERAND (op00, 0);
2850 op00type = TREE_TYPE (op00);
2852 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2853 if (VECTOR_TYPE_P (op00type)
2854 && (same_type_ignoring_top_level_qualifiers_p
2855 (type, TREE_TYPE (op00type))))
2857 HOST_WIDE_INT offset = tree_to_shwi (op01);
2858 tree part_width = TYPE_SIZE (type);
2859 unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
2860 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
2861 tree index = bitsize_int (indexi);
2863 if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
2864 return fold_build3_loc (loc,
2865 BIT_FIELD_REF, type, op00,
2869 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2870 else if (TREE_CODE (op00type) == COMPLEX_TYPE
2871 && (same_type_ignoring_top_level_qualifiers_p
2872 (type, TREE_TYPE (op00type))))
2874 tree size = TYPE_SIZE_UNIT (type);
2875 if (tree_int_cst_equal (size, op01))
2876 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
2878 /* ((foo *)&fooarray)[1] => fooarray[1] */
2879 else if (TREE_CODE (op00type) == ARRAY_TYPE
2880 && (same_type_ignoring_top_level_qualifiers_p
2881 (type, TREE_TYPE (op00type))))
2883 tree type_domain = TYPE_DOMAIN (op00type);
2884 tree min_val = size_zero_node;
2885 if (type_domain && TYPE_MIN_VALUE (type_domain))
2886 min_val = TYPE_MIN_VALUE (type_domain);
2887 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
2888 TYPE_SIZE_UNIT (type));
2889 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
2890 return build4_loc (loc, ARRAY_REF, type, op00, op01,
2891 NULL_TREE, NULL_TREE);
2893 /* Also handle conversion to an empty base class, which
2894 is represented with a NOP_EXPR. */
2895 else if (is_empty_class (type)
2896 && CLASS_TYPE_P (op00type)
2897 && DERIVED_FROM_P (type, op00type))
2902 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2903 else if (RECORD_OR_UNION_TYPE_P (op00type))
2905 tree field = TYPE_FIELDS (op00type);
2906 for (; field; field = DECL_CHAIN (field))
2907 if (TREE_CODE (field) == FIELD_DECL
2908 && tree_int_cst_equal (byte_position (field), op01)
2909 && (same_type_ignoring_top_level_qualifiers_p
2910 (TREE_TYPE (field), type)))
2912 return fold_build3 (COMPONENT_REF, type, op00,
2919 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2920 else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
2921 && (same_type_ignoring_top_level_qualifiers_p
2922 (type, TREE_TYPE (TREE_TYPE (subtype)))))
2925 tree min_val = size_zero_node;
2926 tree newsub = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
2930 sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
2931 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
2932 if (type_domain && TYPE_MIN_VALUE (type_domain))
2933 min_val = TYPE_MIN_VALUE (type_domain);
2934 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
2942 cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
2944 bool *non_constant_p, bool *overflow_p)
2946 tree orig_op0 = TREE_OPERAND (t, 0);
2947 bool empty_base = false;
2949 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
2950 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
2952 if (TREE_CODE (t) == MEM_REF
2953 && (!TREE_OPERAND (t, 1) || !integer_zerop (TREE_OPERAND (t, 1))))
2955 gcc_assert (ctx->quiet);
2956 *non_constant_p = true;
2960 /* First try to simplify it directly. */
2961 tree r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), orig_op0,
2965 /* If that didn't work, evaluate the operand first. */
2966 tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
2967 /*lval*/false, non_constant_p,
2969 /* Don't VERIFY_CONSTANT here. */
2970 if (*non_constant_p)
2973 r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
2977 /* We couldn't fold to a constant value. Make sure it's not
2978 something we should have been able to fold. */
2981 if (TREE_CODE (sub) == ADDR_EXPR)
2983 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2984 (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
2985 /* DR 1188 says we don't have to deal with this. */
2987 error ("accessing value of %qE through a %qT glvalue in a "
2988 "constant expression", build_fold_indirect_ref (sub),
2990 *non_constant_p = true;
2994 if (lval && op0 != orig_op0)
2995 return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
2997 VERIFY_CONSTANT (t);
3002 r = cxx_eval_constant_expression (ctx, r,
3003 lval, non_constant_p, overflow_p);
3004 if (*non_constant_p)
3007 /* If we're pulling out the value of an empty base, make sure
3008 that the whole object is constant and then return an empty
3010 if (empty_base && !lval)
3012 VERIFY_CONSTANT (r);
3013 r = build_constructor (TREE_TYPE (t), NULL);
3014 TREE_CONSTANT (r) = true;
3020 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3021 Shared between potential_constant_expression and
3022 cxx_eval_constant_expression. */
3025 non_const_var_error (tree r)
3027 tree type = TREE_TYPE (r);
3028 error ("the value of %qD is not usable in a constant "
3030 /* Avoid error cascade. */
3031 if (DECL_INITIAL (r) == error_mark_node)
3033 if (DECL_DECLARED_CONSTEXPR_P (r))
3034 inform (DECL_SOURCE_LOCATION (r),
3035 "%qD used in its own initializer", r);
3036 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
3038 if (!CP_TYPE_CONST_P (type))
3039 inform (DECL_SOURCE_LOCATION (r),
3040 "%q#D is not const", r);
3041 else if (CP_TYPE_VOLATILE_P (type))
3042 inform (DECL_SOURCE_LOCATION (r),
3043 "%q#D is volatile", r);
3044 else if (!DECL_INITIAL (r)
3045 || !TREE_CONSTANT (DECL_INITIAL (r))
3046 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r))
3047 inform (DECL_SOURCE_LOCATION (r),
3048 "%qD was not initialized with a constant "
3055 if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
3056 inform (DECL_SOURCE_LOCATION (r),
3057 "%qD was not declared %<constexpr%>", r);
3059 inform (DECL_SOURCE_LOCATION (r),
3060 "%qD does not have integral or enumeration type",
3065 /* Subroutine of cxx_eval_constant_expression.
3066 Like cxx_eval_unary_expression, except for trinary expressions. */
3069 cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
3071 bool *non_constant_p, bool *overflow_p)
3077 for (i = 0; i < 3; i++)
3079 args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
3081 non_constant_p, overflow_p);
3082 VERIFY_CONSTANT (args[i]);
3085 val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
3086 args[0], args[1], args[2]);
3087 if (val == NULL_TREE)
3089 VERIFY_CONSTANT (val);
3094 var_in_constexpr_fn (tree t)
3096 tree ctx = DECL_CONTEXT (t);
3097 return (cxx_dialect >= cxx14 && ctx && TREE_CODE (ctx) == FUNCTION_DECL
3098 && DECL_DECLARED_CONSTEXPR_P (ctx));
3101 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3104 cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
3106 bool *non_constant_p, bool *overflow_p)
3108 constexpr_ctx new_ctx = *ctx;
3110 tree init = TREE_OPERAND (t, 1);
3111 if (TREE_CLOBBER_P (init))
3112 /* Just ignore clobbers. */
3115 /* First we figure out where we're storing to. */
3116 tree target = TREE_OPERAND (t, 0);
3117 tree type = TREE_TYPE (target);
3118 target = cxx_eval_constant_expression (ctx, target,
3120 non_constant_p, overflow_p);
3121 if (*non_constant_p)
3124 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target), type))
3126 /* For initialization of an empty base, the original target will be
3127 *(base*)this, which the above evaluation resolves to the object
3128 argument, which has the derived type rather than the base type. In
3129 this situation, just evaluate the initializer and return, since
3130 there's no actual data to store. */
3131 gcc_assert (is_empty_class (type));
3132 return cxx_eval_constant_expression (ctx, init, false,
3133 non_constant_p, overflow_p);
3136 /* And then find the underlying variable. */
3137 vec<tree,va_gc> *refs = make_tree_vector();
3138 tree object = NULL_TREE;
3139 for (tree probe = target; object == NULL_TREE; )
3141 switch (TREE_CODE (probe))
3146 vec_safe_push (refs, TREE_OPERAND (probe, 1));
3147 vec_safe_push (refs, TREE_TYPE (probe));
3148 probe = TREE_OPERAND (probe, 0);
3156 /* And then find/build up our initializer for the path to the subobject
3157 we're initializing. */
3159 if (DECL_P (object))
3160 valp = ctx->values->get (object);
3165 /* A constant-expression cannot modify objects from outside the
3166 constant-expression. */
3168 error ("modification of %qE is not a constant-expression", object);
3169 *non_constant_p = true;
3172 type = TREE_TYPE (object);
3173 bool no_zero_init = true;
3175 vec<tree,va_gc> *ctors = make_tree_vector ();
3176 while (!refs->is_empty())
3178 if (*valp == NULL_TREE)
3180 *valp = build_constructor (type, NULL);
3181 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init;
3183 else if (TREE_CODE (*valp) == STRING_CST)
3185 /* An array was initialized with a string constant, and now
3186 we're writing into one of its elements. Explode the
3187 single initialization into a set of element
3189 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
3191 tree string = *valp;
3192 tree elt_type = TREE_TYPE (type);
3193 unsigned chars_per_elt = (TYPE_PRECISION (elt_type)
3194 / TYPE_PRECISION (char_type_node));
3195 unsigned num_elts = TREE_STRING_LENGTH (string) / chars_per_elt;
3196 tree ary_ctor = build_constructor (type, NULL);
3198 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor), num_elts);
3199 for (unsigned ix = 0; ix != num_elts; ix++)
3201 constructor_elt elt =
3203 build_int_cst (size_type_node, ix),
3204 extract_string_elt (string, chars_per_elt, ix)
3206 CONSTRUCTOR_ELTS (ary_ctor)->quick_push (elt);
3212 /* If the value of object is already zero-initialized, any new ctors for
3213 subobjects will also be zero-initialized. */
3214 no_zero_init = CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp);
3216 vec_safe_push (ctors, *valp);
3218 enum tree_code code = TREE_CODE (type);
3220 tree index = refs->pop();
3222 constructor_elt *cep = NULL;
3223 if (code == ARRAY_TYPE)
3226 = find_array_ctor_elt (*valp, index, /*insert*/true);
3227 gcc_assert (i >= 0);
3228 cep = CONSTRUCTOR_ELT (*valp, i);
3229 gcc_assert (TREE_CODE (cep->index) != RANGE_EXPR);
3233 gcc_assert (TREE_CODE (index) == FIELD_DECL);
3235 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3236 Usually we meet initializers in that order, but it is
3237 possible for base types to be placed not in program
3239 tree fields = TYPE_FIELDS (DECL_CONTEXT (index));
3240 unsigned HOST_WIDE_INT idx;
3243 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep);
3244 idx++, fields = DECL_CHAIN (fields))
3246 if (index == cep->index)
3249 /* The field we're initializing must be on the field
3250 list. Look to see if it is present before the
3251 field the current ELT initializes. */
3252 for (; fields != cep->index; fields = DECL_CHAIN (fields))
3253 if (index == fields)
3257 /* We fell off the end of the CONSTRUCTOR, so insert a new
3258 entry at the end. */
3261 constructor_elt ce = { index, NULL_TREE };
3263 vec_safe_insert (CONSTRUCTOR_ELTS (*valp), idx, ce);
3264 cep = CONSTRUCTOR_ELT (*valp, idx);
3270 release_tree_vector (refs);
3272 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
3274 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3275 wants to modify it. */
3276 if (*valp == NULL_TREE)
3278 *valp = new_ctx.ctor = build_constructor (type, NULL);
3279 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = no_zero_init;
3282 new_ctx.ctor = *valp;
3283 new_ctx.object = target;
3286 init = cxx_eval_constant_expression (&new_ctx, init, false,
3287 non_constant_p, overflow_p);
3288 /* Don't share a CONSTRUCTOR that might be changed later. */
3289 init = unshare_constructor (init);
3290 if (target == object)
3291 /* The hash table might have moved since the get earlier. */
3292 valp = ctx->values->get (object);
3294 if (TREE_CODE (init) == CONSTRUCTOR)
3296 /* An outer ctx->ctor might be pointing to *valp, so replace
3298 CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init);
3299 TREE_CONSTANT (*valp) = TREE_CONSTANT (init);
3300 TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init);
3301 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp)
3302 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init);
3307 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3308 CONSTRUCTORs, if any. */
3311 bool c = TREE_CONSTANT (init);
3312 bool s = TREE_SIDE_EFFECTS (init);
3314 FOR_EACH_VEC_SAFE_ELT (ctors, i, elt)
3317 TREE_CONSTANT (elt) = false;
3319 TREE_SIDE_EFFECTS (elt) = true;
3321 release_tree_vector (ctors);
3323 if (*non_constant_p)
3331 /* Evaluate a ++ or -- expression. */
3334 cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
3336 bool *non_constant_p, bool *overflow_p)
3338 enum tree_code code = TREE_CODE (t);
3339 tree type = TREE_TYPE (t);
3340 tree op = TREE_OPERAND (t, 0);
3341 tree offset = TREE_OPERAND (t, 1);
3342 gcc_assert (TREE_CONSTANT (offset));
3344 /* The operand as an lvalue. */
3345 op = cxx_eval_constant_expression (ctx, op, true,
3346 non_constant_p, overflow_p);
3348 /* The operand as an rvalue. */
3349 tree val = rvalue (op);
3350 val = cxx_eval_constant_expression (ctx, val, false,
3351 non_constant_p, overflow_p);
3352 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3353 a local array in a constexpr function. */
3354 bool ptr = POINTER_TYPE_P (TREE_TYPE (val));
3356 VERIFY_CONSTANT (val);
3358 /* The modified value. */
3359 bool inc = (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR);
3361 if (POINTER_TYPE_P (type))
3363 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3364 offset = convert_to_ptrofftype (offset);
3366 offset = fold_build1 (NEGATE_EXPR, TREE_TYPE (offset), offset);
3367 mod = fold_build2 (POINTER_PLUS_EXPR, type, val, offset);
3370 mod = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR, type, val, offset);
3372 VERIFY_CONSTANT (mod);
3374 /* Storing the modified value. */
3375 tree store = build2 (MODIFY_EXPR, type, op, mod);
3376 cxx_eval_constant_expression (ctx, store,
3377 true, non_constant_p, overflow_p);
3379 /* And the value of the expression. */
3380 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3382 /* Prefix ops are lvalues. */
3386 /* But we optimize when the caller wants an rvalue. */
3390 /* Postfix ops are rvalues. */
3394 /* Predicates for the meaning of *jump_target. */
3397 returns (tree *jump_target)
3400 && TREE_CODE (*jump_target) == RETURN_EXPR;
3404 breaks (tree *jump_target)
3407 && TREE_CODE (*jump_target) == LABEL_DECL
3408 && LABEL_DECL_BREAK (*jump_target);
3412 continues (tree *jump_target)
3415 && TREE_CODE (*jump_target) == LABEL_DECL
3416 && LABEL_DECL_CONTINUE (*jump_target);
3420 switches (tree *jump_target)
3423 && TREE_CODE (*jump_target) == INTEGER_CST;
3426 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3427 STMT matches *jump_target. If we're looking for a case label and we see
3428 the default label, note it in ctx->css_state. */
3431 label_matches (const constexpr_ctx *ctx, tree *jump_target, tree stmt)
3433 switch (TREE_CODE (*jump_target))
3436 if (TREE_CODE (stmt) == LABEL_EXPR
3437 && LABEL_EXPR_LABEL (stmt) == *jump_target)
3442 if (TREE_CODE (stmt) == CASE_LABEL_EXPR)
3444 gcc_assert (ctx->css_state != NULL);
3445 if (!CASE_LOW (stmt))
3447 /* default: should appear just once in a SWITCH_EXPR
3448 body (excluding nested SWITCH_EXPR). */
3449 gcc_assert (*ctx->css_state != css_default_seen);
3450 /* When evaluating SWITCH_EXPR body for the second time,
3451 return true for the default: label. */
3452 if (*ctx->css_state == css_default_processing)
3454 *ctx->css_state = css_default_seen;
3456 else if (CASE_HIGH (stmt))
3458 if (tree_int_cst_le (CASE_LOW (stmt), *jump_target)
3459 && tree_int_cst_le (*jump_target, CASE_HIGH (stmt)))
3462 else if (tree_int_cst_equal (*jump_target, CASE_LOW (stmt)))
3473 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3474 semantics, for switch, break, continue, and return. */
3477 cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
3478 bool *non_constant_p, bool *overflow_p,
3481 tree_stmt_iterator i;
3483 /* In a statement-expression we want to return the last value. */
3487 local_target = NULL_TREE;
3488 jump_target = &local_target;
3490 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
3492 tree stmt = tsi_stmt (i);
3493 r = cxx_eval_constant_expression (ctx, stmt, false,
3494 non_constant_p, overflow_p,
3496 if (*non_constant_p)
3498 if (returns (jump_target) || breaks (jump_target))
3504 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3505 semantics; continue semantics are covered by cxx_eval_statement_list. */
3508 cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t,
3509 bool *non_constant_p, bool *overflow_p,
3512 constexpr_ctx new_ctx = *ctx;
3514 tree body = TREE_OPERAND (t, 0);
3517 hash_set<tree> save_exprs;
3518 new_ctx.save_exprs = &save_exprs;
3520 cxx_eval_statement_list (&new_ctx, body,
3521 non_constant_p, overflow_p, jump_target);
3523 /* Forget saved values of SAVE_EXPRs. */
3524 for (hash_set<tree>::iterator iter = save_exprs.begin();
3525 iter != save_exprs.end(); ++iter)
3526 new_ctx.values->remove (*iter);
3528 while (!returns (jump_target)
3529 && !breaks (jump_target)
3530 && !switches (jump_target)
3531 && !*non_constant_p);
3533 if (breaks (jump_target))
3534 *jump_target = NULL_TREE;
3539 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3543 cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t,
3544 bool *non_constant_p, bool *overflow_p,
3547 tree cond = TREE_OPERAND (t, 0);
3548 cond = cxx_eval_constant_expression (ctx, cond, false,
3549 non_constant_p, overflow_p);
3550 VERIFY_CONSTANT (cond);
3551 *jump_target = cond;
3553 tree body = TREE_OPERAND (t, 1);
3554 constexpr_ctx new_ctx = *ctx;
3555 constexpr_switch_state css = css_default_not_seen;
3556 new_ctx.css_state = &css;
3557 cxx_eval_constant_expression (&new_ctx, body, false,
3558 non_constant_p, overflow_p, jump_target);
3559 if (switches (jump_target) && css == css_default_seen)
3561 /* If the SWITCH_EXPR body has default: label, process it once again,
3562 this time instructing label_matches to return true for default:
3563 label on switches (jump_target). */
3564 css = css_default_processing;
3565 cxx_eval_constant_expression (&new_ctx, body, false,
3566 non_constant_p, overflow_p, jump_target);
3568 if (breaks (jump_target) || switches (jump_target))
3569 *jump_target = NULL_TREE;
3573 /* Attempt to reduce the expression T to a constant value.
3574 On failure, issue diagnostic and return error_mark_node. */
3575 /* FIXME unify with c_fully_fold */
3576 /* FIXME overflow_p is too global */
3579 cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
3581 bool *non_constant_p, bool *overflow_p,
3584 constexpr_ctx new_ctx;
3587 if (jump_target && *jump_target)
3589 /* If we are jumping, ignore all statements/expressions except those
3590 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
3591 switch (TREE_CODE (t))
3594 case STATEMENT_LIST:
3599 case CASE_LABEL_EXPR:
3600 if (label_matches (ctx, jump_target, t))
3602 *jump_target = NULL_TREE;
3608 if (t == error_mark_node)
3610 *non_constant_p = true;
3613 if (CONSTANT_CLASS_P (t))
3615 if (TREE_OVERFLOW (t))
3618 permerror (input_location, "overflow in constant expression");
3619 if (!flag_permissive || ctx->quiet)
3625 switch (TREE_CODE (t))
3630 /* We ask for an rvalue for the RESULT_DECL when indirecting
3631 through an invisible reference, or in named return value
3633 return (*ctx->values->get (t));
3637 /* We used to not check lval for CONST_DECL, but darwin.c uses
3638 CONST_DECL for aggregate constants. */
3642 r = decl_really_constant_value (t);
3644 r = decl_constant_value (t);
3645 if (TREE_CODE (r) == TARGET_EXPR
3646 && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR)
3647 r = TARGET_EXPR_INITIAL (r);
3649 if (tree *p = ctx->values->get (r))
3650 if (*p != NULL_TREE)
3655 non_const_var_error (r);
3656 *non_constant_p = true;
3664 case CASE_LABEL_EXPR:
3669 if (lval && TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
3671 else if (tree *p = ctx->values->get (r))
3674 /* Defer in case this is only used for its type. */;
3675 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
3676 /* Defer, there's no lvalue->rvalue conversion. */;
3677 else if (is_empty_class (TREE_TYPE (t)))
3679 /* If the class is empty, we aren't actually loading anything. */
3680 r = build_constructor (TREE_TYPE (t), NULL);
3681 TREE_CONSTANT (r) = true;
3686 error ("%qE is not a constant expression", t);
3687 *non_constant_p = true;
3692 case AGGR_INIT_EXPR:
3693 r = cxx_eval_call_expression (ctx, t, lval,
3694 non_constant_p, overflow_p);
3699 r = DECL_EXPR_DECL (t);
3700 if (AGGREGATE_TYPE_P (TREE_TYPE (r))
3701 || VECTOR_TYPE_P (TREE_TYPE (r)))
3705 new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL);
3706 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
3707 new_ctx.values->put (r, new_ctx.ctor);
3711 if (tree init = DECL_INITIAL (r))
3713 init = cxx_eval_constant_expression (ctx, init,
3715 non_constant_p, overflow_p);
3716 /* Don't share a CONSTRUCTOR that might be changed. */
3717 init = unshare_constructor (init);
3718 ctx->values->put (r, init);
3720 else if (ctx == &new_ctx)
3721 /* We gave it a CONSTRUCTOR above. */;
3723 ctx->values->put (r, NULL_TREE);
3728 if (!literal_type_p (TREE_TYPE (t)))
3732 error ("temporary of non-literal type %qT in a "
3733 "constant expression", TREE_TYPE (t));
3734 explain_non_literal_class (TREE_TYPE (t));
3736 *non_constant_p = true;
3739 if ((AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t))))
3741 /* We're being expanded without an explicit target, so start
3742 initializing a new object; expansion with an explicit target
3743 strips the TARGET_EXPR before we get here. */
3745 new_ctx.ctor = build_constructor (TREE_TYPE (t), NULL);
3746 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
3747 new_ctx.object = TARGET_EXPR_SLOT (t);
3748 ctx->values->put (new_ctx.object, new_ctx.ctor);
3751 /* Pass false for 'lval' because this indicates
3752 initialization of a temporary. */
3753 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3755 non_constant_p, overflow_p);
3756 if (!*non_constant_p)
3757 /* Adjust the type of the result to the type of the temporary. */
3758 r = adjust_temp_type (TREE_TYPE (t), r);
3761 tree slot = TARGET_EXPR_SLOT (t);
3762 r = unshare_constructor (r);
3763 ctx->values->put (slot, r);
3770 gcc_assert (jump_target == NULL || *jump_target == NULL_TREE);
3771 r = cxx_eval_store_expression (ctx, t, lval,
3772 non_constant_p, overflow_p);
3776 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3778 non_constant_p, overflow_p);
3782 if (TREE_OPERAND (t, 0) != NULL_TREE)
3783 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3785 non_constant_p, overflow_p);
3790 /* Avoid evaluating a SAVE_EXPR more than once. */
3791 if (tree *p = ctx->values->get (t))
3795 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), false,
3796 non_constant_p, overflow_p);
3797 ctx->values->put (t, r);
3798 if (ctx->save_exprs)
3799 ctx->save_exprs->add (t);
3803 case NON_LVALUE_EXPR:
3804 case TRY_CATCH_EXPR:
3806 case CLEANUP_POINT_EXPR:
3807 case MUST_NOT_THROW_EXPR:
3810 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3812 non_constant_p, overflow_p,
3816 case TRY_FINALLY_EXPR:
3817 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval,
3818 non_constant_p, overflow_p,
3820 if (!*non_constant_p)
3821 /* Also evaluate the cleanup. */
3822 cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), true,
3823 non_constant_p, overflow_p,
3827 /* These differ from cxx_eval_unary_expression in that this doesn't
3828 check for a constant operand or result; an address can be
3829 constant without its operand being, and vice versa. */
3832 r = cxx_eval_indirect_ref (ctx, t, lval,
3833 non_constant_p, overflow_p);
3838 tree oldop = TREE_OPERAND (t, 0);
3839 tree op = cxx_eval_constant_expression (ctx, oldop,
3841 non_constant_p, overflow_p);
3842 /* Don't VERIFY_CONSTANT here. */
3843 if (*non_constant_p)
3845 gcc_checking_assert (TREE_CODE (op) != CONSTRUCTOR);
3846 /* This function does more aggressive folding than fold itself. */
3847 r = build_fold_addr_expr_with_type (op, TREE_TYPE (t));
3848 if (TREE_CODE (r) == ADDR_EXPR && TREE_OPERAND (r, 0) == oldop)
3857 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval,
3858 non_constant_p, overflow_p);
3859 if (r == error_mark_node)
3861 else if (r == TREE_OPERAND (t, 0))
3864 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), r);
3869 case FIX_TRUNC_EXPR:
3874 case TRUTH_NOT_EXPR:
3875 case FIXED_CONVERT_EXPR:
3876 r = cxx_eval_unary_expression (ctx, t, lval,
3877 non_constant_p, overflow_p);
3881 r = fold_sizeof_expr (t);
3882 VERIFY_CONSTANT (r);
3887 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3888 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3889 introduced by build_call_a. */
3890 tree op0 = TREE_OPERAND (t, 0);
3891 tree op1 = TREE_OPERAND (t, 1);
3893 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
3894 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
3895 r = cxx_eval_constant_expression (ctx, op0,
3896 lval, non_constant_p, overflow_p,
3900 /* Check that the LHS is constant and then discard it. */
3901 cxx_eval_constant_expression (ctx, op0,
3902 true, non_constant_p, overflow_p,
3904 op1 = TREE_OPERAND (t, 1);
3905 r = cxx_eval_constant_expression (ctx, op1,
3906 lval, non_constant_p, overflow_p,
3912 case POINTER_PLUS_EXPR:
3916 case TRUNC_DIV_EXPR:
3918 case FLOOR_DIV_EXPR:
3919 case ROUND_DIV_EXPR:
3920 case TRUNC_MOD_EXPR:
3922 case ROUND_MOD_EXPR:
3924 case EXACT_DIV_EXPR:
3934 case TRUTH_XOR_EXPR:
3941 case UNORDERED_EXPR:
3951 r = cxx_eval_binary_expression (ctx, t, lval,
3952 non_constant_p, overflow_p);
3955 /* fold can introduce non-IF versions of these; still treat them as
3956 short-circuiting. */
3957 case TRUTH_AND_EXPR:
3958 case TRUTH_ANDIF_EXPR:
3959 r = cxx_eval_logical_expression (ctx, t, boolean_false_node,
3962 non_constant_p, overflow_p);
3966 case TRUTH_ORIF_EXPR:
3967 r = cxx_eval_logical_expression (ctx, t, boolean_true_node,
3970 non_constant_p, overflow_p);
3974 r = cxx_eval_array_reference (ctx, t, lval,
3975 non_constant_p, overflow_p);
3979 if (is_overloaded_fn (t))
3981 /* We can only get here in checking mode via
3982 build_non_dependent_expr, because any expression that
3983 calls or takes the address of the function will have
3984 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3985 gcc_checking_assert (ctx->quiet || errorcount);
3986 *non_constant_p = true;
3989 r = cxx_eval_component_reference (ctx, t, lval,
3990 non_constant_p, overflow_p);
3994 r = cxx_eval_bit_field_ref (ctx, t, lval,
3995 non_constant_p, overflow_p);
3999 if (jump_target && *jump_target)
4001 /* When jumping to a label, the label might be either in the
4002 then or else blocks, so process then block first in skipping
4003 mode first, and if we are still in the skipping mode at its end,
4004 process the else block too. */
4005 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
4006 lval, non_constant_p, overflow_p,
4009 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
4010 lval, non_constant_p, overflow_p,
4016 r = cxx_eval_conditional_expression (ctx, t, lval,
4017 non_constant_p, overflow_p,
4022 if (TREE_CONSTANT (t))
4024 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4025 VECTOR_CST if applicable. */
4026 /* FIXME after GCC 6 branches, make the verify unconditional. */
4028 verify_constructor_flags (t);
4030 recompute_constructor_flags (t);
4031 if (TREE_CONSTANT (t))
4034 r = cxx_eval_bare_aggregate (ctx, t, lval,
4035 non_constant_p, overflow_p);
4039 /* We can get this in a defaulted constructor for a class with a
4040 non-static data member of array type. Either the initializer will
4041 be NULL, meaning default-initialization, or it will be an lvalue
4042 or xvalue of the same type, meaning direct-initialization from the
4043 corresponding member. */
4044 r = cxx_eval_vec_init (ctx, t, lval,
4045 non_constant_p, overflow_p);
4050 r = cxx_eval_trinary_expression (ctx, t, lval,
4051 non_constant_p, overflow_p);
4055 case VIEW_CONVERT_EXPR:
4057 case UNARY_PLUS_EXPR:
4059 enum tree_code tcode = TREE_CODE (t);
4060 tree oldop = TREE_OPERAND (t, 0);
4062 tree op = cxx_eval_constant_expression (ctx, oldop,
4064 non_constant_p, overflow_p);
4065 if (*non_constant_p)
4067 tree type = TREE_TYPE (t);
4068 if (TREE_CODE (op) == PTRMEM_CST
4069 && !TYPE_PTRMEM_P (type))
4070 op = cplus_expand_constant (op);
4071 if (TREE_CODE (op) == PTRMEM_CST && tcode == NOP_EXPR)
4073 if (same_type_ignoring_top_level_qualifiers_p (type,
4075 return cp_fold_convert (type, op);
4079 error_at (EXPR_LOC_OR_LOC (t, input_location),
4080 "a reinterpret_cast is not a constant-expression");
4081 *non_constant_p = true;
4085 if (POINTER_TYPE_P (type)
4086 && TREE_CODE (op) == INTEGER_CST
4087 && !integer_zerop (op))
4090 error_at (EXPR_LOC_OR_LOC (t, input_location),
4091 "reinterpret_cast from integer to pointer");
4092 *non_constant_p = true;
4095 if (op == oldop && tcode != UNARY_PLUS_EXPR)
4096 /* We didn't fold at the top so we could check for ptr-int
4099 if (tcode == UNARY_PLUS_EXPR)
4100 r = fold_convert (TREE_TYPE (t), op);
4102 r = fold_build1 (tcode, type, op);
4103 /* Conversion of an out-of-range value has implementation-defined
4104 behavior; the language considers it different from arithmetic
4105 overflow, which is undefined. */
4106 if (TREE_OVERFLOW_P (r) && !TREE_OVERFLOW_P (op))
4107 TREE_OVERFLOW (r) = false;
4111 case EMPTY_CLASS_EXPR:
4112 /* This is good enough for a function argument that might not get
4113 used, and they can't do anything with it, so just return it. */
4116 case STATEMENT_LIST:
4118 new_ctx.ctor = new_ctx.object = NULL_TREE;
4119 return cxx_eval_statement_list (&new_ctx, t,
4120 non_constant_p, overflow_p, jump_target);
4123 return cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (t),
4125 non_constant_p, overflow_p,
4128 case PREINCREMENT_EXPR:
4129 case POSTINCREMENT_EXPR:
4130 case PREDECREMENT_EXPR:
4131 case POSTDECREMENT_EXPR:
4132 return cxx_eval_increment_expression (ctx, t,
4133 lval, non_constant_p, overflow_p);
4139 case VEC_DELETE_EXPR:
4142 /* GCC internal stuff. */
4145 case WITH_CLEANUP_EXPR:
4146 case NON_DEPENDENT_EXPR:
4150 error_at (EXPR_LOC_OR_LOC (t, input_location),
4151 "expression %qE is not a constant-expression", t);
4152 *non_constant_p = true;
4155 case PLACEHOLDER_EXPR:
4156 if (!ctx || !ctx->ctor || (lval && !ctx->object)
4157 || !(same_type_ignoring_top_level_qualifiers_p
4158 (TREE_TYPE (t), TREE_TYPE (ctx->ctor))))
4160 /* A placeholder without a referent. We can get here when
4161 checking whether NSDMIs are noexcept, or in massage_init_elt;
4162 just say it's non-constant for now. */
4163 gcc_assert (ctx->quiet);
4164 *non_constant_p = true;
4169 /* Use of the value or address of the current object. We could
4170 use ctx->object unconditionally, but using ctx->ctor when we
4171 can is a minor optimization. */
4172 tree ctor = lval ? ctx->object : ctx->ctor;
4173 return cxx_eval_constant_expression
4175 non_constant_p, overflow_p);
4180 *jump_target = TREE_OPERAND (t, 0);
4181 gcc_assert (breaks (jump_target) || continues (jump_target));
4185 cxx_eval_loop_expr (ctx, t,
4186 non_constant_p, overflow_p, jump_target);
4190 cxx_eval_switch_expr (ctx, t,
4191 non_constant_p, overflow_p, jump_target);
4195 /* It's possible to get a requires-expression in a constant
4196 expression. For example:
4198 template<typename T> concept bool C() {
4199 return requires (T t) { t; };
4202 template<typename T> requires !C<T>() void f(T);
4204 Normalization leaves f with the associated constraint
4205 '!requires (T t) { ... }' which is not transformed into
4207 if (!processing_template_decl)
4208 return evaluate_constraint_expression (t, NULL_TREE);
4210 *non_constant_p = true;
4214 if (STATEMENT_CODE_P (TREE_CODE (t)))
4216 /* This function doesn't know how to deal with pre-genericize
4217 statements; this can only happen with statement-expressions,
4218 so for now just fail. */
4220 error_at (EXPR_LOCATION (t),
4221 "statement is not a constant-expression");
4224 internal_error ("unexpected expression %qE of kind %s", t,
4225 get_tree_code_name (TREE_CODE (t)));
4226 *non_constant_p = true;
4230 if (r == error_mark_node)
4231 *non_constant_p = true;
4233 if (*non_constant_p)
4240 cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
4241 bool strict = true, tree object = NULL_TREE)
4243 bool non_constant_p = false;
4244 bool overflow_p = false;
4245 hash_map<tree,tree> map;
4247 constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL,
4248 allow_non_constant, strict };
4250 tree type = initialized_type (t);
4252 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
4254 /* In C++14 an NSDMI can participate in aggregate initialization,
4255 and can refer to the address of the object being initialized, so
4256 we need to pass in the relevant VAR_DECL if we want to do the
4257 evaluation in a single pass. The evaluation will dynamically
4258 update ctx.values for the VAR_DECL. We use the same strategy
4259 for C++11 constexpr constructors that refer to the object being
4261 ctx.ctor = build_constructor (type, NULL);
4262 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx.ctor) = true;
4265 if (TREE_CODE (t) == TARGET_EXPR)
4266 object = TARGET_EXPR_SLOT (t);
4267 else if (TREE_CODE (t) == AGGR_INIT_EXPR)
4268 object = AGGR_INIT_EXPR_SLOT (t);
4270 ctx.object = object;
4272 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4273 (type, TREE_TYPE (object)));
4274 if (object && DECL_P (object))
4275 map.put (object, ctx.ctor);
4276 if (TREE_CODE (r) == TARGET_EXPR)
4277 /* Avoid creating another CONSTRUCTOR when we expand the
4279 r = TARGET_EXPR_INITIAL (r);
4282 r = cxx_eval_constant_expression (&ctx, r,
4283 false, &non_constant_p, &overflow_p);
4285 verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);
4287 /* Mutable logic is a bit tricky: we want to allow initialization of
4288 constexpr variables with mutable members, but we can't copy those
4289 members to another constexpr variable. */
4290 if (TREE_CODE (r) == CONSTRUCTOR
4291 && CONSTRUCTOR_MUTABLE_POISON (r))
4293 if (!allow_non_constant)
4294 error ("%qE is not a constant expression because it refers to "
4295 "mutable subobjects of %qT", t, type);
4296 non_constant_p = true;
4299 /* Technically we should check this for all subexpressions, but that
4300 runs into problems with our internal representation of pointer
4301 subtraction and the 5.19 rules are still in flux. */
4302 if (CONVERT_EXPR_CODE_P (TREE_CODE (r))
4303 && ARITHMETIC_TYPE_P (TREE_TYPE (r))
4304 && TREE_CODE (TREE_OPERAND (r, 0)) == ADDR_EXPR)
4306 if (!allow_non_constant)
4307 error ("conversion from pointer type %qT "
4308 "to arithmetic type %qT in a constant-expression",
4309 TREE_TYPE (TREE_OPERAND (r, 0)), TREE_TYPE (r));
4310 non_constant_p = true;
4313 if (!non_constant_p && overflow_p)
4314 non_constant_p = true;
4316 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4318 bool should_unshare = true;
4319 if (r == t || TREE_CODE (r) == CONSTRUCTOR)
4320 should_unshare = false;
4322 if (non_constant_p && !allow_non_constant)
4323 return error_mark_node;
4324 else if (non_constant_p && TREE_CONSTANT (r))
4326 /* This isn't actually constant, so unset TREE_CONSTANT. */
4329 else if (TREE_CODE (r) == CONSTRUCTOR)
4330 r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r);
4332 r = build_nop (TREE_TYPE (r), r);
4333 TREE_CONSTANT (r) = false;
4335 else if (non_constant_p || r == t)
4339 r = unshare_expr (r);
4341 if (TREE_CODE (r) == CONSTRUCTOR && CLASS_TYPE_P (TREE_TYPE (r)))
4343 if (TREE_CODE (t) == TARGET_EXPR
4344 && TARGET_EXPR_INITIAL (t) == r)
4348 r = get_target_expr (r);
4349 TREE_CONSTANT (r) = true;
4357 /* Returns true if T is a valid subexpression of a constant expression,
4358 even if it isn't itself a constant expression. */
4361 is_sub_constant_expr (tree t)
4363 bool non_constant_p = false;
4364 bool overflow_p = false;
4365 hash_map <tree, tree> map;
4367 constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL, true, true };
4369 cxx_eval_constant_expression (&ctx, t, false, &non_constant_p,
4371 return !non_constant_p && !overflow_p;
4374 /* If T represents a constant expression returns its reduced value.
4375 Otherwise return error_mark_node. If T is dependent, then
4379 cxx_constant_value (tree t, tree decl)
4381 return cxx_eval_outermost_constant_expr (t, false, true, decl);
4384 /* Helper routine for fold_simple function. Either return simplified
4385 expression T, otherwise NULL_TREE.
4386 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4387 even if we are within template-declaration. So be careful on call, as in
4388 such case types can be undefined. */
4391 fold_simple_1 (tree t)
4394 enum tree_code code = TREE_CODE (t);
4406 return fold_sizeof_expr (t);
4414 case TRUTH_NOT_EXPR:
4416 case VIEW_CONVERT_EXPR:
4419 case FIX_TRUNC_EXPR:
4420 case FIXED_CONVERT_EXPR:
4421 case ADDR_SPACE_CONVERT_EXPR:
4423 op1 = TREE_OPERAND (t, 0);
4425 t = const_unop (code, TREE_TYPE (t), op1);
4429 if (CONVERT_EXPR_CODE_P (code)
4430 && TREE_OVERFLOW_P (t) && !TREE_OVERFLOW_P (op1))
4431 TREE_OVERFLOW (t) = false;
4439 /* If T is a simple constant expression, returns its simplified value.
4440 Otherwise returns T. In contrast to maybe_constant_value do we
4441 simplify only few operations on constant-expressions, and we don't
4442 try to simplify constexpressions. */
4445 fold_simple (tree t)
4448 if (processing_template_decl)
4451 r = fold_simple_1 (t);
4458 /* If T is a constant expression, returns its reduced value.
4459 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4460 Otherwise, returns a version of T without TREE_CONSTANT. */
4463 maybe_constant_value_1 (tree t, tree decl)
4467 if (!potential_nondependent_constant_expression (t))
4469 if (TREE_OVERFLOW_P (t))
4471 t = build_nop (TREE_TYPE (t), t);
4472 TREE_CONSTANT (t) = false;
4477 r = cxx_eval_outermost_constant_expr (t, true, true, decl);
4478 gcc_checking_assert (r == t
4479 || CONVERT_EXPR_P (t)
4480 || TREE_CODE (t) == VIEW_CONVERT_EXPR
4481 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
4482 || !cp_tree_equal (r, t));
4486 static GTY((deletable)) hash_map<tree, tree> *cv_cache;
4488 /* If T is a constant expression, returns its reduced value.
4489 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4490 Otherwise, returns a version of T without TREE_CONSTANT. */
4493 maybe_constant_value (tree t, tree decl)
4495 if (cv_cache == NULL)
4496 cv_cache = hash_map<tree, tree>::create_ggc (101);
4498 if (tree *cached = cv_cache->get (t))
4501 tree ret = maybe_constant_value_1 (t, decl);
4502 cv_cache->put (t, ret);
4506 /* Dispose of the whole CV_CACHE. */
4509 clear_cv_cache (void)
4511 if (cv_cache != NULL)
4515 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4518 clear_cv_and_fold_caches (void)
4521 clear_fold_cache ();
4524 /* Like maybe_constant_value but first fully instantiate the argument.
4526 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4527 (t, tf_none) followed by maybe_constant_value but is more efficient,
4528 because calls instantiation_dependent_expression_p and
4529 potential_constant_expression at most once. */
4532 fold_non_dependent_expr (tree t)
4537 /* If we're in a template, but T isn't value dependent, simplify
4538 it. We're supposed to treat:
4540 template <typename T> void f(T[1 + 1]);
4541 template <typename T> void f(T[2]);
4543 as two declarations of the same function, for example. */
4544 if (processing_template_decl)
4546 if (potential_nondependent_constant_expression (t))
4548 processing_template_decl_sentinel s;
4549 t = instantiate_non_dependent_expr_internal (t, tf_none);
4551 if (type_unknown_p (t)
4552 || BRACE_ENCLOSED_INITIALIZER_P (t))
4554 if (TREE_OVERFLOW_P (t))
4556 t = build_nop (TREE_TYPE (t), t);
4557 TREE_CONSTANT (t) = false;
4562 tree r = cxx_eval_outermost_constant_expr (t, true, true, NULL_TREE);
4563 /* cp_tree_equal looks through NOPs, so allow them. */
4564 gcc_checking_assert (r == t
4565 || CONVERT_EXPR_P (t)
4566 || TREE_CODE (t) == VIEW_CONVERT_EXPR
4567 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
4568 || !cp_tree_equal (r, t));
4571 else if (TREE_OVERFLOW_P (t))
4573 t = build_nop (TREE_TYPE (t), t);
4574 TREE_CONSTANT (t) = false;
4579 return maybe_constant_value (t);
4582 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4583 than wrapped in a TARGET_EXPR. */
4586 maybe_constant_init (tree t, tree decl)
4590 if (TREE_CODE (t) == EXPR_STMT)
4591 t = TREE_OPERAND (t, 0);
4592 if (TREE_CODE (t) == CONVERT_EXPR
4593 && VOID_TYPE_P (TREE_TYPE (t)))
4594 t = TREE_OPERAND (t, 0);
4595 if (TREE_CODE (t) == INIT_EXPR)
4596 t = TREE_OPERAND (t, 1);
4597 if (!potential_nondependent_static_init_expression (t))
4598 /* Don't try to evaluate it. */;
4600 t = cxx_eval_outermost_constant_expr (t, true, false, decl);
4601 if (TREE_CODE (t) == TARGET_EXPR)
4603 tree init = TARGET_EXPR_INITIAL (t);
4604 if (TREE_CODE (init) == CONSTRUCTOR)
4611 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
4612 /* Return true if the object referred to by REF has automatic or thread
4615 enum { ck_ok, ck_bad, ck_unknown };
4617 check_automatic_or_tls (tree ref)
4620 HOST_WIDE_INT bitsize, bitpos;
4622 int volatilep = 0, unsignedp = 0;
4623 tree decl = get_inner_reference (ref, &bitsize, &bitpos, &offset,
4624 &mode, &unsignedp, &volatilep, false);
4627 /* If there isn't a decl in the middle, we don't know the linkage here,
4628 and this isn't a constant expression anyway. */
4631 dk = decl_storage_duration (decl);
4632 return (dk == dk_auto || dk == dk_thread) ? ck_bad : ck_ok;
4636 /* Return true if T denotes a potentially constant expression. Issue
4637 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
4638 an lvalue-rvalue conversion is implied.
4640 C++0x [expr.const] used to say
4642 6 An expression is a potential constant expression if it is
4643 a constant expression where all occurrences of function
4644 parameters are replaced by arbitrary constant expressions
4645 of the appropriate type.
4647 2 A conditional expression is a constant expression unless it
4648 involves one of the following as a potentially evaluated
4649 subexpression (3.2), but subexpressions of logical AND (5.14),
4650 logical OR (5.15), and conditional (5.16) operations that are
4651 not evaluated are not considered. */
4654 potential_constant_expression_1 (tree t, bool want_rval, bool strict,
4655 tsubst_flags_t flags)
4657 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
4658 enum { any = false, rval = true };
4662 if (t == error_mark_node)
4666 if (TREE_THIS_VOLATILE (t) && !DECL_P (t))
4668 if (flags & tf_error)
4669 error ("expression %qE has side-effects", t);
4672 if (CONSTANT_CLASS_P (t))
4675 switch (TREE_CODE (t))
4681 case TEMPLATE_ID_EXPR:
4684 case CASE_LABEL_EXPR:
4690 case TEMPLATE_PARM_INDEX:
4692 case IDENTIFIER_NODE:
4693 case USERDEF_LITERAL:
4694 /* We can see a FIELD_DECL in a pointer-to-member expression. */
4700 case PLACEHOLDER_EXPR:
4706 case AGGR_INIT_EXPR:
4708 /* -- an invocation of a function other than a constexpr function
4709 or a constexpr constructor. */
4711 tree fun = get_function_named_in_call (t);
4712 const int nargs = call_expr_nargs (t);
4715 if (fun == NULL_TREE)
4717 if (TREE_CODE (t) == CALL_EXPR
4718 && CALL_EXPR_FN (t) == NULL_TREE)
4719 switch (CALL_EXPR_IFN (t))
4721 /* These should be ignored, they are optimized away from
4722 constexpr functions. */
4723 case IFN_UBSAN_NULL:
4724 case IFN_UBSAN_BOUNDS:
4725 case IFN_UBSAN_VPTR:
4730 /* fold_call_expr can't do anything with IFN calls. */
4731 if (flags & tf_error)
4732 error_at (EXPR_LOC_OR_LOC (t, input_location),
4733 "call to internal function");
4736 if (is_overloaded_fn (fun))
4738 if (TREE_CODE (fun) == FUNCTION_DECL)
4740 if (builtin_valid_in_constant_expr_p (fun))
4742 if (!DECL_DECLARED_CONSTEXPR_P (fun)
4743 /* Allow any built-in function; if the expansion
4744 isn't constant, we'll deal with that then. */
4745 && !is_builtin_fn (fun))
4747 if (flags & tf_error)
4749 error_at (EXPR_LOC_OR_LOC (t, input_location),
4750 "call to non-constexpr function %qD", fun);
4751 explain_invalid_constexpr_fn (fun);
4755 /* A call to a non-static member function takes the address
4756 of the object as the first argument. But in a constant
4757 expression the address will be folded away, so look
4759 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
4760 && !DECL_CONSTRUCTOR_P (fun))
4762 tree x = get_nth_callarg (t, 0);
4763 if (is_this_parameter (x))
4765 else if (!RECUR (x, rval))
4772 if (!RECUR (fun, true))
4774 fun = get_first_fn (fun);
4776 /* Skip initial arguments to base constructors. */
4777 if (DECL_BASE_CONSTRUCTOR_P (fun))
4778 i = num_artificial_parms_for (fun);
4779 fun = DECL_ORIGIN (fun);
4783 if (RECUR (fun, rval))
4784 /* Might end up being a constant function pointer. */;
4788 for (; i < nargs; ++i)
4790 tree x = get_nth_callarg (t, i);
4791 /* In a template, reference arguments haven't been converted to
4792 REFERENCE_TYPE and we might not even know if the parameter
4793 is a reference, so accept lvalue constants too. */
4794 bool rv = processing_template_decl ? any : rval;
4801 case NON_LVALUE_EXPR:
4802 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
4803 -- an lvalue of integral type that refers to a non-volatile
4804 const variable or static data member initialized with
4805 constant expressions, or
4807 -- an lvalue of literal type that refers to non-volatile
4808 object defined with constexpr, or that refers to a
4809 sub-object of such an object; */
4810 return RECUR (TREE_OPERAND (t, 0), rval);
4814 && !decl_constant_var_p (t)
4816 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t))
4817 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t))
4818 && !var_in_constexpr_fn (t)
4819 && !type_dependent_expression_p (t))
4821 if (flags & tf_error)
4822 non_const_var_error (t);
4829 case VIEW_CONVERT_EXPR:
4830 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4831 may change to something more specific to type-punning (DR 1312). */
4833 tree from = TREE_OPERAND (t, 0);
4834 if (POINTER_TYPE_P (TREE_TYPE (t))
4835 && TREE_CODE (from) == INTEGER_CST
4836 && !integer_zerop (from))
4838 if (flags & tf_error)
4839 error_at (EXPR_LOC_OR_LOC (t, input_location),
4840 "reinterpret_cast from integer to pointer");
4843 return (RECUR (from, TREE_CODE (t) != VIEW_CONVERT_EXPR));
4847 /* -- a unary operator & that is applied to an lvalue that
4848 designates an object with thread or automatic storage
4850 t = TREE_OPERAND (t, 0);
4852 if (TREE_CODE (t) == OFFSET_REF && PTRMEM_OK_P (t))
4853 /* A pointer-to-member constant. */
4857 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4858 any checking here, as we might dereference the pointer later. If
4859 we remove this code, also remove check_automatic_or_tls. */
4860 i = check_automatic_or_tls (t);
4865 if (flags & tf_error)
4866 error ("address-of an object %qE with thread local or "
4867 "automatic storage is not a constant expression", t);
4871 return RECUR (t, any);
4877 /* -- a class member access unless its postfix-expression is
4878 of literal type or of pointer to literal type. */
4879 /* This test would be redundant, as it follows from the
4880 postfix-expression being a potential constant expression. */
4881 if (type_unknown_p (t))
4883 return RECUR (TREE_OPERAND (t, 0), want_rval);
4885 case EXPR_PACK_EXPANSION:
4886 return RECUR (PACK_EXPANSION_PATTERN (t), want_rval);
4890 tree x = TREE_OPERAND (t, 0);
4892 if (is_this_parameter (x))
4894 if (DECL_CONTEXT (x)
4895 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x)))
4897 if (flags & tf_error)
4898 error ("use of %<this%> in a constant expression");
4903 return RECUR (x, rval);
4906 case STATEMENT_LIST:
4908 tree_stmt_iterator i;
4909 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
4911 if (!RECUR (tsi_stmt (i), any))
4919 if (cxx_dialect < cxx14)
4921 if (!RECUR (TREE_OPERAND (t, 0), any))
4923 if (!RECUR (TREE_OPERAND (t, 1), rval))
4928 if (cxx_dialect < cxx14)
4930 if (!RECUR (TREE_OPERAND (t, 0), rval))
4932 if (!RECUR (TREE_OPERAND (t, 2), rval))
4937 if (!RECUR (DO_COND (t), rval))
4939 if (!RECUR (DO_BODY (t), any))
4944 if (!RECUR (FOR_INIT_STMT (t), any))
4946 if (!RECUR (FOR_COND (t), rval))
4948 if (!RECUR (FOR_EXPR (t), any))
4950 if (!RECUR (FOR_BODY (t), any))
4955 if (!RECUR (WHILE_COND (t), rval))
4957 if (!RECUR (WHILE_BODY (t), any))
4962 if (!RECUR (SWITCH_STMT_COND (t), rval))
4964 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
4965 unreachable labels would be checked. */
4969 return RECUR (STMT_EXPR_STMT (t), rval);
4972 case DYNAMIC_CAST_EXPR:
4973 case PSEUDO_DTOR_EXPR:
4977 case VEC_DELETE_EXPR:
4980 case OMP_ATOMIC_READ:
4981 case OMP_ATOMIC_CAPTURE_OLD:
4982 case OMP_ATOMIC_CAPTURE_NEW:
4983 /* GCC internal stuff. */
4986 case TRANSACTION_EXPR:
4988 case AT_ENCODE_EXPR:
4990 if (flags & tf_error)
4991 error ("expression %qE is not a constant-expression", t);
4995 /* -- a typeid expression whose operand is of polymorphic
4998 tree e = TREE_OPERAND (t, 0);
4999 if (!TYPE_P (e) && !type_dependent_expression_p (e)
5000 && TYPE_POLYMORPHIC_P (TREE_TYPE (e)))
5002 if (flags & tf_error)
5003 error ("typeid-expression is not a constant expression "
5004 "because %qE is of polymorphic type", e);
5023 case PREINCREMENT_EXPR:
5024 case POSTINCREMENT_EXPR:
5025 case PREDECREMENT_EXPR:
5026 case POSTDECREMENT_EXPR:
5027 if (cxx_dialect < cxx14)
5033 if (TYPE_P (TREE_OPERAND (t, 0)))
5035 /* else fall through. */
5041 case FIX_TRUNC_EXPR:
5045 case TRUTH_NOT_EXPR:
5046 case FIXED_CONVERT_EXPR:
5047 case UNARY_PLUS_EXPR:
5048 case UNARY_LEFT_FOLD_EXPR:
5049 case UNARY_RIGHT_FOLD_EXPR:
5051 return RECUR (TREE_OPERAND (t, 0), rval);
5054 case CONST_CAST_EXPR:
5055 case STATIC_CAST_EXPR:
5056 case REINTERPRET_CAST_EXPR:
5057 case IMPLICIT_CONV_EXPR:
5058 if (cxx_dialect < cxx11
5059 && !dependent_type_p (TREE_TYPE (t))
5060 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t)))
5061 /* In C++98, a conversion to non-integral type can't be part of a
5062 constant expression. */
5064 if (flags & tf_error)
5065 error ("cast to non-integral type %qT in a constant expression",
5070 return (RECUR (TREE_OPERAND (t, 0),
5071 TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE));
5074 return RECUR (BIND_EXPR_BODY (t), want_rval);
5076 case WITH_CLEANUP_EXPR:
5077 case CLEANUP_POINT_EXPR:
5078 case MUST_NOT_THROW_EXPR:
5079 case TRY_CATCH_EXPR:
5085 case NON_DEPENDENT_EXPR:
5086 /* For convenience. */
5090 return RECUR (TREE_OPERAND (t, 0), want_rval);
5092 case TRY_FINALLY_EXPR:
5093 return (RECUR (TREE_OPERAND (t, 0), want_rval)
5094 && RECUR (TREE_OPERAND (t, 1), any));
5097 return RECUR (TREE_OPERAND (t, 1), want_rval);
5100 if (!literal_type_p (TREE_TYPE (t)))
5102 if (flags & tf_error)
5104 error ("temporary of non-literal type %qT in a "
5105 "constant expression", TREE_TYPE (t));
5106 explain_non_literal_class (TREE_TYPE (t));
5111 return RECUR (TREE_OPERAND (t, 1), rval);
5115 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
5116 constructor_elt *ce;
5117 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
5118 if (!RECUR (ce->value, want_rval))
5125 gcc_assert (TREE_PURPOSE (t) == NULL_TREE
5126 || DECL_P (TREE_PURPOSE (t)));
5127 if (!RECUR (TREE_VALUE (t), want_rval))
5129 if (TREE_CHAIN (t) == NULL_TREE)
5131 return RECUR (TREE_CHAIN (t), want_rval);
5134 case TRUNC_DIV_EXPR:
5136 case FLOOR_DIV_EXPR:
5137 case ROUND_DIV_EXPR:
5138 case TRUNC_MOD_EXPR:
5140 case ROUND_MOD_EXPR:
5142 tree denom = TREE_OPERAND (t, 1);
5143 if (!RECUR (denom, rval))
5145 /* We can't call cxx_eval_outermost_constant_expr on an expression
5146 that hasn't been through instantiate_non_dependent_expr yet. */
5147 if (!processing_template_decl)
5148 denom = cxx_eval_outermost_constant_expr (denom, true);
5149 if (integer_zerop (denom))
5151 if (flags & tf_error)
5152 error ("division by zero is not a constant-expression");
5158 return RECUR (TREE_OPERAND (t, 0), want_rval);
5164 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5165 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5166 introduced by build_call_a. */
5167 tree op0 = TREE_OPERAND (t, 0);
5168 tree op1 = TREE_OPERAND (t, 1);
5170 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
5171 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
5172 return RECUR (op0, want_rval);
5177 /* If the first operand is the non-short-circuit constant, look at
5178 the second operand; otherwise we only care about the first one for
5180 case TRUTH_AND_EXPR:
5181 case TRUTH_ANDIF_EXPR:
5182 tmp = boolean_true_node;
5185 case TRUTH_ORIF_EXPR:
5186 tmp = boolean_false_node;
5189 tree op = TREE_OPERAND (t, 0);
5190 if (!RECUR (op, rval))
5192 if (!processing_template_decl)
5193 op = cxx_eval_outermost_constant_expr (op, true);
5194 if (tree_int_cst_equal (op, tmp))
5195 return RECUR (TREE_OPERAND (t, 1), rval);
5202 case POINTER_PLUS_EXPR:
5204 case EXACT_DIV_EXPR:
5214 case TRUTH_XOR_EXPR:
5215 case UNORDERED_EXPR:
5228 case ARRAY_RANGE_REF:
5232 case BINARY_LEFT_FOLD_EXPR:
5233 case BINARY_RIGHT_FOLD_EXPR:
5235 for (i = 0; i < 2; ++i)
5236 if (!RECUR (TREE_OPERAND (t, i), want_rval))
5240 case CILK_SYNC_STMT:
5241 case CILK_SPAWN_STMT:
5242 case ARRAY_NOTATION_REF:
5247 for (i = 0; i < 3; ++i)
5248 if (!RECUR (TREE_OPERAND (t, i), true))
5253 if (COND_EXPR_IS_VEC_DELETE (t))
5255 if (flags & tf_error)
5256 error_at (location_of (t),
5257 "%<delete[]%> is not a constant-expression");
5263 /* If the condition is a known constant, we know which of the legs we
5264 care about; otherwise we only require that the condition and
5265 either of the legs be potentially constant. */
5266 tmp = TREE_OPERAND (t, 0);
5267 if (!RECUR (tmp, rval))
5269 if (!processing_template_decl)
5270 tmp = cxx_eval_outermost_constant_expr (tmp, true);
5271 if (integer_zerop (tmp))
5272 return RECUR (TREE_OPERAND (t, 2), want_rval);
5273 else if (TREE_CODE (tmp) == INTEGER_CST)
5274 return RECUR (TREE_OPERAND (t, 1), want_rval);
5275 for (i = 1; i < 3; ++i)
5276 if (potential_constant_expression_1 (TREE_OPERAND (t, i),
5277 want_rval, strict, tf_none))
5279 if (flags & tf_error)
5280 error ("expression %qE is not a constant-expression", t);
5284 if (VEC_INIT_EXPR_IS_CONSTEXPR (t))
5286 if (flags & tf_error)
5288 error ("non-constant array initialization");
5289 diagnose_non_constexpr_vec_init (t);
5295 /* We can see these in statement-expressions. */
5299 case EMPTY_CLASS_EXPR:
5304 tree *target = &TREE_OPERAND (t, 0);
5305 /* Gotos representing break and continue are OK. */
5306 if (breaks (target) || continues (target))
5308 if (flags & tf_error)
5309 error ("%<goto%> is not a constant-expression");
5314 if (objc_is_property_ref (t))
5317 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t)));
5324 /* The main entry point to the above. */
5327 potential_constant_expression (tree t)
5329 return potential_constant_expression_1 (t, false, true, tf_none);
5333 potential_static_init_expression (tree t)
5335 return potential_constant_expression_1 (t, false, false, tf_none);
5338 /* As above, but require a constant rvalue. */
5341 potential_rvalue_constant_expression (tree t)
5343 return potential_constant_expression_1 (t, true, true, tf_none);
5346 /* Like above, but complain about non-constant expressions. */
5349 require_potential_constant_expression (tree t)
5351 return potential_constant_expression_1 (t, false, true, tf_warning_or_error);
5354 /* Cross product of the above. */
5357 require_potential_rvalue_constant_expression (tree t)
5359 return potential_constant_expression_1 (t, true, true, tf_warning_or_error);
5362 /* Returns true if T is a potential constant expression that is not
5363 instantiation-dependent, and therefore a candidate for constant folding even
5367 potential_nondependent_constant_expression (tree t)
5369 return (!type_unknown_p (t)
5370 && !BRACE_ENCLOSED_INITIALIZER_P (t)
5371 && potential_constant_expression (t)
5372 && !instantiation_dependent_expression_p (t));
5375 /* Returns true if T is a potential static initializer expression that is not
5376 instantiation-dependent. */
5379 potential_nondependent_static_init_expression (tree t)
5381 return (!type_unknown_p (t)
5382 && !BRACE_ENCLOSED_INITIALIZER_P (t)
5383 && potential_static_init_expression (t)
5384 && !instantiation_dependent_expression_p (t));
5387 /* Finalize constexpr processing after parsing. */
5390 fini_constexpr (void)
5392 /* The contexpr call and fundef copies tables are no longer needed. */
5393 constexpr_call_table = NULL;
5394 fundef_copies_table = NULL;
5397 #include "gt-cp-constexpr.h"