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),
444 case STATEMENT_LIST_END:
452 /* Make sure that there are no statements after LAST in the constructor
453 body represented by LIST. */
456 check_constexpr_ctor_body (tree last, tree list, bool complain)
458 /* C++14 doesn't require a constexpr ctor to have an empty body. */
459 if (cxx_dialect >= cxx14)
463 if (TREE_CODE (list) == STATEMENT_LIST)
465 tree_stmt_iterator i = tsi_last (list);
466 for (; !tsi_end_p (i); tsi_prev (&i))
468 tree t = tsi_stmt (i);
471 if (!check_constexpr_ctor_body_1 (last, t))
478 else if (list != last
479 && !check_constexpr_ctor_body_1 (last, list))
484 error ("constexpr constructor does not have empty body");
485 DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
490 /* V is a vector of constructor elements built up for the base and member
491 initializers of a constructor for TYPE. They need to be in increasing
492 offset order, which they might not be yet if TYPE has a primary base
493 which is not first in the base-clause or a vptr and at least one base
494 all of which are non-primary. */
496 static vec<constructor_elt, va_gc> *
497 sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
499 tree pri = CLASSTYPE_PRIMARY_BINFO (type);
505 field_type = BINFO_TYPE (pri);
506 else if (TYPE_CONTAINS_VPTR_P (type))
507 field_type = vtbl_ptr_type_node;
511 /* Find the element for the primary base or vptr and move it to the
512 beginning of the vec. */
513 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
514 if (TREE_TYPE (ce->index) == field_type)
517 if (i > 0 && i < vec_safe_length (v))
519 vec<constructor_elt, va_gc> &vref = *v;
520 constructor_elt elt = vref[i];
529 /* Build compile-time evalable representations of member-initializer list
530 for a constexpr constructor. */
533 build_constexpr_constructor_member_initializers (tree type, tree body)
535 vec<constructor_elt, va_gc> *vec = NULL;
538 switch (TREE_CODE (body))
540 case MUST_NOT_THROW_EXPR:
542 body = TREE_OPERAND (body, 0);
546 for (tree_stmt_iterator i = tsi_start (body);
547 !tsi_end_p (i); tsi_next (&i))
550 if (TREE_CODE (body) == BIND_EXPR)
556 body = BIND_EXPR_BODY (body);
559 case STATEMENT_LIST_END:
566 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
568 body = TREE_OPERAND (body, 0);
569 if (TREE_CODE (body) == EXPR_STMT)
570 body = TREE_OPERAND (body, 0);
571 if (TREE_CODE (body) == INIT_EXPR
572 && (same_type_ignoring_top_level_qualifiers_p
573 (TREE_TYPE (TREE_OPERAND (body, 0)),
574 current_class_type)))
577 return TREE_OPERAND (body, 1);
579 ok = build_data_member_initialization (body, &vec);
581 else if (TREE_CODE (body) == STATEMENT_LIST)
583 tree_stmt_iterator i;
584 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
586 ok = build_data_member_initialization (tsi_stmt (i), &vec);
591 else if (TREE_CODE (body) == TRY_BLOCK)
593 error ("body of %<constexpr%> constructor cannot be "
594 "a function-try-block");
595 return error_mark_node;
597 else if (EXPR_P (body))
598 ok = build_data_member_initialization (body, &vec);
600 gcc_assert (errorcount > 0);
603 if (vec_safe_length (vec) > 0)
605 /* In a delegating constructor, return the target. */
606 constructor_elt *ce = &(*vec)[0];
607 if (ce->index == current_class_ptr)
614 vec = sort_constexpr_mem_initializers (type, vec);
615 return build_constructor (type, vec);
618 return error_mark_node;
621 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
622 declared to be constexpr, or a sub-statement thereof. Returns the
623 return value if suitable, error_mark_node for a statement not allowed in
624 a constexpr function, or NULL_TREE if no return value was found. */
627 constexpr_fn_retval (tree body)
629 switch (TREE_CODE (body))
633 tree_stmt_iterator i;
634 tree expr = NULL_TREE;
635 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
637 tree s = constexpr_fn_retval (tsi_stmt (i));
638 if (s == error_mark_node)
639 return error_mark_node;
640 else if (s == NULL_TREE)
641 /* Keep iterating. */;
643 /* Multiple return statements. */
644 return error_mark_node;
652 return break_out_target_exprs (TREE_OPERAND (body, 0));
656 tree decl = DECL_EXPR_DECL (body);
657 if (TREE_CODE (decl) == USING_DECL
658 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
659 || DECL_ARTIFICIAL (decl))
661 return error_mark_node;
664 case CLEANUP_POINT_EXPR:
665 return constexpr_fn_retval (TREE_OPERAND (body, 0));
668 if (!check_constexpr_bind_expr_vars (body))
669 return error_mark_node;
670 return constexpr_fn_retval (BIND_EXPR_BODY (body));
673 case STATEMENT_LIST_END:
677 return error_mark_node;
681 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
682 FUN; do the necessary transformations to turn it into a single expression
683 that we can store in the hash table. */
686 massage_constexpr_body (tree fun, tree body)
688 if (DECL_CONSTRUCTOR_P (fun))
689 body = build_constexpr_constructor_member_initializers
690 (DECL_CONTEXT (fun), body);
691 else if (cxx_dialect < cxx14)
693 if (TREE_CODE (body) == EH_SPEC_BLOCK)
694 body = EH_SPEC_STMTS (body);
695 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
696 body = TREE_OPERAND (body, 0);
697 body = constexpr_fn_retval (body);
702 /* FUN is a constexpr constructor with massaged body BODY. Return true
703 if some bases/fields are uninitialized, and complain if COMPLAIN. */
706 cx_check_missing_mem_inits (tree fun, tree body, bool complain)
713 if (TREE_CODE (body) != CONSTRUCTOR)
716 nelts = CONSTRUCTOR_NELTS (body);
717 ctype = DECL_CONTEXT (fun);
718 field = TYPE_FIELDS (ctype);
720 if (TREE_CODE (ctype) == UNION_TYPE)
722 if (nelts == 0 && next_initializable_field (field))
725 error ("%<constexpr%> constructor for union %qT must "
726 "initialize exactly one non-static data member", ctype);
733 for (i = 0; i <= nelts; ++i)
740 index = CONSTRUCTOR_ELT (body, i)->index;
741 /* Skip base and vtable inits. */
742 if (TREE_CODE (index) != FIELD_DECL
743 || DECL_ARTIFICIAL (index))
746 for (; field != index; field = DECL_CHAIN (field))
749 if (TREE_CODE (field) != FIELD_DECL
750 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
751 || DECL_ARTIFICIAL (field))
753 ftype = strip_array_types (TREE_TYPE (field));
754 if (type_has_constexpr_default_constructor (ftype))
756 /* It's OK to skip a member with a trivial constexpr ctor.
757 A constexpr ctor that isn't trivial should have been
759 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
765 error ("member %qD must be initialized by mem-initializer "
766 "in %<constexpr%> constructor", field);
767 inform (DECL_SOURCE_LOCATION (field), "declared here");
770 if (field == NULL_TREE)
772 field = DECL_CHAIN (field);
778 /* We are processing the definition of the constexpr function FUN.
779 Check that its BODY fulfills the propriate requirements and
780 enter it in the constexpr function definition table.
781 For constructor BODY is actually the TREE_LIST of the
782 member-initializer list. */
785 register_constexpr_fundef (tree fun, tree body)
787 constexpr_fundef entry;
788 constexpr_fundef **slot;
790 if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
793 tree massaged = massage_constexpr_body (fun, body);
794 if (massaged == NULL_TREE || massaged == error_mark_node)
796 if (!DECL_CONSTRUCTOR_P (fun))
797 error ("body of constexpr function %qD not a return-statement", fun);
801 if (!potential_rvalue_constant_expression (massaged))
803 if (!DECL_GENERATED_P (fun))
804 require_potential_rvalue_constant_expression (massaged);
808 if (DECL_CONSTRUCTOR_P (fun)
809 && cx_check_missing_mem_inits (fun, massaged, !DECL_GENERATED_P (fun)))
812 /* Create the constexpr function table if necessary. */
813 if (constexpr_fundef_table == NULL)
814 constexpr_fundef_table
815 = hash_table<constexpr_fundef_hasher>::create_ggc (101);
819 slot = constexpr_fundef_table->find_slot (&entry, INSERT);
821 gcc_assert (*slot == NULL);
822 *slot = ggc_alloc<constexpr_fundef> ();
828 /* FUN is a non-constexpr function called in a context that requires a
829 constant expression. If it comes from a constexpr template, explain why
830 the instantiation isn't constexpr. */
833 explain_invalid_constexpr_fn (tree fun)
835 static hash_set<tree> *diagnosed;
838 /* Only diagnose defaulted functions or instantiations. */
839 if (!DECL_DEFAULTED_FN (fun)
840 && !is_instantiation_of_constexpr (fun))
842 if (diagnosed == NULL)
843 diagnosed = new hash_set<tree>;
844 if (diagnosed->add (fun))
845 /* Already explained. */
848 save_loc = input_location;
849 input_location = DECL_SOURCE_LOCATION (fun);
850 inform (input_location,
851 "%qD is not usable as a constexpr function because:", fun);
852 /* First check the declaration. */
853 if (is_valid_constexpr_fn (fun, true))
855 /* Then if it's OK, the body. */
856 if (!DECL_DECLARED_CONSTEXPR_P (fun))
857 explain_implicit_non_constexpr (fun);
860 body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
861 require_potential_rvalue_constant_expression (body);
862 if (DECL_CONSTRUCTOR_P (fun))
863 cx_check_missing_mem_inits (fun, body, true);
866 input_location = save_loc;
869 /* Objects of this type represent calls to constexpr functions
870 along with the bindings of parameters to their arguments, for
871 the purpose of compile time evaluation. */
873 struct GTY((for_user)) constexpr_call {
874 /* Description of the constexpr function definition. */
875 constexpr_fundef *fundef;
876 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
877 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
878 Note: This arrangement is made to accommodate the use of
879 iterative_hash_template_arg (see pt.c). If you change this
880 representation, also change the hash calculation in
881 cxx_eval_call_expression. */
883 /* Result of the call.
884 NULL means the call is being evaluated.
885 error_mark_node means that the evaluation was erroneous;
886 otherwise, the actuall value of the call. */
888 /* The hash of this call; we remember it here to avoid having to
889 recalculate it when expanding the hash table. */
893 struct constexpr_call_hasher : ggc_ptr_hash<constexpr_call>
895 static hashval_t hash (constexpr_call *);
896 static bool equal (constexpr_call *, constexpr_call *);
899 enum constexpr_switch_state {
900 /* Used when processing a switch for the first time by cxx_eval_switch_expr
901 and default: label for that switch has not been seen yet. */
902 css_default_not_seen,
903 /* Used when processing a switch for the first time by cxx_eval_switch_expr
904 and default: label for that switch has been seen already. */
906 /* Used when processing a switch for the second time by
907 cxx_eval_switch_expr, where default: label should match. */
908 css_default_processing
911 /* The constexpr expansion context. CALL is the current function
912 expansion, CTOR is the current aggregate initializer, OBJECT is the
913 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
914 is a map of values of variables initialized within the expression. */
916 struct constexpr_ctx {
917 /* The innermost call we're evaluating. */
918 constexpr_call *call;
919 /* Values for any temporaries or local variables within the
920 constant-expression. */
921 hash_map<tree,tree> *values;
922 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
923 aren't inside a loop. */
924 hash_set<tree> *save_exprs;
925 /* The CONSTRUCTOR we're currently building up for an aggregate
928 /* The object we're building the CONSTRUCTOR for. */
930 /* If inside SWITCH_EXPR. */
931 constexpr_switch_state *css_state;
932 /* Whether we should error on a non-constant expression or fail quietly. */
934 /* Whether we are strictly conforming to constant expression rules or
935 trying harder to get a constant value. */
939 /* A table of all constexpr calls that have been evaluated by the
940 compiler in this translation unit. */
942 static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
944 static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
945 bool, bool *, bool *, tree * = NULL);
947 /* Compute a hash value for a constexpr call representation. */
950 constexpr_call_hasher::hash (constexpr_call *info)
955 /* Return true if the objects pointed to by P and Q represent calls
956 to the same constexpr function with the same arguments.
957 Otherwise, return false. */
960 constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs)
966 if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef))
968 lhs_bindings = lhs->bindings;
969 rhs_bindings = rhs->bindings;
970 while (lhs_bindings != NULL && rhs_bindings != NULL)
972 tree lhs_arg = TREE_VALUE (lhs_bindings);
973 tree rhs_arg = TREE_VALUE (rhs_bindings);
974 gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
975 if (!cp_tree_equal (lhs_arg, rhs_arg))
977 lhs_bindings = TREE_CHAIN (lhs_bindings);
978 rhs_bindings = TREE_CHAIN (rhs_bindings);
980 return lhs_bindings == rhs_bindings;
983 /* Initialize the constexpr call table, if needed. */
986 maybe_initialize_constexpr_call_table (void)
988 if (constexpr_call_table == NULL)
989 constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101);
992 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
993 a function happens to get called recursively, we unshare the callee
994 function's body and evaluate this unshared copy instead of evaluating the
997 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
998 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
999 that's keyed off of the original FUNCTION_DECL and whose value is a
1000 TREE_LIST of this function's unused copies awaiting reuse.
1002 This is not GC-deletable to avoid GC affecting UID generation. */
1004 static GTY(()) hash_map<tree, tree> *fundef_copies_table;
1006 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1009 maybe_initialize_fundef_copies_table ()
1011 if (fundef_copies_table == NULL)
1012 fundef_copies_table = hash_map<tree,tree>::create_ggc (101);
1015 /* Reuse a copy or create a new unshared copy of the function FUN.
1016 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1017 is parms, TYPE is result. */
1020 get_fundef_copy (tree fun)
1022 maybe_initialize_fundef_copies_table ();
1026 tree *slot = &fundef_copies_table->get_or_insert (fun, &existed);
1030 /* There is no cached function available, or in use. We can use
1031 the function directly. That the slot is now created records
1032 that this function is now in use. */
1033 copy = build_tree_list (DECL_SAVED_TREE (fun), DECL_ARGUMENTS (fun));
1034 TREE_TYPE (copy) = DECL_RESULT (fun);
1036 else if (*slot == NULL_TREE)
1038 /* We've already used the function itself, so make a copy. */
1039 copy = build_tree_list (NULL, NULL);
1040 TREE_PURPOSE (copy) = copy_fn (fun, TREE_VALUE (copy), TREE_TYPE (copy));
1044 /* We have a cached function available. */
1046 *slot = TREE_CHAIN (copy);
1052 /* Save the copy COPY of function FUN for later reuse by
1053 get_fundef_copy(). By construction, there will always be an entry
1057 save_fundef_copy (tree fun, tree copy)
1059 tree *slot = fundef_copies_table->get (fun);
1060 TREE_CHAIN (copy) = *slot;
1064 /* We have an expression tree T that represents a call, either CALL_EXPR
1065 or AGGR_INIT_EXPR. If the call is lexically to a named function,
1066 retrun the _DECL for that function. */
1069 get_function_named_in_call (tree t)
1072 switch (TREE_CODE (t))
1075 fun = CALL_EXPR_FN (t);
1078 case AGGR_INIT_EXPR:
1079 fun = AGGR_INIT_EXPR_FN (t);
1086 if (fun && TREE_CODE (fun) == ADDR_EXPR
1087 && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
1088 fun = TREE_OPERAND (fun, 0);
1092 /* We have an expression tree T that represents a call, either CALL_EXPR
1093 or AGGR_INIT_EXPR. Return the Nth argument. */
1096 get_nth_callarg (tree t, int n)
1098 switch (TREE_CODE (t))
1101 return CALL_EXPR_ARG (t, n);
1103 case AGGR_INIT_EXPR:
1104 return AGGR_INIT_EXPR_ARG (t, n);
1112 /* Attempt to evaluate T which represents a call to a builtin function.
1113 We assume here that all builtin functions evaluate to scalar types
1114 represented by _CST nodes. */
1117 cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,
1119 bool *non_constant_p, bool *overflow_p)
1121 const int nargs = call_expr_nargs (t);
1122 tree *args = (tree *) alloca (nargs * sizeof (tree));
1126 /* Don't fold __builtin_constant_p within a constexpr function. */
1127 bool bi_const_p = (DECL_FUNCTION_CODE (fun) == BUILT_IN_CONSTANT_P);
1130 && current_function_decl
1131 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
1133 *non_constant_p = true;
1137 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1138 return constant false for a non-constant argument. */
1139 constexpr_ctx new_ctx = *ctx;
1140 new_ctx.quiet = true;
1141 bool dummy1 = false, dummy2 = false;
1142 for (i = 0; i < nargs; ++i)
1144 args[i] = cxx_eval_constant_expression (&new_ctx, CALL_EXPR_ARG (t, i),
1145 lval, &dummy1, &dummy2);
1147 /* For __built_in_constant_p, fold all expressions with constant values
1148 even if they aren't C++ constant-expressions. */
1149 args[i] = cp_fully_fold (args[i]);
1152 bool save_ffbcp = force_folding_builtin_constant_p;
1153 force_folding_builtin_constant_p = true;
1154 new_call = fold_build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
1155 CALL_EXPR_FN (t), nargs, args);
1156 /* Fold away the NOP_EXPR from fold_builtin_n. */
1157 new_call = fold (new_call);
1158 force_folding_builtin_constant_p = save_ffbcp;
1159 VERIFY_CONSTANT (new_call);
1163 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1164 the type of the value to match. */
1167 adjust_temp_type (tree type, tree temp)
1169 if (TREE_TYPE (temp) == type)
1171 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1172 if (TREE_CODE (temp) == CONSTRUCTOR)
1173 return build_constructor (type, CONSTRUCTOR_ELTS (temp));
1174 gcc_assert (scalarish_type_p (type));
1175 return cp_fold_convert (type, temp);
1178 /* Callback for walk_tree used by unshare_constructor. */
1181 find_constructor (tree *tp, int *walk_subtrees, void *)
1185 if (TREE_CODE (*tp) == CONSTRUCTOR)
1190 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1191 subexpression, return an unshared copy of T. Otherwise return T. */
1194 unshare_constructor (tree t)
1196 tree ctor = walk_tree (&t, find_constructor, NULL, NULL);
1197 if (ctor != NULL_TREE)
1198 return unshare_expr (t);
1202 /* Subroutine of cxx_eval_call_expression.
1203 We are processing a call expression (either CALL_EXPR or
1204 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1205 all arguments and bind their values to correspondings
1206 parameters, making up the NEW_CALL context. */
1209 cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
1210 constexpr_call *new_call,
1211 bool *non_constant_p, bool *overflow_p,
1212 bool *non_constant_args)
1214 const int nargs = call_expr_nargs (t);
1215 tree fun = new_call->fundef->decl;
1216 tree parms = DECL_ARGUMENTS (fun);
1218 tree *p = &new_call->bindings;
1219 for (i = 0; i < nargs; ++i)
1222 tree type = parms ? TREE_TYPE (parms) : void_type_node;
1223 x = get_nth_callarg (t, i);
1224 /* For member function, the first argument is a pointer to the implied
1225 object. For a constructor, it might still be a dummy object, in
1226 which case we get the real argument from ctx. */
1227 if (i == 0 && DECL_CONSTRUCTOR_P (fun)
1228 && is_dummy_object (x))
1231 x = cp_build_addr_expr (x, tf_warning_or_error);
1234 arg = cxx_eval_constant_expression (ctx, x, lval,
1235 non_constant_p, overflow_p);
1236 /* Don't VERIFY_CONSTANT here. */
1237 if (*non_constant_p && ctx->quiet)
1239 /* Just discard ellipsis args after checking their constantitude. */
1242 if (*non_constant_p)
1243 /* Don't try to adjust the type of non-constant args. */
1246 /* Make sure the binding has the same type as the parm. */
1247 if (TREE_CODE (type) != REFERENCE_TYPE)
1248 arg = adjust_temp_type (type, arg);
1249 if (!TREE_CONSTANT (arg))
1250 *non_constant_args = true;
1251 *p = build_tree_list (parms, arg);
1252 p = &TREE_CHAIN (*p);
1254 parms = TREE_CHAIN (parms);
1258 /* Variables and functions to manage constexpr call expansion context.
1259 These do not need to be marked for PCH or GC. */
1261 /* FIXME remember and print actual constant arguments. */
1262 static vec<tree> call_stack = vNULL;
1263 static int call_stack_tick;
1264 static int last_cx_error_tick;
1267 push_cx_call_context (tree call)
1270 if (!EXPR_HAS_LOCATION (call))
1271 SET_EXPR_LOCATION (call, input_location);
1272 call_stack.safe_push (call);
1273 if (call_stack.length () > (unsigned) max_constexpr_depth)
1279 pop_cx_call_context (void)
1286 cx_error_context (void)
1288 vec<tree> r = vNULL;
1289 if (call_stack_tick != last_cx_error_tick
1290 && !call_stack.is_empty ())
1292 last_cx_error_tick = call_stack_tick;
1296 /* Subroutine of cxx_eval_constant_expression.
1297 Evaluate the call expression tree T in the context of OLD_CALL expression
1301 cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
1303 bool *non_constant_p, bool *overflow_p)
1305 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1306 tree fun = get_function_named_in_call (t);
1307 constexpr_call new_call = { NULL, NULL, NULL, 0 };
1310 if (fun == NULL_TREE)
1311 switch (CALL_EXPR_IFN (t))
1313 case IFN_UBSAN_NULL:
1314 case IFN_UBSAN_BOUNDS:
1315 case IFN_UBSAN_VPTR:
1319 error_at (loc, "call to internal function");
1320 *non_constant_p = true;
1324 if (TREE_CODE (fun) != FUNCTION_DECL)
1326 /* Might be a constexpr function pointer. */
1327 fun = cxx_eval_constant_expression (ctx, fun,
1328 /*lval*/false, non_constant_p,
1331 if (TREE_CODE (fun) == ADDR_EXPR)
1332 fun = TREE_OPERAND (fun, 0);
1334 if (TREE_CODE (fun) != FUNCTION_DECL)
1336 if (!ctx->quiet && !*non_constant_p)
1337 error_at (loc, "expression %qE does not designate a constexpr "
1339 *non_constant_p = true;
1342 if (DECL_CLONED_FUNCTION_P (fun))
1343 fun = DECL_CLONED_FUNCTION (fun);
1345 if (is_ubsan_builtin_p (fun))
1348 if (is_builtin_fn (fun))
1349 return cxx_eval_builtin_function_call (ctx, t, fun,
1350 lval, non_constant_p, overflow_p);
1351 if (!DECL_DECLARED_CONSTEXPR_P (fun))
1355 error_at (loc, "call to non-constexpr function %qD", fun);
1356 explain_invalid_constexpr_fn (fun);
1358 *non_constant_p = true;
1362 constexpr_ctx new_ctx = *ctx;
1363 if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
1364 && TREE_CODE (t) == AGGR_INIT_EXPR)
1366 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1367 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1368 new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
1369 tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
1370 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true;
1371 ctx->values->put (new_ctx.object, ctor);
1375 /* Shortcut trivial constructor/op=. */
1376 if (trivial_fn_p (fun))
1378 tree init = NULL_TREE;
1379 if (call_expr_nargs (t) == 2)
1380 init = convert_from_reference (get_nth_callarg (t, 1));
1381 else if (TREE_CODE (t) == AGGR_INIT_EXPR
1382 && AGGR_INIT_ZERO_FIRST (t))
1383 init = build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false);
1386 tree op = get_nth_callarg (t, 0);
1387 if (is_dummy_object (op))
1390 op = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (op)), op);
1391 tree set = build2 (MODIFY_EXPR, TREE_TYPE (op), op, init);
1392 return cxx_eval_constant_expression (ctx, set, lval,
1393 non_constant_p, overflow_p);
1397 /* We can't defer instantiating the function any longer. */
1398 if (!DECL_INITIAL (fun)
1399 && DECL_TEMPLOID_INSTANTIATION (fun))
1402 instantiate_decl (fun, /*defer_ok*/false, /*expl_inst*/false);
1406 /* If in direct recursive call, optimize definition search. */
1407 if (ctx && ctx->call && ctx->call->fundef->decl == fun)
1408 new_call.fundef = ctx->call->fundef;
1411 new_call.fundef = retrieve_constexpr_fundef (fun);
1412 if (new_call.fundef == NULL || new_call.fundef->body == NULL
1413 || fun == current_function_decl)
1417 /* We need to check for current_function_decl here in case we're
1418 being called during cp_fold_function, because at that point
1419 DECL_INITIAL is set properly and we have a fundef but we
1420 haven't lowered invisirefs yet (c++/70344). */
1421 if (DECL_INITIAL (fun) == error_mark_node
1422 || fun == current_function_decl)
1423 error_at (loc, "%qD called in a constant expression before its "
1424 "definition is complete", fun);
1425 else if (DECL_INITIAL (fun))
1427 /* The definition of fun was somehow unsuitable. */
1428 error_at (loc, "%qD called in a constant expression", fun);
1429 explain_invalid_constexpr_fn (fun);
1432 error_at (loc, "%qD used before its definition", fun);
1434 *non_constant_p = true;
1439 bool non_constant_args = false;
1440 cxx_bind_parameters_in_call (ctx, t, &new_call,
1441 non_constant_p, overflow_p, &non_constant_args);
1442 if (*non_constant_p)
1445 depth_ok = push_cx_call_context (t);
1447 tree result = NULL_TREE;
1449 constexpr_call *entry = NULL;
1450 if (depth_ok && !non_constant_args)
1452 new_call.hash = iterative_hash_template_arg
1453 (new_call.bindings, constexpr_fundef_hasher::hash (new_call.fundef));
1455 /* If we have seen this call before, we are done. */
1456 maybe_initialize_constexpr_call_table ();
1457 constexpr_call **slot
1458 = constexpr_call_table->find_slot (&new_call, INSERT);
1462 /* We need to keep a pointer to the entry, not just the slot, as the
1463 slot can move in the call to cxx_eval_builtin_function_call. */
1464 *slot = entry = ggc_alloc<constexpr_call> ();
1467 /* Calls which are in progress have their result set to NULL
1468 so that we can detect circular dependencies. */
1469 else if (entry->result == NULL)
1472 error ("call has circular dependency");
1473 *non_constant_p = true;
1474 entry->result = result = error_mark_node;
1477 result = entry->result;
1483 error ("constexpr evaluation depth exceeds maximum of %d (use "
1484 "-fconstexpr-depth= to increase the maximum)",
1485 max_constexpr_depth);
1486 *non_constant_p = true;
1487 result = error_mark_node;
1491 if (result && result != error_mark_node)
1493 else if (!DECL_SAVED_TREE (fun))
1495 /* When at_eof >= 2, cgraph has started throwing away
1496 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1497 late code generation for VEC_INIT_EXPR, which needs to be
1498 completely reconsidered. */
1499 gcc_assert (at_eof >= 2 && ctx->quiet);
1500 *non_constant_p = true;
1504 tree body, parms, res;
1506 /* Reuse or create a new unshared copy of this function's body. */
1507 tree copy = get_fundef_copy (fun);
1508 body = TREE_PURPOSE (copy);
1509 parms = TREE_VALUE (copy);
1510 res = TREE_TYPE (copy);
1512 /* Associate the bindings with the remapped parms. */
1513 tree bound = new_call.bindings;
1514 tree remapped = parms;
1517 tree oparm = TREE_PURPOSE (bound);
1518 tree arg = TREE_VALUE (bound);
1519 gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm));
1520 /* Don't share a CONSTRUCTOR that might be changed. */
1521 arg = unshare_constructor (arg);
1522 ctx->values->put (remapped, arg);
1523 bound = TREE_CHAIN (bound);
1524 remapped = DECL_CHAIN (remapped);
1526 /* Add the RESULT_DECL to the values map, too. */
1527 tree slot = NULL_TREE;
1528 if (DECL_BY_REFERENCE (res))
1530 slot = AGGR_INIT_EXPR_SLOT (t);
1531 tree addr = build_address (slot);
1532 addr = build_nop (TREE_TYPE (res), addr);
1533 ctx->values->put (res, addr);
1534 ctx->values->put (slot, NULL_TREE);
1537 ctx->values->put (res, NULL_TREE);
1539 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1540 their values after the call. */
1541 constexpr_ctx ctx_with_save_exprs = *ctx;
1542 hash_set<tree> save_exprs;
1543 ctx_with_save_exprs.save_exprs = &save_exprs;
1545 tree jump_target = NULL_TREE;
1546 cxx_eval_constant_expression (&ctx_with_save_exprs, body,
1547 lval, non_constant_p, overflow_p,
1550 if (DECL_CONSTRUCTOR_P (fun))
1551 /* This can be null for a subobject constructor call, in
1552 which case what we care about is the initialization
1553 side-effects rather than the value. We could get at the
1554 value by evaluating *this, but we don't bother; there's
1555 no need to put such a call in the hash table. */
1556 result = lval ? ctx->object : ctx->ctor;
1557 else if (VOID_TYPE_P (TREE_TYPE (res)))
1561 result = *ctx->values->get (slot ? slot : res);
1562 if (result == NULL_TREE && !*non_constant_p)
1565 error ("constexpr call flows off the end "
1567 *non_constant_p = true;
1571 /* Forget the saved values of the callee's SAVE_EXPRs. */
1572 for (hash_set<tree>::iterator iter = save_exprs.begin();
1573 iter != save_exprs.end(); ++iter)
1574 ctx_with_save_exprs.values->remove (*iter);
1576 /* Remove the parms/result from the values map. Is it worth
1577 bothering to do this when the map itself is only live for
1578 one constexpr evaluation? If so, maybe also clear out
1579 other vars from call, maybe in BIND_EXPR handling? */
1580 ctx->values->remove (res);
1582 ctx->values->remove (slot);
1583 for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
1584 ctx->values->remove (parm);
1586 /* Make the unshared function copy we used available for re-use. */
1587 save_fundef_copy (fun, copy);
1590 if (result == error_mark_node)
1591 *non_constant_p = true;
1592 if (*non_constant_p || *overflow_p)
1593 result = error_mark_node;
1597 entry->result = result;
1600 pop_cx_call_context ();
1601 return unshare_constructor (result);
1604 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1607 reduced_constant_expression_p (tree t)
1609 switch (TREE_CODE (t))
1612 /* Even if we can't lower this yet, it's constant. */
1616 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1617 tree elt; unsigned HOST_WIDE_INT idx;
1618 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, elt)
1619 if (!reduced_constant_expression_p (elt))
1624 /* FIXME are we calling this too much? */
1625 return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
1629 /* Some expressions may have constant operands but are not constant
1630 themselves, such as 1/0. Call this function (or rather, the macro
1631 following it) to check for that condition.
1633 We only call this in places that require an arithmetic constant, not in
1634 places where we might have a non-constant expression that can be a
1635 component of a constant expression, such as the address of a constexpr
1636 variable that might be dereferenced later. */
1639 verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
1642 if (!*non_constant_p && !reduced_constant_expression_p (t))
1644 if (!allow_non_constant)
1645 error ("%q+E is not a constant expression", t);
1646 *non_constant_p = true;
1648 if (TREE_OVERFLOW_P (t))
1650 if (!allow_non_constant)
1652 permerror (input_location, "overflow in constant expression");
1653 /* If we're being permissive (and are in an enforcing
1654 context), ignore the overflow. */
1655 if (flag_permissive)
1656 return *non_constant_p;
1660 return *non_constant_p;
1663 /* Check whether the shift operation with code CODE and type TYPE on LHS
1664 and RHS is undefined. If it is, give an error with an explanation,
1665 and return true; return false otherwise. */
1668 cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx,
1669 enum tree_code code, tree type, tree lhs, tree rhs)
1671 if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR)
1672 || TREE_CODE (lhs) != INTEGER_CST
1673 || TREE_CODE (rhs) != INTEGER_CST)
1676 tree lhstype = TREE_TYPE (lhs);
1677 unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs));
1679 /* [expr.shift] The behavior is undefined if the right operand
1680 is negative, or greater than or equal to the length in bits
1681 of the promoted left operand. */
1682 if (tree_int_cst_sgn (rhs) == -1)
1685 permerror (loc, "right operand of shift expression %q+E is negative",
1686 build2_loc (loc, code, type, lhs, rhs));
1687 return (!flag_permissive || ctx->quiet);
1689 if (compare_tree_int (rhs, uprec) >= 0)
1692 permerror (loc, "right operand of shift expression %q+E is >= than "
1693 "the precision of the left operand",
1694 build2_loc (loc, code, type, lhs, rhs));
1695 return (!flag_permissive || ctx->quiet);
1698 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1699 if E1 has a signed type and non-negative value, and E1x2^E2 is
1700 representable in the corresponding unsigned type of the result type,
1701 then that value, converted to the result type, is the resulting value;
1702 otherwise, the behavior is undefined. */
1703 if (code == LSHIFT_EXPR && !TYPE_UNSIGNED (lhstype)
1704 && (cxx_dialect >= cxx11))
1706 if (tree_int_cst_sgn (lhs) == -1)
1710 "left operand of shift expression %q+E is negative",
1711 build2_loc (loc, code, type, lhs, rhs));
1712 return (!flag_permissive || ctx->quiet);
1714 /* For signed x << y the following:
1715 (unsigned) x >> ((prec (lhs) - 1) - y)
1716 if > 1, is undefined. The right-hand side of this formula
1717 is the highest bit of the LHS that can be set (starting from 0),
1718 so that the shift doesn't overflow. We then right-shift the LHS
1719 to see whether any other bit is set making the original shift
1720 undefined -- the result is not representable in the corresponding
1722 tree t = build_int_cst (unsigned_type_node, uprec - 1);
1723 t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs);
1724 tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs);
1725 t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t);
1726 if (tree_int_cst_lt (integer_one_node, t))
1729 permerror (loc, "shift expression %q+E overflows",
1730 build2_loc (loc, code, type, lhs, rhs));
1731 return (!flag_permissive || ctx->quiet);
1737 /* Subroutine of cxx_eval_constant_expression.
1738 Attempt to reduce the unary expression tree T to a compile time value.
1739 If successful, return the value. Otherwise issue a diagnostic
1740 and return error_mark_node. */
1743 cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
1745 bool *non_constant_p, bool *overflow_p)
1748 tree orig_arg = TREE_OPERAND (t, 0);
1749 tree arg = cxx_eval_constant_expression (ctx, orig_arg, /*lval*/false,
1750 non_constant_p, overflow_p);
1751 VERIFY_CONSTANT (arg);
1752 location_t loc = EXPR_LOCATION (t);
1753 enum tree_code code = TREE_CODE (t);
1754 tree type = TREE_TYPE (t);
1755 r = fold_unary_loc (loc, code, type, arg);
1758 if (arg == orig_arg)
1761 r = build1_loc (loc, code, type, arg);
1763 VERIFY_CONSTANT (r);
1767 /* Helper function for cxx_eval_binary_expression. Try to optimize
1768 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1769 generic folding should be used. */
1772 cxx_fold_pointer_plus_expression (const constexpr_ctx *ctx, tree t,
1773 tree lhs, tree rhs, bool *non_constant_p,
1777 if (TREE_CODE (lhs) != ADDR_EXPR)
1780 lhs = TREE_OPERAND (lhs, 0);
1782 /* &A[i] p+ j => &A[i + j] */
1783 if (TREE_CODE (lhs) == ARRAY_REF
1784 && TREE_CODE (TREE_OPERAND (lhs, 1)) == INTEGER_CST
1785 && TREE_CODE (rhs) == INTEGER_CST
1786 && TYPE_SIZE_UNIT (TREE_TYPE (lhs))
1787 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST)
1789 tree orig_type = TREE_TYPE (t);
1790 location_t loc = EXPR_LOCATION (t);
1791 tree type = TREE_TYPE (lhs);
1793 t = fold_convert_loc (loc, ssizetype, TREE_OPERAND (lhs, 1));
1794 tree nelts = array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs, 0)));
1795 nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
1797 if (*non_constant_p)
1799 /* Don't fold an out-of-bound access. */
1800 if (!tree_int_cst_le (t, nelts))
1802 rhs = cp_fold_convert (ssizetype, rhs);
1803 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1804 constexpr int A[1]; ... (char *)&A[0] + 1 */
1805 if (!integer_zerop (fold_build2_loc (loc, TRUNC_MOD_EXPR, sizetype,
1806 rhs, TYPE_SIZE_UNIT (type))))
1808 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1810 rhs = fold_build2_loc (loc, EXACT_DIV_EXPR, ssizetype, rhs,
1811 TYPE_SIZE_UNIT (type));
1812 t = size_binop_loc (loc, PLUS_EXPR, rhs, t);
1813 t = build4_loc (loc, ARRAY_REF, type, TREE_OPERAND (lhs, 0),
1814 t, NULL_TREE, NULL_TREE);
1815 t = cp_build_addr_expr (t, tf_warning_or_error);
1816 t = cp_fold_convert (orig_type, t);
1817 return cxx_eval_constant_expression (ctx, t, /*lval*/false,
1818 non_constant_p, overflow_p);
1824 /* Subroutine of cxx_eval_constant_expression.
1825 Like cxx_eval_unary_expression, except for binary expressions. */
1828 cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
1830 bool *non_constant_p, bool *overflow_p)
1833 tree orig_lhs = TREE_OPERAND (t, 0);
1834 tree orig_rhs = TREE_OPERAND (t, 1);
1836 lhs = cxx_eval_constant_expression (ctx, orig_lhs, /*lval*/false,
1837 non_constant_p, overflow_p);
1838 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
1840 if (*non_constant_p)
1842 rhs = cxx_eval_constant_expression (ctx, orig_rhs, /*lval*/false,
1843 non_constant_p, overflow_p);
1844 if (*non_constant_p)
1847 location_t loc = EXPR_LOCATION (t);
1848 enum tree_code code = TREE_CODE (t);
1849 tree type = TREE_TYPE (t);
1851 if (code == EQ_EXPR || code == NE_EXPR)
1853 bool is_code_eq = (code == EQ_EXPR);
1855 if (TREE_CODE (lhs) == PTRMEM_CST
1856 && TREE_CODE (rhs) == PTRMEM_CST)
1857 r = constant_boolean_node (cp_tree_equal (lhs, rhs) == is_code_eq,
1859 else if ((TREE_CODE (lhs) == PTRMEM_CST
1860 || TREE_CODE (rhs) == PTRMEM_CST)
1861 && (null_member_pointer_value_p (lhs)
1862 || null_member_pointer_value_p (rhs)))
1863 r = constant_boolean_node (!is_code_eq, type);
1864 else if (TREE_CODE (lhs) == PTRMEM_CST)
1865 lhs = cplus_expand_constant (lhs);
1866 else if (TREE_CODE (rhs) == PTRMEM_CST)
1867 rhs = cplus_expand_constant (rhs);
1869 else if (code == POINTER_PLUS_EXPR)
1870 r = cxx_fold_pointer_plus_expression (ctx, t, lhs, rhs, non_constant_p,
1874 r = fold_binary_loc (loc, code, type, lhs, rhs);
1878 if (lhs == orig_lhs && rhs == orig_rhs)
1881 r = build2_loc (loc, code, type, lhs, rhs);
1883 else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs))
1884 *non_constant_p = true;
1885 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1886 a local array in a constexpr function. */
1887 bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs));
1889 VERIFY_CONSTANT (r);
1893 /* Subroutine of cxx_eval_constant_expression.
1894 Attempt to evaluate condition expressions. Dead branches are not
1898 cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
1900 bool *non_constant_p, bool *overflow_p,
1903 tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
1905 non_constant_p, overflow_p);
1906 VERIFY_CONSTANT (val);
1907 /* Don't VERIFY_CONSTANT the other operands. */
1908 if (integer_zerop (val))
1909 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
1911 non_constant_p, overflow_p,
1913 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
1915 non_constant_p, overflow_p,
1919 /* Returns less than, equal to, or greater than zero if KEY is found to be
1920 less than, to match, or to be greater than the constructor_elt's INDEX. */
1923 array_index_cmp (tree key, tree index)
1925 gcc_assert (TREE_CODE (key) == INTEGER_CST);
1927 switch (TREE_CODE (index))
1930 return tree_int_cst_compare (key, index);
1933 tree lo = TREE_OPERAND (index, 0);
1934 tree hi = TREE_OPERAND (index, 1);
1935 if (tree_int_cst_lt (key, lo))
1937 else if (tree_int_cst_lt (hi, key))
1947 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
1948 if none. If INSERT is true, insert a matching element rather than fail. */
1950 static HOST_WIDE_INT
1951 find_array_ctor_elt (tree ary, tree dindex, bool insert = false)
1953 if (tree_int_cst_sgn (dindex) < 0)
1956 unsigned HOST_WIDE_INT i = tree_to_uhwi (dindex);
1957 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ary);
1958 unsigned HOST_WIDE_INT len = vec_safe_length (elts);
1960 unsigned HOST_WIDE_INT end = len;
1961 unsigned HOST_WIDE_INT begin = 0;
1963 /* If the last element of the CONSTRUCTOR has its own index, we can assume
1964 that the same is true of the other elements and index directly. */
1967 tree cindex = (*elts)[end-1].index;
1968 if (TREE_CODE (cindex) == INTEGER_CST
1969 && compare_tree_int (cindex, end-1) == 0)
1978 /* Otherwise, find a matching index by means of a binary search. */
1979 while (begin != end)
1981 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
1982 constructor_elt &elt = (*elts)[middle];
1983 tree idx = elt.index;
1985 int cmp = array_index_cmp (dindex, idx);
1992 if (insert && TREE_CODE (idx) == RANGE_EXPR)
1994 /* We need to split the range. */
1996 tree lo = TREE_OPERAND (idx, 0);
1997 tree hi = TREE_OPERAND (idx, 1);
1998 if (tree_int_cst_lt (lo, dindex))
2000 /* There are still some lower elts; shorten the range. */
2001 tree new_hi = int_const_binop (MINUS_EXPR, dindex,
2003 if (tree_int_cst_equal (lo, new_hi))
2004 /* Only one element left, no longer a range. */
2007 TREE_OPERAND (idx, 1) = new_hi;
2008 /* Append the element we want to insert. */
2011 e.value = unshare_constructor (elt.value);
2012 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle, e);
2015 /* No lower elts, the range elt is now ours. */
2018 if (tree_int_cst_lt (dindex, hi))
2020 /* There are still some higher elts; append a range. */
2021 tree new_lo = int_const_binop (PLUS_EXPR, dindex,
2023 if (tree_int_cst_equal (new_lo, hi))
2026 e.index = build2 (RANGE_EXPR, sizetype, new_lo, hi);
2027 e.value = unshare_constructor (elt.value);
2028 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle+1, e);
2037 constructor_elt e = { dindex, NULL_TREE };
2038 vec_safe_insert (CONSTRUCTOR_ELTS (ary), end, e);
2045 /* Under the control of CTX, issue a detailed diagnostic for
2046 an out-of-bounds subscript INDEX into the expression ARRAY. */
2049 diag_array_subscript (const constexpr_ctx *ctx, tree array, tree index)
2053 tree arraytype = TREE_TYPE (array);
2055 /* Convert the unsigned array subscript to a signed integer to avoid
2056 printing huge numbers for small negative values. */
2057 tree sidx = fold_convert (ssizetype, index);
2060 error ("array subscript value %qE is outside the bounds "
2061 "of array %qD of type %qT", sidx, array, arraytype);
2062 inform (DECL_SOURCE_LOCATION (array), "declared here");
2065 error ("array subscript value %qE is outside the bounds "
2066 "of array type %qT", sidx, arraytype);
2070 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2071 STRING_CST STRING. */
2074 extract_string_elt (tree string, unsigned chars_per_elt, unsigned index)
2076 tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (string)));
2079 if (chars_per_elt == 1)
2080 r = build_int_cst (type, TREE_STRING_POINTER (string)[index]);
2083 const unsigned char *ptr
2084 = ((const unsigned char *)TREE_STRING_POINTER (string)
2085 + index * chars_per_elt);
2086 r = native_interpret_expr (type, ptr, chars_per_elt);
2091 /* Subroutine of cxx_eval_constant_expression.
2092 Attempt to reduce a reference to an array slot. */
2095 cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
2097 bool *non_constant_p, bool *overflow_p)
2099 tree oldary = TREE_OPERAND (t, 0);
2100 tree ary = cxx_eval_constant_expression (ctx, oldary,
2102 non_constant_p, overflow_p);
2106 unsigned len, elem_nchars = 1;
2107 if (*non_constant_p)
2109 oldidx = TREE_OPERAND (t, 1);
2110 index = cxx_eval_constant_expression (ctx, oldidx,
2112 non_constant_p, overflow_p);
2113 VERIFY_CONSTANT (index);
2114 if (lval && ary == oldary && index == oldidx)
2117 return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
2118 elem_type = TREE_TYPE (TREE_TYPE (ary));
2119 if (TREE_CODE (ary) == CONSTRUCTOR)
2120 len = CONSTRUCTOR_NELTS (ary);
2121 else if (TREE_CODE (ary) == STRING_CST)
2123 elem_nchars = (TYPE_PRECISION (elem_type)
2124 / TYPE_PRECISION (char_type_node));
2125 len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
2129 /* We can't do anything with other tree codes, so use
2130 VERIFY_CONSTANT to complain and fail. */
2131 VERIFY_CONSTANT (ary);
2135 if (!tree_fits_shwi_p (index)
2136 || (i = tree_to_shwi (index)) < 0)
2138 diag_array_subscript (ctx, ary, index);
2139 *non_constant_p = true;
2143 tree nelts = array_type_nelts_top (TREE_TYPE (ary));
2144 /* For VLAs, the number of elements won't be an integer constant. */
2145 nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
2147 VERIFY_CONSTANT (nelts);
2148 if (!tree_int_cst_lt (index, nelts))
2150 diag_array_subscript (ctx, ary, index);
2151 *non_constant_p = true;
2156 if (TREE_CODE (ary) == CONSTRUCTOR)
2158 HOST_WIDE_INT ix = find_array_ctor_elt (ary, index);
2169 if (TREE_CODE (ary) == CONSTRUCTOR)
2170 r = (*CONSTRUCTOR_ELTS (ary))[i].value;
2172 r = extract_string_elt (ary, elem_nchars, i);
2175 /* Don't VERIFY_CONSTANT here. */
2178 /* Otherwise the element doesn't have a value yet. */
2183 if (TREE_CODE (ary) == CONSTRUCTOR
2184 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary))
2186 /* 'ary' is part of the aggregate initializer we're currently
2187 building; if there's no initializer for this element yet,
2190 error ("accessing uninitialized array element");
2191 *non_constant_p = true;
2195 /* If it's within the array bounds but doesn't have an explicit
2196 initializer, it's value-initialized. */
2197 tree val = build_value_init (elem_type, tf_warning_or_error);
2198 return cxx_eval_constant_expression (ctx, val, lval, non_constant_p,
2202 /* Subroutine of cxx_eval_constant_expression.
2203 Attempt to reduce a field access of a value of class type. */
2206 cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
2208 bool *non_constant_p, bool *overflow_p)
2210 unsigned HOST_WIDE_INT i;
2213 tree part = TREE_OPERAND (t, 1);
2214 tree orig_whole = TREE_OPERAND (t, 0);
2215 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2217 non_constant_p, overflow_p);
2218 if (TREE_CODE (whole) == PTRMEM_CST)
2219 whole = cplus_expand_constant (whole);
2220 if (whole == orig_whole)
2223 return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
2224 whole, part, NULL_TREE);
2225 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2227 if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
2230 error ("%qE is not a constant expression", orig_whole);
2231 *non_constant_p = true;
2233 if (DECL_MUTABLE_P (part))
2236 error ("mutable %qD is not usable in a constant expression", part);
2237 *non_constant_p = true;
2239 if (*non_constant_p)
2241 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2248 /* We're in the middle of initializing it. */
2252 if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
2253 && CONSTRUCTOR_NELTS (whole) > 0)
2255 /* DR 1188 says we don't have to deal with this. */
2257 error ("accessing %qD member instead of initialized %qD member in "
2258 "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
2259 *non_constant_p = true;
2263 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2264 classes never get represented; throw together a value now. */
2265 if (is_really_empty_class (TREE_TYPE (t)))
2266 return build_constructor (TREE_TYPE (t), NULL);
2268 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole))
2270 /* 'whole' is part of the aggregate initializer we're currently
2271 building; if there's no initializer for this member yet, that's an
2274 error ("accessing uninitialized member %qD", part);
2275 *non_constant_p = true;
2279 /* If there's no explicit init for this field, it's value-initialized. */
2280 value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
2281 return cxx_eval_constant_expression (ctx, value,
2283 non_constant_p, overflow_p);
2286 /* Subroutine of cxx_eval_constant_expression.
2287 Attempt to reduce a field access of a value of class type that is
2288 expressed as a BIT_FIELD_REF. */
2291 cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
2293 bool *non_constant_p, bool *overflow_p)
2295 tree orig_whole = TREE_OPERAND (t, 0);
2296 tree retval, fldval, utype, mask;
2297 bool fld_seen = false;
2298 HOST_WIDE_INT istart, isize;
2299 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2301 non_constant_p, overflow_p);
2302 tree start, field, value;
2303 unsigned HOST_WIDE_INT i;
2305 if (whole == orig_whole)
2307 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2309 if (!*non_constant_p
2310 && TREE_CODE (whole) != VECTOR_CST
2311 && TREE_CODE (whole) != CONSTRUCTOR)
2314 error ("%qE is not a constant expression", orig_whole);
2315 *non_constant_p = true;
2317 if (*non_constant_p)
2320 if (TREE_CODE (whole) == VECTOR_CST)
2321 return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
2322 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
2324 start = TREE_OPERAND (t, 2);
2325 istart = tree_to_shwi (start);
2326 isize = tree_to_shwi (TREE_OPERAND (t, 1));
2327 utype = TREE_TYPE (t);
2328 if (!TYPE_UNSIGNED (utype))
2329 utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
2330 retval = build_int_cst (utype, 0);
2331 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2333 tree bitpos = bit_position (field);
2334 if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
2336 if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
2337 && TREE_CODE (value) == INTEGER_CST
2338 && tree_fits_shwi_p (bitpos)
2339 && tree_fits_shwi_p (DECL_SIZE (field)))
2341 HOST_WIDE_INT bit = tree_to_shwi (bitpos);
2342 HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field));
2343 HOST_WIDE_INT shift;
2344 if (bit >= istart && bit + sz <= istart + isize)
2346 fldval = fold_convert (utype, value);
2347 mask = build_int_cst_type (utype, -1);
2348 mask = fold_build2 (LSHIFT_EXPR, utype, mask,
2349 size_int (TYPE_PRECISION (utype) - sz));
2350 mask = fold_build2 (RSHIFT_EXPR, utype, mask,
2351 size_int (TYPE_PRECISION (utype) - sz));
2352 fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
2353 shift = bit - istart;
2354 if (BYTES_BIG_ENDIAN)
2355 shift = TYPE_PRECISION (utype) - shift - sz;
2356 fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
2358 retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
2364 return fold_convert (TREE_TYPE (t), retval);
2366 return error_mark_node;
2369 /* Subroutine of cxx_eval_constant_expression.
2370 Evaluate a short-circuited logical expression T in the context
2371 of a given constexpr CALL. BAILOUT_VALUE is the value for
2372 early return. CONTINUE_VALUE is used here purely for
2373 sanity check purposes. */
2376 cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
2377 tree bailout_value, tree continue_value,
2379 bool *non_constant_p, bool *overflow_p)
2382 tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
2384 non_constant_p, overflow_p);
2385 VERIFY_CONSTANT (lhs);
2386 if (tree_int_cst_equal (lhs, bailout_value))
2388 gcc_assert (tree_int_cst_equal (lhs, continue_value));
2389 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
2390 lval, non_constant_p,
2392 VERIFY_CONSTANT (r);
2396 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2397 CONSTRUCTOR elements to initialize (part of) an object containing that
2398 field. Return a pointer to the constructor_elt corresponding to the
2399 initialization of the field. */
2401 static constructor_elt *
2402 base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
2404 tree aggr = TREE_OPERAND (ref, 0);
2405 tree field = TREE_OPERAND (ref, 1);
2407 constructor_elt *ce;
2409 gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
2411 if (TREE_CODE (aggr) == COMPONENT_REF)
2413 constructor_elt *base_ce
2414 = base_field_constructor_elt (v, aggr);
2415 v = CONSTRUCTOR_ELTS (base_ce->value);
2418 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
2419 if (ce->index == field)
2426 /* Some of the expressions fed to the constexpr mechanism are calls to
2427 constructors, which have type void. In that case, return the type being
2428 initialized by the constructor. */
2431 initialized_type (tree t)
2435 tree type = cv_unqualified (TREE_TYPE (t));
2436 if (TREE_CODE (t) == CALL_EXPR || TREE_CODE (t) == AGGR_INIT_EXPR)
2438 /* A constructor call has void type, so we need to look deeper. */
2439 tree fn = get_function_named_in_call (t);
2440 if (fn && TREE_CODE (fn) == FUNCTION_DECL
2441 && DECL_CXX_CONSTRUCTOR_P (fn))
2442 type = DECL_CONTEXT (fn);
2447 /* We're about to initialize element INDEX of an array or class from VALUE.
2448 Set up NEW_CTX appropriately by adjusting .object to refer to the
2449 subobject and creating a new CONSTRUCTOR if the element is itself
2450 a class or array. */
2453 init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
2454 tree index, tree &value)
2458 if (index && TREE_CODE (index) != INTEGER_CST
2459 && TREE_CODE (index) != FIELD_DECL)
2460 /* This won't have an element in the new CONSTRUCTOR. */
2463 tree type = initialized_type (value);
2464 if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type))
2465 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2468 /* The sub-aggregate initializer might contain a placeholder;
2469 update object to refer to the subobject and ctor to refer to
2470 the (newly created) sub-initializer. */
2472 new_ctx.object = build_ctor_subob_ref (index, type, ctx->object);
2473 tree elt = build_constructor (type, NULL);
2474 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt) = true;
2477 if (TREE_CODE (value) == TARGET_EXPR)
2478 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2479 value = TARGET_EXPR_INITIAL (value);
2482 /* We're about to process an initializer for a class or array TYPE. Make
2483 sure that CTX is set up appropriately. */
2486 verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
2488 /* We don't bother building a ctor for an empty base subobject. */
2489 if (is_empty_class (type))
2492 /* We're in the middle of an initializer that might involve placeholders;
2493 our caller should have created a CONSTRUCTOR for us to put the
2494 initializer into. We will either return that constructor or T. */
2495 gcc_assert (ctx->ctor);
2496 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2497 (type, TREE_TYPE (ctx->ctor)));
2498 /* We used to check that ctx->ctor was empty, but that isn't the case when
2499 the object is zero-initialized before calling the constructor. */
2501 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2502 (type, TREE_TYPE (ctx->object)));
2503 gcc_assert (!ctx->object || !DECL_P (ctx->object)
2504 || *(ctx->values->get (ctx->object)) == ctx->ctor);
2507 /* Subroutine of cxx_eval_constant_expression.
2508 The expression tree T denotes a C-style array or a C-style
2509 aggregate. Reduce it to a constant expression. */
2512 cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
2514 bool *non_constant_p, bool *overflow_p)
2516 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
2517 bool changed = false;
2518 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
2519 tree type = TREE_TYPE (t);
2521 constexpr_ctx new_ctx;
2522 if (TYPE_PTRMEMFUNC_P (type) || VECTOR_TYPE_P (type))
2524 /* We don't really need the ctx->ctor business for a PMF or
2525 vector, but it's simpler to use the same code. */
2527 new_ctx.ctor = build_constructor (type, NULL);
2528 new_ctx.object = NULL_TREE;
2531 verify_ctor_sanity (ctx, type);
2532 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2533 vec_alloc (*p, vec_safe_length (v));
2537 bool constant_p = true;
2538 bool side_effects_p = false;
2539 FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value)
2541 tree orig_value = value;
2542 init_subob_ctx (ctx, new_ctx, index, value);
2543 if (new_ctx.ctor != ctx->ctor)
2544 /* If we built a new CONSTRUCTOR, attach it now so that other
2545 initializers can refer to it. */
2546 CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor);
2547 tree elt = cxx_eval_constant_expression (&new_ctx, value,
2549 non_constant_p, overflow_p);
2550 /* Don't VERIFY_CONSTANT here. */
2551 if (ctx->quiet && *non_constant_p)
2553 if (elt != orig_value)
2556 if (!TREE_CONSTANT (elt))
2558 if (TREE_SIDE_EFFECTS (elt))
2559 side_effects_p = true;
2560 if (index && TREE_CODE (index) == COMPONENT_REF)
2562 /* This is an initialization of a vfield inside a base
2563 subaggregate that we already initialized; push this
2564 initialization into the previous initialization. */
2565 constructor_elt *inner = base_field_constructor_elt (*p, index);
2570 && (TREE_CODE (index) == NOP_EXPR
2571 || TREE_CODE (index) == POINTER_PLUS_EXPR))
2573 /* This is an initializer for an empty base; now that we've
2574 checked that it's constant, we can ignore it. */
2575 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index))));
2578 else if (new_ctx.ctor != ctx->ctor)
2580 /* We appended this element above; update the value. */
2581 gcc_assert ((*p)->last().index == index);
2582 (*p)->last().value = elt;
2585 CONSTRUCTOR_APPEND_ELT (*p, index, elt);
2587 if (*non_constant_p || !changed)
2590 /* We're done building this CONSTRUCTOR, so now we can interpret an
2591 element without an explicit initializer as value-initialized. */
2592 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
2593 TREE_CONSTANT (t) = constant_p;
2594 TREE_SIDE_EFFECTS (t) = side_effects_p;
2595 if (VECTOR_TYPE_P (type))
2600 /* Subroutine of cxx_eval_constant_expression.
2601 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2602 initialization of a non-static data member of array type. Reduce it to a
2605 Note that apart from value-initialization (when VALUE_INIT is true),
2606 this is only intended to support value-initialization and the
2607 initializations done by defaulted constructors for classes with
2608 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2609 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2610 for the copy/move constructor. */
2613 cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
2614 bool value_init, bool lval,
2615 bool *non_constant_p, bool *overflow_p)
2617 tree elttype = TREE_TYPE (atype);
2618 unsigned HOST_WIDE_INT max = tree_to_uhwi (array_type_nelts_top (atype));
2619 verify_ctor_sanity (ctx, atype);
2620 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2621 vec_alloc (*p, max + 1);
2622 bool pre_init = false;
2623 unsigned HOST_WIDE_INT i;
2625 /* For the default constructor, build up a call to the default
2626 constructor of the element type. We only need to handle class types
2627 here, as for a constructor to be constexpr, all members must be
2628 initialized, which for a defaulted default constructor means they must
2629 be of a class type with a constexpr default constructor. */
2630 if (TREE_CODE (elttype) == ARRAY_TYPE)
2631 /* We only do this at the lowest level. */;
2632 else if (value_init)
2634 init = build_value_init (elttype, tf_warning_or_error);
2639 vec<tree, va_gc> *argvec = make_tree_vector ();
2640 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
2641 &argvec, elttype, LOOKUP_NORMAL,
2642 tf_warning_or_error);
2643 release_tree_vector (argvec);
2644 init = build_aggr_init_expr (TREE_TYPE (init), init);
2648 for (i = 0; i < max; ++i)
2650 tree idx = build_int_cst (size_type_node, i);
2653 constexpr_ctx new_ctx;
2654 init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype);
2655 if (new_ctx.ctor != ctx->ctor)
2656 CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor);
2657 if (TREE_CODE (elttype) == ARRAY_TYPE)
2659 /* A multidimensional array; recurse. */
2660 if (value_init || init == NULL_TREE)
2662 eltinit = NULL_TREE;
2666 eltinit = cp_build_array_ref (input_location, init, idx,
2667 tf_warning_or_error);
2668 eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
2670 non_constant_p, overflow_p);
2674 /* Initializing an element using value or default initialization
2675 we just pre-built above. */
2676 eltinit = cxx_eval_constant_expression (&new_ctx, init, lval,
2677 non_constant_p, overflow_p);
2682 /* Copying an element. */
2683 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2684 (atype, TREE_TYPE (init)));
2685 eltinit = cp_build_array_ref (input_location, init, idx,
2686 tf_warning_or_error);
2687 if (!real_lvalue_p (init))
2688 eltinit = move (eltinit);
2689 eltinit = force_rvalue (eltinit, tf_warning_or_error);
2690 eltinit = (cxx_eval_constant_expression
2691 (&new_ctx, eltinit, lval,
2692 non_constant_p, overflow_p));
2694 if (*non_constant_p && !ctx->quiet)
2696 if (new_ctx.ctor != ctx->ctor)
2698 /* We appended this element above; update the value. */
2699 gcc_assert ((*p)->last().index == idx);
2700 (*p)->last().value = eltinit;
2703 CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit);
2704 /* Reuse the result of cxx_eval_constant_expression call
2705 from the first iteration to all others if it is a constant
2706 initializer that doesn't require relocations. */
2709 && (initializer_constant_valid_p (eltinit, TREE_TYPE (eltinit))
2710 == null_pointer_node))
2712 if (new_ctx.ctor != ctx->ctor)
2713 eltinit = new_ctx.ctor;
2714 for (i = 1; i < max; ++i)
2716 idx = build_int_cst (size_type_node, i);
2717 CONSTRUCTOR_APPEND_ELT (*p, idx, unshare_constructor (eltinit));
2723 if (!*non_constant_p)
2726 CONSTRUCTOR_NO_IMPLICIT_ZERO (init) = false;
2732 cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
2734 bool *non_constant_p, bool *overflow_p)
2736 tree atype = TREE_TYPE (t);
2737 tree init = VEC_INIT_EXPR_INIT (t);
2738 tree r = cxx_eval_vec_init_1 (ctx, atype, init,
2739 VEC_INIT_EXPR_VALUE_INIT (t),
2740 lval, non_constant_p, overflow_p);
2741 if (*non_constant_p)
2747 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2748 match. We want to be less strict for simple *& folding; if we have a
2749 non-const temporary that we access through a const pointer, that should
2750 work. We handle this here rather than change fold_indirect_ref_1
2751 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2752 don't really make sense outside of constant expression evaluation. Also
2753 we want to allow folding to COMPONENT_REF, which could cause trouble
2754 with TBAA in fold_indirect_ref_1.
2756 Try to keep this function synced with fold_indirect_ref_1. */
2759 cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
2765 subtype = TREE_TYPE (sub);
2766 if (!POINTER_TYPE_P (subtype))
2769 if (TREE_CODE (sub) == ADDR_EXPR)
2771 tree op = TREE_OPERAND (sub, 0);
2772 tree optype = TREE_TYPE (op);
2774 /* *&CONST_DECL -> to the value of the const decl. */
2775 if (TREE_CODE (op) == CONST_DECL)
2776 return DECL_INITIAL (op);
2777 /* *&p => p; make sure to handle *&"str"[cst] here. */
2778 if (same_type_ignoring_top_level_qualifiers_p (optype, type)
2779 /* Also handle the case where the desired type is an array of unknown
2780 bounds because the variable has had its bounds deduced since the
2781 ADDR_EXPR was created. */
2782 || (TREE_CODE (type) == ARRAY_TYPE
2783 && TREE_CODE (optype) == ARRAY_TYPE
2784 && TYPE_DOMAIN (type) == NULL_TREE
2785 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype),
2788 tree fop = fold_read_from_constant_string (op);
2794 /* *(foo *)&fooarray => fooarray[0] */
2795 else if (TREE_CODE (optype) == ARRAY_TYPE
2796 && (same_type_ignoring_top_level_qualifiers_p
2797 (type, TREE_TYPE (optype))))
2799 tree type_domain = TYPE_DOMAIN (optype);
2800 tree min_val = size_zero_node;
2801 if (type_domain && TYPE_MIN_VALUE (type_domain))
2802 min_val = TYPE_MIN_VALUE (type_domain);
2803 return build4_loc (loc, ARRAY_REF, type, op, min_val,
2804 NULL_TREE, NULL_TREE);
2806 /* *(foo *)&complexfoo => __real__ complexfoo */
2807 else if (TREE_CODE (optype) == COMPLEX_TYPE
2808 && (same_type_ignoring_top_level_qualifiers_p
2809 (type, TREE_TYPE (optype))))
2810 return fold_build1_loc (loc, REALPART_EXPR, type, op);
2811 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2812 else if (VECTOR_TYPE_P (optype)
2813 && (same_type_ignoring_top_level_qualifiers_p
2814 (type, TREE_TYPE (optype))))
2816 tree part_width = TYPE_SIZE (type);
2817 tree index = bitsize_int (0);
2818 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
2820 /* Also handle conversion to an empty base class, which
2821 is represented with a NOP_EXPR. */
2822 else if (is_empty_class (type)
2823 && CLASS_TYPE_P (optype)
2824 && DERIVED_FROM_P (type, optype))
2829 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2830 else if (RECORD_OR_UNION_TYPE_P (optype))
2832 tree field = TYPE_FIELDS (optype);
2833 for (; field; field = DECL_CHAIN (field))
2834 if (TREE_CODE (field) == FIELD_DECL
2835 && integer_zerop (byte_position (field))
2836 && (same_type_ignoring_top_level_qualifiers_p
2837 (TREE_TYPE (field), type)))
2839 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
2844 else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
2845 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
2847 tree op00 = TREE_OPERAND (sub, 0);
2848 tree op01 = TREE_OPERAND (sub, 1);
2851 if (TREE_CODE (op00) == ADDR_EXPR)
2854 op00 = TREE_OPERAND (op00, 0);
2855 op00type = TREE_TYPE (op00);
2857 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2858 if (VECTOR_TYPE_P (op00type)
2859 && (same_type_ignoring_top_level_qualifiers_p
2860 (type, TREE_TYPE (op00type))))
2862 HOST_WIDE_INT offset = tree_to_shwi (op01);
2863 tree part_width = TYPE_SIZE (type);
2864 unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
2865 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
2866 tree index = bitsize_int (indexi);
2868 if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
2869 return fold_build3_loc (loc,
2870 BIT_FIELD_REF, type, op00,
2874 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2875 else if (TREE_CODE (op00type) == COMPLEX_TYPE
2876 && (same_type_ignoring_top_level_qualifiers_p
2877 (type, TREE_TYPE (op00type))))
2879 tree size = TYPE_SIZE_UNIT (type);
2880 if (tree_int_cst_equal (size, op01))
2881 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
2883 /* ((foo *)&fooarray)[1] => fooarray[1] */
2884 else if (TREE_CODE (op00type) == ARRAY_TYPE
2885 && (same_type_ignoring_top_level_qualifiers_p
2886 (type, TREE_TYPE (op00type))))
2888 tree type_domain = TYPE_DOMAIN (op00type);
2889 tree min_val = size_zero_node;
2890 if (type_domain && TYPE_MIN_VALUE (type_domain))
2891 min_val = TYPE_MIN_VALUE (type_domain);
2892 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
2893 TYPE_SIZE_UNIT (type));
2894 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
2895 return build4_loc (loc, ARRAY_REF, type, op00, op01,
2896 NULL_TREE, NULL_TREE);
2898 /* Also handle conversion to an empty base class, which
2899 is represented with a NOP_EXPR. */
2900 else if (is_empty_class (type)
2901 && CLASS_TYPE_P (op00type)
2902 && DERIVED_FROM_P (type, op00type))
2907 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2908 else if (RECORD_OR_UNION_TYPE_P (op00type))
2910 tree field = TYPE_FIELDS (op00type);
2911 for (; field; field = DECL_CHAIN (field))
2912 if (TREE_CODE (field) == FIELD_DECL
2913 && tree_int_cst_equal (byte_position (field), op01)
2914 && (same_type_ignoring_top_level_qualifiers_p
2915 (TREE_TYPE (field), type)))
2917 return fold_build3 (COMPONENT_REF, type, op00,
2924 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2925 else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
2926 && (same_type_ignoring_top_level_qualifiers_p
2927 (type, TREE_TYPE (TREE_TYPE (subtype)))))
2930 tree min_val = size_zero_node;
2931 tree newsub = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
2935 sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
2936 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
2937 if (type_domain && TYPE_MIN_VALUE (type_domain))
2938 min_val = TYPE_MIN_VALUE (type_domain);
2939 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
2947 cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
2949 bool *non_constant_p, bool *overflow_p)
2951 tree orig_op0 = TREE_OPERAND (t, 0);
2952 bool empty_base = false;
2954 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
2955 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
2957 if (TREE_CODE (t) == MEM_REF
2958 && (!TREE_OPERAND (t, 1) || !integer_zerop (TREE_OPERAND (t, 1))))
2960 gcc_assert (ctx->quiet);
2961 *non_constant_p = true;
2965 /* First try to simplify it directly. */
2966 tree r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), orig_op0,
2970 /* If that didn't work, evaluate the operand first. */
2971 tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
2972 /*lval*/false, non_constant_p,
2974 /* Don't VERIFY_CONSTANT here. */
2975 if (*non_constant_p)
2978 r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
2982 /* We couldn't fold to a constant value. Make sure it's not
2983 something we should have been able to fold. */
2986 if (TREE_CODE (sub) == ADDR_EXPR)
2988 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2989 (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
2990 /* DR 1188 says we don't have to deal with this. */
2992 error ("accessing value of %qE through a %qT glvalue in a "
2993 "constant expression", build_fold_indirect_ref (sub),
2995 *non_constant_p = true;
2999 if (lval && op0 != orig_op0)
3000 return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
3002 VERIFY_CONSTANT (t);
3007 r = cxx_eval_constant_expression (ctx, r,
3008 lval, non_constant_p, overflow_p);
3009 if (*non_constant_p)
3012 /* If we're pulling out the value of an empty base, make sure
3013 that the whole object is constant and then return an empty
3015 if (empty_base && !lval)
3017 VERIFY_CONSTANT (r);
3018 r = build_constructor (TREE_TYPE (t), NULL);
3019 TREE_CONSTANT (r) = true;
3025 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3026 Shared between potential_constant_expression and
3027 cxx_eval_constant_expression. */
3030 non_const_var_error (tree r)
3032 tree type = TREE_TYPE (r);
3033 error ("the value of %qD is not usable in a constant "
3035 /* Avoid error cascade. */
3036 if (DECL_INITIAL (r) == error_mark_node)
3038 if (DECL_DECLARED_CONSTEXPR_P (r))
3039 inform (DECL_SOURCE_LOCATION (r),
3040 "%qD used in its own initializer", r);
3041 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
3043 if (!CP_TYPE_CONST_P (type))
3044 inform (DECL_SOURCE_LOCATION (r),
3045 "%q#D is not const", r);
3046 else if (CP_TYPE_VOLATILE_P (type))
3047 inform (DECL_SOURCE_LOCATION (r),
3048 "%q#D is volatile", r);
3049 else if (!DECL_INITIAL (r)
3050 || !TREE_CONSTANT (DECL_INITIAL (r))
3051 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r))
3052 inform (DECL_SOURCE_LOCATION (r),
3053 "%qD was not initialized with a constant "
3060 if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
3061 inform (DECL_SOURCE_LOCATION (r),
3062 "%qD was not declared %<constexpr%>", r);
3064 inform (DECL_SOURCE_LOCATION (r),
3065 "%qD does not have integral or enumeration type",
3070 /* Subroutine of cxx_eval_constant_expression.
3071 Like cxx_eval_unary_expression, except for trinary expressions. */
3074 cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
3076 bool *non_constant_p, bool *overflow_p)
3082 for (i = 0; i < 3; i++)
3084 args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
3086 non_constant_p, overflow_p);
3087 VERIFY_CONSTANT (args[i]);
3090 val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
3091 args[0], args[1], args[2]);
3092 if (val == NULL_TREE)
3094 VERIFY_CONSTANT (val);
3099 var_in_constexpr_fn (tree t)
3101 tree ctx = DECL_CONTEXT (t);
3102 return (cxx_dialect >= cxx14 && ctx && TREE_CODE (ctx) == FUNCTION_DECL
3103 && DECL_DECLARED_CONSTEXPR_P (ctx));
3106 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3109 cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
3111 bool *non_constant_p, bool *overflow_p)
3113 constexpr_ctx new_ctx = *ctx;
3115 tree init = TREE_OPERAND (t, 1);
3116 if (TREE_CLOBBER_P (init))
3117 /* Just ignore clobbers. */
3120 /* First we figure out where we're storing to. */
3121 tree target = TREE_OPERAND (t, 0);
3122 tree type = TREE_TYPE (target);
3123 target = cxx_eval_constant_expression (ctx, target,
3125 non_constant_p, overflow_p);
3126 if (*non_constant_p)
3129 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target), type))
3131 /* For initialization of an empty base, the original target will be
3132 *(base*)this, which the above evaluation resolves to the object
3133 argument, which has the derived type rather than the base type. In
3134 this situation, just evaluate the initializer and return, since
3135 there's no actual data to store. */
3136 gcc_assert (is_empty_class (type));
3137 return cxx_eval_constant_expression (ctx, init, false,
3138 non_constant_p, overflow_p);
3141 /* And then find the underlying variable. */
3142 vec<tree,va_gc> *refs = make_tree_vector();
3143 tree object = NULL_TREE;
3144 for (tree probe = target; object == NULL_TREE; )
3146 switch (TREE_CODE (probe))
3151 vec_safe_push (refs, TREE_OPERAND (probe, 1));
3152 vec_safe_push (refs, TREE_TYPE (probe));
3153 probe = TREE_OPERAND (probe, 0);
3161 /* And then find/build up our initializer for the path to the subobject
3162 we're initializing. */
3164 if (DECL_P (object))
3165 valp = ctx->values->get (object);
3170 /* A constant-expression cannot modify objects from outside the
3171 constant-expression. */
3173 error ("modification of %qE is not a constant-expression", object);
3174 *non_constant_p = true;
3177 type = TREE_TYPE (object);
3178 bool no_zero_init = true;
3180 vec<tree,va_gc> *ctors = make_tree_vector ();
3181 while (!refs->is_empty())
3183 if (*valp == NULL_TREE)
3185 *valp = build_constructor (type, NULL);
3186 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init;
3188 else if (TREE_CODE (*valp) == STRING_CST)
3190 /* An array was initialized with a string constant, and now
3191 we're writing into one of its elements. Explode the
3192 single initialization into a set of element
3194 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
3196 tree string = *valp;
3197 tree elt_type = TREE_TYPE (type);
3198 unsigned chars_per_elt = (TYPE_PRECISION (elt_type)
3199 / TYPE_PRECISION (char_type_node));
3200 unsigned num_elts = TREE_STRING_LENGTH (string) / chars_per_elt;
3201 tree ary_ctor = build_constructor (type, NULL);
3203 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor), num_elts);
3204 for (unsigned ix = 0; ix != num_elts; ix++)
3206 constructor_elt elt =
3208 build_int_cst (size_type_node, ix),
3209 extract_string_elt (string, chars_per_elt, ix)
3211 CONSTRUCTOR_ELTS (ary_ctor)->quick_push (elt);
3217 /* If the value of object is already zero-initialized, any new ctors for
3218 subobjects will also be zero-initialized. */
3219 no_zero_init = CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp);
3221 vec_safe_push (ctors, *valp);
3223 enum tree_code code = TREE_CODE (type);
3225 tree index = refs->pop();
3227 constructor_elt *cep = NULL;
3228 if (code == ARRAY_TYPE)
3231 = find_array_ctor_elt (*valp, index, /*insert*/true);
3232 gcc_assert (i >= 0);
3233 cep = CONSTRUCTOR_ELT (*valp, i);
3234 gcc_assert (TREE_CODE (cep->index) != RANGE_EXPR);
3238 gcc_assert (TREE_CODE (index) == FIELD_DECL);
3240 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3241 Usually we meet initializers in that order, but it is
3242 possible for base types to be placed not in program
3244 tree fields = TYPE_FIELDS (DECL_CONTEXT (index));
3245 unsigned HOST_WIDE_INT idx;
3248 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep);
3249 idx++, fields = DECL_CHAIN (fields))
3251 if (index == cep->index)
3254 /* The field we're initializing must be on the field
3255 list. Look to see if it is present before the
3256 field the current ELT initializes. */
3257 for (; fields != cep->index; fields = DECL_CHAIN (fields))
3258 if (index == fields)
3262 /* We fell off the end of the CONSTRUCTOR, so insert a new
3263 entry at the end. */
3266 constructor_elt ce = { index, NULL_TREE };
3268 vec_safe_insert (CONSTRUCTOR_ELTS (*valp), idx, ce);
3269 cep = CONSTRUCTOR_ELT (*valp, idx);
3275 release_tree_vector (refs);
3277 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
3279 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3280 wants to modify it. */
3281 if (*valp == NULL_TREE)
3283 *valp = new_ctx.ctor = build_constructor (type, NULL);
3284 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = no_zero_init;
3287 new_ctx.ctor = *valp;
3288 new_ctx.object = target;
3291 init = cxx_eval_constant_expression (&new_ctx, init, false,
3292 non_constant_p, overflow_p);
3293 /* Don't share a CONSTRUCTOR that might be changed later. */
3294 init = unshare_constructor (init);
3295 if (target == object)
3296 /* The hash table might have moved since the get earlier. */
3297 valp = ctx->values->get (object);
3299 if (TREE_CODE (init) == CONSTRUCTOR)
3301 /* An outer ctx->ctor might be pointing to *valp, so replace
3303 CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init);
3304 TREE_CONSTANT (*valp) = TREE_CONSTANT (init);
3305 TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init);
3306 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp)
3307 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init);
3312 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3313 CONSTRUCTORs, if any. */
3316 bool c = TREE_CONSTANT (init);
3317 bool s = TREE_SIDE_EFFECTS (init);
3319 FOR_EACH_VEC_SAFE_ELT (ctors, i, elt)
3322 TREE_CONSTANT (elt) = false;
3324 TREE_SIDE_EFFECTS (elt) = true;
3326 release_tree_vector (ctors);
3328 if (*non_constant_p)
3336 /* Evaluate a ++ or -- expression. */
3339 cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
3341 bool *non_constant_p, bool *overflow_p)
3343 enum tree_code code = TREE_CODE (t);
3344 tree type = TREE_TYPE (t);
3345 tree op = TREE_OPERAND (t, 0);
3346 tree offset = TREE_OPERAND (t, 1);
3347 gcc_assert (TREE_CONSTANT (offset));
3349 /* The operand as an lvalue. */
3350 op = cxx_eval_constant_expression (ctx, op, true,
3351 non_constant_p, overflow_p);
3353 /* The operand as an rvalue. */
3354 tree val = rvalue (op);
3355 val = cxx_eval_constant_expression (ctx, val, false,
3356 non_constant_p, overflow_p);
3357 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3358 a local array in a constexpr function. */
3359 bool ptr = POINTER_TYPE_P (TREE_TYPE (val));
3361 VERIFY_CONSTANT (val);
3363 /* The modified value. */
3364 bool inc = (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR);
3366 if (POINTER_TYPE_P (type))
3368 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3369 offset = convert_to_ptrofftype (offset);
3371 offset = fold_build1 (NEGATE_EXPR, TREE_TYPE (offset), offset);
3372 mod = fold_build2 (POINTER_PLUS_EXPR, type, val, offset);
3375 mod = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR, type, val, offset);
3377 VERIFY_CONSTANT (mod);
3379 /* Storing the modified value. */
3380 tree store = build2 (MODIFY_EXPR, type, op, mod);
3381 cxx_eval_constant_expression (ctx, store,
3382 true, non_constant_p, overflow_p);
3384 /* And the value of the expression. */
3385 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3387 /* Prefix ops are lvalues. */
3391 /* But we optimize when the caller wants an rvalue. */
3395 /* Postfix ops are rvalues. */
3399 /* Predicates for the meaning of *jump_target. */
3402 returns (tree *jump_target)
3405 && TREE_CODE (*jump_target) == RETURN_EXPR;
3409 breaks (tree *jump_target)
3412 && TREE_CODE (*jump_target) == LABEL_DECL
3413 && LABEL_DECL_BREAK (*jump_target);
3417 continues (tree *jump_target)
3420 && TREE_CODE (*jump_target) == LABEL_DECL
3421 && LABEL_DECL_CONTINUE (*jump_target);
3425 switches (tree *jump_target)
3428 && TREE_CODE (*jump_target) == INTEGER_CST;
3431 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3432 STMT matches *jump_target. If we're looking for a case label and we see
3433 the default label, note it in ctx->css_state. */
3436 label_matches (const constexpr_ctx *ctx, tree *jump_target, tree stmt)
3438 switch (TREE_CODE (*jump_target))
3441 if (TREE_CODE (stmt) == LABEL_EXPR
3442 && LABEL_EXPR_LABEL (stmt) == *jump_target)
3447 if (TREE_CODE (stmt) == CASE_LABEL_EXPR)
3449 gcc_assert (ctx->css_state != NULL);
3450 if (!CASE_LOW (stmt))
3452 /* default: should appear just once in a SWITCH_EXPR
3453 body (excluding nested SWITCH_EXPR). */
3454 gcc_assert (*ctx->css_state != css_default_seen);
3455 /* When evaluating SWITCH_EXPR body for the second time,
3456 return true for the default: label. */
3457 if (*ctx->css_state == css_default_processing)
3459 *ctx->css_state = css_default_seen;
3461 else if (CASE_HIGH (stmt))
3463 if (tree_int_cst_le (CASE_LOW (stmt), *jump_target)
3464 && tree_int_cst_le (*jump_target, CASE_HIGH (stmt)))
3467 else if (tree_int_cst_equal (*jump_target, CASE_LOW (stmt)))
3478 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3479 semantics, for switch, break, continue, and return. */
3482 cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
3483 bool *non_constant_p, bool *overflow_p,
3486 tree_stmt_iterator i;
3488 /* In a statement-expression we want to return the last value. */
3492 local_target = NULL_TREE;
3493 jump_target = &local_target;
3495 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
3497 tree stmt = tsi_stmt (i);
3498 r = cxx_eval_constant_expression (ctx, stmt, false,
3499 non_constant_p, overflow_p,
3501 if (*non_constant_p)
3503 if (returns (jump_target) || breaks (jump_target))
3509 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3510 semantics; continue semantics are covered by cxx_eval_statement_list. */
3513 cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t,
3514 bool *non_constant_p, bool *overflow_p,
3517 constexpr_ctx new_ctx = *ctx;
3519 tree body = TREE_OPERAND (t, 0);
3522 hash_set<tree> save_exprs;
3523 new_ctx.save_exprs = &save_exprs;
3525 cxx_eval_statement_list (&new_ctx, body,
3526 non_constant_p, overflow_p, jump_target);
3528 /* Forget saved values of SAVE_EXPRs. */
3529 for (hash_set<tree>::iterator iter = save_exprs.begin();
3530 iter != save_exprs.end(); ++iter)
3531 new_ctx.values->remove (*iter);
3533 while (!returns (jump_target)
3534 && !breaks (jump_target)
3535 && !switches (jump_target)
3536 && !*non_constant_p);
3538 if (breaks (jump_target))
3539 *jump_target = NULL_TREE;
3544 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
3548 cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t,
3549 bool *non_constant_p, bool *overflow_p,
3552 tree cond = TREE_OPERAND (t, 0);
3553 cond = cxx_eval_constant_expression (ctx, cond, false,
3554 non_constant_p, overflow_p);
3555 VERIFY_CONSTANT (cond);
3556 *jump_target = cond;
3558 tree body = TREE_OPERAND (t, 1);
3559 constexpr_ctx new_ctx = *ctx;
3560 constexpr_switch_state css = css_default_not_seen;
3561 new_ctx.css_state = &css;
3562 cxx_eval_constant_expression (&new_ctx, body, false,
3563 non_constant_p, overflow_p, jump_target);
3564 if (switches (jump_target) && css == css_default_seen)
3566 /* If the SWITCH_EXPR body has default: label, process it once again,
3567 this time instructing label_matches to return true for default:
3568 label on switches (jump_target). */
3569 css = css_default_processing;
3570 cxx_eval_constant_expression (&new_ctx, body, false,
3571 non_constant_p, overflow_p, jump_target);
3573 if (breaks (jump_target) || switches (jump_target))
3574 *jump_target = NULL_TREE;
3578 /* Attempt to reduce the expression T to a constant value.
3579 On failure, issue diagnostic and return error_mark_node. */
3580 /* FIXME unify with c_fully_fold */
3581 /* FIXME overflow_p is too global */
3584 cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
3586 bool *non_constant_p, bool *overflow_p,
3589 constexpr_ctx new_ctx;
3592 if (jump_target && *jump_target)
3594 /* If we are jumping, ignore all statements/expressions except those
3595 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
3596 switch (TREE_CODE (t))
3599 case STATEMENT_LIST:
3604 case CASE_LABEL_EXPR:
3605 if (label_matches (ctx, jump_target, t))
3607 *jump_target = NULL_TREE;
3613 if (t == error_mark_node)
3615 *non_constant_p = true;
3618 if (CONSTANT_CLASS_P (t))
3620 if (TREE_OVERFLOW (t))
3623 permerror (input_location, "overflow in constant expression");
3624 if (!flag_permissive || ctx->quiet)
3630 switch (TREE_CODE (t))
3635 /* We ask for an rvalue for the RESULT_DECL when indirecting
3636 through an invisible reference, or in named return value
3638 return (*ctx->values->get (t));
3642 /* We used to not check lval for CONST_DECL, but darwin.c uses
3643 CONST_DECL for aggregate constants. */
3647 r = decl_really_constant_value (t);
3649 r = decl_constant_value (t);
3650 if (TREE_CODE (r) == TARGET_EXPR
3651 && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR)
3652 r = TARGET_EXPR_INITIAL (r);
3654 if (tree *p = ctx->values->get (r))
3655 if (*p != NULL_TREE)
3660 non_const_var_error (r);
3661 *non_constant_p = true;
3669 case CASE_LABEL_EXPR:
3674 if (lval && TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
3676 else if (tree *p = ctx->values->get (r))
3679 /* Defer in case this is only used for its type. */;
3680 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
3681 /* Defer, there's no lvalue->rvalue conversion. */;
3682 else if (is_empty_class (TREE_TYPE (t)))
3684 /* If the class is empty, we aren't actually loading anything. */
3685 r = build_constructor (TREE_TYPE (t), NULL);
3686 TREE_CONSTANT (r) = true;
3691 error ("%qE is not a constant expression", t);
3692 *non_constant_p = true;
3697 case AGGR_INIT_EXPR:
3698 r = cxx_eval_call_expression (ctx, t, lval,
3699 non_constant_p, overflow_p);
3704 r = DECL_EXPR_DECL (t);
3705 if (AGGREGATE_TYPE_P (TREE_TYPE (r))
3706 || VECTOR_TYPE_P (TREE_TYPE (r)))
3710 new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL);
3711 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
3712 new_ctx.values->put (r, new_ctx.ctor);
3716 if (tree init = DECL_INITIAL (r))
3718 init = cxx_eval_constant_expression (ctx, init,
3720 non_constant_p, overflow_p);
3721 /* Don't share a CONSTRUCTOR that might be changed. */
3722 init = unshare_constructor (init);
3723 ctx->values->put (r, init);
3725 else if (ctx == &new_ctx)
3726 /* We gave it a CONSTRUCTOR above. */;
3728 ctx->values->put (r, NULL_TREE);
3733 if (!literal_type_p (TREE_TYPE (t)))
3737 error ("temporary of non-literal type %qT in a "
3738 "constant expression", TREE_TYPE (t));
3739 explain_non_literal_class (TREE_TYPE (t));
3741 *non_constant_p = true;
3744 if ((AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t))))
3746 /* We're being expanded without an explicit target, so start
3747 initializing a new object; expansion with an explicit target
3748 strips the TARGET_EXPR before we get here. */
3750 new_ctx.ctor = build_constructor (TREE_TYPE (t), NULL);
3751 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
3752 new_ctx.object = TARGET_EXPR_SLOT (t);
3753 ctx->values->put (new_ctx.object, new_ctx.ctor);
3756 /* Pass false for 'lval' because this indicates
3757 initialization of a temporary. */
3758 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3760 non_constant_p, overflow_p);
3761 if (!*non_constant_p)
3762 /* Adjust the type of the result to the type of the temporary. */
3763 r = adjust_temp_type (TREE_TYPE (t), r);
3766 tree slot = TARGET_EXPR_SLOT (t);
3767 r = unshare_constructor (r);
3768 ctx->values->put (slot, r);
3775 gcc_assert (jump_target == NULL || *jump_target == NULL_TREE);
3776 r = cxx_eval_store_expression (ctx, t, lval,
3777 non_constant_p, overflow_p);
3781 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3783 non_constant_p, overflow_p);
3787 if (TREE_OPERAND (t, 0) != NULL_TREE)
3788 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3790 non_constant_p, overflow_p);
3795 /* Avoid evaluating a SAVE_EXPR more than once. */
3796 if (tree *p = ctx->values->get (t))
3800 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), false,
3801 non_constant_p, overflow_p);
3802 ctx->values->put (t, r);
3803 if (ctx->save_exprs)
3804 ctx->save_exprs->add (t);
3808 case NON_LVALUE_EXPR:
3809 case TRY_CATCH_EXPR:
3811 case CLEANUP_POINT_EXPR:
3812 case MUST_NOT_THROW_EXPR:
3815 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3817 non_constant_p, overflow_p,
3821 case TRY_FINALLY_EXPR:
3822 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval,
3823 non_constant_p, overflow_p,
3825 if (!*non_constant_p)
3826 /* Also evaluate the cleanup. */
3827 cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), true,
3828 non_constant_p, overflow_p,
3832 /* These differ from cxx_eval_unary_expression in that this doesn't
3833 check for a constant operand or result; an address can be
3834 constant without its operand being, and vice versa. */
3837 r = cxx_eval_indirect_ref (ctx, t, lval,
3838 non_constant_p, overflow_p);
3843 tree oldop = TREE_OPERAND (t, 0);
3844 tree op = cxx_eval_constant_expression (ctx, oldop,
3846 non_constant_p, overflow_p);
3847 /* Don't VERIFY_CONSTANT here. */
3848 if (*non_constant_p)
3850 gcc_checking_assert (TREE_CODE (op) != CONSTRUCTOR);
3851 /* This function does more aggressive folding than fold itself. */
3852 r = build_fold_addr_expr_with_type (op, TREE_TYPE (t));
3853 if (TREE_CODE (r) == ADDR_EXPR && TREE_OPERAND (r, 0) == oldop)
3862 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval,
3863 non_constant_p, overflow_p);
3864 if (r == error_mark_node)
3866 else if (r == TREE_OPERAND (t, 0))
3869 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), r);
3874 case FIX_TRUNC_EXPR:
3879 case TRUTH_NOT_EXPR:
3880 case FIXED_CONVERT_EXPR:
3881 r = cxx_eval_unary_expression (ctx, t, lval,
3882 non_constant_p, overflow_p);
3886 r = fold_sizeof_expr (t);
3887 VERIFY_CONSTANT (r);
3892 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3893 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3894 introduced by build_call_a. */
3895 tree op0 = TREE_OPERAND (t, 0);
3896 tree op1 = TREE_OPERAND (t, 1);
3898 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
3899 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
3900 r = cxx_eval_constant_expression (ctx, op0,
3901 lval, non_constant_p, overflow_p,
3905 /* Check that the LHS is constant and then discard it. */
3906 cxx_eval_constant_expression (ctx, op0,
3907 true, non_constant_p, overflow_p,
3909 op1 = TREE_OPERAND (t, 1);
3910 r = cxx_eval_constant_expression (ctx, op1,
3911 lval, non_constant_p, overflow_p,
3917 case POINTER_PLUS_EXPR:
3921 case TRUNC_DIV_EXPR:
3923 case FLOOR_DIV_EXPR:
3924 case ROUND_DIV_EXPR:
3925 case TRUNC_MOD_EXPR:
3927 case ROUND_MOD_EXPR:
3929 case EXACT_DIV_EXPR:
3939 case TRUTH_XOR_EXPR:
3946 case UNORDERED_EXPR:
3956 r = cxx_eval_binary_expression (ctx, t, lval,
3957 non_constant_p, overflow_p);
3960 /* fold can introduce non-IF versions of these; still treat them as
3961 short-circuiting. */
3962 case TRUTH_AND_EXPR:
3963 case TRUTH_ANDIF_EXPR:
3964 r = cxx_eval_logical_expression (ctx, t, boolean_false_node,
3967 non_constant_p, overflow_p);
3971 case TRUTH_ORIF_EXPR:
3972 r = cxx_eval_logical_expression (ctx, t, boolean_true_node,
3975 non_constant_p, overflow_p);
3979 r = cxx_eval_array_reference (ctx, t, lval,
3980 non_constant_p, overflow_p);
3984 if (is_overloaded_fn (t))
3986 /* We can only get here in checking mode via
3987 build_non_dependent_expr, because any expression that
3988 calls or takes the address of the function will have
3989 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3990 gcc_checking_assert (ctx->quiet || errorcount);
3991 *non_constant_p = true;
3994 r = cxx_eval_component_reference (ctx, t, lval,
3995 non_constant_p, overflow_p);
3999 r = cxx_eval_bit_field_ref (ctx, t, lval,
4000 non_constant_p, overflow_p);
4004 if (jump_target && *jump_target)
4006 /* When jumping to a label, the label might be either in the
4007 then or else blocks, so process then block first in skipping
4008 mode first, and if we are still in the skipping mode at its end,
4009 process the else block too. */
4010 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
4011 lval, non_constant_p, overflow_p,
4014 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
4015 lval, non_constant_p, overflow_p,
4021 r = cxx_eval_conditional_expression (ctx, t, lval,
4022 non_constant_p, overflow_p,
4027 if (TREE_CONSTANT (t))
4029 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4030 VECTOR_CST if applicable. */
4031 /* FIXME after GCC 6 branches, make the verify unconditional. */
4033 verify_constructor_flags (t);
4035 recompute_constructor_flags (t);
4036 if (TREE_CONSTANT (t))
4039 r = cxx_eval_bare_aggregate (ctx, t, lval,
4040 non_constant_p, overflow_p);
4044 /* We can get this in a defaulted constructor for a class with a
4045 non-static data member of array type. Either the initializer will
4046 be NULL, meaning default-initialization, or it will be an lvalue
4047 or xvalue of the same type, meaning direct-initialization from the
4048 corresponding member. */
4049 r = cxx_eval_vec_init (ctx, t, lval,
4050 non_constant_p, overflow_p);
4055 r = cxx_eval_trinary_expression (ctx, t, lval,
4056 non_constant_p, overflow_p);
4060 case VIEW_CONVERT_EXPR:
4062 case UNARY_PLUS_EXPR:
4064 enum tree_code tcode = TREE_CODE (t);
4065 tree oldop = TREE_OPERAND (t, 0);
4067 tree op = cxx_eval_constant_expression (ctx, oldop,
4069 non_constant_p, overflow_p);
4070 if (*non_constant_p)
4072 tree type = TREE_TYPE (t);
4073 if (TREE_CODE (op) == PTRMEM_CST
4074 && !TYPE_PTRMEM_P (type))
4075 op = cplus_expand_constant (op);
4076 if (TREE_CODE (op) == PTRMEM_CST && tcode == NOP_EXPR)
4078 if (same_type_ignoring_top_level_qualifiers_p (type,
4080 return cp_fold_convert (type, op);
4084 error_at (EXPR_LOC_OR_LOC (t, input_location),
4085 "a reinterpret_cast is not a constant-expression");
4086 *non_constant_p = true;
4090 if (POINTER_TYPE_P (type)
4091 && TREE_CODE (op) == INTEGER_CST
4092 && !integer_zerop (op))
4095 error_at (EXPR_LOC_OR_LOC (t, input_location),
4096 "reinterpret_cast from integer to pointer");
4097 *non_constant_p = true;
4100 if (op == oldop && tcode != UNARY_PLUS_EXPR)
4101 /* We didn't fold at the top so we could check for ptr-int
4104 if (tcode == UNARY_PLUS_EXPR)
4105 r = fold_convert (TREE_TYPE (t), op);
4107 r = fold_build1 (tcode, type, op);
4108 /* Conversion of an out-of-range value has implementation-defined
4109 behavior; the language considers it different from arithmetic
4110 overflow, which is undefined. */
4111 if (TREE_OVERFLOW_P (r) && !TREE_OVERFLOW_P (op))
4112 TREE_OVERFLOW (r) = false;
4116 case EMPTY_CLASS_EXPR:
4117 case STATEMENT_LIST_END:
4118 /* This is good enough for a function argument that might not get
4119 used, and they can't do anything with it, so just return it. */
4122 case STATEMENT_LIST:
4124 new_ctx.ctor = new_ctx.object = NULL_TREE;
4125 return cxx_eval_statement_list (&new_ctx, t,
4126 non_constant_p, overflow_p, jump_target);
4129 return cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (t),
4131 non_constant_p, overflow_p,
4134 case PREINCREMENT_EXPR:
4135 case POSTINCREMENT_EXPR:
4136 case PREDECREMENT_EXPR:
4137 case POSTDECREMENT_EXPR:
4138 return cxx_eval_increment_expression (ctx, t,
4139 lval, non_constant_p, overflow_p);
4145 case VEC_DELETE_EXPR:
4148 /* GCC internal stuff. */
4151 case WITH_CLEANUP_EXPR:
4152 case NON_DEPENDENT_EXPR:
4156 error_at (EXPR_LOC_OR_LOC (t, input_location),
4157 "expression %qE is not a constant-expression", t);
4158 *non_constant_p = true;
4161 case PLACEHOLDER_EXPR:
4162 if (!ctx || !ctx->ctor || (lval && !ctx->object)
4163 || !(same_type_ignoring_top_level_qualifiers_p
4164 (TREE_TYPE (t), TREE_TYPE (ctx->ctor))))
4166 /* A placeholder without a referent. We can get here when
4167 checking whether NSDMIs are noexcept, or in massage_init_elt;
4168 just say it's non-constant for now. */
4169 gcc_assert (ctx->quiet);
4170 *non_constant_p = true;
4175 /* Use of the value or address of the current object. We could
4176 use ctx->object unconditionally, but using ctx->ctor when we
4177 can is a minor optimization. */
4178 tree ctor = lval ? ctx->object : ctx->ctor;
4179 return cxx_eval_constant_expression
4181 non_constant_p, overflow_p);
4186 *jump_target = TREE_OPERAND (t, 0);
4187 gcc_assert (breaks (jump_target) || continues (jump_target));
4191 cxx_eval_loop_expr (ctx, t,
4192 non_constant_p, overflow_p, jump_target);
4196 cxx_eval_switch_expr (ctx, t,
4197 non_constant_p, overflow_p, jump_target);
4201 /* It's possible to get a requires-expression in a constant
4202 expression. For example:
4204 template<typename T> concept bool C() {
4205 return requires (T t) { t; };
4208 template<typename T> requires !C<T>() void f(T);
4210 Normalization leaves f with the associated constraint
4211 '!requires (T t) { ... }' which is not transformed into
4213 if (!processing_template_decl)
4214 return evaluate_constraint_expression (t, NULL_TREE);
4216 *non_constant_p = true;
4220 if (STATEMENT_CODE_P (TREE_CODE (t)))
4222 /* This function doesn't know how to deal with pre-genericize
4223 statements; this can only happen with statement-expressions,
4224 so for now just fail. */
4226 error_at (EXPR_LOCATION (t),
4227 "statement is not a constant-expression");
4230 internal_error ("unexpected expression %qE of kind %s", t,
4231 get_tree_code_name (TREE_CODE (t)));
4232 *non_constant_p = true;
4236 if (r == error_mark_node)
4237 *non_constant_p = true;
4239 if (*non_constant_p)
4246 cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
4247 bool strict = true, tree object = NULL_TREE)
4249 bool non_constant_p = false;
4250 bool overflow_p = false;
4251 hash_map<tree,tree> map;
4253 constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL,
4254 allow_non_constant, strict };
4256 tree type = initialized_type (t);
4258 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
4260 /* In C++14 an NSDMI can participate in aggregate initialization,
4261 and can refer to the address of the object being initialized, so
4262 we need to pass in the relevant VAR_DECL if we want to do the
4263 evaluation in a single pass. The evaluation will dynamically
4264 update ctx.values for the VAR_DECL. We use the same strategy
4265 for C++11 constexpr constructors that refer to the object being
4267 ctx.ctor = build_constructor (type, NULL);
4268 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx.ctor) = true;
4271 if (TREE_CODE (t) == TARGET_EXPR)
4272 object = TARGET_EXPR_SLOT (t);
4273 else if (TREE_CODE (t) == AGGR_INIT_EXPR)
4274 object = AGGR_INIT_EXPR_SLOT (t);
4276 ctx.object = object;
4278 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4279 (type, TREE_TYPE (object)));
4280 if (object && DECL_P (object))
4281 map.put (object, ctx.ctor);
4282 if (TREE_CODE (r) == TARGET_EXPR)
4283 /* Avoid creating another CONSTRUCTOR when we expand the
4285 r = TARGET_EXPR_INITIAL (r);
4288 r = cxx_eval_constant_expression (&ctx, r,
4289 false, &non_constant_p, &overflow_p);
4291 verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);
4293 /* Mutable logic is a bit tricky: we want to allow initialization of
4294 constexpr variables with mutable members, but we can't copy those
4295 members to another constexpr variable. */
4296 if (TREE_CODE (r) == CONSTRUCTOR
4297 && CONSTRUCTOR_MUTABLE_POISON (r))
4299 if (!allow_non_constant)
4300 error ("%qE is not a constant expression because it refers to "
4301 "mutable subobjects of %qT", t, type);
4302 non_constant_p = true;
4305 /* Technically we should check this for all subexpressions, but that
4306 runs into problems with our internal representation of pointer
4307 subtraction and the 5.19 rules are still in flux. */
4308 if (CONVERT_EXPR_CODE_P (TREE_CODE (r))
4309 && ARITHMETIC_TYPE_P (TREE_TYPE (r))
4310 && TREE_CODE (TREE_OPERAND (r, 0)) == ADDR_EXPR)
4312 if (!allow_non_constant)
4313 error ("conversion from pointer type %qT "
4314 "to arithmetic type %qT in a constant-expression",
4315 TREE_TYPE (TREE_OPERAND (r, 0)), TREE_TYPE (r));
4316 non_constant_p = true;
4319 if (!non_constant_p && overflow_p)
4320 non_constant_p = true;
4322 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4324 bool should_unshare = true;
4325 if (r == t || TREE_CODE (r) == CONSTRUCTOR)
4326 should_unshare = false;
4328 if (non_constant_p && !allow_non_constant)
4329 return error_mark_node;
4330 else if (non_constant_p && TREE_CONSTANT (r))
4332 /* This isn't actually constant, so unset TREE_CONSTANT. */
4335 else if (TREE_CODE (r) == CONSTRUCTOR)
4336 r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r);
4338 r = build_nop (TREE_TYPE (r), r);
4339 TREE_CONSTANT (r) = false;
4341 else if (non_constant_p || r == t)
4345 r = unshare_expr (r);
4347 if (TREE_CODE (r) == CONSTRUCTOR && CLASS_TYPE_P (TREE_TYPE (r)))
4349 if (TREE_CODE (t) == TARGET_EXPR
4350 && TARGET_EXPR_INITIAL (t) == r)
4354 r = get_target_expr (r);
4355 TREE_CONSTANT (r) = true;
4363 /* Returns true if T is a valid subexpression of a constant expression,
4364 even if it isn't itself a constant expression. */
4367 is_sub_constant_expr (tree t)
4369 bool non_constant_p = false;
4370 bool overflow_p = false;
4371 hash_map <tree, tree> map;
4373 constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL, true, true };
4375 cxx_eval_constant_expression (&ctx, t, false, &non_constant_p,
4377 return !non_constant_p && !overflow_p;
4380 /* If T represents a constant expression returns its reduced value.
4381 Otherwise return error_mark_node. If T is dependent, then
4385 cxx_constant_value (tree t, tree decl)
4387 return cxx_eval_outermost_constant_expr (t, false, true, decl);
4390 /* Helper routine for fold_simple function. Either return simplified
4391 expression T, otherwise NULL_TREE.
4392 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
4393 even if we are within template-declaration. So be careful on call, as in
4394 such case types can be undefined. */
4397 fold_simple_1 (tree t)
4400 enum tree_code code = TREE_CODE (t);
4412 return fold_sizeof_expr (t);
4420 case TRUTH_NOT_EXPR:
4422 case VIEW_CONVERT_EXPR:
4425 case FIX_TRUNC_EXPR:
4426 case FIXED_CONVERT_EXPR:
4427 case ADDR_SPACE_CONVERT_EXPR:
4429 op1 = TREE_OPERAND (t, 0);
4431 t = const_unop (code, TREE_TYPE (t), op1);
4435 if (CONVERT_EXPR_CODE_P (code)
4436 && TREE_OVERFLOW_P (t) && !TREE_OVERFLOW_P (op1))
4437 TREE_OVERFLOW (t) = false;
4445 /* If T is a simple constant expression, returns its simplified value.
4446 Otherwise returns T. In contrast to maybe_constant_value do we
4447 simplify only few operations on constant-expressions, and we don't
4448 try to simplify constexpressions. */
4451 fold_simple (tree t)
4454 if (processing_template_decl)
4457 r = fold_simple_1 (t);
4464 /* If T is a constant expression, returns its reduced value.
4465 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4466 Otherwise, returns a version of T without TREE_CONSTANT. */
4469 maybe_constant_value_1 (tree t, tree decl)
4473 if (!potential_nondependent_constant_expression (t))
4475 if (TREE_OVERFLOW_P (t))
4477 t = build_nop (TREE_TYPE (t), t);
4478 TREE_CONSTANT (t) = false;
4483 r = cxx_eval_outermost_constant_expr (t, true, true, decl);
4484 gcc_checking_assert (r == t
4485 || CONVERT_EXPR_P (t)
4486 || TREE_CODE (t) == VIEW_CONVERT_EXPR
4487 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
4488 || !cp_tree_equal (r, t));
4492 static GTY((deletable)) hash_map<tree, tree> *cv_cache;
4494 /* If T is a constant expression, returns its reduced value.
4495 Otherwise, if T does not have TREE_CONSTANT set, returns T.
4496 Otherwise, returns a version of T without TREE_CONSTANT. */
4499 maybe_constant_value (tree t, tree decl)
4501 if (cv_cache == NULL)
4502 cv_cache = hash_map<tree, tree>::create_ggc (101);
4504 if (tree *cached = cv_cache->get (t))
4507 tree ret = maybe_constant_value_1 (t, decl);
4508 cv_cache->put (t, ret);
4512 /* Dispose of the whole CV_CACHE. */
4515 clear_cv_cache (void)
4517 if (cv_cache != NULL)
4521 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
4524 clear_cv_and_fold_caches (void)
4527 clear_fold_cache ();
4530 /* Like maybe_constant_value but first fully instantiate the argument.
4532 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
4533 (t, tf_none) followed by maybe_constant_value but is more efficient,
4534 because calls instantiation_dependent_expression_p and
4535 potential_constant_expression at most once. */
4538 fold_non_dependent_expr (tree t)
4543 /* If we're in a template, but T isn't value dependent, simplify
4544 it. We're supposed to treat:
4546 template <typename T> void f(T[1 + 1]);
4547 template <typename T> void f(T[2]);
4549 as two declarations of the same function, for example. */
4550 if (processing_template_decl)
4552 if (potential_nondependent_constant_expression (t))
4554 processing_template_decl_sentinel s;
4555 t = instantiate_non_dependent_expr_internal (t, tf_none);
4557 if (type_unknown_p (t)
4558 || BRACE_ENCLOSED_INITIALIZER_P (t))
4560 if (TREE_OVERFLOW_P (t))
4562 t = build_nop (TREE_TYPE (t), t);
4563 TREE_CONSTANT (t) = false;
4568 tree r = cxx_eval_outermost_constant_expr (t, true, true, NULL_TREE);
4569 /* cp_tree_equal looks through NOPs, so allow them. */
4570 gcc_checking_assert (r == t
4571 || CONVERT_EXPR_P (t)
4572 || TREE_CODE (t) == VIEW_CONVERT_EXPR
4573 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
4574 || !cp_tree_equal (r, t));
4577 else if (TREE_OVERFLOW_P (t))
4579 t = build_nop (TREE_TYPE (t), t);
4580 TREE_CONSTANT (t) = false;
4585 return maybe_constant_value (t);
4588 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
4589 than wrapped in a TARGET_EXPR. */
4592 maybe_constant_init (tree t, tree decl)
4596 if (TREE_CODE (t) == EXPR_STMT)
4597 t = TREE_OPERAND (t, 0);
4598 if (TREE_CODE (t) == CONVERT_EXPR
4599 && VOID_TYPE_P (TREE_TYPE (t)))
4600 t = TREE_OPERAND (t, 0);
4601 if (TREE_CODE (t) == INIT_EXPR)
4602 t = TREE_OPERAND (t, 1);
4603 if (!potential_nondependent_static_init_expression (t))
4604 /* Don't try to evaluate it. */;
4606 t = cxx_eval_outermost_constant_expr (t, true, false, decl);
4607 if (TREE_CODE (t) == TARGET_EXPR)
4609 tree init = TARGET_EXPR_INITIAL (t);
4610 if (TREE_CODE (init) == CONSTRUCTOR)
4617 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
4618 /* Return true if the object referred to by REF has automatic or thread
4621 enum { ck_ok, ck_bad, ck_unknown };
4623 check_automatic_or_tls (tree ref)
4626 HOST_WIDE_INT bitsize, bitpos;
4628 int volatilep = 0, unsignedp = 0;
4629 tree decl = get_inner_reference (ref, &bitsize, &bitpos, &offset,
4630 &mode, &unsignedp, &volatilep, false);
4633 /* If there isn't a decl in the middle, we don't know the linkage here,
4634 and this isn't a constant expression anyway. */
4637 dk = decl_storage_duration (decl);
4638 return (dk == dk_auto || dk == dk_thread) ? ck_bad : ck_ok;
4642 /* Return true if T denotes a potentially constant expression. Issue
4643 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
4644 an lvalue-rvalue conversion is implied.
4646 C++0x [expr.const] used to say
4648 6 An expression is a potential constant expression if it is
4649 a constant expression where all occurrences of function
4650 parameters are replaced by arbitrary constant expressions
4651 of the appropriate type.
4653 2 A conditional expression is a constant expression unless it
4654 involves one of the following as a potentially evaluated
4655 subexpression (3.2), but subexpressions of logical AND (5.14),
4656 logical OR (5.15), and conditional (5.16) operations that are
4657 not evaluated are not considered. */
4660 potential_constant_expression_1 (tree t, bool want_rval, bool strict,
4661 tsubst_flags_t flags)
4663 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
4664 enum { any = false, rval = true };
4668 if (t == error_mark_node)
4672 if (TREE_THIS_VOLATILE (t) && !DECL_P (t))
4674 if (flags & tf_error)
4675 error ("expression %qE has side-effects", t);
4678 if (CONSTANT_CLASS_P (t))
4681 switch (TREE_CODE (t))
4687 case TEMPLATE_ID_EXPR:
4690 case CASE_LABEL_EXPR:
4696 case TEMPLATE_PARM_INDEX:
4698 case IDENTIFIER_NODE:
4699 case USERDEF_LITERAL:
4700 /* We can see a FIELD_DECL in a pointer-to-member expression. */
4706 case PLACEHOLDER_EXPR:
4712 case AGGR_INIT_EXPR:
4714 /* -- an invocation of a function other than a constexpr function
4715 or a constexpr constructor. */
4717 tree fun = get_function_named_in_call (t);
4718 const int nargs = call_expr_nargs (t);
4721 if (fun == NULL_TREE)
4723 if (TREE_CODE (t) == CALL_EXPR
4724 && CALL_EXPR_FN (t) == NULL_TREE)
4725 switch (CALL_EXPR_IFN (t))
4727 /* These should be ignored, they are optimized away from
4728 constexpr functions. */
4729 case IFN_UBSAN_NULL:
4730 case IFN_UBSAN_BOUNDS:
4731 case IFN_UBSAN_VPTR:
4736 /* fold_call_expr can't do anything with IFN calls. */
4737 if (flags & tf_error)
4738 error_at (EXPR_LOC_OR_LOC (t, input_location),
4739 "call to internal function");
4742 if (is_overloaded_fn (fun))
4744 if (TREE_CODE (fun) == FUNCTION_DECL)
4746 if (builtin_valid_in_constant_expr_p (fun))
4748 if (!DECL_DECLARED_CONSTEXPR_P (fun)
4749 /* Allow any built-in function; if the expansion
4750 isn't constant, we'll deal with that then. */
4751 && !is_builtin_fn (fun))
4753 if (flags & tf_error)
4755 error_at (EXPR_LOC_OR_LOC (t, input_location),
4756 "call to non-constexpr function %qD", fun);
4757 explain_invalid_constexpr_fn (fun);
4761 /* A call to a non-static member function takes the address
4762 of the object as the first argument. But in a constant
4763 expression the address will be folded away, so look
4765 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
4766 && !DECL_CONSTRUCTOR_P (fun))
4768 tree x = get_nth_callarg (t, 0);
4769 if (is_this_parameter (x))
4771 else if (!RECUR (x, rval))
4778 if (!RECUR (fun, true))
4780 fun = get_first_fn (fun);
4782 /* Skip initial arguments to base constructors. */
4783 if (DECL_BASE_CONSTRUCTOR_P (fun))
4784 i = num_artificial_parms_for (fun);
4785 fun = DECL_ORIGIN (fun);
4789 if (RECUR (fun, rval))
4790 /* Might end up being a constant function pointer. */;
4794 for (; i < nargs; ++i)
4796 tree x = get_nth_callarg (t, i);
4797 /* In a template, reference arguments haven't been converted to
4798 REFERENCE_TYPE and we might not even know if the parameter
4799 is a reference, so accept lvalue constants too. */
4800 bool rv = processing_template_decl ? any : rval;
4807 case NON_LVALUE_EXPR:
4808 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
4809 -- an lvalue of integral type that refers to a non-volatile
4810 const variable or static data member initialized with
4811 constant expressions, or
4813 -- an lvalue of literal type that refers to non-volatile
4814 object defined with constexpr, or that refers to a
4815 sub-object of such an object; */
4816 return RECUR (TREE_OPERAND (t, 0), rval);
4820 && !decl_constant_var_p (t)
4822 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t))
4823 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t))
4824 && !var_in_constexpr_fn (t)
4825 && !type_dependent_expression_p (t))
4827 if (flags & tf_error)
4828 non_const_var_error (t);
4835 case VIEW_CONVERT_EXPR:
4836 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4837 may change to something more specific to type-punning (DR 1312). */
4839 tree from = TREE_OPERAND (t, 0);
4840 if (POINTER_TYPE_P (TREE_TYPE (t))
4841 && TREE_CODE (from) == INTEGER_CST
4842 && !integer_zerop (from))
4844 if (flags & tf_error)
4845 error_at (EXPR_LOC_OR_LOC (t, input_location),
4846 "reinterpret_cast from integer to pointer");
4849 return (RECUR (from, TREE_CODE (t) != VIEW_CONVERT_EXPR));
4853 /* -- a unary operator & that is applied to an lvalue that
4854 designates an object with thread or automatic storage
4856 t = TREE_OPERAND (t, 0);
4858 if (TREE_CODE (t) == OFFSET_REF && PTRMEM_OK_P (t))
4859 /* A pointer-to-member constant. */
4863 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4864 any checking here, as we might dereference the pointer later. If
4865 we remove this code, also remove check_automatic_or_tls. */
4866 i = check_automatic_or_tls (t);
4871 if (flags & tf_error)
4872 error ("address-of an object %qE with thread local or "
4873 "automatic storage is not a constant expression", t);
4877 return RECUR (t, any);
4883 /* -- a class member access unless its postfix-expression is
4884 of literal type or of pointer to literal type. */
4885 /* This test would be redundant, as it follows from the
4886 postfix-expression being a potential constant expression. */
4887 if (type_unknown_p (t))
4889 return RECUR (TREE_OPERAND (t, 0), want_rval);
4891 case EXPR_PACK_EXPANSION:
4892 return RECUR (PACK_EXPANSION_PATTERN (t), want_rval);
4896 tree x = TREE_OPERAND (t, 0);
4898 if (is_this_parameter (x))
4900 if (DECL_CONTEXT (x)
4901 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x)))
4903 if (flags & tf_error)
4904 error ("use of %<this%> in a constant expression");
4909 return RECUR (x, rval);
4912 case STATEMENT_LIST:
4914 tree_stmt_iterator i;
4915 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
4917 if (!RECUR (tsi_stmt (i), any))
4925 if (cxx_dialect < cxx14)
4927 if (!RECUR (TREE_OPERAND (t, 0), any))
4929 if (!RECUR (TREE_OPERAND (t, 1), rval))
4934 if (cxx_dialect < cxx14)
4936 if (!RECUR (TREE_OPERAND (t, 0), rval))
4938 if (!RECUR (TREE_OPERAND (t, 2), rval))
4943 if (!RECUR (DO_COND (t), rval))
4945 if (!RECUR (DO_BODY (t), any))
4950 if (!RECUR (FOR_INIT_STMT (t), any))
4952 if (!RECUR (FOR_COND (t), rval))
4954 if (!RECUR (FOR_EXPR (t), any))
4956 if (!RECUR (FOR_BODY (t), any))
4961 if (!RECUR (WHILE_COND (t), rval))
4963 if (!RECUR (WHILE_BODY (t), any))
4968 if (!RECUR (SWITCH_STMT_COND (t), rval))
4970 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
4971 unreachable labels would be checked. */
4975 return RECUR (STMT_EXPR_STMT (t), rval);
4978 case DYNAMIC_CAST_EXPR:
4979 case PSEUDO_DTOR_EXPR:
4983 case VEC_DELETE_EXPR:
4986 case OMP_ATOMIC_READ:
4987 case OMP_ATOMIC_CAPTURE_OLD:
4988 case OMP_ATOMIC_CAPTURE_NEW:
4989 /* GCC internal stuff. */
4992 case TRANSACTION_EXPR:
4994 case AT_ENCODE_EXPR:
4996 if (flags & tf_error)
4997 error ("expression %qE is not a constant-expression", t);
5001 /* -- a typeid expression whose operand is of polymorphic
5004 tree e = TREE_OPERAND (t, 0);
5005 if (!TYPE_P (e) && !type_dependent_expression_p (e)
5006 && TYPE_POLYMORPHIC_P (TREE_TYPE (e)))
5008 if (flags & tf_error)
5009 error ("typeid-expression is not a constant expression "
5010 "because %qE is of polymorphic type", e);
5029 case PREINCREMENT_EXPR:
5030 case POSTINCREMENT_EXPR:
5031 case PREDECREMENT_EXPR:
5032 case POSTDECREMENT_EXPR:
5033 if (cxx_dialect < cxx14)
5039 if (TYPE_P (TREE_OPERAND (t, 0)))
5041 /* else fall through. */
5047 case FIX_TRUNC_EXPR:
5051 case TRUTH_NOT_EXPR:
5052 case FIXED_CONVERT_EXPR:
5053 case UNARY_PLUS_EXPR:
5054 case UNARY_LEFT_FOLD_EXPR:
5055 case UNARY_RIGHT_FOLD_EXPR:
5057 return RECUR (TREE_OPERAND (t, 0), rval);
5060 case CONST_CAST_EXPR:
5061 case STATIC_CAST_EXPR:
5062 case REINTERPRET_CAST_EXPR:
5063 case IMPLICIT_CONV_EXPR:
5064 if (cxx_dialect < cxx11
5065 && !dependent_type_p (TREE_TYPE (t))
5066 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t)))
5067 /* In C++98, a conversion to non-integral type can't be part of a
5068 constant expression. */
5070 if (flags & tf_error)
5071 error ("cast to non-integral type %qT in a constant expression",
5076 return (RECUR (TREE_OPERAND (t, 0),
5077 TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE));
5080 return RECUR (BIND_EXPR_BODY (t), want_rval);
5082 case WITH_CLEANUP_EXPR:
5083 case CLEANUP_POINT_EXPR:
5084 case MUST_NOT_THROW_EXPR:
5085 case TRY_CATCH_EXPR:
5091 case NON_DEPENDENT_EXPR:
5092 /* For convenience. */
5096 return RECUR (TREE_OPERAND (t, 0), want_rval);
5098 case TRY_FINALLY_EXPR:
5099 return (RECUR (TREE_OPERAND (t, 0), want_rval)
5100 && RECUR (TREE_OPERAND (t, 1), any));
5103 return RECUR (TREE_OPERAND (t, 1), want_rval);
5106 if (!literal_type_p (TREE_TYPE (t)))
5108 if (flags & tf_error)
5110 error ("temporary of non-literal type %qT in a "
5111 "constant expression", TREE_TYPE (t));
5112 explain_non_literal_class (TREE_TYPE (t));
5117 return RECUR (TREE_OPERAND (t, 1), rval);
5121 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
5122 constructor_elt *ce;
5123 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
5124 if (!RECUR (ce->value, want_rval))
5131 gcc_assert (TREE_PURPOSE (t) == NULL_TREE
5132 || DECL_P (TREE_PURPOSE (t)));
5133 if (!RECUR (TREE_VALUE (t), want_rval))
5135 if (TREE_CHAIN (t) == NULL_TREE)
5137 return RECUR (TREE_CHAIN (t), want_rval);
5140 case TRUNC_DIV_EXPR:
5142 case FLOOR_DIV_EXPR:
5143 case ROUND_DIV_EXPR:
5144 case TRUNC_MOD_EXPR:
5146 case ROUND_MOD_EXPR:
5148 tree denom = TREE_OPERAND (t, 1);
5149 if (!RECUR (denom, rval))
5151 /* We can't call cxx_eval_outermost_constant_expr on an expression
5152 that hasn't been through instantiate_non_dependent_expr yet. */
5153 if (!processing_template_decl)
5154 denom = cxx_eval_outermost_constant_expr (denom, true);
5155 if (integer_zerop (denom))
5157 if (flags & tf_error)
5158 error ("division by zero is not a constant-expression");
5164 return RECUR (TREE_OPERAND (t, 0), want_rval);
5170 /* check_return_expr sometimes wraps a TARGET_EXPR in a
5171 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
5172 introduced by build_call_a. */
5173 tree op0 = TREE_OPERAND (t, 0);
5174 tree op1 = TREE_OPERAND (t, 1);
5176 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
5177 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
5178 return RECUR (op0, want_rval);
5183 /* If the first operand is the non-short-circuit constant, look at
5184 the second operand; otherwise we only care about the first one for
5186 case TRUTH_AND_EXPR:
5187 case TRUTH_ANDIF_EXPR:
5188 tmp = boolean_true_node;
5191 case TRUTH_ORIF_EXPR:
5192 tmp = boolean_false_node;
5195 tree op = TREE_OPERAND (t, 0);
5196 if (!RECUR (op, rval))
5198 if (!processing_template_decl)
5199 op = cxx_eval_outermost_constant_expr (op, true);
5200 if (tree_int_cst_equal (op, tmp))
5201 return RECUR (TREE_OPERAND (t, 1), rval);
5208 case POINTER_PLUS_EXPR:
5210 case EXACT_DIV_EXPR:
5220 case TRUTH_XOR_EXPR:
5221 case UNORDERED_EXPR:
5234 case ARRAY_RANGE_REF:
5238 case BINARY_LEFT_FOLD_EXPR:
5239 case BINARY_RIGHT_FOLD_EXPR:
5241 for (i = 0; i < 2; ++i)
5242 if (!RECUR (TREE_OPERAND (t, i), want_rval))
5246 case CILK_SYNC_STMT:
5247 case CILK_SPAWN_STMT:
5248 case ARRAY_NOTATION_REF:
5253 for (i = 0; i < 3; ++i)
5254 if (!RECUR (TREE_OPERAND (t, i), true))
5259 if (COND_EXPR_IS_VEC_DELETE (t))
5261 if (flags & tf_error)
5262 error_at (location_of (t),
5263 "%<delete[]%> is not a constant-expression");
5269 /* If the condition is a known constant, we know which of the legs we
5270 care about; otherwise we only require that the condition and
5271 either of the legs be potentially constant. */
5272 tmp = TREE_OPERAND (t, 0);
5273 if (!RECUR (tmp, rval))
5275 if (!processing_template_decl)
5276 tmp = cxx_eval_outermost_constant_expr (tmp, true);
5277 if (integer_zerop (tmp))
5278 return RECUR (TREE_OPERAND (t, 2), want_rval);
5279 else if (TREE_CODE (tmp) == INTEGER_CST)
5280 return RECUR (TREE_OPERAND (t, 1), want_rval);
5281 for (i = 1; i < 3; ++i)
5282 if (potential_constant_expression_1 (TREE_OPERAND (t, i),
5283 want_rval, strict, tf_none))
5285 if (flags & tf_error)
5286 error ("expression %qE is not a constant-expression", t);
5290 if (VEC_INIT_EXPR_IS_CONSTEXPR (t))
5292 if (flags & tf_error)
5294 error ("non-constant array initialization");
5295 diagnose_non_constexpr_vec_init (t);
5301 case STATEMENT_LIST_END:
5302 /* We can see these in statement-expressions. */
5306 case EMPTY_CLASS_EXPR:
5311 tree *target = &TREE_OPERAND (t, 0);
5312 /* Gotos representing break and continue are OK. */
5313 if (breaks (target) || continues (target))
5315 if (flags & tf_error)
5316 error ("%<goto%> is not a constant-expression");
5321 if (objc_is_property_ref (t))
5324 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t)));
5331 /* The main entry point to the above. */
5334 potential_constant_expression (tree t)
5336 return potential_constant_expression_1 (t, false, true, tf_none);
5340 potential_static_init_expression (tree t)
5342 return potential_constant_expression_1 (t, false, false, tf_none);
5345 /* As above, but require a constant rvalue. */
5348 potential_rvalue_constant_expression (tree t)
5350 return potential_constant_expression_1 (t, true, true, tf_none);
5353 /* Like above, but complain about non-constant expressions. */
5356 require_potential_constant_expression (tree t)
5358 return potential_constant_expression_1 (t, false, true, tf_warning_or_error);
5361 /* Cross product of the above. */
5364 require_potential_rvalue_constant_expression (tree t)
5366 return potential_constant_expression_1 (t, true, true, tf_warning_or_error);
5369 /* Returns true if T is a potential constant expression that is not
5370 instantiation-dependent, and therefore a candidate for constant folding even
5374 potential_nondependent_constant_expression (tree t)
5376 return (!type_unknown_p (t)
5377 && !BRACE_ENCLOSED_INITIALIZER_P (t)
5378 && potential_constant_expression (t)
5379 && !instantiation_dependent_expression_p (t));
5382 /* Returns true if T is a potential static initializer expression that is not
5383 instantiation-dependent. */
5386 potential_nondependent_static_init_expression (tree t)
5388 return (!type_unknown_p (t)
5389 && !BRACE_ENCLOSED_INITIALIZER_P (t)
5390 && potential_static_init_expression (t)
5391 && !instantiation_dependent_expression_p (t));
5394 /* Finalize constexpr processing after parsing. */
5397 fini_constexpr (void)
5399 /* The contexpr call and fundef copies tables are no longer needed. */
5400 constexpr_call_table = NULL;
5401 fundef_copies_table = NULL;
5404 #include "gt-cp-constexpr.h"