1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2 constexpr functions. These routines are used both during actual parsing
3 and during the instantiation of template functions.
5 Copyright (C) 1998-2015 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "double-int.h"
39 #include "c-family/c-objc.h"
40 #include "tree-iterator.h"
43 #include "tree-inline.h"
46 static bool verify_constant (tree, bool, bool *, bool *);
47 #define VERIFY_CONSTANT(X) \
49 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
53 /* Returns true iff FUN is an instantiation of a constexpr function
54 template or a defaulted constexpr function. */
57 is_instantiation_of_constexpr (tree fun)
59 return ((DECL_TEMPLOID_INSTANTIATION (fun)
60 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun)))
61 || (DECL_DEFAULTED_FN (fun)
62 && DECL_DECLARED_CONSTEXPR_P (fun)));
65 /* Return true if T is a literal type. */
68 literal_type_p (tree t)
71 || TREE_CODE (t) == VECTOR_TYPE
72 || TREE_CODE (t) == REFERENCE_TYPE
73 || (VOID_TYPE_P (t) && cxx_dialect >= cxx14))
77 t = complete_type (t);
78 gcc_assert (COMPLETE_TYPE_P (t) || errorcount);
79 return CLASSTYPE_LITERAL_P (t);
81 if (TREE_CODE (t) == ARRAY_TYPE)
82 return literal_type_p (strip_array_types (t));
86 /* If DECL is a variable declared `constexpr', require its type
87 be literal. Return the DECL if OK, otherwise NULL. */
90 ensure_literal_type_for_constexpr_object (tree decl)
92 tree type = TREE_TYPE (decl);
94 && (DECL_DECLARED_CONSTEXPR_P (decl)
95 || var_in_constexpr_fn (decl))
96 && !processing_template_decl)
98 tree stype = strip_array_types (type);
99 if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype)))
100 /* Don't complain here, we'll complain about incompleteness
101 when we try to initialize the variable. */;
102 else if (!literal_type_p (type))
104 if (DECL_DECLARED_CONSTEXPR_P (decl))
106 error ("the type %qT of constexpr variable %qD is not literal",
108 explain_non_literal_class (type);
112 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))
114 error ("variable %qD of non-literal type %qT in %<constexpr%> "
115 "function", decl, type);
116 explain_non_literal_class (type);
118 cp_function_chain->invalid_constexpr = true;
126 /* Representation of entries in the constexpr function definition table. */
128 struct GTY((for_user)) constexpr_fundef {
133 struct constexpr_fundef_hasher : ggc_hasher<constexpr_fundef *>
135 static hashval_t hash (constexpr_fundef *);
136 static bool equal (constexpr_fundef *, constexpr_fundef *);
139 /* This table holds all constexpr function definitions seen in
140 the current translation unit. */
142 static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table;
144 /* Utility function used for managing the constexpr function table.
145 Return true if the entries pointed to by P and Q are for the
146 same constexpr function. */
149 constexpr_fundef_hasher::equal (constexpr_fundef *lhs, constexpr_fundef *rhs)
151 return lhs->decl == rhs->decl;
154 /* Utility function used for managing the constexpr function table.
155 Return a hash value for the entry pointed to by Q. */
158 constexpr_fundef_hasher::hash (constexpr_fundef *fundef)
160 return DECL_UID (fundef->decl);
163 /* Return a previously saved definition of function FUN. */
165 static constexpr_fundef *
166 retrieve_constexpr_fundef (tree fun)
168 constexpr_fundef fundef = { NULL, NULL };
169 if (constexpr_fundef_table == NULL)
173 return constexpr_fundef_table->find (&fundef);
176 /* Check whether the parameter and return types of FUN are valid for a
177 constexpr function, and complain if COMPLAIN. */
180 is_valid_constexpr_fn (tree fun, bool complain)
184 if (DECL_INHERITED_CTOR_BASE (fun)
185 && TREE_CODE (fun) == TEMPLATE_DECL)
189 error ("inherited constructor %qD is not constexpr",
190 get_inherited_ctor (fun));
194 for (tree parm = FUNCTION_FIRST_USER_PARM (fun);
195 parm != NULL_TREE; parm = TREE_CHAIN (parm))
196 if (!literal_type_p (TREE_TYPE (parm)))
201 error ("invalid type for parameter %d of constexpr "
202 "function %q+#D", DECL_PARM_INDEX (parm), fun);
203 explain_non_literal_class (TREE_TYPE (parm));
208 if (!DECL_CONSTRUCTOR_P (fun))
210 tree rettype = TREE_TYPE (TREE_TYPE (fun));
211 if (!literal_type_p (rettype))
216 error ("invalid return type %qT of constexpr function %q+D",
218 explain_non_literal_class (rettype);
222 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
223 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
228 error ("enclosing class of constexpr non-static member "
229 "function %q+#D is not a literal type", fun);
230 explain_non_literal_class (DECL_CONTEXT (fun));
234 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
238 error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
244 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
245 for a member of an anonymous aggregate, INIT is the initializer for that
246 member, and VEC_OUTER is the vector of constructor elements for the class
247 whose constructor we are processing. Add the initializer to the vector
248 and return true to indicate success. */
251 build_anon_member_initialization (tree member, tree init,
252 vec<constructor_elt, va_gc> **vec_outer)
254 /* MEMBER presents the relevant fields from the inside out, but we need
255 to build up the initializer from the outside in so that we can reuse
256 previously built CONSTRUCTORs if this is, say, the second field in an
257 anonymous struct. So we use a vec as a stack. */
258 auto_vec<tree, 2> fields;
261 fields.safe_push (TREE_OPERAND (member, 1));
262 member = TREE_OPERAND (member, 0);
264 while (ANON_AGGR_TYPE_P (TREE_TYPE (member))
265 && TREE_CODE (member) == COMPONENT_REF);
267 /* VEC has the constructor elements vector for the context of FIELD.
268 If FIELD is an anonymous aggregate, we will push inside it. */
269 vec<constructor_elt, va_gc> **vec = vec_outer;
271 while (field = fields.pop(),
272 ANON_AGGR_TYPE_P (TREE_TYPE (field)))
275 /* If there is already an outer constructor entry for the anonymous
276 aggregate FIELD, use it; otherwise, insert one. */
277 if (vec_safe_is_empty (*vec)
278 || (*vec)->last().index != field)
280 ctor = build_constructor (TREE_TYPE (field), NULL);
281 CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
284 ctor = (*vec)->last().value;
285 vec = &CONSTRUCTOR_ELTS (ctor);
288 /* Now we're at the innermost field, the one that isn't an anonymous
289 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
290 gcc_assert (fields.is_empty());
291 CONSTRUCTOR_APPEND_ELT (*vec, field, init);
296 /* Subroutine of build_constexpr_constructor_member_initializers.
297 The expression tree T represents a data member initialization
298 in a (constexpr) constructor definition. Build a pairing of
299 the data member with its initializer, and prepend that pair
300 to the existing initialization pair INITS. */
303 build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
306 if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
307 t = TREE_OPERAND (t, 0);
308 if (TREE_CODE (t) == EXPR_STMT)
309 t = TREE_OPERAND (t, 0);
310 if (t == error_mark_node)
312 if (TREE_CODE (t) == STATEMENT_LIST)
314 tree_stmt_iterator i;
315 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
317 if (! build_data_member_initialization (tsi_stmt (i), vec))
322 if (TREE_CODE (t) == CLEANUP_STMT)
324 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
325 but we can in a constexpr constructor for a non-literal class. Just
326 ignore it; either all the initialization will be constant, in which
327 case the cleanup can't run, or it can't be constexpr.
328 Still recurse into CLEANUP_BODY. */
329 return build_data_member_initialization (CLEANUP_BODY (t), vec);
331 if (TREE_CODE (t) == CONVERT_EXPR)
332 t = TREE_OPERAND (t, 0);
333 if (TREE_CODE (t) == INIT_EXPR
334 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
335 use what this function builds for cx_check_missing_mem_inits, and
336 assignment in the ctor body doesn't count. */
337 || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR))
339 member = TREE_OPERAND (t, 0);
340 init = break_out_target_exprs (TREE_OPERAND (t, 1));
342 else if (TREE_CODE (t) == CALL_EXPR)
344 tree fn = get_callee_fndecl (t);
345 if (!fn || !DECL_CONSTRUCTOR_P (fn))
346 /* We're only interested in calls to subobject constructors. */
348 member = CALL_EXPR_ARG (t, 0);
349 /* We don't use build_cplus_new here because it complains about
350 abstract bases. Leaving the call unwrapped means that it has the
351 wrong type, but cxx_eval_constant_expression doesn't care. */
352 init = break_out_target_exprs (t);
354 else if (TREE_CODE (t) == BIND_EXPR)
355 return build_data_member_initialization (BIND_EXPR_BODY (t), vec);
357 /* Don't add anything else to the CONSTRUCTOR. */
359 if (INDIRECT_REF_P (member))
360 member = TREE_OPERAND (member, 0);
361 if (TREE_CODE (member) == NOP_EXPR)
365 if (TREE_CODE (op) == ADDR_EXPR)
367 gcc_assert (same_type_ignoring_top_level_qualifiers_p
368 (TREE_TYPE (TREE_TYPE (op)),
369 TREE_TYPE (TREE_TYPE (member))));
370 /* Initializing a cv-qualified member; we need to look through
374 else if (op == current_class_ptr
375 && (same_type_ignoring_top_level_qualifiers_p
376 (TREE_TYPE (TREE_TYPE (member)),
377 current_class_type)))
378 /* Delegating constructor. */
382 /* This is an initializer for an empty base; keep it for now so
383 we can check it in cxx_eval_bare_aggregate. */
384 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
387 if (TREE_CODE (member) == ADDR_EXPR)
388 member = TREE_OPERAND (member, 0);
389 if (TREE_CODE (member) == COMPONENT_REF)
391 tree aggr = TREE_OPERAND (member, 0);
392 if (TREE_CODE (aggr) != COMPONENT_REF)
393 /* Normal member initialization. */
394 member = TREE_OPERAND (member, 1);
395 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
396 /* Initializing a member of an anonymous union. */
397 return build_anon_member_initialization (member, init, vec);
399 /* We're initializing a vtable pointer in a base. Leave it as
400 COMPONENT_REF so we remember the path to get to the vfield. */
401 gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
404 CONSTRUCTOR_APPEND_ELT (*vec, member, init);
408 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
409 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
410 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
413 check_constexpr_bind_expr_vars (tree t)
415 gcc_assert (TREE_CODE (t) == BIND_EXPR);
417 for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var))
418 if (TREE_CODE (var) == TYPE_DECL
419 && DECL_IMPLICIT_TYPEDEF_P (var)
420 && !LAMBDA_TYPE_P (TREE_TYPE (var)))
425 /* Subroutine of check_constexpr_ctor_body. */
428 check_constexpr_ctor_body_1 (tree last, tree list)
430 switch (TREE_CODE (list))
433 if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL)
437 case CLEANUP_POINT_EXPR:
438 return check_constexpr_ctor_body (last, TREE_OPERAND (list, 0),
442 if (!check_constexpr_bind_expr_vars (list)
443 || !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list),
457 /* Make sure that there are no statements after LAST in the constructor
458 body represented by LIST. */
461 check_constexpr_ctor_body (tree last, tree list, bool complain)
463 /* C++14 doesn't require a constexpr ctor to have an empty body. */
464 if (cxx_dialect >= cxx14)
468 if (TREE_CODE (list) == STATEMENT_LIST)
470 tree_stmt_iterator i = tsi_last (list);
471 for (; !tsi_end_p (i); tsi_prev (&i))
473 tree t = tsi_stmt (i);
476 if (!check_constexpr_ctor_body_1 (last, t))
483 else if (list != last
484 && !check_constexpr_ctor_body_1 (last, list))
489 error ("constexpr constructor does not have empty body");
490 DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
495 /* V is a vector of constructor elements built up for the base and member
496 initializers of a constructor for TYPE. They need to be in increasing
497 offset order, which they might not be yet if TYPE has a primary base
498 which is not first in the base-clause or a vptr and at least one base
499 all of which are non-primary. */
501 static vec<constructor_elt, va_gc> *
502 sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
504 tree pri = CLASSTYPE_PRIMARY_BINFO (type);
510 field_type = BINFO_TYPE (pri);
511 else if (TYPE_CONTAINS_VPTR_P (type))
512 field_type = vtbl_ptr_type_node;
516 /* Find the element for the primary base or vptr and move it to the
517 beginning of the vec. */
518 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
519 if (TREE_TYPE (ce->index) == field_type)
522 if (i > 0 && i < vec_safe_length (v))
524 vec<constructor_elt, va_gc> &vref = *v;
525 constructor_elt elt = vref[i];
534 /* Build compile-time evalable representations of member-initializer list
535 for a constexpr constructor. */
538 build_constexpr_constructor_member_initializers (tree type, tree body)
540 vec<constructor_elt, va_gc> *vec = NULL;
542 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR
543 || TREE_CODE (body) == EH_SPEC_BLOCK)
544 body = TREE_OPERAND (body, 0);
545 if (TREE_CODE (body) == STATEMENT_LIST)
547 for (tree_stmt_iterator i = tsi_start (body);
548 !tsi_end_p (i); tsi_next (&i))
551 if (TREE_CODE (body) == BIND_EXPR)
555 if (TREE_CODE (body) == BIND_EXPR)
556 body = BIND_EXPR_BODY (body);
557 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
559 body = TREE_OPERAND (body, 0);
560 if (TREE_CODE (body) == EXPR_STMT)
561 body = TREE_OPERAND (body, 0);
562 if (TREE_CODE (body) == INIT_EXPR
563 && (same_type_ignoring_top_level_qualifiers_p
564 (TREE_TYPE (TREE_OPERAND (body, 0)),
565 current_class_type)))
568 return TREE_OPERAND (body, 1);
570 ok = build_data_member_initialization (body, &vec);
572 else if (TREE_CODE (body) == STATEMENT_LIST)
574 tree_stmt_iterator i;
575 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
577 ok = build_data_member_initialization (tsi_stmt (i), &vec);
582 else if (TREE_CODE (body) == TRY_BLOCK)
584 error ("body of %<constexpr%> constructor cannot be "
585 "a function-try-block");
586 return error_mark_node;
588 else if (EXPR_P (body))
589 ok = build_data_member_initialization (body, &vec);
591 gcc_assert (errorcount > 0);
594 if (vec_safe_length (vec) > 0)
596 /* In a delegating constructor, return the target. */
597 constructor_elt *ce = &(*vec)[0];
598 if (ce->index == current_class_ptr)
605 vec = sort_constexpr_mem_initializers (type, vec);
606 return build_constructor (type, vec);
609 return error_mark_node;
612 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
613 declared to be constexpr, or a sub-statement thereof. Returns the
614 return value if suitable, error_mark_node for a statement not allowed in
615 a constexpr function, or NULL_TREE if no return value was found. */
618 constexpr_fn_retval (tree body)
620 switch (TREE_CODE (body))
624 tree_stmt_iterator i;
625 tree expr = NULL_TREE;
626 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
628 tree s = constexpr_fn_retval (tsi_stmt (i));
629 if (s == error_mark_node)
630 return error_mark_node;
631 else if (s == NULL_TREE)
632 /* Keep iterating. */;
634 /* Multiple return statements. */
635 return error_mark_node;
643 return break_out_target_exprs (TREE_OPERAND (body, 0));
647 tree decl = DECL_EXPR_DECL (body);
648 if (TREE_CODE (decl) == USING_DECL
649 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
650 || DECL_ARTIFICIAL (decl))
652 return error_mark_node;
655 case CLEANUP_POINT_EXPR:
656 return constexpr_fn_retval (TREE_OPERAND (body, 0));
659 if (!check_constexpr_bind_expr_vars (body))
660 return error_mark_node;
661 return constexpr_fn_retval (BIND_EXPR_BODY (body));
667 return error_mark_node;
671 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
672 FUN; do the necessary transformations to turn it into a single expression
673 that we can store in the hash table. */
676 massage_constexpr_body (tree fun, tree body)
678 if (DECL_CONSTRUCTOR_P (fun))
679 body = build_constexpr_constructor_member_initializers
680 (DECL_CONTEXT (fun), body);
681 else if (cxx_dialect < cxx14)
683 if (TREE_CODE (body) == EH_SPEC_BLOCK)
684 body = EH_SPEC_STMTS (body);
685 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
686 body = TREE_OPERAND (body, 0);
687 body = constexpr_fn_retval (body);
692 /* FUN is a constexpr constructor with massaged body BODY. Return true
693 if some bases/fields are uninitialized, and complain if COMPLAIN. */
696 cx_check_missing_mem_inits (tree fun, tree body, bool complain)
703 if (TREE_CODE (body) != CONSTRUCTOR)
706 nelts = CONSTRUCTOR_NELTS (body);
707 ctype = DECL_CONTEXT (fun);
708 field = TYPE_FIELDS (ctype);
710 if (TREE_CODE (ctype) == UNION_TYPE)
712 if (nelts == 0 && next_initializable_field (field))
715 error ("%<constexpr%> constructor for union %qT must "
716 "initialize exactly one non-static data member", ctype);
723 for (i = 0; i <= nelts; ++i)
730 index = CONSTRUCTOR_ELT (body, i)->index;
731 /* Skip base and vtable inits. */
732 if (TREE_CODE (index) != FIELD_DECL
733 || DECL_ARTIFICIAL (index))
736 for (; field != index; field = DECL_CHAIN (field))
739 if (TREE_CODE (field) != FIELD_DECL
740 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
741 || DECL_ARTIFICIAL (field))
743 ftype = strip_array_types (TREE_TYPE (field));
744 if (type_has_constexpr_default_constructor (ftype))
746 /* It's OK to skip a member with a trivial constexpr ctor.
747 A constexpr ctor that isn't trivial should have been
749 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
755 error ("member %qD must be initialized by mem-initializer "
756 "in %<constexpr%> constructor", field);
757 inform (DECL_SOURCE_LOCATION (field), "declared here");
760 if (field == NULL_TREE)
762 field = DECL_CHAIN (field);
768 /* We are processing the definition of the constexpr function FUN.
769 Check that its BODY fulfills the propriate requirements and
770 enter it in the constexpr function definition table.
771 For constructor BODY is actually the TREE_LIST of the
772 member-initializer list. */
775 register_constexpr_fundef (tree fun, tree body)
777 constexpr_fundef entry;
778 constexpr_fundef **slot;
780 if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
783 body = massage_constexpr_body (fun, body);
784 if (body == NULL_TREE || body == error_mark_node)
786 if (!DECL_CONSTRUCTOR_P (fun))
787 error ("body of constexpr function %qD not a return-statement", fun);
791 if (!potential_rvalue_constant_expression (body))
793 if (!DECL_GENERATED_P (fun))
794 require_potential_rvalue_constant_expression (body);
798 if (DECL_CONSTRUCTOR_P (fun)
799 && cx_check_missing_mem_inits (fun, body, !DECL_GENERATED_P (fun)))
802 /* Create the constexpr function table if necessary. */
803 if (constexpr_fundef_table == NULL)
804 constexpr_fundef_table
805 = hash_table<constexpr_fundef_hasher>::create_ggc (101);
809 slot = constexpr_fundef_table->find_slot (&entry, INSERT);
811 gcc_assert (*slot == NULL);
812 *slot = ggc_alloc<constexpr_fundef> ();
818 /* FUN is a non-constexpr function called in a context that requires a
819 constant expression. If it comes from a constexpr template, explain why
820 the instantiation isn't constexpr. */
823 explain_invalid_constexpr_fn (tree fun)
825 static hash_set<tree> *diagnosed;
828 /* Only diagnose defaulted functions or instantiations. */
829 if (!DECL_DEFAULTED_FN (fun)
830 && !is_instantiation_of_constexpr (fun))
832 if (diagnosed == NULL)
833 diagnosed = new hash_set<tree>;
834 if (diagnosed->add (fun))
835 /* Already explained. */
838 save_loc = input_location;
839 input_location = DECL_SOURCE_LOCATION (fun);
840 inform (0, "%q+D is not usable as a constexpr function because:", fun);
841 /* First check the declaration. */
842 if (is_valid_constexpr_fn (fun, true))
844 /* Then if it's OK, the body. */
845 if (!DECL_DECLARED_CONSTEXPR_P (fun))
846 explain_implicit_non_constexpr (fun);
849 body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
850 require_potential_rvalue_constant_expression (body);
851 if (DECL_CONSTRUCTOR_P (fun))
852 cx_check_missing_mem_inits (fun, body, true);
855 input_location = save_loc;
858 /* Objects of this type represent calls to constexpr functions
859 along with the bindings of parameters to their arguments, for
860 the purpose of compile time evaluation. */
862 struct GTY((for_user)) constexpr_call {
863 /* Description of the constexpr function definition. */
864 constexpr_fundef *fundef;
865 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
866 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
867 Note: This arrangement is made to accommodate the use of
868 iterative_hash_template_arg (see pt.c). If you change this
869 representation, also change the hash calculation in
870 cxx_eval_call_expression. */
872 /* Result of the call.
873 NULL means the call is being evaluated.
874 error_mark_node means that the evaluation was erroneous;
875 otherwise, the actuall value of the call. */
877 /* The hash of this call; we remember it here to avoid having to
878 recalculate it when expanding the hash table. */
882 struct constexpr_call_hasher : ggc_hasher<constexpr_call *>
884 static hashval_t hash (constexpr_call *);
885 static bool equal (constexpr_call *, constexpr_call *);
888 /* The constexpr expansion context. CALL is the current function
889 expansion, CTOR is the current aggregate initializer, OBJECT is the
890 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
891 is a map of values of variables initialized within the expression. */
893 struct constexpr_ctx {
894 /* The innermost call we're evaluating. */
895 constexpr_call *call;
896 /* Values for any temporaries or local variables within the
897 constant-expression. */
898 hash_map<tree,tree> *values;
899 /* The CONSTRUCTOR we're currently building up for an aggregate
902 /* The object we're building the CONSTRUCTOR for. */
904 /* Whether we should error on a non-constant expression or fail quietly. */
906 /* Whether we are strictly conforming to constant expression rules or
907 trying harder to get a constant value. */
911 /* A table of all constexpr calls that have been evaluated by the
912 compiler in this translation unit. */
914 static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
916 static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
917 bool, bool *, bool *, tree * = NULL);
919 /* Compute a hash value for a constexpr call representation. */
922 constexpr_call_hasher::hash (constexpr_call *info)
927 /* Return true if the objects pointed to by P and Q represent calls
928 to the same constexpr function with the same arguments.
929 Otherwise, return false. */
932 constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs)
938 if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef))
940 lhs_bindings = lhs->bindings;
941 rhs_bindings = rhs->bindings;
942 while (lhs_bindings != NULL && rhs_bindings != NULL)
944 tree lhs_arg = TREE_VALUE (lhs_bindings);
945 tree rhs_arg = TREE_VALUE (rhs_bindings);
946 gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
947 if (!cp_tree_equal (lhs_arg, rhs_arg))
949 lhs_bindings = TREE_CHAIN (lhs_bindings);
950 rhs_bindings = TREE_CHAIN (rhs_bindings);
952 return lhs_bindings == rhs_bindings;
955 /* Initialize the constexpr call table, if needed. */
958 maybe_initialize_constexpr_call_table (void)
960 if (constexpr_call_table == NULL)
961 constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101);
964 /* We have an expression tree T that represents a call, either CALL_EXPR
965 or AGGR_INIT_EXPR. If the call is lexically to a named function,
966 retrun the _DECL for that function. */
969 get_function_named_in_call (tree t)
972 switch (TREE_CODE (t))
975 fun = CALL_EXPR_FN (t);
979 fun = AGGR_INIT_EXPR_FN (t);
986 if (fun && TREE_CODE (fun) == ADDR_EXPR
987 && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
988 fun = TREE_OPERAND (fun, 0);
992 /* We have an expression tree T that represents a call, either CALL_EXPR
993 or AGGR_INIT_EXPR. Return the Nth argument. */
996 get_nth_callarg (tree t, int n)
998 switch (TREE_CODE (t))
1001 return CALL_EXPR_ARG (t, n);
1003 case AGGR_INIT_EXPR:
1004 return AGGR_INIT_EXPR_ARG (t, n);
1012 /* Look up the binding of the function parameter T in a constexpr
1013 function call context CALL. */
1016 lookup_parameter_binding (const constexpr_call *call, tree t)
1018 tree b = purpose_member (t, call->bindings);
1019 return TREE_VALUE (b);
1022 /* Attempt to evaluate T which represents a call to a builtin function.
1023 We assume here that all builtin functions evaluate to scalar types
1024 represented by _CST nodes. */
1027 cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t,
1029 bool *non_constant_p, bool *overflow_p)
1031 const int nargs = call_expr_nargs (t);
1032 tree *args = (tree *) alloca (nargs * sizeof (tree));
1035 for (i = 0; i < nargs; ++i)
1037 args[i] = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, i),
1039 non_constant_p, overflow_p);
1040 if (ctx->quiet && *non_constant_p)
1043 if (*non_constant_p)
1045 new_call = fold_build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
1046 CALL_EXPR_FN (t), nargs, args);
1047 VERIFY_CONSTANT (new_call);
1051 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1052 the type of the value to match. */
1055 adjust_temp_type (tree type, tree temp)
1057 if (TREE_TYPE (temp) == type)
1059 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1060 if (TREE_CODE (temp) == CONSTRUCTOR)
1061 return build_constructor (type, CONSTRUCTOR_ELTS (temp));
1062 gcc_assert (scalarish_type_p (type));
1063 return cp_fold_convert (type, temp);
1066 /* True if we want to use the new handling of constexpr calls based on
1068 #define use_new_call true
1070 /* Subroutine of cxx_eval_call_expression.
1071 We are processing a call expression (either CALL_EXPR or
1072 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1073 all arguments and bind their values to correspondings
1074 parameters, making up the NEW_CALL context. */
1077 cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
1078 constexpr_call *new_call,
1079 bool *non_constant_p, bool *overflow_p,
1080 bool *non_constant_args)
1082 const int nargs = call_expr_nargs (t);
1083 tree fun = new_call->fundef->decl;
1084 tree parms = DECL_ARGUMENTS (fun);
1086 tree *p = &new_call->bindings;
1087 for (i = 0; i < nargs; ++i)
1090 tree type = parms ? TREE_TYPE (parms) : void_type_node;
1091 x = get_nth_callarg (t, i);
1092 /* For member function, the first argument is a pointer to the implied
1093 object. For a constructor, it might still be a dummy object, in
1094 which case we get the real argument from ctx. */
1095 if (i == 0 && DECL_CONSTRUCTOR_P (fun)
1096 && is_dummy_object (x))
1099 x = cp_build_addr_expr (x, tf_warning_or_error);
1102 if (parms && DECL_BY_REFERENCE (parms) && !use_new_call)
1104 /* cp_genericize made this a reference for argument passing, but
1105 we don't want to treat it like one for C++11 constexpr
1106 evaluation. C++14 constexpr evaluation uses the genericized
1108 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1109 gcc_assert (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE);
1110 type = TREE_TYPE (type);
1111 x = convert_from_reference (x);
1114 arg = cxx_eval_constant_expression (ctx, x, lval,
1115 non_constant_p, overflow_p);
1116 /* Don't VERIFY_CONSTANT here. */
1117 if (*non_constant_p && ctx->quiet)
1119 /* Just discard ellipsis args after checking their constantitude. */
1122 if (*non_constant_p)
1123 /* Don't try to adjust the type of non-constant args. */
1126 /* Make sure the binding has the same type as the parm. */
1127 if (TREE_CODE (type) != REFERENCE_TYPE)
1128 arg = adjust_temp_type (type, arg);
1129 if (!TREE_CONSTANT (arg))
1130 *non_constant_args = true;
1131 *p = build_tree_list (parms, arg);
1132 p = &TREE_CHAIN (*p);
1134 parms = TREE_CHAIN (parms);
1138 /* Variables and functions to manage constexpr call expansion context.
1139 These do not need to be marked for PCH or GC. */
1141 /* FIXME remember and print actual constant arguments. */
1142 static vec<tree> call_stack = vNULL;
1143 static int call_stack_tick;
1144 static int last_cx_error_tick;
1147 push_cx_call_context (tree call)
1150 if (!EXPR_HAS_LOCATION (call))
1151 SET_EXPR_LOCATION (call, input_location);
1152 call_stack.safe_push (call);
1153 if (call_stack.length () > (unsigned) max_constexpr_depth)
1159 pop_cx_call_context (void)
1166 cx_error_context (void)
1168 vec<tree> r = vNULL;
1169 if (call_stack_tick != last_cx_error_tick
1170 && !call_stack.is_empty ())
1172 last_cx_error_tick = call_stack_tick;
1176 /* Subroutine of cxx_eval_constant_expression.
1177 Evaluate the call expression tree T in the context of OLD_CALL expression
1181 cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
1183 bool *non_constant_p, bool *overflow_p)
1185 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1186 tree fun = get_function_named_in_call (t);
1187 constexpr_call new_call = { NULL, NULL, NULL, 0 };
1190 if (fun == NULL_TREE)
1191 switch (CALL_EXPR_IFN (t))
1193 case IFN_UBSAN_NULL:
1194 case IFN_UBSAN_BOUNDS:
1195 case IFN_UBSAN_VPTR:
1199 error_at (loc, "call to internal function");
1200 *non_constant_p = true;
1204 if (TREE_CODE (fun) != FUNCTION_DECL)
1206 /* Might be a constexpr function pointer. */
1207 fun = cxx_eval_constant_expression (ctx, fun,
1208 /*lval*/false, non_constant_p,
1211 if (TREE_CODE (fun) == ADDR_EXPR)
1212 fun = TREE_OPERAND (fun, 0);
1214 if (TREE_CODE (fun) != FUNCTION_DECL)
1216 if (!ctx->quiet && !*non_constant_p)
1217 error_at (loc, "expression %qE does not designate a constexpr "
1219 *non_constant_p = true;
1222 if (DECL_CLONED_FUNCTION_P (fun))
1223 fun = DECL_CLONED_FUNCTION (fun);
1225 if (is_ubsan_builtin_p (fun))
1228 if (is_builtin_fn (fun))
1229 return cxx_eval_builtin_function_call (ctx, t,
1230 lval, non_constant_p, overflow_p);
1231 if (!DECL_DECLARED_CONSTEXPR_P (fun))
1235 error_at (loc, "call to non-constexpr function %qD", fun);
1236 explain_invalid_constexpr_fn (fun);
1238 *non_constant_p = true;
1242 /* Shortcut trivial constructor/op=. */
1243 if (trivial_fn_p (fun))
1245 if (call_expr_nargs (t) == 2)
1247 tree arg = convert_from_reference (get_nth_callarg (t, 1));
1248 return cxx_eval_constant_expression (ctx, arg,
1249 lval, non_constant_p,
1252 else if (TREE_CODE (t) == AGGR_INIT_EXPR
1253 && AGGR_INIT_ZERO_FIRST (t))
1254 return build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false);
1257 /* We can't defer instantiating the function any longer. */
1258 if (!DECL_INITIAL (fun)
1259 && DECL_TEMPLOID_INSTANTIATION (fun))
1262 instantiate_decl (fun, /*defer_ok*/false, /*expl_inst*/false);
1266 /* If in direct recursive call, optimize definition search. */
1267 if (ctx && ctx->call && ctx->call->fundef->decl == fun)
1268 new_call.fundef = ctx->call->fundef;
1271 new_call.fundef = retrieve_constexpr_fundef (fun);
1272 if (new_call.fundef == NULL || new_call.fundef->body == NULL)
1276 if (DECL_INITIAL (fun))
1278 /* The definition of fun was somehow unsuitable. */
1279 error_at (loc, "%qD called in a constant expression", fun);
1280 explain_invalid_constexpr_fn (fun);
1283 error_at (loc, "%qD used before its definition", fun);
1285 *non_constant_p = true;
1290 constexpr_ctx new_ctx = *ctx;
1291 if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
1292 && TREE_CODE (t) == AGGR_INIT_EXPR)
1294 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1295 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1296 new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
1297 tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
1298 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true;
1299 ctx->values->put (new_ctx.object, ctor);
1303 bool non_constant_args = false;
1304 cxx_bind_parameters_in_call (ctx, t, &new_call,
1305 non_constant_p, overflow_p, &non_constant_args);
1306 if (*non_constant_p)
1309 depth_ok = push_cx_call_context (t);
1311 tree result = NULL_TREE;
1313 constexpr_call *entry = NULL;
1314 if (!non_constant_args)
1316 new_call.hash = iterative_hash_template_arg
1317 (new_call.bindings, constexpr_fundef_hasher::hash (new_call.fundef));
1319 /* If we have seen this call before, we are done. */
1320 maybe_initialize_constexpr_call_table ();
1321 constexpr_call **slot
1322 = constexpr_call_table->find_slot (&new_call, INSERT);
1326 /* We need to keep a pointer to the entry, not just the slot, as the
1327 slot can move in the call to cxx_eval_builtin_function_call. */
1328 *slot = entry = ggc_alloc<constexpr_call> ();
1331 /* Calls which are in progress have their result set to NULL
1332 so that we can detect circular dependencies. */
1333 else if (entry->result == NULL)
1336 error ("call has circular dependency");
1337 *non_constant_p = true;
1338 entry->result = result = error_mark_node;
1341 result = entry->result;
1347 error ("constexpr evaluation depth exceeds maximum of %d (use "
1348 "-fconstexpr-depth= to increase the maximum)",
1349 max_constexpr_depth);
1350 *non_constant_p = true;
1351 result = error_mark_node;
1355 if (!result || result == error_mark_node)
1359 new_ctx.call = &new_call;
1360 result = (cxx_eval_constant_expression
1361 (&new_ctx, new_call.fundef->body,
1363 non_constant_p, overflow_p));
1367 if (DECL_SAVED_TREE (fun) == NULL_TREE
1368 && (DECL_CONSTRUCTOR_P (fun) || DECL_DESTRUCTOR_P (fun)))
1369 /* The maybe-in-charge 'tor had its DECL_SAVED_TREE
1370 cleared, try a clone. */
1371 for (fun = DECL_CHAIN (fun);
1372 fun && DECL_CLONED_FUNCTION_P (fun);
1373 fun = DECL_CHAIN (fun))
1374 if (DECL_SAVED_TREE (fun))
1376 if (!DECL_SAVED_TREE (fun))
1378 /* cgraph/gimplification have released the DECL_SAVED_TREE
1379 for this function. Fail gracefully. */
1380 gcc_assert (ctx->quiet);
1381 *non_constant_p = true;
1386 /* Unshare the whole function body. */
1387 tree body = copy_fn (fun, parms, res);
1389 /* Associate the bindings with the remapped parms. */
1390 tree bound = new_call.bindings;
1391 tree remapped = parms;
1394 tree oparm = TREE_PURPOSE (bound);
1395 tree arg = TREE_VALUE (bound);
1396 gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm));
1397 ctx->values->put (remapped, arg);
1398 bound = TREE_CHAIN (bound);
1399 remapped = DECL_CHAIN (remapped);
1401 /* Add the RESULT_DECL to the values map, too. */
1402 tree slot = NULL_TREE;
1403 if (DECL_BY_REFERENCE (res))
1405 slot = AGGR_INIT_EXPR_SLOT (t);
1406 tree addr = build_address (slot);
1407 addr = build_nop (TREE_TYPE (res), addr);
1408 ctx->values->put (res, addr);
1409 ctx->values->put (slot, NULL_TREE);
1412 ctx->values->put (res, NULL_TREE);
1414 tree jump_target = NULL_TREE;
1415 cxx_eval_constant_expression (ctx, body,
1416 lval, non_constant_p, overflow_p,
1419 if (DECL_CONSTRUCTOR_P (fun))
1420 /* This can be null for a subobject constructor call, in
1421 which case what we care about is the initialization
1422 side-effects rather than the value. We could get at the
1423 value by evaluating *this, but we don't bother; there's
1424 no need to put such a call in the hash table. */
1425 result = lval ? ctx->object : ctx->ctor;
1426 else if (VOID_TYPE_P (TREE_TYPE (res)))
1430 result = *ctx->values->get (slot ? slot : res);
1431 if (result == NULL_TREE && !*non_constant_p)
1434 error ("constexpr call flows off the end "
1436 *non_constant_p = true;
1440 /* Remove the parms/result from the values map. Is it worth
1441 bothering to do this when the map itself is only live for
1442 one constexpr evaluation? If so, maybe also clear out
1443 other vars from call, maybe in BIND_EXPR handling? */
1444 ctx->values->remove (res);
1446 ctx->values->remove (slot);
1447 for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
1448 ctx->values->remove (parm);
1452 if (result == error_mark_node)
1453 *non_constant_p = true;
1454 if (*non_constant_p)
1455 result = error_mark_node;
1458 /* If this was a call to initialize an object, set the type of
1459 the CONSTRUCTOR to the type of that object. */
1460 if (DECL_CONSTRUCTOR_P (fun) && !use_new_call)
1462 tree ob_arg = get_nth_callarg (t, 0);
1463 STRIP_NOPS (ob_arg);
1464 gcc_assert (TYPE_PTR_P (TREE_TYPE (ob_arg))
1465 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg))));
1466 result = adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg)),
1473 entry->result = result;
1476 pop_cx_call_context ();
1477 return unshare_expr (result);
1480 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1483 reduced_constant_expression_p (tree t)
1485 switch (TREE_CODE (t))
1488 /* Even if we can't lower this yet, it's constant. */
1492 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1493 tree elt; unsigned HOST_WIDE_INT idx;
1494 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, elt)
1495 if (!reduced_constant_expression_p (elt))
1500 /* FIXME are we calling this too much? */
1501 return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
1505 /* Some expressions may have constant operands but are not constant
1506 themselves, such as 1/0. Call this function (or rather, the macro
1507 following it) to check for that condition.
1509 We only call this in places that require an arithmetic constant, not in
1510 places where we might have a non-constant expression that can be a
1511 component of a constant expression, such as the address of a constexpr
1512 variable that might be dereferenced later. */
1515 verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
1518 if (!*non_constant_p && !reduced_constant_expression_p (t))
1520 if (!allow_non_constant)
1521 error ("%q+E is not a constant expression", t);
1522 *non_constant_p = true;
1524 if (TREE_OVERFLOW_P (t))
1526 if (!allow_non_constant)
1528 permerror (input_location, "overflow in constant expression");
1529 /* If we're being permissive (and are in an enforcing
1530 context), ignore the overflow. */
1531 if (flag_permissive)
1532 return *non_constant_p;
1536 return *non_constant_p;
1539 /* Check whether the shift operation with code CODE and type TYPE on LHS
1540 and RHS is undefined. If it is, give an error with an explanation,
1541 and return true; return false otherwise. */
1544 cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx,
1545 enum tree_code code, tree type, tree lhs, tree rhs)
1547 if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR)
1548 || TREE_CODE (lhs) != INTEGER_CST
1549 || TREE_CODE (rhs) != INTEGER_CST)
1552 tree lhstype = TREE_TYPE (lhs);
1553 unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs));
1555 /* [expr.shift] The behavior is undefined if the right operand
1556 is negative, or greater than or equal to the length in bits
1557 of the promoted left operand. */
1558 if (tree_int_cst_sgn (rhs) == -1)
1561 error_at (loc, "right operand of shift expression %q+E is negative",
1562 build2_loc (loc, code, type, lhs, rhs));
1565 if (compare_tree_int (rhs, uprec) >= 0)
1568 error_at (loc, "right operand of shift expression %q+E is >= than "
1569 "the precision of the left operand",
1570 build2_loc (loc, code, type, lhs, rhs));
1574 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1575 if E1 has a signed type and non-negative value, and E1x2^E2 is
1576 representable in the corresponding unsigned type of the result type,
1577 then that value, converted to the result type, is the resulting value;
1578 otherwise, the behavior is undefined. */
1579 if (code == LSHIFT_EXPR && !TYPE_UNSIGNED (lhstype)
1580 && (cxx_dialect >= cxx11))
1582 if (tree_int_cst_sgn (lhs) == -1)
1585 error_at (loc, "left operand of shift expression %q+E is negative",
1586 build2_loc (loc, code, type, lhs, rhs));
1589 /* For signed x << y the following:
1590 (unsigned) x >> ((prec (lhs) - 1) - y)
1591 if > 1, is undefined. The right-hand side of this formula
1592 is the highest bit of the LHS that can be set (starting from 0),
1593 so that the shift doesn't overflow. We then right-shift the LHS
1594 to see whether any other bit is set making the original shift
1595 undefined -- the result is not representable in the corresponding
1597 tree t = build_int_cst (unsigned_type_node, uprec - 1);
1598 t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs);
1599 tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs);
1600 t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t);
1601 if (tree_int_cst_lt (integer_one_node, t))
1604 error_at (loc, "shift expression %q+E overflows",
1605 build2_loc (loc, code, type, lhs, rhs));
1612 /* Subroutine of cxx_eval_constant_expression.
1613 Attempt to reduce the unary expression tree T to a compile time value.
1614 If successful, return the value. Otherwise issue a diagnostic
1615 and return error_mark_node. */
1618 cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
1620 bool *non_constant_p, bool *overflow_p)
1623 tree orig_arg = TREE_OPERAND (t, 0);
1624 tree arg = cxx_eval_constant_expression (ctx, orig_arg, /*lval*/false,
1625 non_constant_p, overflow_p);
1626 VERIFY_CONSTANT (arg);
1627 location_t loc = EXPR_LOCATION (t);
1628 enum tree_code code = TREE_CODE (t);
1629 tree type = TREE_TYPE (t);
1630 r = fold_unary_loc (loc, code, type, arg);
1633 if (arg == orig_arg)
1636 r = build1_loc (loc, code, type, arg);
1638 VERIFY_CONSTANT (r);
1642 /* Subroutine of cxx_eval_constant_expression.
1643 Like cxx_eval_unary_expression, except for binary expressions. */
1646 cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
1648 bool *non_constant_p, bool *overflow_p)
1651 tree orig_lhs = TREE_OPERAND (t, 0);
1652 tree orig_rhs = TREE_OPERAND (t, 1);
1654 lhs = cxx_eval_constant_expression (ctx, orig_lhs, /*lval*/false,
1655 non_constant_p, overflow_p);
1656 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1657 a local array in a constexpr function. */
1658 bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs));
1660 VERIFY_CONSTANT (lhs);
1661 rhs = cxx_eval_constant_expression (ctx, orig_rhs, /*lval*/false,
1662 non_constant_p, overflow_p);
1664 VERIFY_CONSTANT (rhs);
1666 location_t loc = EXPR_LOCATION (t);
1667 enum tree_code code = TREE_CODE (t);
1668 tree type = TREE_TYPE (t);
1669 r = fold_binary_loc (loc, code, type, lhs, rhs);
1672 if (lhs == orig_lhs && rhs == orig_rhs)
1675 r = build2_loc (loc, code, type, lhs, rhs);
1677 else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs))
1678 *non_constant_p = true;
1680 VERIFY_CONSTANT (r);
1684 /* Subroutine of cxx_eval_constant_expression.
1685 Attempt to evaluate condition expressions. Dead branches are not
1689 cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
1691 bool *non_constant_p, bool *overflow_p,
1694 tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
1696 non_constant_p, overflow_p);
1697 VERIFY_CONSTANT (val);
1698 /* Don't VERIFY_CONSTANT the other operands. */
1699 if (integer_zerop (val))
1700 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
1702 non_constant_p, overflow_p,
1704 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
1706 non_constant_p, overflow_p,
1710 /* Subroutine of cxx_eval_constant_expression.
1711 Attempt to reduce a reference to an array slot. */
1714 cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
1716 bool *non_constant_p, bool *overflow_p)
1718 tree oldary = TREE_OPERAND (t, 0);
1719 tree ary = cxx_eval_constant_expression (ctx, oldary,
1721 non_constant_p, overflow_p);
1725 unsigned len, elem_nchars = 1;
1726 if (*non_constant_p)
1728 oldidx = TREE_OPERAND (t, 1);
1729 index = cxx_eval_constant_expression (ctx, oldidx,
1731 non_constant_p, overflow_p);
1732 VERIFY_CONSTANT (index);
1733 if (lval && ary == oldary && index == oldidx)
1736 return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
1737 elem_type = TREE_TYPE (TREE_TYPE (ary));
1738 if (TREE_CODE (ary) == CONSTRUCTOR)
1739 len = CONSTRUCTOR_NELTS (ary);
1740 else if (TREE_CODE (ary) == STRING_CST)
1742 elem_nchars = (TYPE_PRECISION (elem_type)
1743 / TYPE_PRECISION (char_type_node));
1744 len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
1748 /* We can't do anything with other tree codes, so use
1749 VERIFY_CONSTANT to complain and fail. */
1750 VERIFY_CONSTANT (ary);
1753 if (compare_tree_int (index, len) >= 0)
1755 if (tree_int_cst_lt (index, array_type_nelts_top (TREE_TYPE (ary))))
1757 /* If it's within the array bounds but doesn't have an explicit
1758 initializer, it's value-initialized. */
1759 tree val = build_value_init (elem_type, tf_warning_or_error);
1760 return cxx_eval_constant_expression (ctx, val,
1762 non_constant_p, overflow_p);
1766 error ("array subscript out of bound");
1767 *non_constant_p = true;
1770 else if (tree_int_cst_lt (index, integer_zero_node))
1773 error ("negative array subscript");
1774 *non_constant_p = true;
1777 i = tree_to_shwi (index);
1778 if (TREE_CODE (ary) == CONSTRUCTOR)
1779 return (*CONSTRUCTOR_ELTS (ary))[i].value;
1780 else if (elem_nchars == 1)
1781 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary))),
1782 TREE_STRING_POINTER (ary)[i]);
1785 tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (ary)));
1786 return native_interpret_expr (type, (const unsigned char *)
1787 TREE_STRING_POINTER (ary)
1788 + i * elem_nchars, elem_nchars);
1790 /* Don't VERIFY_CONSTANT here. */
1793 /* Subroutine of cxx_eval_constant_expression.
1794 Attempt to reduce a field access of a value of class type. */
1797 cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
1799 bool *non_constant_p, bool *overflow_p)
1801 unsigned HOST_WIDE_INT i;
1804 tree part = TREE_OPERAND (t, 1);
1805 tree orig_whole = TREE_OPERAND (t, 0);
1806 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
1808 non_constant_p, overflow_p);
1809 if (whole == orig_whole)
1812 return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
1813 whole, part, NULL_TREE);
1814 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1816 if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
1819 error ("%qE is not a constant expression", orig_whole);
1820 *non_constant_p = true;
1822 if (DECL_MUTABLE_P (part))
1825 error ("mutable %qD is not usable in a constant expression", part);
1826 *non_constant_p = true;
1828 if (*non_constant_p)
1830 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
1837 /* We're in the middle of initializing it. */
1841 if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
1842 && CONSTRUCTOR_NELTS (whole) > 0)
1844 /* DR 1188 says we don't have to deal with this. */
1846 error ("accessing %qD member instead of initialized %qD member in "
1847 "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
1848 *non_constant_p = true;
1852 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole))
1854 /* 'whole' is part of the aggregate initializer we're currently
1855 building; if there's no initializer for this member yet, that's an
1858 error ("accessing uninitialized member %qD", part);
1859 *non_constant_p = true;
1863 /* If there's no explicit init for this field, it's value-initialized. */
1864 value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
1865 return cxx_eval_constant_expression (ctx, value,
1867 non_constant_p, overflow_p);
1870 /* Subroutine of cxx_eval_constant_expression.
1871 Attempt to reduce a field access of a value of class type that is
1872 expressed as a BIT_FIELD_REF. */
1875 cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
1877 bool *non_constant_p, bool *overflow_p)
1879 tree orig_whole = TREE_OPERAND (t, 0);
1880 tree retval, fldval, utype, mask;
1881 bool fld_seen = false;
1882 HOST_WIDE_INT istart, isize;
1883 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
1885 non_constant_p, overflow_p);
1886 tree start, field, value;
1887 unsigned HOST_WIDE_INT i;
1889 if (whole == orig_whole)
1891 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1893 if (!*non_constant_p
1894 && TREE_CODE (whole) != VECTOR_CST
1895 && TREE_CODE (whole) != CONSTRUCTOR)
1898 error ("%qE is not a constant expression", orig_whole);
1899 *non_constant_p = true;
1901 if (*non_constant_p)
1904 if (TREE_CODE (whole) == VECTOR_CST)
1905 return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
1906 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
1908 start = TREE_OPERAND (t, 2);
1909 istart = tree_to_shwi (start);
1910 isize = tree_to_shwi (TREE_OPERAND (t, 1));
1911 utype = TREE_TYPE (t);
1912 if (!TYPE_UNSIGNED (utype))
1913 utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
1914 retval = build_int_cst (utype, 0);
1915 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
1917 tree bitpos = bit_position (field);
1918 if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
1920 if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
1921 && TREE_CODE (value) == INTEGER_CST
1922 && tree_fits_shwi_p (bitpos)
1923 && tree_fits_shwi_p (DECL_SIZE (field)))
1925 HOST_WIDE_INT bit = tree_to_shwi (bitpos);
1926 HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field));
1927 HOST_WIDE_INT shift;
1928 if (bit >= istart && bit + sz <= istart + isize)
1930 fldval = fold_convert (utype, value);
1931 mask = build_int_cst_type (utype, -1);
1932 mask = fold_build2 (LSHIFT_EXPR, utype, mask,
1933 size_int (TYPE_PRECISION (utype) - sz));
1934 mask = fold_build2 (RSHIFT_EXPR, utype, mask,
1935 size_int (TYPE_PRECISION (utype) - sz));
1936 fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
1937 shift = bit - istart;
1938 if (BYTES_BIG_ENDIAN)
1939 shift = TYPE_PRECISION (utype) - shift - sz;
1940 fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
1942 retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
1948 return fold_convert (TREE_TYPE (t), retval);
1950 return error_mark_node;
1953 /* Subroutine of cxx_eval_constant_expression.
1954 Evaluate a short-circuited logical expression T in the context
1955 of a given constexpr CALL. BAILOUT_VALUE is the value for
1956 early return. CONTINUE_VALUE is used here purely for
1957 sanity check purposes. */
1960 cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
1961 tree bailout_value, tree continue_value,
1963 bool *non_constant_p, bool *overflow_p)
1966 tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
1968 non_constant_p, overflow_p);
1969 VERIFY_CONSTANT (lhs);
1970 if (tree_int_cst_equal (lhs, bailout_value))
1972 gcc_assert (tree_int_cst_equal (lhs, continue_value));
1973 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
1974 lval, non_constant_p,
1976 VERIFY_CONSTANT (r);
1980 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
1981 CONSTRUCTOR elements to initialize (part of) an object containing that
1982 field. Return a pointer to the constructor_elt corresponding to the
1983 initialization of the field. */
1985 static constructor_elt *
1986 base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
1988 tree aggr = TREE_OPERAND (ref, 0);
1989 tree field = TREE_OPERAND (ref, 1);
1991 constructor_elt *ce;
1993 gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
1995 if (TREE_CODE (aggr) == COMPONENT_REF)
1997 constructor_elt *base_ce
1998 = base_field_constructor_elt (v, aggr);
1999 v = CONSTRUCTOR_ELTS (base_ce->value);
2002 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
2003 if (ce->index == field)
2010 /* Some of the expressions fed to the constexpr mechanism are calls to
2011 constructors, which have type void. In that case, return the type being
2012 initialized by the constructor. */
2015 initialized_type (tree t)
2019 tree type = cv_unqualified (TREE_TYPE (t));
2020 if (TREE_CODE (t) == CALL_EXPR || TREE_CODE (t) == AGGR_INIT_EXPR)
2022 /* A constructor call has void type, so we need to look deeper. */
2023 tree fn = get_function_named_in_call (t);
2024 if (fn && TREE_CODE (fn) == FUNCTION_DECL
2025 && DECL_CXX_CONSTRUCTOR_P (fn))
2026 type = DECL_CONTEXT (fn);
2031 /* We're about to initialize element INDEX of an array or class from VALUE.
2032 Set up NEW_CTX appropriately by adjusting .object to refer to the
2033 subobject and creating a new CONSTRUCTOR if the element is itself
2034 a class or array. */
2037 init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
2038 tree index, tree &value)
2042 if (index && TREE_CODE (index) != INTEGER_CST
2043 && TREE_CODE (index) != FIELD_DECL)
2044 /* This won't have an element in the new CONSTRUCTOR. */
2047 tree type = initialized_type (value);
2048 if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type))
2049 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2052 /* The sub-aggregate initializer might contain a placeholder;
2053 update object to refer to the subobject and ctor to refer to
2054 the (newly created) sub-initializer. */
2056 new_ctx.object = build_ctor_subob_ref (index, type, ctx->object);
2057 tree elt = build_constructor (type, NULL);
2058 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt) = true;
2061 if (TREE_CODE (value) == TARGET_EXPR)
2062 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2063 value = TARGET_EXPR_INITIAL (value);
2066 /* We're about to process an initializer for a class or array TYPE. Make
2067 sure that CTX is set up appropriately. */
2070 verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
2072 /* We don't bother building a ctor for an empty base subobject. */
2073 if (is_empty_class (type))
2076 /* We're in the middle of an initializer that might involve placeholders;
2077 our caller should have created a CONSTRUCTOR for us to put the
2078 initializer into. We will either return that constructor or T. */
2079 gcc_assert (ctx->ctor);
2080 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2081 (type, TREE_TYPE (ctx->ctor)));
2082 gcc_assert (CONSTRUCTOR_NELTS (ctx->ctor) == 0);
2084 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2085 (type, TREE_TYPE (ctx->object)));
2086 gcc_assert (!ctx->object || !DECL_P (ctx->object)
2087 || *(ctx->values->get (ctx->object)) == ctx->ctor);
2090 /* Subroutine of cxx_eval_constant_expression.
2091 The expression tree T denotes a C-style array or a C-style
2092 aggregate. Reduce it to a constant expression. */
2095 cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
2097 bool *non_constant_p, bool *overflow_p)
2099 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
2100 bool changed = false;
2101 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
2103 verify_ctor_sanity (ctx, TREE_TYPE (t));
2104 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2105 vec_alloc (*p, vec_safe_length (v));
2107 unsigned i; tree index, value;
2108 FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value)
2110 constexpr_ctx new_ctx;
2111 init_subob_ctx (ctx, new_ctx, index, value);
2112 if (new_ctx.ctor != ctx->ctor)
2113 /* If we built a new CONSTRUCTOR, attach it now so that other
2114 initializers can refer to it. */
2115 CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor);
2116 tree elt = cxx_eval_constant_expression (&new_ctx, value,
2118 non_constant_p, overflow_p);
2119 /* Don't VERIFY_CONSTANT here. */
2120 if (ctx->quiet && *non_constant_p)
2124 if (index && TREE_CODE (index) == COMPONENT_REF)
2126 /* This is an initialization of a vfield inside a base
2127 subaggregate that we already initialized; push this
2128 initialization into the previous initialization. */
2129 constructor_elt *inner = base_field_constructor_elt (*p, index);
2134 && (TREE_CODE (index) == NOP_EXPR
2135 || TREE_CODE (index) == POINTER_PLUS_EXPR))
2137 /* This is an initializer for an empty base; now that we've
2138 checked that it's constant, we can ignore it. */
2139 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index))));
2142 else if (new_ctx.ctor != ctx->ctor)
2144 /* We appended this element above; update the value. */
2145 gcc_assert ((*p)->last().index == index);
2146 (*p)->last().value = elt;
2149 CONSTRUCTOR_APPEND_ELT (*p, index, elt);
2151 if (*non_constant_p || !changed)
2154 /* We're done building this CONSTRUCTOR, so now we can interpret an
2155 element without an explicit initializer as value-initialized. */
2156 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
2157 if (TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2162 /* Subroutine of cxx_eval_constant_expression.
2163 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2164 initialization of a non-static data member of array type. Reduce it to a
2167 Note that apart from value-initialization (when VALUE_INIT is true),
2168 this is only intended to support value-initialization and the
2169 initializations done by defaulted constructors for classes with
2170 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2171 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2172 for the copy/move constructor. */
2175 cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
2176 bool value_init, bool lval,
2177 bool *non_constant_p, bool *overflow_p)
2179 tree elttype = TREE_TYPE (atype);
2180 unsigned HOST_WIDE_INT max = tree_to_uhwi (array_type_nelts_top (atype));
2181 verify_ctor_sanity (ctx, atype);
2182 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2183 vec_alloc (*p, max + 1);
2184 bool pre_init = false;
2185 unsigned HOST_WIDE_INT i;
2187 /* For the default constructor, build up a call to the default
2188 constructor of the element type. We only need to handle class types
2189 here, as for a constructor to be constexpr, all members must be
2190 initialized, which for a defaulted default constructor means they must
2191 be of a class type with a constexpr default constructor. */
2192 if (TREE_CODE (elttype) == ARRAY_TYPE)
2193 /* We only do this at the lowest level. */;
2194 else if (value_init)
2196 init = build_value_init (elttype, tf_warning_or_error);
2201 vec<tree, va_gc> *argvec = make_tree_vector ();
2202 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
2203 &argvec, elttype, LOOKUP_NORMAL,
2204 tf_warning_or_error);
2205 release_tree_vector (argvec);
2206 init = build_aggr_init_expr (TREE_TYPE (init), init);
2210 for (i = 0; i < max; ++i)
2212 tree idx = build_int_cst (size_type_node, i);
2214 constexpr_ctx new_ctx;
2215 init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype);
2216 if (new_ctx.ctor != ctx->ctor)
2217 CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor);
2218 if (TREE_CODE (elttype) == ARRAY_TYPE)
2220 /* A multidimensional array; recurse. */
2221 if (value_init || init == NULL_TREE)
2222 eltinit = NULL_TREE;
2224 eltinit = cp_build_array_ref (input_location, init, idx,
2225 tf_warning_or_error);
2226 eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
2228 non_constant_p, overflow_p);
2232 /* Initializing an element using value or default initialization
2233 we just pre-built above. */
2234 eltinit = (cxx_eval_constant_expression
2236 lval, non_constant_p, overflow_p));
2240 /* Copying an element. */
2241 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2242 (atype, TREE_TYPE (init)));
2243 eltinit = cp_build_array_ref (input_location, init, idx,
2244 tf_warning_or_error);
2245 if (!real_lvalue_p (init))
2246 eltinit = move (eltinit);
2247 eltinit = force_rvalue (eltinit, tf_warning_or_error);
2248 eltinit = (cxx_eval_constant_expression
2249 (&new_ctx, eltinit, lval,
2250 non_constant_p, overflow_p));
2252 if (*non_constant_p && !ctx->quiet)
2254 if (new_ctx.ctor != ctx->ctor)
2256 /* We appended this element above; update the value. */
2257 gcc_assert ((*p)->last().index == idx);
2258 (*p)->last().value = eltinit;
2261 CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit);
2264 if (!*non_constant_p)
2267 CONSTRUCTOR_NO_IMPLICIT_ZERO (init) = false;
2273 cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
2275 bool *non_constant_p, bool *overflow_p)
2277 tree atype = TREE_TYPE (t);
2278 tree init = VEC_INIT_EXPR_INIT (t);
2279 tree r = cxx_eval_vec_init_1 (ctx, atype, init,
2280 VEC_INIT_EXPR_VALUE_INIT (t),
2281 lval, non_constant_p, overflow_p);
2282 if (*non_constant_p)
2288 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2289 match. We want to be less strict for simple *& folding; if we have a
2290 non-const temporary that we access through a const pointer, that should
2291 work. We handle this here rather than change fold_indirect_ref_1
2292 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2293 don't really make sense outside of constant expression evaluation. Also
2294 we want to allow folding to COMPONENT_REF, which could cause trouble
2295 with TBAA in fold_indirect_ref_1.
2297 Try to keep this function synced with fold_indirect_ref_1. */
2300 cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
2306 subtype = TREE_TYPE (sub);
2307 if (!POINTER_TYPE_P (subtype))
2310 if (TREE_CODE (sub) == ADDR_EXPR)
2312 tree op = TREE_OPERAND (sub, 0);
2313 tree optype = TREE_TYPE (op);
2315 /* *&CONST_DECL -> to the value of the const decl. */
2316 if (TREE_CODE (op) == CONST_DECL)
2317 return DECL_INITIAL (op);
2318 /* *&p => p; make sure to handle *&"str"[cst] here. */
2319 if (same_type_ignoring_top_level_qualifiers_p (optype, type))
2321 tree fop = fold_read_from_constant_string (op);
2327 /* *(foo *)&fooarray => fooarray[0] */
2328 else if (TREE_CODE (optype) == ARRAY_TYPE
2329 && (same_type_ignoring_top_level_qualifiers_p
2330 (type, TREE_TYPE (optype))))
2332 tree type_domain = TYPE_DOMAIN (optype);
2333 tree min_val = size_zero_node;
2334 if (type_domain && TYPE_MIN_VALUE (type_domain))
2335 min_val = TYPE_MIN_VALUE (type_domain);
2336 return build4_loc (loc, ARRAY_REF, type, op, min_val,
2337 NULL_TREE, NULL_TREE);
2339 /* *(foo *)&complexfoo => __real__ complexfoo */
2340 else if (TREE_CODE (optype) == COMPLEX_TYPE
2341 && (same_type_ignoring_top_level_qualifiers_p
2342 (type, TREE_TYPE (optype))))
2343 return fold_build1_loc (loc, REALPART_EXPR, type, op);
2344 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2345 else if (TREE_CODE (optype) == VECTOR_TYPE
2346 && (same_type_ignoring_top_level_qualifiers_p
2347 (type, TREE_TYPE (optype))))
2349 tree part_width = TYPE_SIZE (type);
2350 tree index = bitsize_int (0);
2351 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
2353 /* Also handle conversion to an empty base class, which
2354 is represented with a NOP_EXPR. */
2355 else if (is_empty_class (type)
2356 && CLASS_TYPE_P (optype)
2357 && DERIVED_FROM_P (type, optype))
2362 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2363 else if (RECORD_OR_UNION_TYPE_P (optype))
2365 tree field = TYPE_FIELDS (optype);
2366 for (; field; field = DECL_CHAIN (field))
2367 if (TREE_CODE (field) == FIELD_DECL
2368 && integer_zerop (byte_position (field))
2369 && (same_type_ignoring_top_level_qualifiers_p
2370 (TREE_TYPE (field), type)))
2372 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
2377 else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
2378 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
2380 tree op00 = TREE_OPERAND (sub, 0);
2381 tree op01 = TREE_OPERAND (sub, 1);
2384 if (TREE_CODE (op00) == ADDR_EXPR)
2387 op00 = TREE_OPERAND (op00, 0);
2388 op00type = TREE_TYPE (op00);
2390 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2391 if (TREE_CODE (op00type) == VECTOR_TYPE
2392 && (same_type_ignoring_top_level_qualifiers_p
2393 (type, TREE_TYPE (op00type))))
2395 HOST_WIDE_INT offset = tree_to_shwi (op01);
2396 tree part_width = TYPE_SIZE (type);
2397 unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
2398 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
2399 tree index = bitsize_int (indexi);
2401 if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
2402 return fold_build3_loc (loc,
2403 BIT_FIELD_REF, type, op00,
2407 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2408 else if (TREE_CODE (op00type) == COMPLEX_TYPE
2409 && (same_type_ignoring_top_level_qualifiers_p
2410 (type, TREE_TYPE (op00type))))
2412 tree size = TYPE_SIZE_UNIT (type);
2413 if (tree_int_cst_equal (size, op01))
2414 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
2416 /* ((foo *)&fooarray)[1] => fooarray[1] */
2417 else if (TREE_CODE (op00type) == ARRAY_TYPE
2418 && (same_type_ignoring_top_level_qualifiers_p
2419 (type, TREE_TYPE (op00type))))
2421 tree type_domain = TYPE_DOMAIN (op00type);
2422 tree min_val = size_zero_node;
2423 if (type_domain && TYPE_MIN_VALUE (type_domain))
2424 min_val = TYPE_MIN_VALUE (type_domain);
2425 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
2426 TYPE_SIZE_UNIT (type));
2427 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
2428 return build4_loc (loc, ARRAY_REF, type, op00, op01,
2429 NULL_TREE, NULL_TREE);
2431 /* Also handle conversion to an empty base class, which
2432 is represented with a NOP_EXPR. */
2433 else if (is_empty_class (type)
2434 && CLASS_TYPE_P (op00type)
2435 && DERIVED_FROM_P (type, op00type))
2440 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2441 else if (RECORD_OR_UNION_TYPE_P (op00type))
2443 tree field = TYPE_FIELDS (op00type);
2444 for (; field; field = DECL_CHAIN (field))
2445 if (TREE_CODE (field) == FIELD_DECL
2446 && tree_int_cst_equal (byte_position (field), op01)
2447 && (same_type_ignoring_top_level_qualifiers_p
2448 (TREE_TYPE (field), type)))
2450 return fold_build3 (COMPONENT_REF, type, op00,
2457 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2458 else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
2459 && (same_type_ignoring_top_level_qualifiers_p
2460 (type, TREE_TYPE (TREE_TYPE (subtype)))))
2463 tree min_val = size_zero_node;
2464 tree newsub = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
2468 sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
2469 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
2470 if (type_domain && TYPE_MIN_VALUE (type_domain))
2471 min_val = TYPE_MIN_VALUE (type_domain);
2472 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
2480 cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
2482 bool *non_constant_p, bool *overflow_p)
2484 tree orig_op0 = TREE_OPERAND (t, 0);
2485 tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
2486 /*lval*/false, non_constant_p,
2488 bool empty_base = false;
2491 /* Don't VERIFY_CONSTANT here. */
2492 if (*non_constant_p)
2495 r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
2499 r = cxx_eval_constant_expression (ctx, r,
2500 lval, non_constant_p, overflow_p);
2505 if (TREE_CODE (sub) == ADDR_EXPR)
2507 /* We couldn't fold to a constant value. Make sure it's not
2508 something we should have been able to fold. */
2509 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2510 (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
2511 /* DR 1188 says we don't have to deal with this. */
2513 error ("accessing value of %qE through a %qT glvalue in a "
2514 "constant expression", build_fold_indirect_ref (sub),
2516 *non_constant_p = true;
2521 /* If we're pulling out the value of an empty base, make sure
2522 that the whole object is constant and then return an empty
2524 if (empty_base && !lval)
2526 VERIFY_CONSTANT (r);
2527 r = build_constructor (TREE_TYPE (t), NULL);
2528 TREE_CONSTANT (r) = true;
2533 if (lval && op0 != orig_op0)
2534 return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
2536 VERIFY_CONSTANT (t);
2542 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2543 Shared between potential_constant_expression and
2544 cxx_eval_constant_expression. */
2547 non_const_var_error (tree r)
2549 tree type = TREE_TYPE (r);
2550 error ("the value of %qD is not usable in a constant "
2552 /* Avoid error cascade. */
2553 if (DECL_INITIAL (r) == error_mark_node)
2555 if (DECL_DECLARED_CONSTEXPR_P (r))
2556 inform (DECL_SOURCE_LOCATION (r),
2557 "%qD used in its own initializer", r);
2558 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
2560 if (!CP_TYPE_CONST_P (type))
2561 inform (DECL_SOURCE_LOCATION (r),
2562 "%q#D is not const", r);
2563 else if (CP_TYPE_VOLATILE_P (type))
2564 inform (DECL_SOURCE_LOCATION (r),
2565 "%q#D is volatile", r);
2566 else if (!DECL_INITIAL (r)
2567 || !TREE_CONSTANT (DECL_INITIAL (r)))
2568 inform (DECL_SOURCE_LOCATION (r),
2569 "%qD was not initialized with a constant "
2576 if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
2577 inform (DECL_SOURCE_LOCATION (r),
2578 "%qD was not declared %<constexpr%>", r);
2580 inform (DECL_SOURCE_LOCATION (r),
2581 "%qD does not have integral or enumeration type",
2586 /* Subroutine of cxx_eval_constant_expression.
2587 Like cxx_eval_unary_expression, except for trinary expressions. */
2590 cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
2592 bool *non_constant_p, bool *overflow_p)
2598 for (i = 0; i < 3; i++)
2600 args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
2602 non_constant_p, overflow_p);
2603 VERIFY_CONSTANT (args[i]);
2606 val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
2607 args[0], args[1], args[2]);
2608 if (val == NULL_TREE)
2610 VERIFY_CONSTANT (val);
2615 var_in_constexpr_fn (tree t)
2617 tree ctx = DECL_CONTEXT (t);
2618 return (cxx_dialect >= cxx14 && ctx && TREE_CODE (ctx) == FUNCTION_DECL
2619 && DECL_DECLARED_CONSTEXPR_P (ctx));
2622 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
2625 cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
2627 bool *non_constant_p, bool *overflow_p)
2629 constexpr_ctx new_ctx = *ctx;
2631 tree init = TREE_OPERAND (t, 1);
2633 /* First we figure out where we're storing to. */
2634 tree target = TREE_OPERAND (t, 0);
2635 tree type = TREE_TYPE (target);
2636 target = cxx_eval_constant_expression (ctx, target,
2638 non_constant_p, overflow_p);
2639 if (*non_constant_p)
2642 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target), type)
2643 && is_empty_class (type))
2645 /* For initialization of an empty base, the original target will be
2646 *(base*)this, which the above evaluation resolves to the object
2647 argument, which has the derived type rather than the base type. In
2648 this situation, just evaluate the initializer and return, since
2649 there's no actual data to store. */
2650 return cxx_eval_constant_expression (ctx, init, false,
2651 non_constant_p, overflow_p);
2654 /* And then find the underlying variable. */
2655 vec<tree,va_gc> *refs = make_tree_vector();
2656 tree object = NULL_TREE;
2657 for (tree probe = target; object == NULL_TREE; )
2659 switch (TREE_CODE (probe))
2664 vec_safe_push (refs, TREE_OPERAND (probe, 1));
2665 vec_safe_push (refs, TREE_TYPE (probe));
2666 probe = TREE_OPERAND (probe, 0);
2674 /* And then find/build up our initializer for the path to the subobject
2675 we're initializing. */
2677 if (DECL_P (object))
2678 valp = ctx->values->get (object);
2683 /* A constant-expression cannot modify objects from outside the
2684 constant-expression. */
2686 error ("modification of %qE is not a constant-expression", object);
2687 *non_constant_p = true;
2690 type = TREE_TYPE (object);
2691 while (!refs->is_empty())
2693 if (*valp == NULL_TREE)
2695 *valp = build_constructor (type, NULL);
2696 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = true;
2701 ce.index = refs->pop();
2702 ce.value = NULL_TREE;
2704 unsigned HOST_WIDE_INT idx = 0;
2705 constructor_elt *cep = NULL;
2707 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep);
2710 if (cp_tree_equal (ce.index, cep->index))
2713 cep = vec_safe_push (CONSTRUCTOR_ELTS (*valp), ce);
2716 release_tree_vector (refs);
2718 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
2720 /* Create a new CONSTRUCTOR in case evaluation of the initializer
2721 wants to modify it. */
2722 new_ctx.ctor = build_constructor (type, NULL);
2723 if (*valp == NULL_TREE)
2724 *valp = new_ctx.ctor;
2725 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
2726 new_ctx.object = target;
2729 init = cxx_eval_constant_expression (&new_ctx, init, false,
2730 non_constant_p, overflow_p);
2731 if (target == object)
2733 /* The hash table might have moved since the get earlier. */
2734 valp = ctx->values->get (object);
2735 if (TREE_CODE (init) == CONSTRUCTOR)
2736 /* An outer ctx->ctor might be pointing to *valp, so just replace
2738 CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init);
2745 if (*non_constant_p)
2753 /* Evaluate a ++ or -- expression. */
2756 cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
2758 bool *non_constant_p, bool *overflow_p)
2760 enum tree_code code = TREE_CODE (t);
2761 tree type = TREE_TYPE (t);
2762 tree op = TREE_OPERAND (t, 0);
2763 tree offset = TREE_OPERAND (t, 1);
2764 gcc_assert (TREE_CONSTANT (offset));
2766 /* The operand as an lvalue. */
2767 op = cxx_eval_constant_expression (ctx, op, true,
2768 non_constant_p, overflow_p);
2770 /* The operand as an rvalue. */
2771 tree val = rvalue (op);
2772 val = cxx_eval_constant_expression (ctx, val, false,
2773 non_constant_p, overflow_p);
2774 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2775 a local array in a constexpr function. */
2776 bool ptr = POINTER_TYPE_P (TREE_TYPE (val));
2778 VERIFY_CONSTANT (val);
2780 /* The modified value. */
2781 bool inc = (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR);
2783 if (POINTER_TYPE_P (type))
2785 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
2786 offset = convert_to_ptrofftype (offset);
2788 offset = fold_build1 (NEGATE_EXPR, TREE_TYPE (offset), offset);
2789 mod = fold_build2 (POINTER_PLUS_EXPR, type, val, offset);
2792 mod = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR, type, val, offset);
2794 VERIFY_CONSTANT (mod);
2796 /* Storing the modified value. */
2797 tree store = build2 (MODIFY_EXPR, type, op, mod);
2798 cxx_eval_constant_expression (ctx, store,
2799 true, non_constant_p, overflow_p);
2801 /* And the value of the expression. */
2802 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2804 /* Prefix ops are lvalues. */
2808 /* But we optimize when the caller wants an rvalue. */
2812 /* Postfix ops are rvalues. */
2816 /* Predicates for the meaning of *jump_target. */
2819 returns (tree *jump_target)
2822 && TREE_CODE (*jump_target) == RETURN_EXPR;
2826 breaks (tree *jump_target)
2829 && TREE_CODE (*jump_target) == LABEL_DECL
2830 && LABEL_DECL_BREAK (*jump_target);
2834 continues (tree *jump_target)
2837 && TREE_CODE (*jump_target) == LABEL_DECL
2838 && LABEL_DECL_CONTINUE (*jump_target);
2842 switches (tree *jump_target)
2845 && TREE_CODE (*jump_target) == INTEGER_CST;
2848 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
2849 at I matches *jump_target. If we're looking for a case label and we see
2850 the default label, copy I into DEFAULT_LABEL. */
2853 label_matches (tree *jump_target, tree_stmt_iterator i,
2854 tree_stmt_iterator& default_label)
2856 tree stmt = tsi_stmt (i);
2857 switch (TREE_CODE (*jump_target))
2860 if (TREE_CODE (stmt) == LABEL_EXPR
2861 && LABEL_EXPR_LABEL (stmt) == *jump_target)
2866 if (TREE_CODE (stmt) == CASE_LABEL_EXPR)
2868 if (!CASE_LOW (stmt))
2870 else if (tree_int_cst_equal (*jump_target, CASE_LOW (stmt)))
2881 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
2882 semantics, for switch, break, continue, and return. */
2885 cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
2886 bool *non_constant_p, bool *overflow_p,
2889 tree_stmt_iterator i;
2890 tree_stmt_iterator default_label = tree_stmt_iterator();
2892 /* In a statement-expression we want to return the last value. */
2896 local_target = NULL_TREE;
2897 jump_target = &local_target;
2899 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
2902 tree stmt = tsi_stmt (i);
2905 if (TREE_CODE (stmt) == STATEMENT_LIST)
2906 /* The label we want might be inside. */;
2907 else if (label_matches (jump_target, i, default_label))
2909 *jump_target = NULL_TREE;
2913 r = cxx_eval_constant_expression (ctx, stmt, false,
2914 non_constant_p, overflow_p,
2916 if (*non_constant_p)
2918 if (returns (jump_target) || breaks (jump_target))
2921 if (switches (jump_target) && !tsi_end_p (default_label))
2924 *jump_target = NULL_TREE;
2930 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
2931 semantics; continue semantics are covered by cxx_eval_statement_list. */
2934 cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t,
2935 bool *non_constant_p, bool *overflow_p,
2938 tree body = TREE_OPERAND (t, 0);
2941 cxx_eval_statement_list (ctx, body,
2942 non_constant_p, overflow_p, jump_target);
2943 if (returns (jump_target) || breaks (jump_target) || *non_constant_p)
2946 if (breaks (jump_target))
2947 *jump_target = NULL_TREE;
2951 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
2955 cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t,
2956 bool *non_constant_p, bool *overflow_p,
2959 tree cond = TREE_OPERAND (t, 0);
2960 cond = cxx_eval_constant_expression (ctx, cond, false,
2961 non_constant_p, overflow_p);
2962 VERIFY_CONSTANT (cond);
2963 *jump_target = cond;
2965 tree body = TREE_OPERAND (t, 1);
2966 cxx_eval_statement_list (ctx, body,
2967 non_constant_p, overflow_p, jump_target);
2968 if (breaks (jump_target) || switches (jump_target))
2969 *jump_target = NULL_TREE;
2973 /* Subroutine of cxx_eval_constant_expression.
2974 Attempt to reduce a POINTER_PLUS_EXPR expression T. */
2977 cxx_eval_pointer_plus_expression (const constexpr_ctx *ctx, tree t,
2978 bool lval, bool *non_constant_p,
2981 tree orig_type = TREE_TYPE (t);
2982 tree op00 = TREE_OPERAND (t, 0);
2983 tree op01 = TREE_OPERAND (t, 1);
2984 location_t loc = EXPR_LOCATION (t);
2986 op00 = cxx_eval_constant_expression (ctx, op00, lval,
2987 non_constant_p, overflow_p);
2990 if (TREE_CODE (op00) != ADDR_EXPR)
2993 op00 = TREE_OPERAND (op00, 0);
2995 /* &A[i] p+ j => &A[i + j] */
2996 if (TREE_CODE (op00) == ARRAY_REF
2997 && TREE_CODE (TREE_OPERAND (op00, 1)) == INTEGER_CST
2998 && TREE_CODE (op01) == INTEGER_CST
2999 && TYPE_SIZE_UNIT (TREE_TYPE (op00))
3000 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (op00))) == INTEGER_CST)
3002 tree type = TREE_TYPE (op00);
3003 t = fold_convert_loc (loc, ssizetype, TREE_OPERAND (op00, 1));
3004 tree nelts = array_type_nelts_top (TREE_TYPE (TREE_OPERAND (op00, 0)));
3005 /* Don't fold an out-of-bound access. */
3006 if (!tree_int_cst_le (t, nelts))
3008 op01 = cp_fold_convert (ssizetype, op01);
3009 /* Don't fold if op01 can't be divided exactly by TYPE_SIZE_UNIT.
3010 constexpr int A[1]; ... (char *)&A[0] + 1 */
3011 if (!integer_zerop (fold_build2_loc (loc, TRUNC_MOD_EXPR, sizetype,
3012 op01, TYPE_SIZE_UNIT (type))))
3014 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
3016 op01 = fold_build2_loc (loc, EXACT_DIV_EXPR, ssizetype, op01,
3017 TYPE_SIZE_UNIT (type));
3018 t = size_binop_loc (loc, PLUS_EXPR, op01, t);
3019 t = build4_loc (loc, ARRAY_REF, type, TREE_OPERAND (op00, 0),
3020 t, NULL_TREE, NULL_TREE);
3021 t = cp_build_addr_expr (t, tf_warning_or_error);
3022 t = cp_fold_convert (orig_type, t);
3023 return cxx_eval_constant_expression (ctx, t, lval, non_constant_p,
3030 /* Attempt to reduce the expression T to a constant value.
3031 On failure, issue diagnostic and return error_mark_node. */
3032 /* FIXME unify with c_fully_fold */
3033 /* FIXME overflow_p is too global */
3036 cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
3038 bool *non_constant_p, bool *overflow_p,
3041 constexpr_ctx new_ctx;
3044 if (t == error_mark_node)
3046 *non_constant_p = true;
3049 if (CONSTANT_CLASS_P (t))
3051 if (TREE_CODE (t) == PTRMEM_CST)
3052 t = cplus_expand_constant (t);
3053 else if (TREE_OVERFLOW (t) && (!flag_permissive || ctx->quiet))
3058 switch (TREE_CODE (t))
3063 /* We ask for an rvalue for the RESULT_DECL when indirecting
3064 through an invisible reference, or in named return value
3066 return (*ctx->values->get (t));
3070 /* We used to not check lval for CONST_DECL, but darwin.c uses
3071 CONST_DECL for aggregate constants. */
3075 r = decl_really_constant_value (t);
3077 r = decl_constant_value (t);
3078 if (TREE_CODE (r) == TARGET_EXPR
3079 && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR)
3080 r = TARGET_EXPR_INITIAL (r);
3081 if (TREE_CODE (r) == VAR_DECL)
3082 if (tree *p = ctx->values->get (r))
3087 non_const_var_error (r);
3088 *non_constant_p = true;
3096 case CASE_LABEL_EXPR:
3100 if (!use_new_call && ctx
3101 && ctx->call && DECL_CONTEXT (t) == ctx->call->fundef->decl)
3102 r = lookup_parameter_binding (ctx->call, t);
3103 else if (lval && TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
3105 else if (tree *p = ctx->values->get (r))
3108 /* Defer in case this is only used for its type. */;
3109 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
3110 /* Defer, there's no lvalue->rvalue conversion. */;
3111 else if (is_empty_class (TREE_TYPE (t)))
3113 /* If the class is empty, we aren't actually loading anything. */
3114 r = build_constructor (TREE_TYPE (t), NULL);
3115 TREE_CONSTANT (r) = true;
3120 error ("%qE is not a constant expression", t);
3121 *non_constant_p = true;
3126 case AGGR_INIT_EXPR:
3127 r = cxx_eval_call_expression (ctx, t, lval,
3128 non_constant_p, overflow_p);
3133 r = DECL_EXPR_DECL (t);
3134 if (AGGREGATE_TYPE_P (TREE_TYPE (r))
3135 || VECTOR_TYPE_P (TREE_TYPE (r)))
3139 new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL);
3140 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
3141 new_ctx.values->put (r, new_ctx.ctor);
3145 if (tree init = DECL_INITIAL (r))
3147 init = cxx_eval_constant_expression (ctx, init,
3149 non_constant_p, overflow_p);
3150 ctx->values->put (r, init);
3152 else if (ctx == &new_ctx)
3153 /* We gave it a CONSTRUCTOR above. */;
3155 ctx->values->put (r, NULL_TREE);
3160 if (!literal_type_p (TREE_TYPE (t)))
3164 error ("temporary of non-literal type %qT in a "
3165 "constant expression", TREE_TYPE (t));
3166 explain_non_literal_class (TREE_TYPE (t));
3168 *non_constant_p = true;
3171 if ((AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t))))
3173 /* We're being expanded without an explicit target, so start
3174 initializing a new object; expansion with an explicit target
3175 strips the TARGET_EXPR before we get here. */
3177 new_ctx.ctor = build_constructor (TREE_TYPE (t), NULL);
3178 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
3179 new_ctx.object = TARGET_EXPR_SLOT (t);
3180 ctx->values->put (new_ctx.object, new_ctx.ctor);
3183 /* Pass false for 'lval' because this indicates
3184 initialization of a temporary. */
3185 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3187 non_constant_p, overflow_p);
3188 if (!*non_constant_p)
3189 /* Adjust the type of the result to the type of the temporary. */
3190 r = adjust_temp_type (TREE_TYPE (t), r);
3193 tree slot = TARGET_EXPR_SLOT (t);
3194 ctx->values->put (slot, r);
3202 /* In C++11 constexpr evaluation we are looking for the value,
3203 not the side-effect of the initialization. */
3204 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3206 non_constant_p, overflow_p);
3209 /* else fall through */
3211 r = cxx_eval_store_expression (ctx, t, lval,
3212 non_constant_p, overflow_p);
3216 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3218 non_constant_p, overflow_p);
3222 if (TREE_OPERAND (t, 0) != NULL_TREE)
3223 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3225 non_constant_p, overflow_p);
3230 /* Avoid evaluating a SAVE_EXPR more than once. */
3231 if (tree *p = ctx->values->get (t))
3235 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), false,
3236 non_constant_p, overflow_p);
3237 ctx->values->put (t, r);
3241 case NON_LVALUE_EXPR:
3242 case TRY_CATCH_EXPR:
3244 case CLEANUP_POINT_EXPR:
3245 case MUST_NOT_THROW_EXPR:
3248 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3250 non_constant_p, overflow_p,
3254 case TRY_FINALLY_EXPR:
3255 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval,
3256 non_constant_p, overflow_p,
3258 if (!*non_constant_p)
3259 /* Also evaluate the cleanup. */
3260 cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), true,
3261 non_constant_p, overflow_p,
3265 /* These differ from cxx_eval_unary_expression in that this doesn't
3266 check for a constant operand or result; an address can be
3267 constant without its operand being, and vice versa. */
3269 r = cxx_eval_indirect_ref (ctx, t, lval,
3270 non_constant_p, overflow_p);
3275 tree oldop = TREE_OPERAND (t, 0);
3276 tree op = cxx_eval_constant_expression (ctx, oldop,
3278 non_constant_p, overflow_p);
3279 /* Don't VERIFY_CONSTANT here. */
3280 if (*non_constant_p)
3282 gcc_checking_assert (TREE_CODE (op) != CONSTRUCTOR);
3283 /* This function does more aggressive folding than fold itself. */
3284 r = build_fold_addr_expr_with_type (op, TREE_TYPE (t));
3285 if (TREE_CODE (r) == ADDR_EXPR && TREE_OPERAND (r, 0) == oldop)
3293 case FIX_TRUNC_EXPR:
3298 case TRUTH_NOT_EXPR:
3299 case FIXED_CONVERT_EXPR:
3300 r = cxx_eval_unary_expression (ctx, t, lval,
3301 non_constant_p, overflow_p);
3305 if (SIZEOF_EXPR_TYPE_P (t))
3306 r = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t, 0)),
3307 SIZEOF_EXPR, false);
3308 else if (TYPE_P (TREE_OPERAND (t, 0)))
3309 r = cxx_sizeof_or_alignof_type (TREE_OPERAND (t, 0), SIZEOF_EXPR,
3312 r = cxx_sizeof_or_alignof_expr (TREE_OPERAND (t, 0), SIZEOF_EXPR,
3314 if (r == error_mark_node)
3316 VERIFY_CONSTANT (r);
3321 /* check_return_expr sometimes wraps a TARGET_EXPR in a
3322 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
3323 introduced by build_call_a. */
3324 tree op0 = TREE_OPERAND (t, 0);
3325 tree op1 = TREE_OPERAND (t, 1);
3327 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
3328 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
3329 r = cxx_eval_constant_expression (ctx, op0,
3330 lval, non_constant_p, overflow_p,
3334 /* Check that the LHS is constant and then discard it. */
3335 cxx_eval_constant_expression (ctx, op0,
3336 true, non_constant_p, overflow_p,
3338 op1 = TREE_OPERAND (t, 1);
3339 r = cxx_eval_constant_expression (ctx, op1,
3340 lval, non_constant_p, overflow_p,
3346 case POINTER_PLUS_EXPR:
3347 r = cxx_eval_pointer_plus_expression (ctx, t, lval, non_constant_p,
3351 /* else fall through */
3356 case TRUNC_DIV_EXPR:
3358 case FLOOR_DIV_EXPR:
3359 case ROUND_DIV_EXPR:
3360 case TRUNC_MOD_EXPR:
3362 case ROUND_MOD_EXPR:
3364 case EXACT_DIV_EXPR:
3374 case TRUTH_XOR_EXPR:
3381 case UNORDERED_EXPR:
3391 r = cxx_eval_binary_expression (ctx, t, lval,
3392 non_constant_p, overflow_p);
3395 /* fold can introduce non-IF versions of these; still treat them as
3396 short-circuiting. */
3397 case TRUTH_AND_EXPR:
3398 case TRUTH_ANDIF_EXPR:
3399 r = cxx_eval_logical_expression (ctx, t, boolean_false_node,
3402 non_constant_p, overflow_p);
3406 case TRUTH_ORIF_EXPR:
3407 r = cxx_eval_logical_expression (ctx, t, boolean_true_node,
3410 non_constant_p, overflow_p);
3414 r = cxx_eval_array_reference (ctx, t, lval,
3415 non_constant_p, overflow_p);
3419 if (is_overloaded_fn (t))
3421 /* We can only get here in checking mode via
3422 build_non_dependent_expr, because any expression that
3423 calls or takes the address of the function will have
3424 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
3425 gcc_checking_assert (ctx->quiet || errorcount);
3426 *non_constant_p = true;
3429 r = cxx_eval_component_reference (ctx, t, lval,
3430 non_constant_p, overflow_p);
3434 r = cxx_eval_bit_field_ref (ctx, t, lval,
3435 non_constant_p, overflow_p);
3440 r = cxx_eval_conditional_expression (ctx, t, lval,
3441 non_constant_p, overflow_p,
3446 if (TREE_CONSTANT (t))
3447 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3448 VECTOR_CST if applicable. */
3450 r = cxx_eval_bare_aggregate (ctx, t, lval,
3451 non_constant_p, overflow_p);
3455 /* We can get this in a defaulted constructor for a class with a
3456 non-static data member of array type. Either the initializer will
3457 be NULL, meaning default-initialization, or it will be an lvalue
3458 or xvalue of the same type, meaning direct-initialization from the
3459 corresponding member. */
3460 r = cxx_eval_vec_init (ctx, t, lval,
3461 non_constant_p, overflow_p);
3466 r = cxx_eval_trinary_expression (ctx, t, lval,
3467 non_constant_p, overflow_p);
3471 case VIEW_CONVERT_EXPR:
3474 tree oldop = TREE_OPERAND (t, 0);
3475 tree op = cxx_eval_constant_expression (ctx, oldop,
3477 non_constant_p, overflow_p);
3478 if (*non_constant_p)
3480 if (POINTER_TYPE_P (TREE_TYPE (t))
3481 && TREE_CODE (op) == INTEGER_CST
3482 && !integer_zerop (op))
3485 error_at (EXPR_LOC_OR_LOC (t, input_location),
3486 "reinterpret_cast from integer to pointer");
3487 *non_constant_p = true;
3491 /* We didn't fold at the top so we could check for ptr-int
3494 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), op);
3495 /* Conversion of an out-of-range value has implementation-defined
3496 behavior; the language considers it different from arithmetic
3497 overflow, which is undefined. */
3498 if (TREE_OVERFLOW_P (r) && !TREE_OVERFLOW_P (op))
3499 TREE_OVERFLOW (r) = false;
3503 case EMPTY_CLASS_EXPR:
3504 /* This is good enough for a function argument that might not get
3505 used, and they can't do anything with it, so just return it. */
3508 case STATEMENT_LIST:
3510 new_ctx.ctor = new_ctx.object = NULL_TREE;
3511 return cxx_eval_statement_list (&new_ctx, t,
3512 non_constant_p, overflow_p, jump_target);
3515 return cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (t),
3517 non_constant_p, overflow_p,
3520 case PREINCREMENT_EXPR:
3521 case POSTINCREMENT_EXPR:
3522 case PREDECREMENT_EXPR:
3523 case POSTDECREMENT_EXPR:
3524 return cxx_eval_increment_expression (ctx, t,
3525 lval, non_constant_p, overflow_p);
3531 case VEC_DELETE_EXPR:
3534 /* GCC internal stuff. */
3537 case WITH_CLEANUP_EXPR:
3538 case NON_DEPENDENT_EXPR:
3542 error_at (EXPR_LOC_OR_LOC (t, input_location),
3543 "expression %qE is not a constant-expression", t);
3544 *non_constant_p = true;
3547 case PLACEHOLDER_EXPR:
3548 if (!ctx || !ctx->ctor || (lval && !ctx->object)
3549 || !(same_type_ignoring_top_level_qualifiers_p
3550 (TREE_TYPE (t), TREE_TYPE (ctx->ctor))))
3552 /* A placeholder without a referent. We can get here when
3553 checking whether NSDMIs are noexcept, or in massage_init_elt;
3554 just say it's non-constant for now. */
3555 gcc_assert (ctx->quiet);
3556 *non_constant_p = true;
3561 /* Use of the value or address of the current object. We could
3562 use ctx->object unconditionally, but using ctx->ctor when we
3563 can is a minor optimization. */
3564 tree ctor = lval ? ctx->object : ctx->ctor;
3565 return cxx_eval_constant_expression
3567 non_constant_p, overflow_p);
3572 *jump_target = TREE_OPERAND (t, 0);
3573 gcc_assert (breaks (jump_target) || continues (jump_target));
3577 cxx_eval_loop_expr (ctx, t,
3578 non_constant_p, overflow_p, jump_target);
3582 cxx_eval_switch_expr (ctx, t,
3583 non_constant_p, overflow_p, jump_target);
3587 if (STATEMENT_CODE_P (TREE_CODE (t)))
3589 /* This function doesn't know how to deal with pre-genericize
3590 statements; this can only happen with statement-expressions,
3591 so for now just fail. */
3593 error_at (EXPR_LOCATION (t),
3594 "statement is not a constant-expression");
3597 internal_error ("unexpected expression %qE of kind %s", t,
3598 get_tree_code_name (TREE_CODE (t)));
3599 *non_constant_p = true;
3603 if (r == error_mark_node)
3604 *non_constant_p = true;
3606 if (*non_constant_p)
3613 cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
3614 bool strict = true, tree object = NULL_TREE)
3616 bool non_constant_p = false;
3617 bool overflow_p = false;
3618 hash_map<tree,tree> map;
3619 constexpr_ctx ctx = { NULL, &map, NULL, NULL, allow_non_constant, strict };
3620 tree type = initialized_type (t);
3622 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
3624 /* In C++14 an NSDMI can participate in aggregate initialization,
3625 and can refer to the address of the object being initialized, so
3626 we need to pass in the relevant VAR_DECL if we want to do the
3627 evaluation in a single pass. The evaluation will dynamically
3628 update ctx.values for the VAR_DECL. We use the same strategy
3629 for C++11 constexpr constructors that refer to the object being
3631 ctx.ctor = build_constructor (type, NULL);
3632 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx.ctor) = true;
3635 if (TREE_CODE (t) == TARGET_EXPR)
3636 object = TARGET_EXPR_SLOT (t);
3637 else if (TREE_CODE (t) == AGGR_INIT_EXPR)
3638 object = AGGR_INIT_EXPR_SLOT (t);
3640 ctx.object = object;
3642 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3643 (type, TREE_TYPE (object)));
3644 if (object && DECL_P (object))
3645 map.put (object, ctx.ctor);
3646 if (TREE_CODE (r) == TARGET_EXPR)
3647 /* Avoid creating another CONSTRUCTOR when we expand the
3649 r = TARGET_EXPR_INITIAL (r);
3652 r = cxx_eval_constant_expression (&ctx, r,
3653 false, &non_constant_p, &overflow_p);
3655 verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);
3657 /* Mutable logic is a bit tricky: we want to allow initialization of
3658 constexpr variables with mutable members, but we can't copy those
3659 members to another constexpr variable. */
3660 if (TREE_CODE (r) == CONSTRUCTOR
3661 && CONSTRUCTOR_MUTABLE_POISON (r))
3663 if (!allow_non_constant)
3664 error ("%qE is not a constant expression because it refers to "
3665 "mutable subobjects of %qT", t, type);
3666 non_constant_p = true;
3669 /* Technically we should check this for all subexpressions, but that
3670 runs into problems with our internal representation of pointer
3671 subtraction and the 5.19 rules are still in flux. */
3672 if (CONVERT_EXPR_CODE_P (TREE_CODE (r))
3673 && ARITHMETIC_TYPE_P (TREE_TYPE (r))
3674 && TREE_CODE (TREE_OPERAND (r, 0)) == ADDR_EXPR)
3676 if (!allow_non_constant)
3677 error ("conversion from pointer type %qT "
3678 "to arithmetic type %qT in a constant-expression",
3679 TREE_TYPE (TREE_OPERAND (r, 0)), TREE_TYPE (r));
3680 non_constant_p = true;
3683 if (!non_constant_p && overflow_p)
3684 non_constant_p = true;
3686 if (non_constant_p && !allow_non_constant)
3687 return error_mark_node;
3688 else if (non_constant_p && TREE_CONSTANT (r))
3690 /* This isn't actually constant, so unset TREE_CONSTANT. */
3693 else if (TREE_CODE (r) == CONSTRUCTOR)
3694 r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r);
3696 r = build_nop (TREE_TYPE (r), r);
3697 TREE_CONSTANT (r) = false;
3699 else if (non_constant_p || r == t)
3702 if (TREE_CODE (r) == CONSTRUCTOR && CLASS_TYPE_P (TREE_TYPE (r)))
3704 if (TREE_CODE (t) == TARGET_EXPR
3705 && TARGET_EXPR_INITIAL (t) == r)
3709 r = get_target_expr (r);
3710 TREE_CONSTANT (r) = true;
3718 /* Returns true if T is a valid subexpression of a constant expression,
3719 even if it isn't itself a constant expression. */
3722 is_sub_constant_expr (tree t)
3724 bool non_constant_p = false;
3725 bool overflow_p = false;
3726 hash_map <tree, tree> map;
3727 constexpr_ctx ctx = { NULL, &map, NULL, NULL, true, true };
3728 cxx_eval_constant_expression (&ctx, t, false, &non_constant_p,
3730 return !non_constant_p && !overflow_p;
3733 /* If T represents a constant expression returns its reduced value.
3734 Otherwise return error_mark_node. If T is dependent, then
3738 cxx_constant_value (tree t, tree decl)
3740 return cxx_eval_outermost_constant_expr (t, false, true, decl);
3743 /* If T is a constant expression, returns its reduced value.
3744 Otherwise, if T does not have TREE_CONSTANT set, returns T.
3745 Otherwise, returns a version of T without TREE_CONSTANT. */
3748 maybe_constant_value (tree t, tree decl)
3752 if (instantiation_dependent_expression_p (t)
3753 || type_unknown_p (t)
3754 || BRACE_ENCLOSED_INITIALIZER_P (t)
3755 || !potential_constant_expression (t))
3757 if (TREE_OVERFLOW_P (t))
3759 t = build_nop (TREE_TYPE (t), t);
3760 TREE_CONSTANT (t) = false;
3765 r = cxx_eval_outermost_constant_expr (t, true, true, decl);
3766 #ifdef ENABLE_CHECKING
3768 || CONVERT_EXPR_P (t)
3769 || TREE_CODE (t) == VIEW_CONVERT_EXPR
3770 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
3771 || !cp_tree_equal (r, t));
3776 /* Like maybe_constant_value but first fully instantiate the argument.
3778 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3779 (t, tf_none) followed by maybe_constant_value but is more efficient,
3780 because calls instantiation_dependent_expression_p and
3781 potential_constant_expression at most once. */
3784 fold_non_dependent_expr (tree t)
3789 /* If we're in a template, but T isn't value dependent, simplify
3790 it. We're supposed to treat:
3792 template <typename T> void f(T[1 + 1]);
3793 template <typename T> void f(T[2]);
3795 as two declarations of the same function, for example. */
3796 if (processing_template_decl)
3798 if (!instantiation_dependent_expression_p (t)
3799 && potential_constant_expression (t))
3801 processing_template_decl_sentinel s;
3802 t = instantiate_non_dependent_expr_internal (t, tf_none);
3804 if (type_unknown_p (t)
3805 || BRACE_ENCLOSED_INITIALIZER_P (t))
3807 if (TREE_OVERFLOW_P (t))
3809 t = build_nop (TREE_TYPE (t), t);
3810 TREE_CONSTANT (t) = false;
3815 tree r = cxx_eval_outermost_constant_expr (t, true, true, NULL_TREE);
3816 #ifdef ENABLE_CHECKING
3817 /* cp_tree_equal looks through NOPs, so allow them. */
3819 || CONVERT_EXPR_P (t)
3820 || TREE_CODE (t) == VIEW_CONVERT_EXPR
3821 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
3822 || !cp_tree_equal (r, t));
3826 else if (TREE_OVERFLOW_P (t))
3828 t = build_nop (TREE_TYPE (t), t);
3829 TREE_CONSTANT (t) = false;
3834 return maybe_constant_value (t);
3837 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3838 than wrapped in a TARGET_EXPR. */
3841 maybe_constant_init (tree t, tree decl)
3843 if (TREE_CODE (t) == EXPR_STMT)
3844 t = TREE_OPERAND (t, 0);
3845 if (TREE_CODE (t) == CONVERT_EXPR
3846 && VOID_TYPE_P (TREE_TYPE (t)))
3847 t = TREE_OPERAND (t, 0);
3848 if (TREE_CODE (t) == INIT_EXPR)
3849 t = TREE_OPERAND (t, 1);
3850 if (instantiation_dependent_expression_p (t)
3851 || type_unknown_p (t)
3852 || BRACE_ENCLOSED_INITIALIZER_P (t)
3853 || !potential_static_init_expression (t))
3854 /* Don't try to evaluate it. */;
3856 t = cxx_eval_outermost_constant_expr (t, true, false, decl);
3857 if (TREE_CODE (t) == TARGET_EXPR)
3859 tree init = TARGET_EXPR_INITIAL (t);
3860 if (TREE_CODE (init) == CONSTRUCTOR)
3867 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
3868 /* Return true if the object referred to by REF has automatic or thread
3871 enum { ck_ok, ck_bad, ck_unknown };
3873 check_automatic_or_tls (tree ref)
3876 HOST_WIDE_INT bitsize, bitpos;
3878 int volatilep = 0, unsignedp = 0;
3879 tree decl = get_inner_reference (ref, &bitsize, &bitpos, &offset,
3880 &mode, &unsignedp, &volatilep, false);
3883 /* If there isn't a decl in the middle, we don't know the linkage here,
3884 and this isn't a constant expression anyway. */
3887 dk = decl_storage_duration (decl);
3888 return (dk == dk_auto || dk == dk_thread) ? ck_bad : ck_ok;
3892 /* Return true if T denotes a potentially constant expression. Issue
3893 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
3894 an lvalue-rvalue conversion is implied.
3896 C++0x [expr.const] used to say
3898 6 An expression is a potential constant expression if it is
3899 a constant expression where all occurrences of function
3900 parameters are replaced by arbitrary constant expressions
3901 of the appropriate type.
3903 2 A conditional expression is a constant expression unless it
3904 involves one of the following as a potentially evaluated
3905 subexpression (3.2), but subexpressions of logical AND (5.14),
3906 logical OR (5.15), and conditional (5.16) operations that are
3907 not evaluated are not considered. */
3910 potential_constant_expression_1 (tree t, bool want_rval, bool strict,
3911 tsubst_flags_t flags)
3913 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
3914 enum { any = false, rval = true };
3918 if (t == error_mark_node)
3922 if (TREE_THIS_VOLATILE (t))
3924 if (flags & tf_error)
3925 error ("expression %qE has side-effects", t);
3928 if (CONSTANT_CLASS_P (t))
3931 switch (TREE_CODE (t))
3937 case TEMPLATE_ID_EXPR:
3940 case CASE_LABEL_EXPR:
3946 case TEMPLATE_PARM_INDEX:
3948 case IDENTIFIER_NODE:
3949 case USERDEF_LITERAL:
3950 /* We can see a FIELD_DECL in a pointer-to-member expression. */
3955 case PLACEHOLDER_EXPR:
3960 case AGGR_INIT_EXPR:
3962 /* -- an invocation of a function other than a constexpr function
3963 or a constexpr constructor. */
3965 tree fun = get_function_named_in_call (t);
3966 const int nargs = call_expr_nargs (t);
3969 if (fun == NULL_TREE)
3971 if (TREE_CODE (t) == CALL_EXPR
3972 && CALL_EXPR_FN (t) == NULL_TREE)
3973 switch (CALL_EXPR_IFN (t))
3975 /* These should be ignored, they are optimized away from
3976 constexpr functions. */
3977 case IFN_UBSAN_NULL:
3978 case IFN_UBSAN_BOUNDS:
3979 case IFN_UBSAN_VPTR:
3984 /* fold_call_expr can't do anything with IFN calls. */
3985 if (flags & tf_error)
3986 error_at (EXPR_LOC_OR_LOC (t, input_location),
3987 "call to internal function");
3990 if (is_overloaded_fn (fun))
3992 if (TREE_CODE (fun) == FUNCTION_DECL)
3994 if (builtin_valid_in_constant_expr_p (fun))
3996 if (!DECL_DECLARED_CONSTEXPR_P (fun)
3997 /* Allow any built-in function; if the expansion
3998 isn't constant, we'll deal with that then. */
3999 && !is_builtin_fn (fun))
4001 if (flags & tf_error)
4003 error_at (EXPR_LOC_OR_LOC (t, input_location),
4004 "call to non-constexpr function %qD", fun);
4005 explain_invalid_constexpr_fn (fun);
4009 /* A call to a non-static member function takes the address
4010 of the object as the first argument. But in a constant
4011 expression the address will be folded away, so look
4013 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
4014 && !DECL_CONSTRUCTOR_P (fun))
4016 tree x = get_nth_callarg (t, 0);
4017 if (is_this_parameter (x))
4019 else if (!RECUR (x, rval))
4026 if (!RECUR (fun, true))
4028 fun = get_first_fn (fun);
4030 /* Skip initial arguments to base constructors. */
4031 if (DECL_BASE_CONSTRUCTOR_P (fun))
4032 i = num_artificial_parms_for (fun);
4033 fun = DECL_ORIGIN (fun);
4037 if (RECUR (fun, rval))
4038 /* Might end up being a constant function pointer. */;
4042 for (; i < nargs; ++i)
4044 tree x = get_nth_callarg (t, i);
4045 /* In a template, reference arguments haven't been converted to
4046 REFERENCE_TYPE and we might not even know if the parameter
4047 is a reference, so accept lvalue constants too. */
4048 bool rv = processing_template_decl ? any : rval;
4055 case NON_LVALUE_EXPR:
4056 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
4057 -- an lvalue of integral type that refers to a non-volatile
4058 const variable or static data member initialized with
4059 constant expressions, or
4061 -- an lvalue of literal type that refers to non-volatile
4062 object defined with constexpr, or that refers to a
4063 sub-object of such an object; */
4064 return RECUR (TREE_OPERAND (t, 0), rval);
4068 && !decl_constant_var_p (t)
4070 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t))
4071 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t))
4072 && !var_in_constexpr_fn (t)
4073 && !type_dependent_expression_p (t))
4075 if (flags & tf_error)
4076 non_const_var_error (t);
4083 case VIEW_CONVERT_EXPR:
4084 /* -- a reinterpret_cast. FIXME not implemented, and this rule
4085 may change to something more specific to type-punning (DR 1312). */
4087 tree from = TREE_OPERAND (t, 0);
4088 if (POINTER_TYPE_P (TREE_TYPE (t))
4089 && TREE_CODE (from) == INTEGER_CST
4090 && !integer_zerop (from))
4092 if (flags & tf_error)
4093 error_at (EXPR_LOC_OR_LOC (t, input_location),
4094 "reinterpret_cast from integer to pointer");
4097 return (RECUR (from, TREE_CODE (t) != VIEW_CONVERT_EXPR));
4101 /* -- a unary operator & that is applied to an lvalue that
4102 designates an object with thread or automatic storage
4104 t = TREE_OPERAND (t, 0);
4106 if (TREE_CODE (t) == OFFSET_REF && PTRMEM_OK_P (t))
4107 /* A pointer-to-member constant. */
4111 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
4112 any checking here, as we might dereference the pointer later. If
4113 we remove this code, also remove check_automatic_or_tls. */
4114 i = check_automatic_or_tls (t);
4119 if (flags & tf_error)
4120 error ("address-of an object %qE with thread local or "
4121 "automatic storage is not a constant expression", t);
4125 return RECUR (t, any);
4131 /* -- a class member access unless its postfix-expression is
4132 of literal type or of pointer to literal type. */
4133 /* This test would be redundant, as it follows from the
4134 postfix-expression being a potential constant expression. */
4135 return RECUR (TREE_OPERAND (t, 0), want_rval);
4137 case EXPR_PACK_EXPANSION:
4138 return RECUR (PACK_EXPANSION_PATTERN (t), want_rval);
4142 tree x = TREE_OPERAND (t, 0);
4144 if (is_this_parameter (x))
4146 if (DECL_CONTEXT (x)
4147 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x)))
4149 if (flags & tf_error)
4150 error ("use of %<this%> in a constant expression");
4155 return RECUR (x, rval);
4158 case STATEMENT_LIST:
4160 tree_stmt_iterator i;
4161 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
4163 if (!RECUR (tsi_stmt (i), any))
4171 if (cxx_dialect < cxx14)
4173 if (!RECUR (TREE_OPERAND (t, 0), any))
4175 if (!RECUR (TREE_OPERAND (t, 1), rval))
4180 if (cxx_dialect < cxx14)
4182 if (!RECUR (TREE_OPERAND (t, 0), rval))
4184 if (!RECUR (TREE_OPERAND (t, 2), rval))
4189 if (!RECUR (IF_COND (t), rval))
4191 if (!RECUR (THEN_CLAUSE (t), any))
4193 if (!RECUR (ELSE_CLAUSE (t), any))
4198 if (!RECUR (DO_COND (t), rval))
4200 if (!RECUR (DO_BODY (t), any))
4205 if (!RECUR (FOR_INIT_STMT (t), any))
4207 if (!RECUR (FOR_COND (t), rval))
4209 if (!RECUR (FOR_EXPR (t), any))
4211 if (!RECUR (FOR_BODY (t), any))
4216 if (!RECUR (WHILE_COND (t), rval))
4218 if (!RECUR (WHILE_BODY (t), any))
4223 if (!RECUR (SWITCH_STMT_COND (t), rval))
4225 if (!RECUR (SWITCH_STMT_BODY (t), any))
4230 return RECUR (STMT_EXPR_STMT (t), rval);
4233 case DYNAMIC_CAST_EXPR:
4234 case PSEUDO_DTOR_EXPR:
4238 case VEC_DELETE_EXPR:
4241 case OMP_ATOMIC_READ:
4242 case OMP_ATOMIC_CAPTURE_OLD:
4243 case OMP_ATOMIC_CAPTURE_NEW:
4244 /* GCC internal stuff. */
4247 case TRANSACTION_EXPR:
4250 if (flags & tf_error)
4251 error ("expression %qE is not a constant-expression", t);
4255 /* -- a typeid expression whose operand is of polymorphic
4258 tree e = TREE_OPERAND (t, 0);
4259 if (!TYPE_P (e) && !type_dependent_expression_p (e)
4260 && TYPE_POLYMORPHIC_P (TREE_TYPE (e)))
4262 if (flags & tf_error)
4263 error ("typeid-expression is not a constant expression "
4264 "because %qE is of polymorphic type", e);
4271 /* -- a subtraction where both operands are pointers. */
4272 if (TYPE_PTR_P (TREE_OPERAND (t, 0))
4273 && TYPE_PTR_P (TREE_OPERAND (t, 1)))
4275 if (flags & tf_error)
4276 error ("difference of two pointer expressions is not "
4277 "a constant expression");
4289 /* -- a relational or equality operator where at least
4290 one of the operands is a pointer. */
4291 if (TYPE_PTR_P (TREE_OPERAND (t, 0))
4292 || TYPE_PTR_P (TREE_OPERAND (t, 1)))
4294 if (flags & tf_error)
4295 error ("pointer comparison expression is not a "
4296 "constant expression");
4302 case PREINCREMENT_EXPR:
4303 case POSTINCREMENT_EXPR:
4304 case PREDECREMENT_EXPR:
4305 case POSTDECREMENT_EXPR:
4306 if (cxx_dialect < cxx14)
4312 if (TYPE_P (TREE_OPERAND (t, 0)))
4314 /* else fall through. */
4320 case FIX_TRUNC_EXPR:
4324 case TRUTH_NOT_EXPR:
4325 case FIXED_CONVERT_EXPR:
4326 case UNARY_PLUS_EXPR:
4328 return RECUR (TREE_OPERAND (t, 0), rval);
4331 case CONST_CAST_EXPR:
4332 case STATIC_CAST_EXPR:
4333 case REINTERPRET_CAST_EXPR:
4334 case IMPLICIT_CONV_EXPR:
4335 if (cxx_dialect < cxx11
4336 && !dependent_type_p (TREE_TYPE (t))
4337 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t)))
4338 /* In C++98, a conversion to non-integral type can't be part of a
4339 constant expression. */
4341 if (flags & tf_error)
4342 error ("cast to non-integral type %qT in a constant expression",
4347 return (RECUR (TREE_OPERAND (t, 0),
4348 TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE));
4351 return RECUR (BIND_EXPR_BODY (t), want_rval);
4353 case WITH_CLEANUP_EXPR:
4354 case CLEANUP_POINT_EXPR:
4355 case MUST_NOT_THROW_EXPR:
4356 case TRY_CATCH_EXPR:
4362 case NON_DEPENDENT_EXPR:
4363 /* For convenience. */
4365 return RECUR (TREE_OPERAND (t, 0), want_rval);
4367 case TRY_FINALLY_EXPR:
4368 return (RECUR (TREE_OPERAND (t, 0), want_rval)
4369 && RECUR (TREE_OPERAND (t, 1), any));
4372 return RECUR (TREE_OPERAND (t, 1), want_rval);
4375 if (!literal_type_p (TREE_TYPE (t)))
4377 if (flags & tf_error)
4379 error ("temporary of non-literal type %qT in a "
4380 "constant expression", TREE_TYPE (t));
4381 explain_non_literal_class (TREE_TYPE (t));
4386 return RECUR (TREE_OPERAND (t, 1), rval);
4390 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
4391 constructor_elt *ce;
4392 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
4393 if (!RECUR (ce->value, want_rval))
4400 gcc_assert (TREE_PURPOSE (t) == NULL_TREE
4401 || DECL_P (TREE_PURPOSE (t)));
4402 if (!RECUR (TREE_VALUE (t), want_rval))
4404 if (TREE_CHAIN (t) == NULL_TREE)
4406 return RECUR (TREE_CHAIN (t), want_rval);
4409 case TRUNC_DIV_EXPR:
4411 case FLOOR_DIV_EXPR:
4412 case ROUND_DIV_EXPR:
4413 case TRUNC_MOD_EXPR:
4415 case ROUND_MOD_EXPR:
4417 tree denom = TREE_OPERAND (t, 1);
4418 if (!RECUR (denom, rval))
4420 /* We can't call cxx_eval_outermost_constant_expr on an expression
4421 that hasn't been through instantiate_non_dependent_expr yet. */
4422 if (!processing_template_decl)
4423 denom = cxx_eval_outermost_constant_expr (denom, true);
4424 if (integer_zerop (denom))
4426 if (flags & tf_error)
4427 error ("division by zero is not a constant-expression");
4433 return RECUR (TREE_OPERAND (t, 0), want_rval);
4439 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4440 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4441 introduced by build_call_a. */
4442 tree op0 = TREE_OPERAND (t, 0);
4443 tree op1 = TREE_OPERAND (t, 1);
4445 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
4446 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
4447 return RECUR (op0, want_rval);
4452 /* If the first operand is the non-short-circuit constant, look at
4453 the second operand; otherwise we only care about the first one for
4455 case TRUTH_AND_EXPR:
4456 case TRUTH_ANDIF_EXPR:
4457 tmp = boolean_true_node;
4460 case TRUTH_ORIF_EXPR:
4461 tmp = boolean_false_node;
4464 tree op = TREE_OPERAND (t, 0);
4465 if (!RECUR (op, rval))
4467 if (!processing_template_decl)
4468 op = cxx_eval_outermost_constant_expr (op, true);
4469 if (tree_int_cst_equal (op, tmp))
4470 return RECUR (TREE_OPERAND (t, 1), rval);
4477 case POINTER_PLUS_EXPR:
4479 case EXACT_DIV_EXPR:
4489 case TRUTH_XOR_EXPR:
4490 case UNORDERED_EXPR:
4503 case ARRAY_RANGE_REF:
4508 for (i = 0; i < 2; ++i)
4509 if (!RECUR (TREE_OPERAND (t, i), want_rval))
4513 case CILK_SYNC_STMT:
4514 case CILK_SPAWN_STMT:
4515 case ARRAY_NOTATION_REF:
4520 for (i = 0; i < 3; ++i)
4521 if (!RECUR (TREE_OPERAND (t, i), true))
4527 /* If the condition is a known constant, we know which of the legs we
4528 care about; otherwise we only require that the condition and
4529 either of the legs be potentially constant. */
4530 tmp = TREE_OPERAND (t, 0);
4531 if (!RECUR (tmp, rval))
4533 if (!processing_template_decl)
4534 tmp = cxx_eval_outermost_constant_expr (tmp, true);
4535 if (integer_zerop (tmp))
4536 return RECUR (TREE_OPERAND (t, 2), want_rval);
4537 else if (TREE_CODE (tmp) == INTEGER_CST)
4538 return RECUR (TREE_OPERAND (t, 1), want_rval);
4539 for (i = 1; i < 3; ++i)
4540 if (potential_constant_expression_1 (TREE_OPERAND (t, i),
4541 want_rval, strict, tf_none))
4543 if (flags & tf_error)
4544 error ("expression %qE is not a constant-expression", t);
4548 if (VEC_INIT_EXPR_IS_CONSTEXPR (t))
4550 if (flags & tf_error)
4552 error ("non-constant array initialization");
4553 diagnose_non_constexpr_vec_init (t);
4559 /* We can see these in statement-expressions. */
4563 if (objc_is_property_ref (t))
4566 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t)));
4573 /* The main entry point to the above. */
4576 potential_constant_expression (tree t)
4578 return potential_constant_expression_1 (t, false, true, tf_none);
4582 potential_static_init_expression (tree t)
4584 return potential_constant_expression_1 (t, false, false, tf_none);
4587 /* As above, but require a constant rvalue. */
4590 potential_rvalue_constant_expression (tree t)
4592 return potential_constant_expression_1 (t, true, true, tf_none);
4595 /* Like above, but complain about non-constant expressions. */
4598 require_potential_constant_expression (tree t)
4600 return potential_constant_expression_1 (t, false, true, tf_warning_or_error);
4603 /* Cross product of the above. */
4606 require_potential_rvalue_constant_expression (tree t)
4608 return potential_constant_expression_1 (t, true, true, tf_warning_or_error);
4611 #include "gt-cp-constexpr.h"