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.
4
5 Copyright (C) 1998-2018 Free Software Foundation, Inc.
6
7 This file is part of GCC.
8
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)
12 any later version.
13
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.
18
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/>. */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "cp-tree.h"
27 #include "varasm.h"
28 #include "c-family/c-objc.h"
29 #include "tree-iterator.h"
30 #include "gimplify.h"
31 #include "builtins.h"
32 #include "tree-inline.h"
33 #include "ubsan.h"
34 #include "gimple-fold.h"
35 #include "timevar.h"
36
37 static bool verify_constant (tree, bool, bool *, bool *);
38 #define VERIFY_CONSTANT(X) \
39 do { \
40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
41 return t; \
42 } while (0)
43
44 /* Returns true iff FUN is an instantiation of a constexpr function
45 template or a defaulted constexpr function. */
46
47 bool
is_instantiation_of_constexpr(tree fun)48 is_instantiation_of_constexpr (tree fun)
49 {
50 return ((DECL_TEMPLOID_INSTANTIATION (fun)
51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun)))
52 || (DECL_DEFAULTED_FN (fun)
53 && DECL_DECLARED_CONSTEXPR_P (fun)));
54 }
55
56 /* Return true if T is a literal type. */
57
58 bool
literal_type_p(tree t)59 literal_type_p (tree t)
60 {
61 if (SCALAR_TYPE_P (t)
62 || VECTOR_TYPE_P (t)
63 || TREE_CODE (t) == REFERENCE_TYPE
64 || (VOID_TYPE_P (t) && cxx_dialect >= cxx14))
65 return true;
66 if (CLASS_TYPE_P (t))
67 {
68 t = complete_type (t);
69 gcc_assert (COMPLETE_TYPE_P (t) || errorcount);
70 return CLASSTYPE_LITERAL_P (t);
71 }
72 if (TREE_CODE (t) == ARRAY_TYPE)
73 return literal_type_p (strip_array_types (t));
74 return false;
75 }
76
77 /* If DECL is a variable declared `constexpr', require its type
78 be literal. Return error_mark_node if we give an error, the
79 DECL otherwise. */
80
81 tree
ensure_literal_type_for_constexpr_object(tree decl)82 ensure_literal_type_for_constexpr_object (tree decl)
83 {
84 tree type = TREE_TYPE (decl);
85 if (VAR_P (decl)
86 && (DECL_DECLARED_CONSTEXPR_P (decl)
87 || var_in_constexpr_fn (decl))
88 && !processing_template_decl)
89 {
90 tree stype = strip_array_types (type);
91 if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype)))
92 /* Don't complain here, we'll complain about incompleteness
93 when we try to initialize the variable. */;
94 else if (!literal_type_p (type))
95 {
96 if (DECL_DECLARED_CONSTEXPR_P (decl))
97 {
98 error ("the type %qT of %<constexpr%> variable %qD "
99 "is not literal", type, decl);
100 explain_non_literal_class (type);
101 decl = error_mark_node;
102 }
103 else
104 {
105 if (!is_instantiation_of_constexpr (current_function_decl))
106 {
107 error ("variable %qD of non-literal type %qT in %<constexpr%> "
108 "function", decl, type);
109 explain_non_literal_class (type);
110 decl = error_mark_node;
111 }
112 cp_function_chain->invalid_constexpr = true;
113 }
114 }
115 else if (DECL_DECLARED_CONSTEXPR_P (decl)
116 && variably_modified_type_p (type, NULL_TREE))
117 {
118 error ("%<constexpr%> variable %qD has variably-modified type %qT",
119 decl, type);
120 decl = error_mark_node;
121 }
122 }
123 return decl;
124 }
125
126 /* Representation of entries in the constexpr function definition table. */
127
128 struct GTY((for_user)) constexpr_fundef {
129 tree decl;
130 tree body;
131 };
132
133 struct constexpr_fundef_hasher : ggc_ptr_hash<constexpr_fundef>
134 {
135 static hashval_t hash (constexpr_fundef *);
136 static bool equal (constexpr_fundef *, constexpr_fundef *);
137 };
138
139 /* This table holds all constexpr function definitions seen in
140 the current translation unit. */
141
142 static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table;
143
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. */
147
148 inline bool
equal(constexpr_fundef * lhs,constexpr_fundef * rhs)149 constexpr_fundef_hasher::equal (constexpr_fundef *lhs, constexpr_fundef *rhs)
150 {
151 return lhs->decl == rhs->decl;
152 }
153
154 /* Utility function used for managing the constexpr function table.
155 Return a hash value for the entry pointed to by Q. */
156
157 inline hashval_t
hash(constexpr_fundef * fundef)158 constexpr_fundef_hasher::hash (constexpr_fundef *fundef)
159 {
160 return DECL_UID (fundef->decl);
161 }
162
163 /* Return a previously saved definition of function FUN. */
164
165 static constexpr_fundef *
retrieve_constexpr_fundef(tree fun)166 retrieve_constexpr_fundef (tree fun)
167 {
168 constexpr_fundef fundef = { NULL, NULL };
169 if (constexpr_fundef_table == NULL)
170 return NULL;
171
172 fundef.decl = fun;
173 return constexpr_fundef_table->find (&fundef);
174 }
175
176 /* Check whether the parameter and return types of FUN are valid for a
177 constexpr function, and complain if COMPLAIN. */
178
179 bool
is_valid_constexpr_fn(tree fun,bool complain)180 is_valid_constexpr_fn (tree fun, bool complain)
181 {
182 bool ret = true;
183
184 if (DECL_INHERITED_CTOR (fun)
185 && TREE_CODE (fun) == TEMPLATE_DECL)
186 {
187 ret = false;
188 if (complain)
189 error ("inherited constructor %qD is not %<constexpr%>",
190 DECL_INHERITED_CTOR (fun));
191 }
192 else
193 {
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)))
197 {
198 ret = false;
199 if (complain)
200 {
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));
204 }
205 }
206 }
207
208 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)) && cxx_dialect < cxx17)
209 {
210 ret = false;
211 if (complain)
212 inform (DECL_SOURCE_LOCATION (fun),
213 "lambdas are implicitly %<constexpr%> only in C++17 and later");
214 }
215 else if (!DECL_CONSTRUCTOR_P (fun))
216 {
217 tree rettype = TREE_TYPE (TREE_TYPE (fun));
218 if (!literal_type_p (rettype))
219 {
220 ret = false;
221 if (complain)
222 {
223 error ("invalid return type %qT of %<constexpr%> function %q+D",
224 rettype, fun);
225 explain_non_literal_class (rettype);
226 }
227 }
228
229 /* C++14 DR 1684 removed this restriction. */
230 if (cxx_dialect < cxx14
231 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
232 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
233 {
234 ret = false;
235 if (complain
236 && pedwarn (DECL_SOURCE_LOCATION (fun), OPT_Wpedantic,
237 "enclosing class of %<constexpr%> non-static member "
238 "function %q+#D is not a literal type", fun))
239 explain_non_literal_class (DECL_CONTEXT (fun));
240 }
241 }
242 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
243 {
244 ret = false;
245 if (complain)
246 error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
247 }
248
249 return ret;
250 }
251
252 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
253 for a member of an anonymous aggregate, INIT is the initializer for that
254 member, and VEC_OUTER is the vector of constructor elements for the class
255 whose constructor we are processing. Add the initializer to the vector
256 and return true to indicate success. */
257
258 static bool
build_anon_member_initialization(tree member,tree init,vec<constructor_elt,va_gc> ** vec_outer)259 build_anon_member_initialization (tree member, tree init,
260 vec<constructor_elt, va_gc> **vec_outer)
261 {
262 /* MEMBER presents the relevant fields from the inside out, but we need
263 to build up the initializer from the outside in so that we can reuse
264 previously built CONSTRUCTORs if this is, say, the second field in an
265 anonymous struct. So we use a vec as a stack. */
266 auto_vec<tree, 2> fields;
267 do
268 {
269 fields.safe_push (TREE_OPERAND (member, 1));
270 member = TREE_OPERAND (member, 0);
271 }
272 while (ANON_AGGR_TYPE_P (TREE_TYPE (member))
273 && TREE_CODE (member) == COMPONENT_REF);
274
275 /* VEC has the constructor elements vector for the context of FIELD.
276 If FIELD is an anonymous aggregate, we will push inside it. */
277 vec<constructor_elt, va_gc> **vec = vec_outer;
278 tree field;
279 while (field = fields.pop(),
280 ANON_AGGR_TYPE_P (TREE_TYPE (field)))
281 {
282 tree ctor;
283 /* If there is already an outer constructor entry for the anonymous
284 aggregate FIELD, use it; otherwise, insert one. */
285 if (vec_safe_is_empty (*vec)
286 || (*vec)->last().index != field)
287 {
288 ctor = build_constructor (TREE_TYPE (field), NULL);
289 CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
290 }
291 else
292 ctor = (*vec)->last().value;
293 vec = &CONSTRUCTOR_ELTS (ctor);
294 }
295
296 /* Now we're at the innermost field, the one that isn't an anonymous
297 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
298 gcc_assert (fields.is_empty());
299 CONSTRUCTOR_APPEND_ELT (*vec, field, init);
300
301 return true;
302 }
303
304 /* Subroutine of build_constexpr_constructor_member_initializers.
305 The expression tree T represents a data member initialization
306 in a (constexpr) constructor definition. Build a pairing of
307 the data member with its initializer, and prepend that pair
308 to the existing initialization pair INITS. */
309
310 static bool
build_data_member_initialization(tree t,vec<constructor_elt,va_gc> ** vec)311 build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
312 {
313 tree member, init;
314 if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
315 t = TREE_OPERAND (t, 0);
316 if (TREE_CODE (t) == EXPR_STMT)
317 t = TREE_OPERAND (t, 0);
318 if (t == error_mark_node)
319 return false;
320 if (TREE_CODE (t) == STATEMENT_LIST)
321 {
322 tree_stmt_iterator i;
323 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
324 {
325 if (! build_data_member_initialization (tsi_stmt (i), vec))
326 return false;
327 }
328 return true;
329 }
330 if (TREE_CODE (t) == CLEANUP_STMT)
331 {
332 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
333 but we can in a constexpr constructor for a non-literal class. Just
334 ignore it; either all the initialization will be constant, in which
335 case the cleanup can't run, or it can't be constexpr.
336 Still recurse into CLEANUP_BODY. */
337 return build_data_member_initialization (CLEANUP_BODY (t), vec);
338 }
339 if (TREE_CODE (t) == CONVERT_EXPR)
340 t = TREE_OPERAND (t, 0);
341 if (TREE_CODE (t) == INIT_EXPR
342 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
343 use what this function builds for cx_check_missing_mem_inits, and
344 assignment in the ctor body doesn't count. */
345 || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR))
346 {
347 member = TREE_OPERAND (t, 0);
348 init = break_out_target_exprs (TREE_OPERAND (t, 1));
349 }
350 else if (TREE_CODE (t) == CALL_EXPR)
351 {
352 tree fn = get_callee_fndecl (t);
353 if (!fn || !DECL_CONSTRUCTOR_P (fn))
354 /* We're only interested in calls to subobject constructors. */
355 return true;
356 member = CALL_EXPR_ARG (t, 0);
357 /* We don't use build_cplus_new here because it complains about
358 abstract bases. Leaving the call unwrapped means that it has the
359 wrong type, but cxx_eval_constant_expression doesn't care. */
360 init = break_out_target_exprs (t);
361 }
362 else if (TREE_CODE (t) == BIND_EXPR)
363 return build_data_member_initialization (BIND_EXPR_BODY (t), vec);
364 else
365 /* Don't add anything else to the CONSTRUCTOR. */
366 return true;
367 if (INDIRECT_REF_P (member))
368 member = TREE_OPERAND (member, 0);
369 if (TREE_CODE (member) == NOP_EXPR)
370 {
371 tree op = member;
372 STRIP_NOPS (op);
373 if (TREE_CODE (op) == ADDR_EXPR)
374 {
375 gcc_assert (same_type_ignoring_top_level_qualifiers_p
376 (TREE_TYPE (TREE_TYPE (op)),
377 TREE_TYPE (TREE_TYPE (member))));
378 /* Initializing a cv-qualified member; we need to look through
379 the const_cast. */
380 member = op;
381 }
382 else if (op == current_class_ptr
383 && (same_type_ignoring_top_level_qualifiers_p
384 (TREE_TYPE (TREE_TYPE (member)),
385 current_class_type)))
386 /* Delegating constructor. */
387 member = op;
388 else
389 {
390 /* This is an initializer for an empty base; keep it for now so
391 we can check it in cxx_eval_bare_aggregate. */
392 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
393 }
394 }
395 if (TREE_CODE (member) == ADDR_EXPR)
396 member = TREE_OPERAND (member, 0);
397 if (TREE_CODE (member) == COMPONENT_REF)
398 {
399 tree aggr = TREE_OPERAND (member, 0);
400 if (TREE_CODE (aggr) == VAR_DECL)
401 /* Initializing a local variable, don't add anything. */
402 return true;
403 if (TREE_CODE (aggr) != COMPONENT_REF)
404 /* Normal member initialization. */
405 member = TREE_OPERAND (member, 1);
406 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
407 /* Initializing a member of an anonymous union. */
408 return build_anon_member_initialization (member, init, vec);
409 else
410 /* We're initializing a vtable pointer in a base. Leave it as
411 COMPONENT_REF so we remember the path to get to the vfield. */
412 gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
413 }
414
415 /* Value-initialization can produce multiple initializers for the
416 same field; use the last one. */
417 if (!vec_safe_is_empty (*vec) && (*vec)->last().index == member)
418 (*vec)->last().value = init;
419 else
420 CONSTRUCTOR_APPEND_ELT (*vec, member, init);
421 return true;
422 }
423
424 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
425 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
426 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
427
428 static bool
check_constexpr_bind_expr_vars(tree t)429 check_constexpr_bind_expr_vars (tree t)
430 {
431 gcc_assert (TREE_CODE (t) == BIND_EXPR);
432
433 for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var))
434 if (TREE_CODE (var) == TYPE_DECL
435 && DECL_IMPLICIT_TYPEDEF_P (var)
436 && !LAMBDA_TYPE_P (TREE_TYPE (var)))
437 return false;
438 return true;
439 }
440
441 /* Subroutine of check_constexpr_ctor_body. */
442
443 static bool
check_constexpr_ctor_body_1(tree last,tree list)444 check_constexpr_ctor_body_1 (tree last, tree list)
445 {
446 switch (TREE_CODE (list))
447 {
448 case DECL_EXPR:
449 if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL
450 || TREE_CODE (DECL_EXPR_DECL (list)) == TYPE_DECL)
451 return true;
452 return false;
453
454 case CLEANUP_POINT_EXPR:
455 return check_constexpr_ctor_body (last, TREE_OPERAND (list, 0),
456 /*complain=*/false);
457
458 case BIND_EXPR:
459 if (!check_constexpr_bind_expr_vars (list)
460 || !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list),
461 /*complain=*/false))
462 return false;
463 return true;
464
465 case USING_STMT:
466 case STATIC_ASSERT:
467 case DEBUG_BEGIN_STMT:
468 return true;
469
470 default:
471 return false;
472 }
473 }
474
475 /* Make sure that there are no statements after LAST in the constructor
476 body represented by LIST. */
477
478 bool
check_constexpr_ctor_body(tree last,tree list,bool complain)479 check_constexpr_ctor_body (tree last, tree list, bool complain)
480 {
481 /* C++14 doesn't require a constexpr ctor to have an empty body. */
482 if (cxx_dialect >= cxx14)
483 return true;
484
485 bool ok = true;
486 if (TREE_CODE (list) == STATEMENT_LIST)
487 {
488 tree_stmt_iterator i = tsi_last (list);
489 for (; !tsi_end_p (i); tsi_prev (&i))
490 {
491 tree t = tsi_stmt (i);
492 if (t == last)
493 break;
494 if (!check_constexpr_ctor_body_1 (last, t))
495 {
496 ok = false;
497 break;
498 }
499 }
500 }
501 else if (list != last
502 && !check_constexpr_ctor_body_1 (last, list))
503 ok = false;
504 if (!ok)
505 {
506 if (complain)
507 error ("%<constexpr%> constructor does not have empty body");
508 DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
509 }
510 return ok;
511 }
512
513 /* V is a vector of constructor elements built up for the base and member
514 initializers of a constructor for TYPE. They need to be in increasing
515 offset order, which they might not be yet if TYPE has a primary base
516 which is not first in the base-clause or a vptr and at least one base
517 all of which are non-primary. */
518
519 static vec<constructor_elt, va_gc> *
sort_constexpr_mem_initializers(tree type,vec<constructor_elt,va_gc> * v)520 sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
521 {
522 tree pri = CLASSTYPE_PRIMARY_BINFO (type);
523 tree field_type;
524 unsigned i;
525 constructor_elt *ce;
526
527 if (pri)
528 field_type = BINFO_TYPE (pri);
529 else if (TYPE_CONTAINS_VPTR_P (type))
530 field_type = vtbl_ptr_type_node;
531 else
532 return v;
533
534 /* Find the element for the primary base or vptr and move it to the
535 beginning of the vec. */
536 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
537 if (TREE_TYPE (ce->index) == field_type)
538 break;
539
540 if (i > 0 && i < vec_safe_length (v))
541 {
542 vec<constructor_elt, va_gc> &vref = *v;
543 constructor_elt elt = vref[i];
544 for (; i > 0; --i)
545 vref[i] = vref[i-1];
546 vref[0] = elt;
547 }
548
549 return v;
550 }
551
552 /* Build compile-time evalable representations of member-initializer list
553 for a constexpr constructor. */
554
555 static tree
build_constexpr_constructor_member_initializers(tree type,tree body)556 build_constexpr_constructor_member_initializers (tree type, tree body)
557 {
558 vec<constructor_elt, va_gc> *vec = NULL;
559 bool ok = true;
560 while (true)
561 switch (TREE_CODE (body))
562 {
563 case MUST_NOT_THROW_EXPR:
564 case EH_SPEC_BLOCK:
565 body = TREE_OPERAND (body, 0);
566 break;
567
568 case STATEMENT_LIST:
569 for (tree_stmt_iterator i = tsi_start (body);
570 !tsi_end_p (i); tsi_next (&i))
571 {
572 body = tsi_stmt (i);
573 if (TREE_CODE (body) == BIND_EXPR)
574 break;
575 }
576 break;
577
578 case BIND_EXPR:
579 body = BIND_EXPR_BODY (body);
580 goto found;
581
582 default:
583 gcc_unreachable ();
584 }
585 found:
586 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
587 {
588 body = TREE_OPERAND (body, 0);
589 if (TREE_CODE (body) == EXPR_STMT)
590 body = TREE_OPERAND (body, 0);
591 if (TREE_CODE (body) == INIT_EXPR
592 && (same_type_ignoring_top_level_qualifiers_p
593 (TREE_TYPE (TREE_OPERAND (body, 0)),
594 current_class_type)))
595 {
596 /* Trivial copy. */
597 return TREE_OPERAND (body, 1);
598 }
599 ok = build_data_member_initialization (body, &vec);
600 }
601 else if (TREE_CODE (body) == STATEMENT_LIST)
602 {
603 tree_stmt_iterator i;
604 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
605 {
606 ok = build_data_member_initialization (tsi_stmt (i), &vec);
607 if (!ok)
608 break;
609 }
610 }
611 else if (TREE_CODE (body) == TRY_BLOCK)
612 {
613 error ("body of %<constexpr%> constructor cannot be "
614 "a function-try-block");
615 return error_mark_node;
616 }
617 else if (EXPR_P (body))
618 ok = build_data_member_initialization (body, &vec);
619 else
620 gcc_assert (errorcount > 0);
621 if (ok)
622 {
623 if (vec_safe_length (vec) > 0)
624 {
625 /* In a delegating constructor, return the target. */
626 constructor_elt *ce = &(*vec)[0];
627 if (ce->index == current_class_ptr)
628 {
629 body = ce->value;
630 vec_free (vec);
631 return body;
632 }
633 }
634 vec = sort_constexpr_mem_initializers (type, vec);
635 return build_constructor (type, vec);
636 }
637 else
638 return error_mark_node;
639 }
640
641 /* We have an expression tree T that represents a call, either CALL_EXPR
642 or AGGR_INIT_EXPR. If the call is lexically to a named function,
643 retrun the _DECL for that function. */
644
645 static tree
get_function_named_in_call(tree t)646 get_function_named_in_call (tree t)
647 {
648 tree fun = cp_get_callee (t);
649 if (fun && TREE_CODE (fun) == ADDR_EXPR
650 && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
651 fun = TREE_OPERAND (fun, 0);
652 return fun;
653 }
654
655 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
656 declared to be constexpr, or a sub-statement thereof. Returns the
657 return value if suitable, error_mark_node for a statement not allowed in
658 a constexpr function, or NULL_TREE if no return value was found. */
659
660 tree
constexpr_fn_retval(tree body)661 constexpr_fn_retval (tree body)
662 {
663 switch (TREE_CODE (body))
664 {
665 case STATEMENT_LIST:
666 {
667 tree_stmt_iterator i;
668 tree expr = NULL_TREE;
669 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
670 {
671 tree s = constexpr_fn_retval (tsi_stmt (i));
672 if (s == error_mark_node)
673 return error_mark_node;
674 else if (s == NULL_TREE)
675 /* Keep iterating. */;
676 else if (expr)
677 /* Multiple return statements. */
678 return error_mark_node;
679 else
680 expr = s;
681 }
682 return expr;
683 }
684
685 case RETURN_EXPR:
686 return break_out_target_exprs (TREE_OPERAND (body, 0));
687
688 case DECL_EXPR:
689 {
690 tree decl = DECL_EXPR_DECL (body);
691 if (TREE_CODE (decl) == USING_DECL
692 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
693 || DECL_ARTIFICIAL (decl))
694 return NULL_TREE;
695 return error_mark_node;
696 }
697
698 case CLEANUP_POINT_EXPR:
699 return constexpr_fn_retval (TREE_OPERAND (body, 0));
700
701 case BIND_EXPR:
702 if (!check_constexpr_bind_expr_vars (body))
703 return error_mark_node;
704 return constexpr_fn_retval (BIND_EXPR_BODY (body));
705
706 case USING_STMT:
707 case DEBUG_BEGIN_STMT:
708 return NULL_TREE;
709
710 case CALL_EXPR:
711 {
712 tree fun = get_function_named_in_call (body);
713 if (fun != NULL_TREE
714 && DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE)
715 return NULL_TREE;
716 }
717 /* Fallthru. */
718
719 default:
720 return error_mark_node;
721 }
722 }
723
724 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
725 FUN; do the necessary transformations to turn it into a single expression
726 that we can store in the hash table. */
727
728 static tree
massage_constexpr_body(tree fun,tree body)729 massage_constexpr_body (tree fun, tree body)
730 {
731 if (DECL_CONSTRUCTOR_P (fun))
732 body = build_constexpr_constructor_member_initializers
733 (DECL_CONTEXT (fun), body);
734 else if (cxx_dialect < cxx14)
735 {
736 if (TREE_CODE (body) == EH_SPEC_BLOCK)
737 body = EH_SPEC_STMTS (body);
738 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
739 body = TREE_OPERAND (body, 0);
740 body = constexpr_fn_retval (body);
741 }
742 return body;
743 }
744
745 /* CTYPE is a type constructed from BODY. Return true if some
746 bases/fields are uninitialized, and complain if COMPLAIN. */
747
748 static bool
cx_check_missing_mem_inits(tree ctype,tree body,bool complain)749 cx_check_missing_mem_inits (tree ctype, tree body, bool complain)
750 {
751 unsigned nelts = 0;
752
753 if (body)
754 {
755 if (TREE_CODE (body) != CONSTRUCTOR)
756 return false;
757 nelts = CONSTRUCTOR_NELTS (body);
758 }
759 tree field = TYPE_FIELDS (ctype);
760
761 if (TREE_CODE (ctype) == UNION_TYPE)
762 {
763 if (nelts == 0 && next_initializable_field (field))
764 {
765 if (complain)
766 error ("%<constexpr%> constructor for union %qT must "
767 "initialize exactly one non-static data member", ctype);
768 return true;
769 }
770 return false;
771 }
772
773 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
774 need an explicit initialization. */
775 bool bad = false;
776 for (unsigned i = 0; i <= nelts; ++i)
777 {
778 tree index = NULL_TREE;
779 if (i < nelts)
780 {
781 index = CONSTRUCTOR_ELT (body, i)->index;
782 /* Skip base and vtable inits. */
783 if (TREE_CODE (index) != FIELD_DECL
784 || DECL_ARTIFICIAL (index))
785 continue;
786 }
787
788 for (; field != index; field = DECL_CHAIN (field))
789 {
790 tree ftype;
791 if (TREE_CODE (field) != FIELD_DECL)
792 continue;
793 if (DECL_UNNAMED_BIT_FIELD (field))
794 continue;
795 if (DECL_ARTIFICIAL (field))
796 continue;
797 if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
798 {
799 /* Recurse to check the anonummous aggregate member. */
800 bad |= cx_check_missing_mem_inits
801 (TREE_TYPE (field), NULL_TREE, complain);
802 if (bad && !complain)
803 return true;
804 continue;
805 }
806 ftype = strip_array_types (TREE_TYPE (field));
807 if (type_has_constexpr_default_constructor (ftype))
808 {
809 /* It's OK to skip a member with a trivial constexpr ctor.
810 A constexpr ctor that isn't trivial should have been
811 added in by now. */
812 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
813 || errorcount != 0);
814 continue;
815 }
816 if (!complain)
817 return true;
818 error ("member %qD must be initialized by mem-initializer "
819 "in %<constexpr%> constructor", field);
820 inform (DECL_SOURCE_LOCATION (field), "declared here");
821 bad = true;
822 }
823 if (field == NULL_TREE)
824 break;
825
826 if (ANON_AGGR_TYPE_P (TREE_TYPE (index)))
827 {
828 /* Check the anonymous aggregate initializer is valid. */
829 bad |= cx_check_missing_mem_inits
830 (TREE_TYPE (index), CONSTRUCTOR_ELT (body, i)->value, complain);
831 if (bad && !complain)
832 return true;
833 }
834 field = DECL_CHAIN (field);
835 }
836
837 return bad;
838 }
839
840 /* We are processing the definition of the constexpr function FUN.
841 Check that its BODY fulfills the propriate requirements and
842 enter it in the constexpr function definition table.
843 For constructor BODY is actually the TREE_LIST of the
844 member-initializer list. */
845
846 tree
register_constexpr_fundef(tree fun,tree body)847 register_constexpr_fundef (tree fun, tree body)
848 {
849 constexpr_fundef entry;
850 constexpr_fundef **slot;
851
852 if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
853 return NULL;
854
855 tree massaged = massage_constexpr_body (fun, body);
856 if (massaged == NULL_TREE || massaged == error_mark_node)
857 {
858 if (!DECL_CONSTRUCTOR_P (fun))
859 error ("body of %<constexpr%> function %qD not a return-statement",
860 fun);
861 return NULL;
862 }
863
864 if (!potential_rvalue_constant_expression (massaged))
865 {
866 if (!DECL_GENERATED_P (fun))
867 require_potential_rvalue_constant_expression (massaged);
868 return NULL;
869 }
870
871 if (DECL_CONSTRUCTOR_P (fun)
872 && cx_check_missing_mem_inits (DECL_CONTEXT (fun),
873 massaged, !DECL_GENERATED_P (fun)))
874 return NULL;
875
876 /* Create the constexpr function table if necessary. */
877 if (constexpr_fundef_table == NULL)
878 constexpr_fundef_table
879 = hash_table<constexpr_fundef_hasher>::create_ggc (101);
880
881 entry.decl = fun;
882 entry.body = body;
883 slot = constexpr_fundef_table->find_slot (&entry, INSERT);
884
885 gcc_assert (*slot == NULL);
886 *slot = ggc_alloc<constexpr_fundef> ();
887 **slot = entry;
888
889 return fun;
890 }
891
892 /* FUN is a non-constexpr function called in a context that requires a
893 constant expression. If it comes from a constexpr template, explain why
894 the instantiation isn't constexpr. */
895
896 void
explain_invalid_constexpr_fn(tree fun)897 explain_invalid_constexpr_fn (tree fun)
898 {
899 static hash_set<tree> *diagnosed;
900 tree body;
901 location_t save_loc;
902 /* Only diagnose defaulted functions, lambdas, or instantiations. */
903 if (!DECL_DEFAULTED_FN (fun)
904 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun))
905 && !is_instantiation_of_constexpr (fun))
906 return;
907 if (diagnosed == NULL)
908 diagnosed = new hash_set<tree>;
909 if (diagnosed->add (fun))
910 /* Already explained. */
911 return;
912
913 save_loc = input_location;
914 if (!lambda_static_thunk_p (fun))
915 {
916 /* Diagnostics should completely ignore the static thunk, so leave
917 input_location set to our caller's location. */
918 input_location = DECL_SOURCE_LOCATION (fun);
919 inform (input_location,
920 "%qD is not usable as a %<constexpr%> function because:", fun);
921 }
922 /* First check the declaration. */
923 if (is_valid_constexpr_fn (fun, true))
924 {
925 /* Then if it's OK, the body. */
926 if (!DECL_DECLARED_CONSTEXPR_P (fun)
927 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)))
928 explain_implicit_non_constexpr (fun);
929 else
930 {
931 body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
932 require_potential_rvalue_constant_expression (body);
933 if (DECL_CONSTRUCTOR_P (fun))
934 cx_check_missing_mem_inits (DECL_CONTEXT (fun), body, true);
935 }
936 }
937 input_location = save_loc;
938 }
939
940 /* Objects of this type represent calls to constexpr functions
941 along with the bindings of parameters to their arguments, for
942 the purpose of compile time evaluation. */
943
944 struct GTY((for_user)) constexpr_call {
945 /* Description of the constexpr function definition. */
946 constexpr_fundef *fundef;
947 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
948 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
949 Note: This arrangement is made to accommodate the use of
950 iterative_hash_template_arg (see pt.c). If you change this
951 representation, also change the hash calculation in
952 cxx_eval_call_expression. */
953 tree bindings;
954 /* Result of the call.
955 NULL means the call is being evaluated.
956 error_mark_node means that the evaluation was erroneous;
957 otherwise, the actuall value of the call. */
958 tree result;
959 /* The hash of this call; we remember it here to avoid having to
960 recalculate it when expanding the hash table. */
961 hashval_t hash;
962 };
963
964 struct constexpr_call_hasher : ggc_ptr_hash<constexpr_call>
965 {
966 static hashval_t hash (constexpr_call *);
967 static bool equal (constexpr_call *, constexpr_call *);
968 };
969
970 enum constexpr_switch_state {
971 /* Used when processing a switch for the first time by cxx_eval_switch_expr
972 and default: label for that switch has not been seen yet. */
973 css_default_not_seen,
974 /* Used when processing a switch for the first time by cxx_eval_switch_expr
975 and default: label for that switch has been seen already. */
976 css_default_seen,
977 /* Used when processing a switch for the second time by
978 cxx_eval_switch_expr, where default: label should match. */
979 css_default_processing
980 };
981
982 /* The constexpr expansion context. CALL is the current function
983 expansion, CTOR is the current aggregate initializer, OBJECT is the
984 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
985 is a map of values of variables initialized within the expression. */
986
987 struct constexpr_ctx {
988 /* The innermost call we're evaluating. */
989 constexpr_call *call;
990 /* Values for any temporaries or local variables within the
991 constant-expression. */
992 hash_map<tree,tree> *values;
993 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
994 aren't inside a loop. */
995 hash_set<tree> *save_exprs;
996 /* The CONSTRUCTOR we're currently building up for an aggregate
997 initializer. */
998 tree ctor;
999 /* The object we're building the CONSTRUCTOR for. */
1000 tree object;
1001 /* If inside SWITCH_EXPR. */
1002 constexpr_switch_state *css_state;
1003 /* Whether we should error on a non-constant expression or fail quietly. */
1004 bool quiet;
1005 /* Whether we are strictly conforming to constant expression rules or
1006 trying harder to get a constant value. */
1007 bool strict;
1008 };
1009
1010 /* A table of all constexpr calls that have been evaluated by the
1011 compiler in this translation unit. */
1012
1013 static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
1014
1015 static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
1016 bool, bool *, bool *, tree * = NULL);
1017
1018 /* Compute a hash value for a constexpr call representation. */
1019
1020 inline hashval_t
hash(constexpr_call * info)1021 constexpr_call_hasher::hash (constexpr_call *info)
1022 {
1023 return info->hash;
1024 }
1025
1026 /* Return true if the objects pointed to by P and Q represent calls
1027 to the same constexpr function with the same arguments.
1028 Otherwise, return false. */
1029
1030 bool
equal(constexpr_call * lhs,constexpr_call * rhs)1031 constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs)
1032 {
1033 tree lhs_bindings;
1034 tree rhs_bindings;
1035 if (lhs == rhs)
1036 return true;
1037 if (lhs->hash != rhs->hash)
1038 return false;
1039 if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef))
1040 return false;
1041 lhs_bindings = lhs->bindings;
1042 rhs_bindings = rhs->bindings;
1043 while (lhs_bindings != NULL && rhs_bindings != NULL)
1044 {
1045 tree lhs_arg = TREE_VALUE (lhs_bindings);
1046 tree rhs_arg = TREE_VALUE (rhs_bindings);
1047 gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
1048 if (!cp_tree_equal (lhs_arg, rhs_arg))
1049 return false;
1050 lhs_bindings = TREE_CHAIN (lhs_bindings);
1051 rhs_bindings = TREE_CHAIN (rhs_bindings);
1052 }
1053 return lhs_bindings == rhs_bindings;
1054 }
1055
1056 /* Initialize the constexpr call table, if needed. */
1057
1058 static void
maybe_initialize_constexpr_call_table(void)1059 maybe_initialize_constexpr_call_table (void)
1060 {
1061 if (constexpr_call_table == NULL)
1062 constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101);
1063 }
1064
1065 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1066 a function happens to get called recursively, we unshare the callee
1067 function's body and evaluate this unshared copy instead of evaluating the
1068 original body.
1069
1070 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1071 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1072 that's keyed off of the original FUNCTION_DECL and whose value is a
1073 TREE_LIST of this function's unused copies awaiting reuse.
1074
1075 This is not GC-deletable to avoid GC affecting UID generation. */
1076
1077 static GTY(()) hash_map<tree, tree> *fundef_copies_table;
1078
1079 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1080
1081 static void
maybe_initialize_fundef_copies_table()1082 maybe_initialize_fundef_copies_table ()
1083 {
1084 if (fundef_copies_table == NULL)
1085 fundef_copies_table = hash_map<tree,tree>::create_ggc (101);
1086 }
1087
1088 /* Reuse a copy or create a new unshared copy of the function FUN.
1089 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1090 is parms, TYPE is result. */
1091
1092 static tree
get_fundef_copy(tree fun)1093 get_fundef_copy (tree fun)
1094 {
1095 maybe_initialize_fundef_copies_table ();
1096
1097 tree copy;
1098 bool existed;
1099 tree *slot = &fundef_copies_table->get_or_insert (fun, &existed);
1100
1101 if (!existed)
1102 {
1103 /* There is no cached function available, or in use. We can use
1104 the function directly. That the slot is now created records
1105 that this function is now in use. */
1106 copy = build_tree_list (DECL_SAVED_TREE (fun), DECL_ARGUMENTS (fun));
1107 TREE_TYPE (copy) = DECL_RESULT (fun);
1108 }
1109 else if (*slot == NULL_TREE)
1110 {
1111 /* We've already used the function itself, so make a copy. */
1112 copy = build_tree_list (NULL, NULL);
1113 TREE_PURPOSE (copy) = copy_fn (fun, TREE_VALUE (copy), TREE_TYPE (copy));
1114 }
1115 else
1116 {
1117 /* We have a cached function available. */
1118 copy = *slot;
1119 *slot = TREE_CHAIN (copy);
1120 }
1121
1122 return copy;
1123 }
1124
1125 /* Save the copy COPY of function FUN for later reuse by
1126 get_fundef_copy(). By construction, there will always be an entry
1127 to find. */
1128
1129 static void
save_fundef_copy(tree fun,tree copy)1130 save_fundef_copy (tree fun, tree copy)
1131 {
1132 tree *slot = fundef_copies_table->get (fun);
1133 TREE_CHAIN (copy) = *slot;
1134 *slot = copy;
1135 }
1136
1137 /* We have an expression tree T that represents a call, either CALL_EXPR
1138 or AGGR_INIT_EXPR. Return the Nth argument. */
1139
1140 static inline tree
get_nth_callarg(tree t,int n)1141 get_nth_callarg (tree t, int n)
1142 {
1143 switch (TREE_CODE (t))
1144 {
1145 case CALL_EXPR:
1146 return CALL_EXPR_ARG (t, n);
1147
1148 case AGGR_INIT_EXPR:
1149 return AGGR_INIT_EXPR_ARG (t, n);
1150
1151 default:
1152 gcc_unreachable ();
1153 return NULL;
1154 }
1155 }
1156
1157 /* Attempt to evaluate T which represents a call to a builtin function.
1158 We assume here that all builtin functions evaluate to scalar types
1159 represented by _CST nodes. */
1160
1161 static tree
cxx_eval_builtin_function_call(const constexpr_ctx * ctx,tree t,tree fun,bool lval,bool * non_constant_p,bool * overflow_p)1162 cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,
1163 bool lval,
1164 bool *non_constant_p, bool *overflow_p)
1165 {
1166 const int nargs = call_expr_nargs (t);
1167 tree *args = (tree *) alloca (nargs * sizeof (tree));
1168 tree new_call;
1169 int i;
1170
1171 /* Don't fold __builtin_constant_p within a constexpr function. */
1172 bool bi_const_p = (DECL_FUNCTION_CODE (fun) == BUILT_IN_CONSTANT_P);
1173
1174 /* If we aren't requiring a constant expression, defer __builtin_constant_p
1175 in a constexpr function until we have values for the parameters. */
1176 if (bi_const_p
1177 && ctx->quiet
1178 && current_function_decl
1179 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
1180 {
1181 *non_constant_p = true;
1182 return t;
1183 }
1184
1185 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1186 return constant false for a non-constant argument. */
1187 constexpr_ctx new_ctx = *ctx;
1188 new_ctx.quiet = true;
1189 bool dummy1 = false, dummy2 = false;
1190 for (i = 0; i < nargs; ++i)
1191 {
1192 args[i] = CALL_EXPR_ARG (t, i);
1193 /* If builtin_valid_in_constant_expr_p is true,
1194 potential_constant_expression_1 has not recursed into the arguments
1195 of the builtin, verify it here. */
1196 if (!builtin_valid_in_constant_expr_p (fun)
1197 || potential_constant_expression (args[i]))
1198 args[i] = cxx_eval_constant_expression (&new_ctx, args[i], false,
1199 &dummy1, &dummy2);
1200 if (bi_const_p)
1201 /* For __built_in_constant_p, fold all expressions with constant values
1202 even if they aren't C++ constant-expressions. */
1203 args[i] = cp_fully_fold (args[i]);
1204 }
1205
1206 bool save_ffbcp = force_folding_builtin_constant_p;
1207 force_folding_builtin_constant_p = true;
1208 new_call = fold_builtin_call_array (EXPR_LOCATION (t), TREE_TYPE (t),
1209 CALL_EXPR_FN (t), nargs, args);
1210 force_folding_builtin_constant_p = save_ffbcp;
1211 if (new_call == NULL)
1212 {
1213 if (!*non_constant_p && !ctx->quiet)
1214 {
1215 /* Do not allow__builtin_unreachable in constexpr function.
1216 The __builtin_unreachable call with BUILTINS_LOCATION
1217 comes from cp_maybe_instrument_return. */
1218 if (DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE
1219 && EXPR_LOCATION (t) == BUILTINS_LOCATION)
1220 error ("%<constexpr%> call flows off the end of the function");
1221 else
1222 {
1223 new_call = build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
1224 CALL_EXPR_FN (t), nargs, args);
1225 error ("%q+E is not a constant expression", new_call);
1226 }
1227 }
1228 *non_constant_p = true;
1229 return t;
1230 }
1231
1232 if (!is_constant_expression (new_call))
1233 {
1234 if (!*non_constant_p && !ctx->quiet)
1235 error ("%q+E is not a constant expression", new_call);
1236 *non_constant_p = true;
1237 return t;
1238 }
1239
1240 return cxx_eval_constant_expression (&new_ctx, new_call, lval,
1241 non_constant_p, overflow_p);
1242 }
1243
1244 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1245 the type of the value to match. */
1246
1247 static tree
adjust_temp_type(tree type,tree temp)1248 adjust_temp_type (tree type, tree temp)
1249 {
1250 if (TREE_TYPE (temp) == type)
1251 return temp;
1252 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1253 if (TREE_CODE (temp) == CONSTRUCTOR)
1254 return build_constructor (type, CONSTRUCTOR_ELTS (temp));
1255 if (TREE_CODE (temp) == EMPTY_CLASS_EXPR)
1256 return build0 (EMPTY_CLASS_EXPR, type);
1257 gcc_assert (scalarish_type_p (type));
1258 /* Now we know we're dealing with a scalar, and a prvalue of non-class
1259 type is cv-unqualified. */
1260 return cp_fold_convert (cv_unqualified (type), temp);
1261 }
1262
1263 /* Callback for walk_tree used by unshare_constructor. */
1264
1265 static tree
find_constructor(tree * tp,int * walk_subtrees,void *)1266 find_constructor (tree *tp, int *walk_subtrees, void *)
1267 {
1268 if (TYPE_P (*tp))
1269 *walk_subtrees = 0;
1270 if (TREE_CODE (*tp) == CONSTRUCTOR)
1271 return *tp;
1272 return NULL_TREE;
1273 }
1274
1275 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1276 subexpression, return an unshared copy of T. Otherwise return T. */
1277
1278 static tree
unshare_constructor(tree t)1279 unshare_constructor (tree t)
1280 {
1281 tree ctor = walk_tree (&t, find_constructor, NULL, NULL);
1282 if (ctor != NULL_TREE)
1283 return unshare_expr (t);
1284 return t;
1285 }
1286
1287 /* Subroutine of cxx_eval_call_expression.
1288 We are processing a call expression (either CALL_EXPR or
1289 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1290 all arguments and bind their values to correspondings
1291 parameters, making up the NEW_CALL context. */
1292
1293 static void
cxx_bind_parameters_in_call(const constexpr_ctx * ctx,tree t,constexpr_call * new_call,bool * non_constant_p,bool * overflow_p,bool * non_constant_args)1294 cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
1295 constexpr_call *new_call,
1296 bool *non_constant_p, bool *overflow_p,
1297 bool *non_constant_args)
1298 {
1299 const int nargs = call_expr_nargs (t);
1300 tree fun = new_call->fundef->decl;
1301 tree parms = DECL_ARGUMENTS (fun);
1302 int i;
1303 tree *p = &new_call->bindings;
1304 for (i = 0; i < nargs; ++i)
1305 {
1306 tree x, arg;
1307 tree type = parms ? TREE_TYPE (parms) : void_type_node;
1308 x = get_nth_callarg (t, i);
1309 /* For member function, the first argument is a pointer to the implied
1310 object. For a constructor, it might still be a dummy object, in
1311 which case we get the real argument from ctx. */
1312 if (i == 0 && DECL_CONSTRUCTOR_P (fun)
1313 && is_dummy_object (x))
1314 {
1315 x = ctx->object;
1316 x = build_address (x);
1317 }
1318 arg = cxx_eval_constant_expression (ctx, x, /*lval=*/false,
1319 non_constant_p, overflow_p);
1320 /* Don't VERIFY_CONSTANT here. */
1321 if (*non_constant_p && ctx->quiet)
1322 return;
1323 /* Just discard ellipsis args after checking their constantitude. */
1324 if (!parms)
1325 continue;
1326
1327 if (!*non_constant_p)
1328 {
1329 /* Don't share a CONSTRUCTOR that might be changed. */
1330 arg = unshare_constructor (arg);
1331 /* Make sure the binding has the same type as the parm. But
1332 only for constant args. */
1333 if (TREE_CODE (type) != REFERENCE_TYPE)
1334 arg = adjust_temp_type (type, arg);
1335 if (!TREE_CONSTANT (arg))
1336 *non_constant_args = true;
1337 *p = build_tree_list (parms, arg);
1338 p = &TREE_CHAIN (*p);
1339 }
1340 parms = TREE_CHAIN (parms);
1341 }
1342 }
1343
1344 /* Variables and functions to manage constexpr call expansion context.
1345 These do not need to be marked for PCH or GC. */
1346
1347 /* FIXME remember and print actual constant arguments. */
1348 static vec<tree> call_stack;
1349 static int call_stack_tick;
1350 static int last_cx_error_tick;
1351
1352 static bool
push_cx_call_context(tree call)1353 push_cx_call_context (tree call)
1354 {
1355 ++call_stack_tick;
1356 if (!EXPR_HAS_LOCATION (call))
1357 SET_EXPR_LOCATION (call, input_location);
1358 call_stack.safe_push (call);
1359 if (call_stack.length () > (unsigned) max_constexpr_depth)
1360 return false;
1361 return true;
1362 }
1363
1364 static void
pop_cx_call_context(void)1365 pop_cx_call_context (void)
1366 {
1367 ++call_stack_tick;
1368 call_stack.pop ();
1369 }
1370
1371 vec<tree>
cx_error_context(void)1372 cx_error_context (void)
1373 {
1374 vec<tree> r = vNULL;
1375 if (call_stack_tick != last_cx_error_tick
1376 && !call_stack.is_empty ())
1377 r = call_stack;
1378 last_cx_error_tick = call_stack_tick;
1379 return r;
1380 }
1381
1382 /* Evaluate a call T to a GCC internal function when possible and return
1383 the evaluated result or, under the control of CTX, give an error, set
1384 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1385
1386 static tree
cxx_eval_internal_function(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)1387 cxx_eval_internal_function (const constexpr_ctx *ctx, tree t,
1388 bool lval,
1389 bool *non_constant_p, bool *overflow_p)
1390 {
1391 enum tree_code opcode = ERROR_MARK;
1392
1393 switch (CALL_EXPR_IFN (t))
1394 {
1395 case IFN_UBSAN_NULL:
1396 case IFN_UBSAN_BOUNDS:
1397 case IFN_UBSAN_VPTR:
1398 case IFN_FALLTHROUGH:
1399 return void_node;
1400
1401 case IFN_ADD_OVERFLOW:
1402 opcode = PLUS_EXPR;
1403 break;
1404 case IFN_SUB_OVERFLOW:
1405 opcode = MINUS_EXPR;
1406 break;
1407 case IFN_MUL_OVERFLOW:
1408 opcode = MULT_EXPR;
1409 break;
1410
1411 case IFN_LAUNDER:
1412 return cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0),
1413 false, non_constant_p, overflow_p);
1414
1415 default:
1416 if (!ctx->quiet)
1417 error_at (EXPR_LOC_OR_LOC (t, input_location),
1418 "call to internal function %qE", t);
1419 *non_constant_p = true;
1420 return t;
1421 }
1422
1423 /* Evaluate constant arguments using OPCODE and return a complex
1424 number containing the result and the overflow bit. */
1425 tree arg0 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0), lval,
1426 non_constant_p, overflow_p);
1427 tree arg1 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 1), lval,
1428 non_constant_p, overflow_p);
1429
1430 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1431 {
1432 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1433 tree type = TREE_TYPE (TREE_TYPE (t));
1434 tree result = fold_binary_loc (loc, opcode, type,
1435 fold_convert_loc (loc, type, arg0),
1436 fold_convert_loc (loc, type, arg1));
1437 tree ovf
1438 = build_int_cst (type, arith_overflowed_p (opcode, type, arg0, arg1));
1439 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1440 if (TREE_OVERFLOW (result))
1441 TREE_OVERFLOW (result) = 0;
1442
1443 return build_complex (TREE_TYPE (t), result, ovf);
1444 }
1445
1446 *non_constant_p = true;
1447 return t;
1448 }
1449
1450 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1451
1452 static void
clear_no_implicit_zero(tree ctor)1453 clear_no_implicit_zero (tree ctor)
1454 {
1455 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor))
1456 {
1457 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = false;
1458 tree elt; unsigned HOST_WIDE_INT idx;
1459 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), idx, elt)
1460 if (TREE_CODE (elt) == CONSTRUCTOR)
1461 clear_no_implicit_zero (elt);
1462 }
1463 }
1464
1465 /* Subroutine of cxx_eval_constant_expression.
1466 Evaluate the call expression tree T in the context of OLD_CALL expression
1467 evaluation. */
1468
1469 static tree
cxx_eval_call_expression(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)1470 cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
1471 bool lval,
1472 bool *non_constant_p, bool *overflow_p)
1473 {
1474 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1475 tree fun = get_function_named_in_call (t);
1476 constexpr_call new_call = { NULL, NULL, NULL, 0 };
1477 bool depth_ok;
1478
1479 if (fun == NULL_TREE)
1480 return cxx_eval_internal_function (ctx, t, lval,
1481 non_constant_p, overflow_p);
1482
1483 if (TREE_CODE (fun) != FUNCTION_DECL)
1484 {
1485 /* Might be a constexpr function pointer. */
1486 fun = cxx_eval_constant_expression (ctx, fun,
1487 /*lval*/false, non_constant_p,
1488 overflow_p);
1489 STRIP_NOPS (fun);
1490 if (TREE_CODE (fun) == ADDR_EXPR)
1491 fun = TREE_OPERAND (fun, 0);
1492 }
1493 if (TREE_CODE (fun) != FUNCTION_DECL)
1494 {
1495 if (!ctx->quiet && !*non_constant_p)
1496 error_at (loc, "expression %qE does not designate a %<constexpr%> "
1497 "function", fun);
1498 *non_constant_p = true;
1499 return t;
1500 }
1501 if (DECL_CLONED_FUNCTION_P (fun))
1502 fun = DECL_CLONED_FUNCTION (fun);
1503
1504 if (is_ubsan_builtin_p (fun))
1505 return void_node;
1506
1507 if (is_builtin_fn (fun))
1508 return cxx_eval_builtin_function_call (ctx, t, fun,
1509 lval, non_constant_p, overflow_p);
1510 if (!DECL_DECLARED_CONSTEXPR_P (fun))
1511 {
1512 if (!ctx->quiet)
1513 {
1514 if (!lambda_static_thunk_p (fun))
1515 error_at (loc, "call to non-%<constexpr%> function %qD", fun);
1516 explain_invalid_constexpr_fn (fun);
1517 }
1518 *non_constant_p = true;
1519 return t;
1520 }
1521
1522 constexpr_ctx new_ctx = *ctx;
1523 if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
1524 && TREE_CODE (t) == AGGR_INIT_EXPR)
1525 {
1526 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1527 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1528 new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
1529 tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
1530 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true;
1531 ctx->values->put (new_ctx.object, ctor);
1532 ctx = &new_ctx;
1533 }
1534
1535 /* Shortcut trivial constructor/op=. */
1536 if (trivial_fn_p (fun))
1537 {
1538 tree init = NULL_TREE;
1539 if (call_expr_nargs (t) == 2)
1540 init = convert_from_reference (get_nth_callarg (t, 1));
1541 else if (TREE_CODE (t) == AGGR_INIT_EXPR
1542 && AGGR_INIT_ZERO_FIRST (t))
1543 init = build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false);
1544 if (init)
1545 {
1546 tree op = get_nth_callarg (t, 0);
1547 if (is_dummy_object (op))
1548 op = ctx->object;
1549 else
1550 op = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (op)), op);
1551 tree set = build2 (MODIFY_EXPR, TREE_TYPE (op), op, init);
1552 new_ctx.call = &new_call;
1553 return cxx_eval_constant_expression (&new_ctx, set, lval,
1554 non_constant_p, overflow_p);
1555 }
1556 }
1557
1558 /* We can't defer instantiating the function any longer. */
1559 if (!DECL_INITIAL (fun)
1560 && DECL_TEMPLOID_INSTANTIATION (fun))
1561 {
1562 location_t save_loc = input_location;
1563 input_location = loc;
1564 ++function_depth;
1565 instantiate_decl (fun, /*defer_ok*/false, /*expl_inst*/false);
1566 --function_depth;
1567 input_location = save_loc;
1568 }
1569
1570 /* If in direct recursive call, optimize definition search. */
1571 if (ctx && ctx->call && ctx->call->fundef && ctx->call->fundef->decl == fun)
1572 new_call.fundef = ctx->call->fundef;
1573 else
1574 {
1575 new_call.fundef = retrieve_constexpr_fundef (fun);
1576 if (new_call.fundef == NULL || new_call.fundef->body == NULL
1577 || fun == current_function_decl)
1578 {
1579 if (!ctx->quiet)
1580 {
1581 /* We need to check for current_function_decl here in case we're
1582 being called during cp_fold_function, because at that point
1583 DECL_INITIAL is set properly and we have a fundef but we
1584 haven't lowered invisirefs yet (c++/70344). */
1585 if (DECL_INITIAL (fun) == error_mark_node
1586 || fun == current_function_decl)
1587 error_at (loc, "%qD called in a constant expression before its "
1588 "definition is complete", fun);
1589 else if (DECL_INITIAL (fun))
1590 {
1591 /* The definition of fun was somehow unsuitable. But pretend
1592 that lambda static thunks don't exist. */
1593 if (!lambda_static_thunk_p (fun))
1594 error_at (loc, "%qD called in a constant expression", fun);
1595 explain_invalid_constexpr_fn (fun);
1596 }
1597 else
1598 error_at (loc, "%qD used before its definition", fun);
1599 }
1600 *non_constant_p = true;
1601 return t;
1602 }
1603 }
1604
1605 bool non_constant_args = false;
1606 cxx_bind_parameters_in_call (ctx, t, &new_call,
1607 non_constant_p, overflow_p, &non_constant_args);
1608 if (*non_constant_p)
1609 return t;
1610
1611 depth_ok = push_cx_call_context (t);
1612
1613 tree result = NULL_TREE;
1614
1615 constexpr_call *entry = NULL;
1616 if (depth_ok && !non_constant_args && ctx->strict)
1617 {
1618 new_call.hash = iterative_hash_template_arg
1619 (new_call.bindings, constexpr_fundef_hasher::hash (new_call.fundef));
1620
1621 /* If we have seen this call before, we are done. */
1622 maybe_initialize_constexpr_call_table ();
1623 constexpr_call **slot
1624 = constexpr_call_table->find_slot (&new_call, INSERT);
1625 entry = *slot;
1626 if (entry == NULL)
1627 {
1628 /* We need to keep a pointer to the entry, not just the slot, as the
1629 slot can move in the call to cxx_eval_builtin_function_call. */
1630 *slot = entry = ggc_alloc<constexpr_call> ();
1631 *entry = new_call;
1632 }
1633 /* Calls that are in progress have their result set to NULL,
1634 so that we can detect circular dependencies. */
1635 else if (entry->result == NULL)
1636 {
1637 if (!ctx->quiet)
1638 error ("call has circular dependency");
1639 *non_constant_p = true;
1640 entry->result = result = error_mark_node;
1641 }
1642 else
1643 result = entry->result;
1644 }
1645
1646 if (!depth_ok)
1647 {
1648 if (!ctx->quiet)
1649 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1650 "-fconstexpr-depth= to increase the maximum)",
1651 max_constexpr_depth);
1652 *non_constant_p = true;
1653 result = error_mark_node;
1654 }
1655 else
1656 {
1657 if (result && result != error_mark_node)
1658 /* OK */;
1659 else if (!DECL_SAVED_TREE (fun))
1660 {
1661 /* When at_eof >= 2, cgraph has started throwing away
1662 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1663 late code generation for VEC_INIT_EXPR, which needs to be
1664 completely reconsidered. */
1665 gcc_assert (at_eof >= 2 && ctx->quiet);
1666 *non_constant_p = true;
1667 }
1668 else
1669 {
1670 tree body, parms, res;
1671
1672 /* Reuse or create a new unshared copy of this function's body. */
1673 tree copy = get_fundef_copy (fun);
1674 body = TREE_PURPOSE (copy);
1675 parms = TREE_VALUE (copy);
1676 res = TREE_TYPE (copy);
1677
1678 /* Associate the bindings with the remapped parms. */
1679 tree bound = new_call.bindings;
1680 tree remapped = parms;
1681 while (bound)
1682 {
1683 tree oparm = TREE_PURPOSE (bound);
1684 tree arg = TREE_VALUE (bound);
1685 gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm));
1686 /* Don't share a CONSTRUCTOR that might be changed. */
1687 arg = unshare_constructor (arg);
1688 ctx->values->put (remapped, arg);
1689 bound = TREE_CHAIN (bound);
1690 remapped = DECL_CHAIN (remapped);
1691 }
1692 /* Add the RESULT_DECL to the values map, too. */
1693 tree slot = NULL_TREE;
1694 if (DECL_BY_REFERENCE (res))
1695 {
1696 slot = AGGR_INIT_EXPR_SLOT (t);
1697 tree addr = build_address (slot);
1698 addr = build_nop (TREE_TYPE (res), addr);
1699 ctx->values->put (res, addr);
1700 ctx->values->put (slot, NULL_TREE);
1701 }
1702 else
1703 ctx->values->put (res, NULL_TREE);
1704
1705 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1706 their values after the call. */
1707 constexpr_ctx ctx_with_save_exprs = *ctx;
1708 hash_set<tree> save_exprs;
1709 ctx_with_save_exprs.save_exprs = &save_exprs;
1710 ctx_with_save_exprs.call = &new_call;
1711
1712 tree jump_target = NULL_TREE;
1713 cxx_eval_constant_expression (&ctx_with_save_exprs, body,
1714 lval, non_constant_p, overflow_p,
1715 &jump_target);
1716
1717 if (DECL_CONSTRUCTOR_P (fun))
1718 /* This can be null for a subobject constructor call, in
1719 which case what we care about is the initialization
1720 side-effects rather than the value. We could get at the
1721 value by evaluating *this, but we don't bother; there's
1722 no need to put such a call in the hash table. */
1723 result = lval ? ctx->object : ctx->ctor;
1724 else if (VOID_TYPE_P (TREE_TYPE (res)))
1725 result = void_node;
1726 else
1727 {
1728 result = *ctx->values->get (slot ? slot : res);
1729 if (result == NULL_TREE && !*non_constant_p)
1730 {
1731 if (!ctx->quiet)
1732 error ("%<constexpr%> call flows off the end "
1733 "of the function");
1734 *non_constant_p = true;
1735 }
1736 }
1737
1738 /* Forget the saved values of the callee's SAVE_EXPRs. */
1739 for (hash_set<tree>::iterator iter = save_exprs.begin();
1740 iter != save_exprs.end(); ++iter)
1741 ctx_with_save_exprs.values->remove (*iter);
1742
1743 /* Remove the parms/result from the values map. Is it worth
1744 bothering to do this when the map itself is only live for
1745 one constexpr evaluation? If so, maybe also clear out
1746 other vars from call, maybe in BIND_EXPR handling? */
1747 ctx->values->remove (res);
1748 if (slot)
1749 ctx->values->remove (slot);
1750 for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
1751 ctx->values->remove (parm);
1752
1753 /* Make the unshared function copy we used available for re-use. */
1754 save_fundef_copy (fun, copy);
1755 }
1756
1757 if (result == error_mark_node)
1758 *non_constant_p = true;
1759 if (*non_constant_p || *overflow_p)
1760 result = error_mark_node;
1761 else if (!result)
1762 result = void_node;
1763 if (entry)
1764 entry->result = result;
1765 }
1766
1767 /* The result of a constexpr function must be completely initialized. */
1768 if (TREE_CODE (result) == CONSTRUCTOR)
1769 clear_no_implicit_zero (result);
1770
1771 pop_cx_call_context ();
1772 return unshare_constructor (result);
1773 }
1774
1775 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1776
1777 bool
reduced_constant_expression_p(tree t)1778 reduced_constant_expression_p (tree t)
1779 {
1780 if (t == NULL_TREE)
1781 return false;
1782
1783 switch (TREE_CODE (t))
1784 {
1785 case PTRMEM_CST:
1786 /* Even if we can't lower this yet, it's constant. */
1787 return true;
1788
1789 case CONSTRUCTOR:
1790 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1791 tree idx, val, field; unsigned HOST_WIDE_INT i;
1792 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t))
1793 {
1794 if (TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1795 /* An initialized vector would have a VECTOR_CST. */
1796 return false;
1797 else
1798 field = next_initializable_field (TYPE_FIELDS (TREE_TYPE (t)));
1799 }
1800 else
1801 field = NULL_TREE;
1802 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, idx, val)
1803 {
1804 /* If VAL is null, we're in the middle of initializing this
1805 element. */
1806 if (!reduced_constant_expression_p (val))
1807 return false;
1808 if (field)
1809 {
1810 if (idx != field)
1811 return false;
1812 field = next_initializable_field (DECL_CHAIN (field));
1813 }
1814 }
1815 if (field)
1816 return false;
1817 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t))
1818 /* All the fields are initialized. */
1819 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
1820 return true;
1821
1822 default:
1823 /* FIXME are we calling this too much? */
1824 return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
1825 }
1826 }
1827
1828 /* Some expressions may have constant operands but are not constant
1829 themselves, such as 1/0. Call this function to check for that
1830 condition.
1831
1832 We only call this in places that require an arithmetic constant, not in
1833 places where we might have a non-constant expression that can be a
1834 component of a constant expression, such as the address of a constexpr
1835 variable that might be dereferenced later. */
1836
1837 static bool
verify_constant(tree t,bool allow_non_constant,bool * non_constant_p,bool * overflow_p)1838 verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
1839 bool *overflow_p)
1840 {
1841 if (!*non_constant_p && !reduced_constant_expression_p (t))
1842 {
1843 if (!allow_non_constant)
1844 error ("%q+E is not a constant expression", t);
1845 *non_constant_p = true;
1846 }
1847 if (TREE_OVERFLOW_P (t))
1848 {
1849 if (!allow_non_constant)
1850 {
1851 permerror (input_location, "overflow in constant expression");
1852 /* If we're being permissive (and are in an enforcing
1853 context), ignore the overflow. */
1854 if (flag_permissive)
1855 return *non_constant_p;
1856 }
1857 *overflow_p = true;
1858 }
1859 return *non_constant_p;
1860 }
1861
1862 /* Check whether the shift operation with code CODE and type TYPE on LHS
1863 and RHS is undefined. If it is, give an error with an explanation,
1864 and return true; return false otherwise. */
1865
1866 static bool
cxx_eval_check_shift_p(location_t loc,const constexpr_ctx * ctx,enum tree_code code,tree type,tree lhs,tree rhs)1867 cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx,
1868 enum tree_code code, tree type, tree lhs, tree rhs)
1869 {
1870 if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR)
1871 || TREE_CODE (lhs) != INTEGER_CST
1872 || TREE_CODE (rhs) != INTEGER_CST)
1873 return false;
1874
1875 tree lhstype = TREE_TYPE (lhs);
1876 unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs));
1877
1878 /* [expr.shift] The behavior is undefined if the right operand
1879 is negative, or greater than or equal to the length in bits
1880 of the promoted left operand. */
1881 if (tree_int_cst_sgn (rhs) == -1)
1882 {
1883 if (!ctx->quiet)
1884 permerror (loc, "right operand of shift expression %q+E is negative",
1885 build2_loc (loc, code, type, lhs, rhs));
1886 return (!flag_permissive || ctx->quiet);
1887 }
1888 if (compare_tree_int (rhs, uprec) >= 0)
1889 {
1890 if (!ctx->quiet)
1891 permerror (loc, "right operand of shift expression %q+E is >= than "
1892 "the precision of the left operand",
1893 build2_loc (loc, code, type, lhs, rhs));
1894 return (!flag_permissive || ctx->quiet);
1895 }
1896
1897 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1898 if E1 has a signed type and non-negative value, and E1x2^E2 is
1899 representable in the corresponding unsigned type of the result type,
1900 then that value, converted to the result type, is the resulting value;
1901 otherwise, the behavior is undefined. */
1902 if (code == LSHIFT_EXPR && !TYPE_UNSIGNED (lhstype)
1903 && (cxx_dialect >= cxx11))
1904 {
1905 if (tree_int_cst_sgn (lhs) == -1)
1906 {
1907 if (!ctx->quiet)
1908 permerror (loc,
1909 "left operand of shift expression %q+E is negative",
1910 build2_loc (loc, code, type, lhs, rhs));
1911 return (!flag_permissive || ctx->quiet);
1912 }
1913 /* For signed x << y the following:
1914 (unsigned) x >> ((prec (lhs) - 1) - y)
1915 if > 1, is undefined. The right-hand side of this formula
1916 is the highest bit of the LHS that can be set (starting from 0),
1917 so that the shift doesn't overflow. We then right-shift the LHS
1918 to see whether any other bit is set making the original shift
1919 undefined -- the result is not representable in the corresponding
1920 unsigned type. */
1921 tree t = build_int_cst (unsigned_type_node, uprec - 1);
1922 t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs);
1923 tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs);
1924 t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t);
1925 if (tree_int_cst_lt (integer_one_node, t))
1926 {
1927 if (!ctx->quiet)
1928 permerror (loc, "shift expression %q+E overflows",
1929 build2_loc (loc, code, type, lhs, rhs));
1930 return (!flag_permissive || ctx->quiet);
1931 }
1932 }
1933 return false;
1934 }
1935
1936 /* Subroutine of cxx_eval_constant_expression.
1937 Attempt to reduce the unary expression tree T to a compile time value.
1938 If successful, return the value. Otherwise issue a diagnostic
1939 and return error_mark_node. */
1940
1941 static tree
cxx_eval_unary_expression(const constexpr_ctx * ctx,tree t,bool,bool * non_constant_p,bool * overflow_p)1942 cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
1943 bool /*lval*/,
1944 bool *non_constant_p, bool *overflow_p)
1945 {
1946 tree r;
1947 tree orig_arg = TREE_OPERAND (t, 0);
1948 tree arg = cxx_eval_constant_expression (ctx, orig_arg, /*lval*/false,
1949 non_constant_p, overflow_p);
1950 VERIFY_CONSTANT (arg);
1951 location_t loc = EXPR_LOCATION (t);
1952 enum tree_code code = TREE_CODE (t);
1953 tree type = TREE_TYPE (t);
1954 r = fold_unary_loc (loc, code, type, arg);
1955 if (r == NULL_TREE)
1956 {
1957 if (arg == orig_arg)
1958 r = t;
1959 else
1960 r = build1_loc (loc, code, type, arg);
1961 }
1962 VERIFY_CONSTANT (r);
1963 return r;
1964 }
1965
1966 /* Helper function for cxx_eval_binary_expression. Try to optimize
1967 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1968 generic folding should be used. */
1969
1970 static tree
cxx_fold_pointer_plus_expression(const constexpr_ctx * ctx,tree t,tree lhs,tree rhs,bool * non_constant_p,bool * overflow_p)1971 cxx_fold_pointer_plus_expression (const constexpr_ctx *ctx, tree t,
1972 tree lhs, tree rhs, bool *non_constant_p,
1973 bool *overflow_p)
1974 {
1975 STRIP_NOPS (lhs);
1976 if (TREE_CODE (lhs) != ADDR_EXPR)
1977 return NULL_TREE;
1978
1979 lhs = TREE_OPERAND (lhs, 0);
1980
1981 /* &A[i] p+ j => &A[i + j] */
1982 if (TREE_CODE (lhs) == ARRAY_REF
1983 && TREE_CODE (TREE_OPERAND (lhs, 1)) == INTEGER_CST
1984 && TREE_CODE (rhs) == INTEGER_CST
1985 && TYPE_SIZE_UNIT (TREE_TYPE (lhs))
1986 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST)
1987 {
1988 tree orig_type = TREE_TYPE (t);
1989 location_t loc = EXPR_LOCATION (t);
1990 tree type = TREE_TYPE (lhs);
1991
1992 t = fold_convert_loc (loc, ssizetype, TREE_OPERAND (lhs, 1));
1993 tree nelts = array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs, 0)));
1994 nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
1995 overflow_p);
1996 if (*non_constant_p)
1997 return NULL_TREE;
1998 /* Don't fold an out-of-bound access. */
1999 if (!tree_int_cst_le (t, nelts))
2000 return NULL_TREE;
2001 rhs = cp_fold_convert (ssizetype, rhs);
2002 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
2003 constexpr int A[1]; ... (char *)&A[0] + 1 */
2004 if (!integer_zerop (fold_build2_loc (loc, TRUNC_MOD_EXPR, sizetype,
2005 rhs, TYPE_SIZE_UNIT (type))))
2006 return NULL_TREE;
2007 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
2008 as signed. */
2009 rhs = fold_build2_loc (loc, EXACT_DIV_EXPR, ssizetype, rhs,
2010 TYPE_SIZE_UNIT (type));
2011 t = size_binop_loc (loc, PLUS_EXPR, rhs, t);
2012 t = build4_loc (loc, ARRAY_REF, type, TREE_OPERAND (lhs, 0),
2013 t, NULL_TREE, NULL_TREE);
2014 t = cp_build_addr_expr (t, tf_warning_or_error);
2015 t = cp_fold_convert (orig_type, t);
2016 return cxx_eval_constant_expression (ctx, t, /*lval*/false,
2017 non_constant_p, overflow_p);
2018 }
2019
2020 return NULL_TREE;
2021 }
2022
2023 /* Subroutine of cxx_eval_constant_expression.
2024 Like cxx_eval_unary_expression, except for binary expressions. */
2025
2026 static tree
cxx_eval_binary_expression(const constexpr_ctx * ctx,tree t,bool,bool * non_constant_p,bool * overflow_p)2027 cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
2028 bool /*lval*/,
2029 bool *non_constant_p, bool *overflow_p)
2030 {
2031 tree r = NULL_TREE;
2032 tree orig_lhs = TREE_OPERAND (t, 0);
2033 tree orig_rhs = TREE_OPERAND (t, 1);
2034 tree lhs, rhs;
2035 lhs = cxx_eval_constant_expression (ctx, orig_lhs, /*lval*/false,
2036 non_constant_p, overflow_p);
2037 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2038 subtraction. */
2039 if (*non_constant_p)
2040 return t;
2041 rhs = cxx_eval_constant_expression (ctx, orig_rhs, /*lval*/false,
2042 non_constant_p, overflow_p);
2043 if (*non_constant_p)
2044 return t;
2045
2046 location_t loc = EXPR_LOCATION (t);
2047 enum tree_code code = TREE_CODE (t);
2048 tree type = TREE_TYPE (t);
2049
2050 if (code == EQ_EXPR || code == NE_EXPR)
2051 {
2052 bool is_code_eq = (code == EQ_EXPR);
2053
2054 if (TREE_CODE (lhs) == PTRMEM_CST
2055 && TREE_CODE (rhs) == PTRMEM_CST)
2056 r = constant_boolean_node (cp_tree_equal (lhs, rhs) == is_code_eq,
2057 type);
2058 else if ((TREE_CODE (lhs) == PTRMEM_CST
2059 || TREE_CODE (rhs) == PTRMEM_CST)
2060 && (null_member_pointer_value_p (lhs)
2061 || null_member_pointer_value_p (rhs)))
2062 r = constant_boolean_node (!is_code_eq, type);
2063 else if (TREE_CODE (lhs) == PTRMEM_CST)
2064 lhs = cplus_expand_constant (lhs);
2065 else if (TREE_CODE (rhs) == PTRMEM_CST)
2066 rhs = cplus_expand_constant (rhs);
2067 }
2068 if (code == POINTER_PLUS_EXPR && !*non_constant_p
2069 && integer_zerop (lhs) && !integer_zerop (rhs))
2070 {
2071 if (!ctx->quiet)
2072 error ("arithmetic involving a null pointer in %qE", lhs);
2073 *non_constant_p = true;
2074 return t;
2075 }
2076 else if (code == POINTER_PLUS_EXPR)
2077 r = cxx_fold_pointer_plus_expression (ctx, t, lhs, rhs, non_constant_p,
2078 overflow_p);
2079
2080 if (r == NULL_TREE)
2081 r = fold_binary_loc (loc, code, type, lhs, rhs);
2082
2083 if (r == NULL_TREE)
2084 {
2085 if (lhs == orig_lhs && rhs == orig_rhs)
2086 r = t;
2087 else
2088 r = build2_loc (loc, code, type, lhs, rhs);
2089 }
2090 else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs))
2091 *non_constant_p = true;
2092 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2093 a local array in a constexpr function. */
2094 bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs));
2095 if (!ptr)
2096 VERIFY_CONSTANT (r);
2097 return r;
2098 }
2099
2100 /* Subroutine of cxx_eval_constant_expression.
2101 Attempt to evaluate condition expressions. Dead branches are not
2102 looked into. */
2103
2104 static tree
cxx_eval_conditional_expression(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p,tree * jump_target)2105 cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
2106 bool lval,
2107 bool *non_constant_p, bool *overflow_p,
2108 tree *jump_target)
2109 {
2110 tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
2111 /*lval*/false,
2112 non_constant_p, overflow_p);
2113 VERIFY_CONSTANT (val);
2114 /* Don't VERIFY_CONSTANT the other operands. */
2115 if (integer_zerop (val))
2116 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
2117 lval,
2118 non_constant_p, overflow_p,
2119 jump_target);
2120 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
2121 lval,
2122 non_constant_p, overflow_p,
2123 jump_target);
2124 }
2125
2126 /* Subroutine of cxx_eval_constant_expression.
2127 Attempt to evaluate vector condition expressions. Unlike
2128 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2129 ternary arithmetics operation, where all 3 arguments have to be
2130 evaluated as constants and then folding computes the result from
2131 them. */
2132
2133 static tree
cxx_eval_vector_conditional_expression(const constexpr_ctx * ctx,tree t,bool * non_constant_p,bool * overflow_p)2134 cxx_eval_vector_conditional_expression (const constexpr_ctx *ctx, tree t,
2135 bool *non_constant_p, bool *overflow_p)
2136 {
2137 tree arg1 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
2138 /*lval*/false,
2139 non_constant_p, overflow_p);
2140 VERIFY_CONSTANT (arg1);
2141 tree arg2 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
2142 /*lval*/false,
2143 non_constant_p, overflow_p);
2144 VERIFY_CONSTANT (arg2);
2145 tree arg3 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
2146 /*lval*/false,
2147 non_constant_p, overflow_p);
2148 VERIFY_CONSTANT (arg3);
2149 location_t loc = EXPR_LOCATION (t);
2150 tree type = TREE_TYPE (t);
2151 tree r = fold_ternary_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3);
2152 if (r == NULL_TREE)
2153 {
2154 if (arg1 == TREE_OPERAND (t, 0)
2155 && arg2 == TREE_OPERAND (t, 1)
2156 && arg3 == TREE_OPERAND (t, 2))
2157 r = t;
2158 else
2159 r = build3_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3);
2160 }
2161 VERIFY_CONSTANT (r);
2162 return r;
2163 }
2164
2165 /* Returns less than, equal to, or greater than zero if KEY is found to be
2166 less than, to match, or to be greater than the constructor_elt's INDEX. */
2167
2168 static int
array_index_cmp(tree key,tree index)2169 array_index_cmp (tree key, tree index)
2170 {
2171 gcc_assert (TREE_CODE (key) == INTEGER_CST);
2172
2173 switch (TREE_CODE (index))
2174 {
2175 case INTEGER_CST:
2176 return tree_int_cst_compare (key, index);
2177 case RANGE_EXPR:
2178 {
2179 tree lo = TREE_OPERAND (index, 0);
2180 tree hi = TREE_OPERAND (index, 1);
2181 if (tree_int_cst_lt (key, lo))
2182 return -1;
2183 else if (tree_int_cst_lt (hi, key))
2184 return 1;
2185 else
2186 return 0;
2187 }
2188 default:
2189 gcc_unreachable ();
2190 }
2191 }
2192
2193 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2194 if none. If INSERT is true, insert a matching element rather than fail. */
2195
2196 static HOST_WIDE_INT
2197 find_array_ctor_elt (tree ary, tree dindex, bool insert = false)
2198 {
2199 if (tree_int_cst_sgn (dindex) < 0)
2200 return -1;
2201
2202 unsigned HOST_WIDE_INT i = tree_to_uhwi (dindex);
2203 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ary);
2204 unsigned HOST_WIDE_INT len = vec_safe_length (elts);
2205
2206 unsigned HOST_WIDE_INT end = len;
2207 unsigned HOST_WIDE_INT begin = 0;
2208
2209 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2210 that the same is true of the other elements and index directly. */
2211 if (end > 0)
2212 {
2213 tree cindex = (*elts)[end - 1].index;
2214 if (TREE_CODE (cindex) == INTEGER_CST
2215 && compare_tree_int (cindex, end - 1) == 0)
2216 {
2217 if (i < end)
2218 return i;
2219 else
2220 begin = end;
2221 }
2222 }
2223
2224 /* Otherwise, find a matching index by means of a binary search. */
2225 while (begin != end)
2226 {
2227 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
2228 constructor_elt &elt = (*elts)[middle];
2229 tree idx = elt.index;
2230
2231 int cmp = array_index_cmp (dindex, idx);
2232 if (cmp < 0)
2233 end = middle;
2234 else if (cmp > 0)
2235 begin = middle + 1;
2236 else
2237 {
2238 if (insert && TREE_CODE (idx) == RANGE_EXPR)
2239 {
2240 /* We need to split the range. */
2241 constructor_elt e;
2242 tree lo = TREE_OPERAND (idx, 0);
2243 tree hi = TREE_OPERAND (idx, 1);
2244 tree value = elt.value;
2245 dindex = fold_convert (sizetype, dindex);
2246 if (tree_int_cst_lt (lo, dindex))
2247 {
2248 /* There are still some lower elts; shorten the range. */
2249 tree new_hi = int_const_binop (MINUS_EXPR, dindex,
2250 size_one_node);
2251 if (tree_int_cst_equal (lo, new_hi))
2252 /* Only one element left, no longer a range. */
2253 elt.index = lo;
2254 else
2255 TREE_OPERAND (idx, 1) = new_hi;
2256 /* Append the element we want to insert. */
2257 ++middle;
2258 e.index = dindex;
2259 e.value = unshare_constructor (value);
2260 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle, e);
2261 }
2262 else
2263 /* No lower elts, the range elt is now ours. */
2264 elt.index = dindex;
2265
2266 if (tree_int_cst_lt (dindex, hi))
2267 {
2268 /* There are still some higher elts; append a range. */
2269 tree new_lo = int_const_binop (PLUS_EXPR, dindex,
2270 size_one_node);
2271 if (tree_int_cst_equal (new_lo, hi))
2272 e.index = hi;
2273 else
2274 e.index = build2 (RANGE_EXPR, sizetype, new_lo, hi);
2275 e.value = unshare_constructor (value);
2276 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle + 1, e);
2277 }
2278 }
2279 return middle;
2280 }
2281 }
2282
2283 if (insert)
2284 {
2285 constructor_elt e = { dindex, NULL_TREE };
2286 vec_safe_insert (CONSTRUCTOR_ELTS (ary), end, e);
2287 return end;
2288 }
2289
2290 return -1;
2291 }
2292
2293 /* Under the control of CTX, issue a detailed diagnostic for
2294 an out-of-bounds subscript INDEX into the expression ARRAY. */
2295
2296 static void
diag_array_subscript(const constexpr_ctx * ctx,tree array,tree index)2297 diag_array_subscript (const constexpr_ctx *ctx, tree array, tree index)
2298 {
2299 if (!ctx->quiet)
2300 {
2301 tree arraytype = TREE_TYPE (array);
2302
2303 /* Convert the unsigned array subscript to a signed integer to avoid
2304 printing huge numbers for small negative values. */
2305 tree sidx = fold_convert (ssizetype, index);
2306 if (DECL_P (array))
2307 {
2308 if (TYPE_DOMAIN (arraytype))
2309 error ("array subscript value %qE is outside the bounds "
2310 "of array %qD of type %qT", sidx, array, arraytype);
2311 else
2312 error ("non-zero array subscript %qE is used with array %qD of "
2313 "type %qT with unknown bounds", sidx, array, arraytype);
2314 inform (DECL_SOURCE_LOCATION (array), "declared here");
2315 }
2316 else if (TYPE_DOMAIN (arraytype))
2317 error ("array subscript value %qE is outside the bounds "
2318 "of array type %qT", sidx, arraytype);
2319 else
2320 error ("non-zero array subscript %qE is used with array of type %qT "
2321 "with unknown bounds", sidx, arraytype);
2322 }
2323 }
2324
2325 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
2326 a VECTOR_TYPE). */
2327
2328 static tree
get_array_or_vector_nelts(const constexpr_ctx * ctx,tree type,bool * non_constant_p,bool * overflow_p)2329 get_array_or_vector_nelts (const constexpr_ctx *ctx, tree type,
2330 bool *non_constant_p, bool *overflow_p)
2331 {
2332 tree nelts;
2333 if (TREE_CODE (type) == ARRAY_TYPE)
2334 {
2335 if (TYPE_DOMAIN (type))
2336 nelts = array_type_nelts_top (type);
2337 else
2338 nelts = size_zero_node;
2339 }
2340 else if (VECTOR_TYPE_P (type))
2341 nelts = size_int (TYPE_VECTOR_SUBPARTS (type));
2342 else
2343 gcc_unreachable ();
2344
2345 /* For VLAs, the number of elements won't be an integer constant. */
2346 nelts = cxx_eval_constant_expression (ctx, nelts, false,
2347 non_constant_p, overflow_p);
2348 return nelts;
2349 }
2350
2351 /* Extract element INDEX consisting of CHARS_PER_ELT chars from
2352 STRING_CST STRING. */
2353
2354 static tree
extract_string_elt(tree string,unsigned chars_per_elt,unsigned index)2355 extract_string_elt (tree string, unsigned chars_per_elt, unsigned index)
2356 {
2357 tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (string)));
2358 tree r;
2359
2360 if (chars_per_elt == 1)
2361 r = build_int_cst (type, TREE_STRING_POINTER (string)[index]);
2362 else
2363 {
2364 const unsigned char *ptr
2365 = ((const unsigned char *)TREE_STRING_POINTER (string)
2366 + index * chars_per_elt);
2367 r = native_interpret_expr (type, ptr, chars_per_elt);
2368 }
2369 return r;
2370 }
2371
2372 /* Subroutine of cxx_eval_constant_expression.
2373 Attempt to reduce a reference to an array slot. */
2374
2375 static tree
cxx_eval_array_reference(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)2376 cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
2377 bool lval,
2378 bool *non_constant_p, bool *overflow_p)
2379 {
2380 tree oldary = TREE_OPERAND (t, 0);
2381 tree ary = cxx_eval_constant_expression (ctx, oldary,
2382 lval,
2383 non_constant_p, overflow_p);
2384 tree index, oldidx;
2385 HOST_WIDE_INT i = 0;
2386 tree elem_type = NULL_TREE;
2387 unsigned len = 0, elem_nchars = 1;
2388 if (*non_constant_p)
2389 return t;
2390 oldidx = TREE_OPERAND (t, 1);
2391 index = cxx_eval_constant_expression (ctx, oldidx,
2392 false,
2393 non_constant_p, overflow_p);
2394 VERIFY_CONSTANT (index);
2395 if (!lval)
2396 {
2397 elem_type = TREE_TYPE (TREE_TYPE (ary));
2398 if (TREE_CODE (ary) == VIEW_CONVERT_EXPR
2399 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary, 0)))
2400 && TREE_TYPE (t) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary, 0))))
2401 ary = TREE_OPERAND (ary, 0);
2402 if (TREE_CODE (ary) == CONSTRUCTOR)
2403 len = CONSTRUCTOR_NELTS (ary);
2404 else if (TREE_CODE (ary) == STRING_CST)
2405 {
2406 elem_nchars = (TYPE_PRECISION (elem_type)
2407 / TYPE_PRECISION (char_type_node));
2408 len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
2409 }
2410 else if (TREE_CODE (ary) == VECTOR_CST)
2411 /* We don't create variable-length VECTOR_CSTs. */
2412 len = VECTOR_CST_NELTS (ary).to_constant ();
2413 else
2414 {
2415 /* We can't do anything with other tree codes, so use
2416 VERIFY_CONSTANT to complain and fail. */
2417 VERIFY_CONSTANT (ary);
2418 gcc_unreachable ();
2419 }
2420
2421 if (!tree_fits_shwi_p (index)
2422 || (i = tree_to_shwi (index)) < 0)
2423 {
2424 diag_array_subscript (ctx, ary, index);
2425 *non_constant_p = true;
2426 return t;
2427 }
2428 }
2429
2430 tree nelts = get_array_or_vector_nelts (ctx, TREE_TYPE (ary), non_constant_p,
2431 overflow_p);
2432 VERIFY_CONSTANT (nelts);
2433 if ((lval
2434 ? !tree_int_cst_le (index, nelts)
2435 : !tree_int_cst_lt (index, nelts))
2436 || tree_int_cst_sgn (index) < 0)
2437 {
2438 diag_array_subscript (ctx, ary, index);
2439 *non_constant_p = true;
2440 return t;
2441 }
2442
2443 if (lval && ary == oldary && index == oldidx)
2444 return t;
2445 else if (lval)
2446 return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
2447
2448 bool found;
2449 if (TREE_CODE (ary) == CONSTRUCTOR)
2450 {
2451 HOST_WIDE_INT ix = find_array_ctor_elt (ary, index);
2452 found = (ix >= 0);
2453 if (found)
2454 i = ix;
2455 }
2456 else
2457 found = (i < len);
2458
2459 if (found)
2460 {
2461 tree r;
2462 if (TREE_CODE (ary) == CONSTRUCTOR)
2463 r = (*CONSTRUCTOR_ELTS (ary))[i].value;
2464 else if (TREE_CODE (ary) == VECTOR_CST)
2465 r = VECTOR_CST_ELT (ary, i);
2466 else
2467 r = extract_string_elt (ary, elem_nchars, i);
2468
2469 if (r)
2470 /* Don't VERIFY_CONSTANT here. */
2471 return r;
2472
2473 /* Otherwise the element doesn't have a value yet. */
2474 }
2475
2476 /* Not found. */
2477
2478 if (TREE_CODE (ary) == CONSTRUCTOR
2479 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary))
2480 {
2481 /* 'ary' is part of the aggregate initializer we're currently
2482 building; if there's no initializer for this element yet,
2483 that's an error. */
2484 if (!ctx->quiet)
2485 error ("accessing uninitialized array element");
2486 *non_constant_p = true;
2487 return t;
2488 }
2489
2490 /* If it's within the array bounds but doesn't have an explicit
2491 initializer, it's initialized from {}. But use build_value_init
2492 directly for non-aggregates to avoid creating a garbage CONSTRUCTOR. */
2493 tree val;
2494 if (CP_AGGREGATE_TYPE_P (elem_type))
2495 {
2496 tree empty_ctor = build_constructor (init_list_type_node, NULL);
2497 val = digest_init (elem_type, empty_ctor, tf_warning_or_error);
2498 }
2499 else
2500 val = build_value_init (elem_type, tf_warning_or_error);
2501 return cxx_eval_constant_expression (ctx, val, lval, non_constant_p,
2502 overflow_p);
2503 }
2504
2505 /* Subroutine of cxx_eval_constant_expression.
2506 Attempt to reduce a field access of a value of class type. */
2507
2508 static tree
cxx_eval_component_reference(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)2509 cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
2510 bool lval,
2511 bool *non_constant_p, bool *overflow_p)
2512 {
2513 unsigned HOST_WIDE_INT i;
2514 tree field;
2515 tree value;
2516 tree part = TREE_OPERAND (t, 1);
2517 tree orig_whole = TREE_OPERAND (t, 0);
2518 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2519 lval,
2520 non_constant_p, overflow_p);
2521 if (INDIRECT_REF_P (whole)
2522 && integer_zerop (TREE_OPERAND (whole, 0)))
2523 {
2524 if (!ctx->quiet)
2525 error ("dereferencing a null pointer in %qE", orig_whole);
2526 *non_constant_p = true;
2527 return t;
2528 }
2529
2530 if (TREE_CODE (whole) == PTRMEM_CST)
2531 whole = cplus_expand_constant (whole);
2532 if (whole == orig_whole)
2533 return t;
2534 if (lval)
2535 return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
2536 whole, part, NULL_TREE);
2537 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2538 CONSTRUCTOR. */
2539 if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
2540 {
2541 if (!ctx->quiet)
2542 error ("%qE is not a constant expression", orig_whole);
2543 *non_constant_p = true;
2544 }
2545 if (DECL_MUTABLE_P (part))
2546 {
2547 if (!ctx->quiet)
2548 error ("mutable %qD is not usable in a constant expression", part);
2549 *non_constant_p = true;
2550 }
2551 if (*non_constant_p)
2552 return t;
2553 bool pmf = TYPE_PTRMEMFUNC_P (TREE_TYPE (whole));
2554 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2555 {
2556 /* Use name match for PMF fields, as a variant will have a
2557 different FIELD_DECL with a different type. */
2558 if (pmf ? DECL_NAME (field) == DECL_NAME (part)
2559 : field == part)
2560 {
2561 if (value)
2562 return value;
2563 else
2564 /* We're in the middle of initializing it. */
2565 break;
2566 }
2567 }
2568 if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
2569 && CONSTRUCTOR_NELTS (whole) > 0)
2570 {
2571 /* DR 1188 says we don't have to deal with this. */
2572 if (!ctx->quiet)
2573 error ("accessing %qD member instead of initialized %qD member in "
2574 "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
2575 *non_constant_p = true;
2576 return t;
2577 }
2578
2579 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2580 classes never get represented; throw together a value now. */
2581 if (is_really_empty_class (TREE_TYPE (t)))
2582 return build_constructor (TREE_TYPE (t), NULL);
2583
2584 gcc_assert (DECL_CONTEXT (part) == TYPE_MAIN_VARIANT (TREE_TYPE (whole)));
2585
2586 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole))
2587 {
2588 /* 'whole' is part of the aggregate initializer we're currently
2589 building; if there's no initializer for this member yet, that's an
2590 error. */
2591 if (!ctx->quiet)
2592 error ("accessing uninitialized member %qD", part);
2593 *non_constant_p = true;
2594 return t;
2595 }
2596
2597 /* If there's no explicit init for this field, it's value-initialized. */
2598 value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
2599 return cxx_eval_constant_expression (ctx, value,
2600 lval,
2601 non_constant_p, overflow_p);
2602 }
2603
2604 /* Subroutine of cxx_eval_constant_expression.
2605 Attempt to reduce a field access of a value of class type that is
2606 expressed as a BIT_FIELD_REF. */
2607
2608 static tree
cxx_eval_bit_field_ref(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)2609 cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
2610 bool lval,
2611 bool *non_constant_p, bool *overflow_p)
2612 {
2613 tree orig_whole = TREE_OPERAND (t, 0);
2614 tree retval, fldval, utype, mask;
2615 bool fld_seen = false;
2616 HOST_WIDE_INT istart, isize;
2617 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2618 lval,
2619 non_constant_p, overflow_p);
2620 tree start, field, value;
2621 unsigned HOST_WIDE_INT i;
2622
2623 if (whole == orig_whole)
2624 return t;
2625 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2626 CONSTRUCTOR. */
2627 if (!*non_constant_p
2628 && TREE_CODE (whole) != VECTOR_CST
2629 && TREE_CODE (whole) != CONSTRUCTOR)
2630 {
2631 if (!ctx->quiet)
2632 error ("%qE is not a constant expression", orig_whole);
2633 *non_constant_p = true;
2634 }
2635 if (*non_constant_p)
2636 return t;
2637
2638 if (TREE_CODE (whole) == VECTOR_CST)
2639 return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
2640 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
2641
2642 start = TREE_OPERAND (t, 2);
2643 istart = tree_to_shwi (start);
2644 isize = tree_to_shwi (TREE_OPERAND (t, 1));
2645 utype = TREE_TYPE (t);
2646 if (!TYPE_UNSIGNED (utype))
2647 utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
2648 retval = build_int_cst (utype, 0);
2649 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2650 {
2651 tree bitpos = bit_position (field);
2652 if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
2653 return value;
2654 if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
2655 && TREE_CODE (value) == INTEGER_CST
2656 && tree_fits_shwi_p (bitpos)
2657 && tree_fits_shwi_p (DECL_SIZE (field)))
2658 {
2659 HOST_WIDE_INT bit = tree_to_shwi (bitpos);
2660 HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field));
2661 HOST_WIDE_INT shift;
2662 if (bit >= istart && bit + sz <= istart + isize)
2663 {
2664 fldval = fold_convert (utype, value);
2665 mask = build_int_cst_type (utype, -1);
2666 mask = fold_build2 (LSHIFT_EXPR, utype, mask,
2667 size_int (TYPE_PRECISION (utype) - sz));
2668 mask = fold_build2 (RSHIFT_EXPR, utype, mask,
2669 size_int (TYPE_PRECISION (utype) - sz));
2670 fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
2671 shift = bit - istart;
2672 if (BYTES_BIG_ENDIAN)
2673 shift = TYPE_PRECISION (utype) - shift - sz;
2674 fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
2675 size_int (shift));
2676 retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
2677 fld_seen = true;
2678 }
2679 }
2680 }
2681 if (fld_seen)
2682 return fold_convert (TREE_TYPE (t), retval);
2683 gcc_unreachable ();
2684 return error_mark_node;
2685 }
2686
2687 /* Subroutine of cxx_eval_constant_expression.
2688 Evaluate a short-circuited logical expression T in the context
2689 of a given constexpr CALL. BAILOUT_VALUE is the value for
2690 early return. CONTINUE_VALUE is used here purely for
2691 sanity check purposes. */
2692
2693 static tree
cxx_eval_logical_expression(const constexpr_ctx * ctx,tree t,tree bailout_value,tree continue_value,bool lval,bool * non_constant_p,bool * overflow_p)2694 cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
2695 tree bailout_value, tree continue_value,
2696 bool lval,
2697 bool *non_constant_p, bool *overflow_p)
2698 {
2699 tree r;
2700 tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
2701 lval,
2702 non_constant_p, overflow_p);
2703 VERIFY_CONSTANT (lhs);
2704 if (tree_int_cst_equal (lhs, bailout_value))
2705 return lhs;
2706 gcc_assert (tree_int_cst_equal (lhs, continue_value));
2707 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
2708 lval, non_constant_p,
2709 overflow_p);
2710 VERIFY_CONSTANT (r);
2711 return r;
2712 }
2713
2714 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
2715 CONSTRUCTOR elements to initialize (part of) an object containing that
2716 field. Return a pointer to the constructor_elt corresponding to the
2717 initialization of the field. */
2718
2719 static constructor_elt *
base_field_constructor_elt(vec<constructor_elt,va_gc> * v,tree ref)2720 base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
2721 {
2722 tree aggr = TREE_OPERAND (ref, 0);
2723 tree field = TREE_OPERAND (ref, 1);
2724 HOST_WIDE_INT i;
2725 constructor_elt *ce;
2726
2727 gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
2728
2729 if (TREE_CODE (aggr) == COMPONENT_REF)
2730 {
2731 constructor_elt *base_ce
2732 = base_field_constructor_elt (v, aggr);
2733 v = CONSTRUCTOR_ELTS (base_ce->value);
2734 }
2735
2736 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
2737 if (ce->index == field)
2738 return ce;
2739
2740 gcc_unreachable ();
2741 return NULL;
2742 }
2743
2744 /* Some of the expressions fed to the constexpr mechanism are calls to
2745 constructors, which have type void. In that case, return the type being
2746 initialized by the constructor. */
2747
2748 static tree
initialized_type(tree t)2749 initialized_type (tree t)
2750 {
2751 if (TYPE_P (t))
2752 return t;
2753 tree type = cv_unqualified (TREE_TYPE (t));
2754 if (TREE_CODE (t) == CALL_EXPR || TREE_CODE (t) == AGGR_INIT_EXPR)
2755 {
2756 /* A constructor call has void type, so we need to look deeper. */
2757 tree fn = get_function_named_in_call (t);
2758 if (fn && TREE_CODE (fn) == FUNCTION_DECL
2759 && DECL_CXX_CONSTRUCTOR_P (fn))
2760 type = DECL_CONTEXT (fn);
2761 }
2762 return type;
2763 }
2764
2765 /* We're about to initialize element INDEX of an array or class from VALUE.
2766 Set up NEW_CTX appropriately by adjusting .object to refer to the
2767 subobject and creating a new CONSTRUCTOR if the element is itself
2768 a class or array. */
2769
2770 static void
init_subob_ctx(const constexpr_ctx * ctx,constexpr_ctx & new_ctx,tree index,tree & value)2771 init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
2772 tree index, tree &value)
2773 {
2774 new_ctx = *ctx;
2775
2776 if (index && TREE_CODE (index) != INTEGER_CST
2777 && TREE_CODE (index) != FIELD_DECL)
2778 /* This won't have an element in the new CONSTRUCTOR. */
2779 return;
2780
2781 tree type = initialized_type (value);
2782 if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type))
2783 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2784 return;
2785
2786 /* The sub-aggregate initializer might contain a placeholder;
2787 update object to refer to the subobject and ctor to refer to
2788 the (newly created) sub-initializer. */
2789 if (ctx->object)
2790 new_ctx.object = build_ctor_subob_ref (index, type, ctx->object);
2791 tree elt = build_constructor (type, NULL);
2792 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt) = true;
2793 new_ctx.ctor = elt;
2794
2795 if (TREE_CODE (value) == TARGET_EXPR)
2796 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2797 value = TARGET_EXPR_INITIAL (value);
2798 }
2799
2800 /* We're about to process an initializer for a class or array TYPE. Make
2801 sure that CTX is set up appropriately. */
2802
2803 static void
verify_ctor_sanity(const constexpr_ctx * ctx,tree type)2804 verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
2805 {
2806 /* We don't bother building a ctor for an empty base subobject. */
2807 if (is_empty_class (type))
2808 return;
2809
2810 /* We're in the middle of an initializer that might involve placeholders;
2811 our caller should have created a CONSTRUCTOR for us to put the
2812 initializer into. We will either return that constructor or T. */
2813 gcc_assert (ctx->ctor);
2814 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2815 (type, TREE_TYPE (ctx->ctor)));
2816 /* We used to check that ctx->ctor was empty, but that isn't the case when
2817 the object is zero-initialized before calling the constructor. */
2818 if (ctx->object)
2819 {
2820 tree otype = TREE_TYPE (ctx->object);
2821 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, otype)
2822 /* Handle flexible array members. */
2823 || (TREE_CODE (otype) == ARRAY_TYPE
2824 && TYPE_DOMAIN (otype) == NULL_TREE
2825 && TREE_CODE (type) == ARRAY_TYPE
2826 && (same_type_ignoring_top_level_qualifiers_p
2827 (TREE_TYPE (type), TREE_TYPE (otype)))));
2828 }
2829 gcc_assert (!ctx->object || !DECL_P (ctx->object)
2830 || *(ctx->values->get (ctx->object)) == ctx->ctor);
2831 }
2832
2833 /* Subroutine of cxx_eval_constant_expression.
2834 The expression tree T denotes a C-style array or a C-style
2835 aggregate. Reduce it to a constant expression. */
2836
2837 static tree
cxx_eval_bare_aggregate(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)2838 cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
2839 bool lval,
2840 bool *non_constant_p, bool *overflow_p)
2841 {
2842 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
2843 bool changed = false;
2844 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
2845 tree type = TREE_TYPE (t);
2846
2847 constexpr_ctx new_ctx;
2848 if (TYPE_PTRMEMFUNC_P (type) || VECTOR_TYPE_P (type))
2849 {
2850 /* We don't really need the ctx->ctor business for a PMF or
2851 vector, but it's simpler to use the same code. */
2852 new_ctx = *ctx;
2853 new_ctx.ctor = build_constructor (type, NULL);
2854 new_ctx.object = NULL_TREE;
2855 ctx = &new_ctx;
2856 };
2857 verify_ctor_sanity (ctx, type);
2858 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2859 vec_alloc (*p, vec_safe_length (v));
2860
2861 unsigned i;
2862 tree index, value;
2863 bool constant_p = true;
2864 bool side_effects_p = false;
2865 FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value)
2866 {
2867 tree orig_value = value;
2868 init_subob_ctx (ctx, new_ctx, index, value);
2869 if (new_ctx.ctor != ctx->ctor)
2870 /* If we built a new CONSTRUCTOR, attach it now so that other
2871 initializers can refer to it. */
2872 CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor);
2873 tree elt = cxx_eval_constant_expression (&new_ctx, value,
2874 lval,
2875 non_constant_p, overflow_p);
2876 /* Don't VERIFY_CONSTANT here. */
2877 if (ctx->quiet && *non_constant_p)
2878 break;
2879 if (elt != orig_value)
2880 changed = true;
2881
2882 if (!TREE_CONSTANT (elt))
2883 constant_p = false;
2884 if (TREE_SIDE_EFFECTS (elt))
2885 side_effects_p = true;
2886 if (index && TREE_CODE (index) == COMPONENT_REF)
2887 {
2888 /* This is an initialization of a vfield inside a base
2889 subaggregate that we already initialized; push this
2890 initialization into the previous initialization. */
2891 constructor_elt *inner = base_field_constructor_elt (*p, index);
2892 inner->value = elt;
2893 changed = true;
2894 }
2895 else if (index
2896 && (TREE_CODE (index) == NOP_EXPR
2897 || TREE_CODE (index) == POINTER_PLUS_EXPR))
2898 {
2899 /* This is an initializer for an empty base; now that we've
2900 checked that it's constant, we can ignore it. */
2901 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index))));
2902 changed = true;
2903 }
2904 else
2905 {
2906 if (new_ctx.ctor != ctx->ctor)
2907 {
2908 /* We appended this element above; update the value. */
2909 gcc_assert ((*p)->last().index == index);
2910 (*p)->last().value = elt;
2911 }
2912 else
2913 CONSTRUCTOR_APPEND_ELT (*p, index, elt);
2914 /* Adding or replacing an element might change the ctor's flags. */
2915 TREE_CONSTANT (ctx->ctor) = constant_p;
2916 TREE_SIDE_EFFECTS (ctx->ctor) = side_effects_p;
2917 }
2918 }
2919 if (*non_constant_p || !changed)
2920 return t;
2921 t = ctx->ctor;
2922 /* We're done building this CONSTRUCTOR, so now we can interpret an
2923 element without an explicit initializer as value-initialized. */
2924 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
2925 TREE_CONSTANT (t) = constant_p;
2926 TREE_SIDE_EFFECTS (t) = side_effects_p;
2927 if (VECTOR_TYPE_P (type))
2928 t = fold (t);
2929 return t;
2930 }
2931
2932 /* Subroutine of cxx_eval_constant_expression.
2933 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2934 initialization of a non-static data member of array type. Reduce it to a
2935 CONSTRUCTOR.
2936
2937 Note that apart from value-initialization (when VALUE_INIT is true),
2938 this is only intended to support value-initialization and the
2939 initializations done by defaulted constructors for classes with
2940 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2941 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2942 for the copy/move constructor. */
2943
2944 static tree
cxx_eval_vec_init_1(const constexpr_ctx * ctx,tree atype,tree init,bool value_init,bool lval,bool * non_constant_p,bool * overflow_p)2945 cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
2946 bool value_init, bool lval,
2947 bool *non_constant_p, bool *overflow_p)
2948 {
2949 tree elttype = TREE_TYPE (atype);
2950 verify_ctor_sanity (ctx, atype);
2951 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2952 bool pre_init = false;
2953 unsigned HOST_WIDE_INT i;
2954
2955 /* For the default constructor, build up a call to the default
2956 constructor of the element type. We only need to handle class types
2957 here, as for a constructor to be constexpr, all members must be
2958 initialized, which for a defaulted default constructor means they must
2959 be of a class type with a constexpr default constructor. */
2960 if (TREE_CODE (elttype) == ARRAY_TYPE)
2961 /* We only do this at the lowest level. */;
2962 else if (value_init)
2963 {
2964 init = build_value_init (elttype, tf_warning_or_error);
2965 pre_init = true;
2966 }
2967 else if (!init)
2968 {
2969 vec<tree, va_gc> *argvec = make_tree_vector ();
2970 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
2971 &argvec, elttype, LOOKUP_NORMAL,
2972 tf_warning_or_error);
2973 release_tree_vector (argvec);
2974 init = build_aggr_init_expr (TREE_TYPE (init), init);
2975 pre_init = true;
2976 }
2977
2978 tree nelts = get_array_or_vector_nelts (ctx, atype, non_constant_p,
2979 overflow_p);
2980 unsigned HOST_WIDE_INT max = tree_to_uhwi (nelts);
2981 for (i = 0; i < max; ++i)
2982 {
2983 tree idx = build_int_cst (size_type_node, i);
2984 tree eltinit;
2985 bool reuse = false;
2986 constexpr_ctx new_ctx;
2987 init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype);
2988 if (new_ctx.ctor != ctx->ctor)
2989 CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor);
2990 if (TREE_CODE (elttype) == ARRAY_TYPE)
2991 {
2992 /* A multidimensional array; recurse. */
2993 if (value_init || init == NULL_TREE)
2994 {
2995 eltinit = NULL_TREE;
2996 reuse = i == 0;
2997 }
2998 else
2999 eltinit = cp_build_array_ref (input_location, init, idx,
3000 tf_warning_or_error);
3001 eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
3002 lval,
3003 non_constant_p, overflow_p);
3004 }
3005 else if (pre_init)
3006 {
3007 /* Initializing an element using value or default initialization
3008 we just pre-built above. */
3009 if (init == void_node)
3010 /* Trivial default-init, don't do anything to the CONSTRUCTOR. */
3011 return ctx->ctor;
3012 eltinit = cxx_eval_constant_expression (&new_ctx, init, lval,
3013 non_constant_p, overflow_p);
3014 reuse = i == 0;
3015 }
3016 else
3017 {
3018 /* Copying an element. */
3019 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3020 (atype, TREE_TYPE (init)));
3021 eltinit = cp_build_array_ref (input_location, init, idx,
3022 tf_warning_or_error);
3023 if (!lvalue_p (init))
3024 eltinit = move (eltinit);
3025 eltinit = force_rvalue (eltinit, tf_warning_or_error);
3026 eltinit = cxx_eval_constant_expression (&new_ctx, eltinit, lval,
3027 non_constant_p, overflow_p);
3028 }
3029 if (*non_constant_p && !ctx->quiet)
3030 break;
3031 if (new_ctx.ctor != ctx->ctor)
3032 {
3033 /* We appended this element above; update the value. */
3034 gcc_assert ((*p)->last().index == idx);
3035 (*p)->last().value = eltinit;
3036 }
3037 else
3038 CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit);
3039 /* Reuse the result of cxx_eval_constant_expression call
3040 from the first iteration to all others if it is a constant
3041 initializer that doesn't require relocations. */
3042 if (reuse
3043 && max > 1
3044 && (eltinit == NULL_TREE
3045 || (initializer_constant_valid_p (eltinit, TREE_TYPE (eltinit))
3046 == null_pointer_node)))
3047 {
3048 if (new_ctx.ctor != ctx->ctor)
3049 eltinit = new_ctx.ctor;
3050 tree range = build2 (RANGE_EXPR, size_type_node,
3051 build_int_cst (size_type_node, 1),
3052 build_int_cst (size_type_node, max - 1));
3053 CONSTRUCTOR_APPEND_ELT (*p, range, unshare_constructor (eltinit));
3054 break;
3055 }
3056 else if (i == 0)
3057 vec_safe_reserve (*p, max);
3058 }
3059
3060 if (!*non_constant_p)
3061 {
3062 init = ctx->ctor;
3063 CONSTRUCTOR_NO_IMPLICIT_ZERO (init) = false;
3064 }
3065 return init;
3066 }
3067
3068 static tree
cxx_eval_vec_init(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)3069 cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
3070 bool lval,
3071 bool *non_constant_p, bool *overflow_p)
3072 {
3073 tree atype = TREE_TYPE (t);
3074 tree init = VEC_INIT_EXPR_INIT (t);
3075 tree r = cxx_eval_vec_init_1 (ctx, atype, init,
3076 VEC_INIT_EXPR_VALUE_INIT (t),
3077 lval, non_constant_p, overflow_p);
3078 if (*non_constant_p)
3079 return t;
3080 else
3081 return r;
3082 }
3083
3084 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3085 match. We want to be less strict for simple *& folding; if we have a
3086 non-const temporary that we access through a const pointer, that should
3087 work. We handle this here rather than change fold_indirect_ref_1
3088 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3089 don't really make sense outside of constant expression evaluation. Also
3090 we want to allow folding to COMPONENT_REF, which could cause trouble
3091 with TBAA in fold_indirect_ref_1.
3092
3093 Try to keep this function synced with fold_indirect_ref_1. */
3094
3095 static tree
cxx_fold_indirect_ref(location_t loc,tree type,tree op0,bool * empty_base)3096 cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
3097 {
3098 tree sub = op0;
3099 tree subtype;
3100 poly_uint64 const_op01;
3101
3102 STRIP_NOPS (sub);
3103 subtype = TREE_TYPE (sub);
3104 if (!POINTER_TYPE_P (subtype))
3105 return NULL_TREE;
3106
3107 if (TREE_CODE (sub) == ADDR_EXPR)
3108 {
3109 tree op = TREE_OPERAND (sub, 0);
3110 tree optype = TREE_TYPE (op);
3111
3112 /* *&CONST_DECL -> to the value of the const decl. */
3113 if (TREE_CODE (op) == CONST_DECL)
3114 return DECL_INITIAL (op);
3115 /* *&p => p; make sure to handle *&"str"[cst] here. */
3116 if (same_type_ignoring_top_level_qualifiers_p (optype, type)
3117 /* Also handle the case where the desired type is an array of unknown
3118 bounds because the variable has had its bounds deduced since the
3119 ADDR_EXPR was created. */
3120 || (TREE_CODE (type) == ARRAY_TYPE
3121 && TREE_CODE (optype) == ARRAY_TYPE
3122 && TYPE_DOMAIN (type) == NULL_TREE
3123 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype),
3124 TREE_TYPE (type))))
3125 {
3126 tree fop = fold_read_from_constant_string (op);
3127 if (fop)
3128 return fop;
3129 else
3130 return op;
3131 }
3132 /* *(foo *)&fooarray => fooarray[0] */
3133 else if (TREE_CODE (optype) == ARRAY_TYPE
3134 && (same_type_ignoring_top_level_qualifiers_p
3135 (type, TREE_TYPE (optype))))
3136 {
3137 tree type_domain = TYPE_DOMAIN (optype);
3138 tree min_val = size_zero_node;
3139 if (type_domain && TYPE_MIN_VALUE (type_domain))
3140 min_val = TYPE_MIN_VALUE (type_domain);
3141 return build4_loc (loc, ARRAY_REF, type, op, min_val,
3142 NULL_TREE, NULL_TREE);
3143 }
3144 /* *(foo *)&complexfoo => __real__ complexfoo */
3145 else if (TREE_CODE (optype) == COMPLEX_TYPE
3146 && (same_type_ignoring_top_level_qualifiers_p
3147 (type, TREE_TYPE (optype))))
3148 return fold_build1_loc (loc, REALPART_EXPR, type, op);
3149 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3150 else if (VECTOR_TYPE_P (optype)
3151 && (same_type_ignoring_top_level_qualifiers_p
3152 (type, TREE_TYPE (optype))))
3153 {
3154 tree part_width = TYPE_SIZE (type);
3155 tree index = bitsize_int (0);
3156 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width,
3157 index);
3158 }
3159 /* Also handle conversion to an empty base class, which
3160 is represented with a NOP_EXPR. */
3161 else if (is_empty_class (type)
3162 && CLASS_TYPE_P (optype)
3163 && DERIVED_FROM_P (type, optype))
3164 {
3165 *empty_base = true;
3166 return op;
3167 }
3168 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3169 else if (RECORD_OR_UNION_TYPE_P (optype))
3170 {
3171 tree field = TYPE_FIELDS (optype);
3172 for (; field; field = DECL_CHAIN (field))
3173 if (TREE_CODE (field) == FIELD_DECL
3174 && TREE_TYPE (field) != error_mark_node
3175 && integer_zerop (byte_position (field))
3176 && (same_type_ignoring_top_level_qualifiers_p
3177 (TREE_TYPE (field), type)))
3178 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
3179 }
3180 }
3181 else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
3182 && poly_int_tree_p (TREE_OPERAND (sub, 1), &const_op01))
3183 {
3184 tree op00 = TREE_OPERAND (sub, 0);
3185 tree op01 = TREE_OPERAND (sub, 1);
3186
3187 STRIP_NOPS (op00);
3188 if (TREE_CODE (op00) == ADDR_EXPR)
3189 {
3190 tree op00type;
3191 op00 = TREE_OPERAND (op00, 0);
3192 op00type = TREE_TYPE (op00);
3193
3194 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3195 if (VECTOR_TYPE_P (op00type)
3196 && same_type_ignoring_top_level_qualifiers_p
3197 (type, TREE_TYPE (op00type))
3198 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
3199 but we want to treat offsets with MSB set as negative.
3200 For the code below negative offsets are invalid and
3201 TYPE_SIZE of the element is something unsigned, so
3202 check whether op01 fits into poly_int64, which implies
3203 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
3204 then just use poly_uint64 because we want to treat the
3205 value as unsigned. */
3206 && tree_fits_poly_int64_p (op01))
3207 {
3208 tree part_width = TYPE_SIZE (type);
3209 poly_uint64 max_offset
3210 = (tree_to_uhwi (part_width) / BITS_PER_UNIT
3211 * TYPE_VECTOR_SUBPARTS (op00type));
3212 if (known_lt (const_op01, max_offset))
3213 {
3214 tree index = bitsize_int (const_op01 * BITS_PER_UNIT);
3215 return fold_build3_loc (loc,
3216 BIT_FIELD_REF, type, op00,
3217 part_width, index);
3218 }
3219 }
3220 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3221 else if (TREE_CODE (op00type) == COMPLEX_TYPE
3222 && (same_type_ignoring_top_level_qualifiers_p
3223 (type, TREE_TYPE (op00type))))
3224 {
3225 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type)),
3226 const_op01))
3227 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
3228 }
3229 /* ((foo *)&fooarray)[1] => fooarray[1] */
3230 else if (TREE_CODE (op00type) == ARRAY_TYPE
3231 && (same_type_ignoring_top_level_qualifiers_p
3232 (type, TREE_TYPE (op00type))))
3233 {
3234 tree type_domain = TYPE_DOMAIN (op00type);
3235 tree min_val = size_zero_node;
3236 if (type_domain && TYPE_MIN_VALUE (type_domain))
3237 min_val = TYPE_MIN_VALUE (type_domain);
3238 offset_int off = wi::to_offset (op01);
3239 offset_int el_sz = wi::to_offset (TYPE_SIZE_UNIT (type));
3240 offset_int remainder;
3241 off = wi::divmod_trunc (off, el_sz, SIGNED, &remainder);
3242 if (remainder == 0 && TREE_CODE (min_val) == INTEGER_CST)
3243 {
3244 off = off + wi::to_offset (min_val);
3245 op01 = wide_int_to_tree (sizetype, off);
3246 return build4_loc (loc, ARRAY_REF, type, op00, op01,
3247 NULL_TREE, NULL_TREE);
3248 }
3249 }
3250 /* Also handle conversion to an empty base class, which
3251 is represented with a NOP_EXPR. */
3252 else if (is_empty_class (type)
3253 && CLASS_TYPE_P (op00type)
3254 && DERIVED_FROM_P (type, op00type))
3255 {
3256 *empty_base = true;
3257 return op00;
3258 }
3259 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3260 else if (RECORD_OR_UNION_TYPE_P (op00type))
3261 {
3262 tree field = TYPE_FIELDS (op00type);
3263 for (; field; field = DECL_CHAIN (field))
3264 if (TREE_CODE (field) == FIELD_DECL
3265 && TREE_TYPE (field) != error_mark_node
3266 && tree_int_cst_equal (byte_position (field), op01)
3267 && (same_type_ignoring_top_level_qualifiers_p
3268 (TREE_TYPE (field), type)))
3269 return fold_build3 (COMPONENT_REF, type, op00,
3270 field, NULL_TREE);
3271 }
3272 }
3273 }
3274 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3275 else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
3276 && (same_type_ignoring_top_level_qualifiers_p
3277 (type, TREE_TYPE (TREE_TYPE (subtype)))))
3278 {
3279 tree type_domain;
3280 tree min_val = size_zero_node;
3281 tree newsub
3282 = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
3283 if (newsub)
3284 sub = newsub;
3285 else
3286 sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
3287 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
3288 if (type_domain && TYPE_MIN_VALUE (type_domain))
3289 min_val = TYPE_MIN_VALUE (type_domain);
3290 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
3291 NULL_TREE);
3292 }
3293
3294 return NULL_TREE;
3295 }
3296
3297 static tree
cxx_eval_indirect_ref(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)3298 cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
3299 bool lval,
3300 bool *non_constant_p, bool *overflow_p)
3301 {
3302 tree orig_op0 = TREE_OPERAND (t, 0);
3303 bool empty_base = false;
3304
3305 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3306 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3307
3308 if (TREE_CODE (t) == MEM_REF
3309 && (!TREE_OPERAND (t, 1) || !integer_zerop (TREE_OPERAND (t, 1))))
3310 {
3311 gcc_assert (ctx->quiet);
3312 *non_constant_p = true;
3313 return t;
3314 }
3315
3316 /* First try to simplify it directly. */
3317 tree r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), orig_op0,
3318 &empty_base);
3319 if (!r)
3320 {
3321 /* If that didn't work, evaluate the operand first. */
3322 tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
3323 /*lval*/false, non_constant_p,
3324 overflow_p);
3325 /* Don't VERIFY_CONSTANT here. */
3326 if (*non_constant_p)
3327 return t;
3328
3329 if (!lval && integer_zerop (op0))
3330 {
3331 if (!ctx->quiet)
3332 error ("dereferencing a null pointer");
3333 *non_constant_p = true;
3334 return t;
3335 }
3336
3337 r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
3338 &empty_base);
3339 if (r == NULL_TREE)
3340 {
3341 /* We couldn't fold to a constant value. Make sure it's not
3342 something we should have been able to fold. */
3343 tree sub = op0;
3344 STRIP_NOPS (sub);
3345 if (TREE_CODE (sub) == ADDR_EXPR)
3346 {
3347 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3348 (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
3349 /* DR 1188 says we don't have to deal with this. */
3350 if (!ctx->quiet)
3351 error ("accessing value of %qE through a %qT glvalue in a "
3352 "constant expression", build_fold_indirect_ref (sub),
3353 TREE_TYPE (t));
3354 *non_constant_p = true;
3355 return t;
3356 }
3357
3358 if (lval && op0 != orig_op0)
3359 return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
3360 if (!lval)
3361 VERIFY_CONSTANT (t);
3362 return t;
3363 }
3364 }
3365
3366 r = cxx_eval_constant_expression (ctx, r,
3367 lval, non_constant_p, overflow_p);
3368 if (*non_constant_p)
3369 return t;
3370
3371 /* If we're pulling out the value of an empty base, just return an empty
3372 CONSTRUCTOR. */
3373 if (empty_base && !lval)
3374 {
3375 r = build_constructor (TREE_TYPE (t), NULL);
3376 TREE_CONSTANT (r) = true;
3377 }
3378
3379 return r;
3380 }
3381
3382 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
3383 Shared between potential_constant_expression and
3384 cxx_eval_constant_expression. */
3385
3386 static void
non_const_var_error(tree r)3387 non_const_var_error (tree r)
3388 {
3389 tree type = TREE_TYPE (r);
3390 error ("the value of %qD is not usable in a constant "
3391 "expression", r);
3392 /* Avoid error cascade. */
3393 if (DECL_INITIAL (r) == error_mark_node)
3394 return;
3395 if (DECL_DECLARED_CONSTEXPR_P (r))
3396 inform (DECL_SOURCE_LOCATION (r),
3397 "%qD used in its own initializer", r);
3398 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
3399 {
3400 if (!CP_TYPE_CONST_P (type))
3401 inform (DECL_SOURCE_LOCATION (r),
3402 "%q#D is not const", r);
3403 else if (CP_TYPE_VOLATILE_P (type))
3404 inform (DECL_SOURCE_LOCATION (r),
3405 "%q#D is volatile", r);
3406 else if (!DECL_INITIAL (r)
3407 || !TREE_CONSTANT (DECL_INITIAL (r))
3408 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r))
3409 inform (DECL_SOURCE_LOCATION (r),
3410 "%qD was not initialized with a constant "
3411 "expression", r);
3412 else
3413 gcc_unreachable ();
3414 }
3415 else if (TREE_CODE (type) == REFERENCE_TYPE)
3416 inform (DECL_SOURCE_LOCATION (r),
3417 "%qD was not initialized with a constant "
3418 "expression", r);
3419 else
3420 {
3421 if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
3422 inform (DECL_SOURCE_LOCATION (r),
3423 "%qD was not declared %<constexpr%>", r);
3424 else
3425 inform (DECL_SOURCE_LOCATION (r),
3426 "%qD does not have integral or enumeration type",
3427 r);
3428 }
3429 }
3430
3431 /* Subroutine of cxx_eval_constant_expression.
3432 Like cxx_eval_unary_expression, except for trinary expressions. */
3433
3434 static tree
cxx_eval_trinary_expression(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)3435 cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
3436 bool lval,
3437 bool *non_constant_p, bool *overflow_p)
3438 {
3439 int i;
3440 tree args[3];
3441 tree val;
3442
3443 for (i = 0; i < 3; i++)
3444 {
3445 args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
3446 lval,
3447 non_constant_p, overflow_p);
3448 VERIFY_CONSTANT (args[i]);
3449 }
3450
3451 val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
3452 args[0], args[1], args[2]);
3453 if (val == NULL_TREE)
3454 return t;
3455 VERIFY_CONSTANT (val);
3456 return val;
3457 }
3458
3459 /* True if T was declared in a function declared to be constexpr, and
3460 therefore potentially constant in C++14. */
3461
3462 bool
var_in_constexpr_fn(tree t)3463 var_in_constexpr_fn (tree t)
3464 {
3465 tree ctx = DECL_CONTEXT (t);
3466 return (ctx && TREE_CODE (ctx) == FUNCTION_DECL
3467 && DECL_DECLARED_CONSTEXPR_P (ctx));
3468 }
3469
3470 /* True if T was declared in a function that might be constexpr: either a
3471 function that was declared constexpr, or a C++17 lambda op(). */
3472
3473 bool
var_in_maybe_constexpr_fn(tree t)3474 var_in_maybe_constexpr_fn (tree t)
3475 {
3476 if (cxx_dialect >= cxx17
3477 && DECL_FUNCTION_SCOPE_P (t)
3478 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t)))
3479 return true;
3480 return var_in_constexpr_fn (t);
3481 }
3482
3483 /* We're assigning INIT to TARGET. In do_build_copy_constructor and
3484 build_over_call we implement trivial copy of a class with tail padding using
3485 assignment of character arrays, which is valid in normal code, but not in
3486 constexpr evaluation. We don't need to worry about clobbering tail padding
3487 in constexpr evaluation, so strip the type punning. */
3488
3489 static void
maybe_simplify_trivial_copy(tree & target,tree & init)3490 maybe_simplify_trivial_copy (tree &target, tree &init)
3491 {
3492 if (TREE_CODE (target) == MEM_REF
3493 && TREE_CODE (init) == MEM_REF
3494 && TREE_TYPE (target) == TREE_TYPE (init)
3495 && TREE_CODE (TREE_TYPE (target)) == ARRAY_TYPE
3496 && TREE_TYPE (TREE_TYPE (target)) == unsigned_char_type_node)
3497 {
3498 target = build_fold_indirect_ref (TREE_OPERAND (target, 0));
3499 init = build_fold_indirect_ref (TREE_OPERAND (init, 0));
3500 }
3501 }
3502
3503 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3504
3505 static tree
cxx_eval_store_expression(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)3506 cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
3507 bool lval,
3508 bool *non_constant_p, bool *overflow_p)
3509 {
3510 constexpr_ctx new_ctx = *ctx;
3511
3512 tree init = TREE_OPERAND (t, 1);
3513 if (TREE_CLOBBER_P (init))
3514 /* Just ignore clobbers. */
3515 return void_node;
3516
3517 /* First we figure out where we're storing to. */
3518 tree target = TREE_OPERAND (t, 0);
3519
3520 maybe_simplify_trivial_copy (target, init);
3521
3522 tree type = TREE_TYPE (target);
3523 target = cxx_eval_constant_expression (ctx, target,
3524 true,
3525 non_constant_p, overflow_p);
3526 if (*non_constant_p)
3527 return t;
3528
3529 /* cxx_eval_array_reference for lval = true allows references one past
3530 end of array, because it does not know if it is just taking address
3531 (which is valid), or actual dereference. Here we know it is
3532 a dereference, so diagnose it here. */
3533 for (tree probe = target; probe; )
3534 {
3535 switch (TREE_CODE (probe))
3536 {
3537 case ARRAY_REF:
3538 tree nelts, ary;
3539 ary = TREE_OPERAND (probe, 0);
3540 nelts = get_array_or_vector_nelts (ctx, TREE_TYPE (ary),
3541 non_constant_p, overflow_p);
3542 VERIFY_CONSTANT (nelts);
3543 gcc_assert (TREE_CODE (nelts) == INTEGER_CST
3544 && TREE_CODE (TREE_OPERAND (probe, 1)) == INTEGER_CST);
3545 if (wi::to_widest (TREE_OPERAND (probe, 1)) == wi::to_widest (nelts))
3546 {
3547 diag_array_subscript (ctx, ary, TREE_OPERAND (probe, 1));
3548 *non_constant_p = true;
3549 return t;
3550 }
3551 /* FALLTHRU */
3552
3553 case BIT_FIELD_REF:
3554 case COMPONENT_REF:
3555 probe = TREE_OPERAND (probe, 0);
3556 continue;
3557
3558 default:
3559 probe = NULL_TREE;
3560 continue;
3561 }
3562 }
3563
3564 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target), type))
3565 {
3566 /* For initialization of an empty base, the original target will be
3567 *(base*)this, which the above evaluation resolves to the object
3568 argument, which has the derived type rather than the base type. In
3569 this situation, just evaluate the initializer and return, since
3570 there's no actual data to store. */
3571 gcc_assert (is_empty_class (type));
3572 return cxx_eval_constant_expression (ctx, init, false,
3573 non_constant_p, overflow_p);
3574 }
3575
3576 /* And then find the underlying variable. */
3577 vec<tree,va_gc> *refs = make_tree_vector();
3578 tree object = NULL_TREE;
3579 for (tree probe = target; object == NULL_TREE; )
3580 {
3581 switch (TREE_CODE (probe))
3582 {
3583 case BIT_FIELD_REF:
3584 case COMPONENT_REF:
3585 case ARRAY_REF:
3586 vec_safe_push (refs, TREE_OPERAND (probe, 1));
3587 vec_safe_push (refs, TREE_TYPE (probe));
3588 probe = TREE_OPERAND (probe, 0);
3589 break;
3590
3591 default:
3592 object = probe;
3593 }
3594 }
3595
3596 /* And then find/build up our initializer for the path to the subobject
3597 we're initializing. */
3598 tree *valp;
3599 if (object == ctx->object && VAR_P (object)
3600 && DECL_NAME (object) && ctx->call == NULL)
3601 /* The variable we're building up an aggregate initializer for is outside
3602 the constant-expression, so don't evaluate the store. We check
3603 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3604 valp = NULL;
3605 else if (DECL_P (object))
3606 valp = ctx->values->get (object);
3607 else
3608 valp = NULL;
3609 if (!valp)
3610 {
3611 /* A constant-expression cannot modify objects from outside the
3612 constant-expression. */
3613 if (!ctx->quiet)
3614 error ("modification of %qE is not a constant expression", object);
3615 *non_constant_p = true;
3616 return t;
3617 }
3618 type = TREE_TYPE (object);
3619 bool no_zero_init = true;
3620
3621 vec<tree,va_gc> *ctors = make_tree_vector ();
3622 while (!refs->is_empty())
3623 {
3624 if (*valp == NULL_TREE)
3625 {
3626 *valp = build_constructor (type, NULL);
3627 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init;
3628 }
3629 else if (TREE_CODE (*valp) == STRING_CST)
3630 {
3631 /* An array was initialized with a string constant, and now
3632 we're writing into one of its elements. Explode the
3633 single initialization into a set of element
3634 initializations. */
3635 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
3636
3637 tree string = *valp;
3638 tree elt_type = TREE_TYPE (type);
3639 unsigned chars_per_elt = (TYPE_PRECISION (elt_type)
3640 / TYPE_PRECISION (char_type_node));
3641 unsigned num_elts = TREE_STRING_LENGTH (string) / chars_per_elt;
3642 tree ary_ctor = build_constructor (type, NULL);
3643
3644 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor), num_elts);
3645 for (unsigned ix = 0; ix != num_elts; ix++)
3646 {
3647 constructor_elt elt =
3648 {
3649 build_int_cst (size_type_node, ix),
3650 extract_string_elt (string, chars_per_elt, ix)
3651 };
3652 CONSTRUCTOR_ELTS (ary_ctor)->quick_push (elt);
3653 }
3654
3655 *valp = ary_ctor;
3656 }
3657
3658 /* If the value of object is already zero-initialized, any new ctors for
3659 subobjects will also be zero-initialized. */
3660 no_zero_init = CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp);
3661
3662 vec_safe_push (ctors, *valp);
3663
3664 enum tree_code code = TREE_CODE (type);
3665 type = refs->pop();
3666 tree index = refs->pop();
3667
3668 constructor_elt *cep = NULL;
3669 if (code == ARRAY_TYPE)
3670 {
3671 HOST_WIDE_INT i
3672 = find_array_ctor_elt (*valp, index, /*insert*/true);
3673 gcc_assert (i >= 0);
3674 cep = CONSTRUCTOR_ELT (*valp, i);
3675 gcc_assert (TREE_CODE (cep->index) != RANGE_EXPR);
3676 }
3677 else
3678 {
3679 gcc_assert (TREE_CODE (index) == FIELD_DECL);
3680
3681 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3682 Usually we meet initializers in that order, but it is
3683 possible for base types to be placed not in program
3684 order. */
3685 tree fields = TYPE_FIELDS (DECL_CONTEXT (index));
3686 unsigned HOST_WIDE_INT idx;
3687
3688 if (code == UNION_TYPE && CONSTRUCTOR_NELTS (*valp)
3689 && CONSTRUCTOR_ELT (*valp, 0)->index != index)
3690 /* Changing active member. */
3691 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp), 0);
3692
3693 for (idx = 0;
3694 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep);
3695 idx++, fields = DECL_CHAIN (fields))
3696 {
3697 if (index == cep->index)
3698 goto found;
3699
3700 /* The field we're initializing must be on the field
3701 list. Look to see if it is present before the
3702 field the current ELT initializes. */
3703 for (; fields != cep->index; fields = DECL_CHAIN (fields))
3704 if (index == fields)
3705 goto insert;
3706 }
3707
3708 /* We fell off the end of the CONSTRUCTOR, so insert a new
3709 entry at the end. */
3710 insert:
3711 {
3712 constructor_elt ce = { index, NULL_TREE };
3713
3714 vec_safe_insert (CONSTRUCTOR_ELTS (*valp), idx, ce);
3715 cep = CONSTRUCTOR_ELT (*valp, idx);
3716 }
3717 found:;
3718 }
3719 valp = &cep->value;
3720 }
3721 release_tree_vector (refs);
3722
3723 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
3724 {
3725 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3726 wants to modify it. */
3727 if (*valp == NULL_TREE)
3728 {
3729 *valp = build_constructor (type, NULL);
3730 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init;
3731 }
3732 else if (TREE_CODE (*valp) == PTRMEM_CST)
3733 *valp = cplus_expand_constant (*valp);
3734 new_ctx.ctor = *valp;
3735 new_ctx.object = target;
3736 }
3737
3738 init = cxx_eval_constant_expression (&new_ctx, init, false,
3739 non_constant_p, overflow_p);
3740 /* Don't share a CONSTRUCTOR that might be changed later. */
3741 init = unshare_constructor (init);
3742 if (target == object)
3743 /* The hash table might have moved since the get earlier. */
3744 valp = ctx->values->get (object);
3745
3746 if (TREE_CODE (init) == CONSTRUCTOR)
3747 {
3748 /* An outer ctx->ctor might be pointing to *valp, so replace
3749 its contents. */
3750 CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init);
3751 TREE_CONSTANT (*valp) = TREE_CONSTANT (init);
3752 TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init);
3753 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp)
3754 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init);
3755 }
3756 else
3757 *valp = init;
3758
3759 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3760 CONSTRUCTORs, if any. */
3761 tree elt;
3762 unsigned i;
3763 bool c = TREE_CONSTANT (init);
3764 bool s = TREE_SIDE_EFFECTS (init);
3765 if (!c || s)
3766 FOR_EACH_VEC_SAFE_ELT (ctors, i, elt)
3767 {
3768 if (!c)
3769 TREE_CONSTANT (elt) = false;
3770 if (s)
3771 TREE_SIDE_EFFECTS (elt) = true;
3772 }
3773 release_tree_vector (ctors);
3774
3775 if (*non_constant_p)
3776 return t;
3777 else if (lval)
3778 return target;
3779 else
3780 return init;
3781 }
3782
3783 /* Evaluate a ++ or -- expression. */
3784
3785 static tree
cxx_eval_increment_expression(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p)3786 cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
3787 bool lval,
3788 bool *non_constant_p, bool *overflow_p)
3789 {
3790 enum tree_code code = TREE_CODE (t);
3791 tree type = TREE_TYPE (t);
3792 tree op = TREE_OPERAND (t, 0);
3793 tree offset = TREE_OPERAND (t, 1);
3794 gcc_assert (TREE_CONSTANT (offset));
3795
3796 /* The operand as an lvalue. */
3797 op = cxx_eval_constant_expression (ctx, op, true,
3798 non_constant_p, overflow_p);
3799
3800 /* The operand as an rvalue. */
3801 tree val
3802 = cxx_eval_constant_expression (ctx, op, false,
3803 non_constant_p, overflow_p);
3804 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3805 a local array in a constexpr function. */
3806 bool ptr = POINTER_TYPE_P (TREE_TYPE (val));
3807 if (!ptr)
3808 VERIFY_CONSTANT (val);
3809
3810 /* The modified value. */
3811 bool inc = (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR);
3812 tree mod;
3813 if (POINTER_TYPE_P (type))
3814 {
3815 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
3816 offset = convert_to_ptrofftype (offset);
3817 if (!inc)
3818 offset = fold_build1 (NEGATE_EXPR, TREE_TYPE (offset), offset);
3819 mod = fold_build2 (POINTER_PLUS_EXPR, type, val, offset);
3820 }
3821 else
3822 mod = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR, type, val, offset);
3823 if (!ptr)
3824 VERIFY_CONSTANT (mod);
3825
3826 /* Storing the modified value. */
3827 tree store = build2 (MODIFY_EXPR, type, op, mod);
3828 cxx_eval_constant_expression (ctx, store,
3829 true, non_constant_p, overflow_p);
3830
3831 /* And the value of the expression. */
3832 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3833 {
3834 /* Prefix ops are lvalues. */
3835 if (lval)
3836 return op;
3837 else
3838 /* But we optimize when the caller wants an rvalue. */
3839 return mod;
3840 }
3841 else
3842 /* Postfix ops are rvalues. */
3843 return val;
3844 }
3845
3846 /* Predicates for the meaning of *jump_target. */
3847
3848 static bool
returns(tree * jump_target)3849 returns (tree *jump_target)
3850 {
3851 return *jump_target
3852 && (TREE_CODE (*jump_target) == RETURN_EXPR
3853 || (TREE_CODE (*jump_target) == LABEL_DECL
3854 && LABEL_DECL_CDTOR (*jump_target)));
3855 }
3856
3857 static bool
breaks(tree * jump_target)3858 breaks (tree *jump_target)
3859 {
3860 return *jump_target
3861 && ((TREE_CODE (*jump_target) == LABEL_DECL
3862 && LABEL_DECL_BREAK (*jump_target))
3863 || TREE_CODE (*jump_target) == EXIT_EXPR);
3864 }
3865
3866 static bool
continues(tree * jump_target)3867 continues (tree *jump_target)
3868 {
3869 return *jump_target
3870 && TREE_CODE (*jump_target) == LABEL_DECL
3871 && LABEL_DECL_CONTINUE (*jump_target);
3872 }
3873
3874 static bool
switches(tree * jump_target)3875 switches (tree *jump_target)
3876 {
3877 return *jump_target
3878 && TREE_CODE (*jump_target) == INTEGER_CST;
3879 }
3880
3881 /* Subroutine of cxx_eval_statement_list. Determine whether the statement
3882 STMT matches *jump_target. If we're looking for a case label and we see
3883 the default label, note it in ctx->css_state. */
3884
3885 static bool
label_matches(const constexpr_ctx * ctx,tree * jump_target,tree stmt)3886 label_matches (const constexpr_ctx *ctx, tree *jump_target, tree stmt)
3887 {
3888 switch (TREE_CODE (*jump_target))
3889 {
3890 case LABEL_DECL:
3891 if (TREE_CODE (stmt) == LABEL_EXPR
3892 && LABEL_EXPR_LABEL (stmt) == *jump_target)
3893 return true;
3894 break;
3895
3896 case INTEGER_CST:
3897 if (TREE_CODE (stmt) == CASE_LABEL_EXPR)
3898 {
3899 gcc_assert (ctx->css_state != NULL);
3900 if (!CASE_LOW (stmt))
3901 {
3902 /* default: should appear just once in a SWITCH_EXPR
3903 body (excluding nested SWITCH_EXPR). */
3904 gcc_assert (*ctx->css_state != css_default_seen);
3905 /* When evaluating SWITCH_EXPR body for the second time,
3906 return true for the default: label. */
3907 if (*ctx->css_state == css_default_processing)
3908 return true;
3909 *ctx->css_state = css_default_seen;
3910 }
3911 else if (CASE_HIGH (stmt))
3912 {
3913 if (tree_int_cst_le (CASE_LOW (stmt), *jump_target)
3914 && tree_int_cst_le (*jump_target, CASE_HIGH (stmt)))
3915 return true;
3916 }
3917 else if (tree_int_cst_equal (*jump_target, CASE_LOW (stmt)))
3918 return true;
3919 }
3920 break;
3921
3922 default:
3923 gcc_unreachable ();
3924 }
3925 return false;
3926 }
3927
3928 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
3929 semantics, for switch, break, continue, and return. */
3930
3931 static tree
cxx_eval_statement_list(const constexpr_ctx * ctx,tree t,bool * non_constant_p,bool * overflow_p,tree * jump_target)3932 cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
3933 bool *non_constant_p, bool *overflow_p,
3934 tree *jump_target)
3935 {
3936 tree_stmt_iterator i;
3937 tree local_target;
3938 /* In a statement-expression we want to return the last value.
3939 For empty statement expression return void_node. */
3940 tree r = void_node;
3941 if (!jump_target)
3942 {
3943 local_target = NULL_TREE;
3944 jump_target = &local_target;
3945 }
3946 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
3947 {
3948 tree stmt = tsi_stmt (i);
3949 /* We've found a continue, so skip everything until we reach
3950 the label its jumping to. */
3951 if (continues (jump_target))
3952 {
3953 if (label_matches (ctx, jump_target, stmt))
3954 /* Found it. */
3955 *jump_target = NULL_TREE;
3956 else
3957 continue;
3958 }
3959 if (TREE_CODE (stmt) == DEBUG_BEGIN_STMT)
3960 continue;
3961 r = cxx_eval_constant_expression (ctx, stmt, false,
3962 non_constant_p, overflow_p,
3963 jump_target);
3964 if (*non_constant_p)
3965 break;
3966 if (returns (jump_target) || breaks (jump_target))
3967 break;
3968 }
3969 return r;
3970 }
3971
3972 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
3973 semantics; continue semantics are covered by cxx_eval_statement_list. */
3974
3975 static tree
cxx_eval_loop_expr(const constexpr_ctx * ctx,tree t,bool * non_constant_p,bool * overflow_p,tree * jump_target)3976 cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t,
3977 bool *non_constant_p, bool *overflow_p,
3978 tree *jump_target)
3979 {
3980 constexpr_ctx new_ctx = *ctx;
3981
3982 tree body = TREE_OPERAND (t, 0);
3983 int count = 0;
3984 do
3985 {
3986 hash_set<tree> save_exprs;
3987 new_ctx.save_exprs = &save_exprs;
3988
3989 cxx_eval_constant_expression (&new_ctx, body, /*lval*/false,
3990 non_constant_p, overflow_p, jump_target);
3991
3992 /* Forget saved values of SAVE_EXPRs. */
3993 for (hash_set<tree>::iterator iter = save_exprs.begin();
3994 iter != save_exprs.end(); ++iter)
3995 new_ctx.values->remove (*iter);
3996 if (++count >= constexpr_loop_limit)
3997 {
3998 if (!ctx->quiet)
3999 error_at (EXPR_LOC_OR_LOC (t, input_location),
4000 "%<constexpr%> loop iteration count exceeds limit of %d "
4001 "(use -fconstexpr-loop-limit= to increase the limit)",
4002 constexpr_loop_limit);
4003 *non_constant_p = true;
4004 break;
4005 }
4006 }
4007 while (!returns (jump_target)
4008 && !breaks (jump_target)
4009 && !switches (jump_target)
4010 && !*non_constant_p);
4011
4012 if (breaks (jump_target))
4013 *jump_target = NULL_TREE;
4014
4015 return NULL_TREE;
4016 }
4017
4018 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
4019 semantics. */
4020
4021 static tree
cxx_eval_switch_expr(const constexpr_ctx * ctx,tree t,bool * non_constant_p,bool * overflow_p,tree * jump_target)4022 cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t,
4023 bool *non_constant_p, bool *overflow_p,
4024 tree *jump_target)
4025 {
4026 tree cond = SWITCH_COND (t);
4027 cond = cxx_eval_constant_expression (ctx, cond, false,
4028 non_constant_p, overflow_p);
4029 VERIFY_CONSTANT (cond);
4030 *jump_target = cond;
4031
4032 tree body = SWITCH_BODY (t);
4033 constexpr_ctx new_ctx = *ctx;
4034 constexpr_switch_state css = css_default_not_seen;
4035 new_ctx.css_state = &css;
4036 cxx_eval_constant_expression (&new_ctx, body, false,
4037 non_constant_p, overflow_p, jump_target);
4038 if (switches (jump_target) && css == css_default_seen)
4039 {
4040 /* If the SWITCH_EXPR body has default: label, process it once again,
4041 this time instructing label_matches to return true for default:
4042 label on switches (jump_target). */
4043 css = css_default_processing;
4044 cxx_eval_constant_expression (&new_ctx, body, false,
4045 non_constant_p, overflow_p, jump_target);
4046 }
4047 if (breaks (jump_target) || switches (jump_target))
4048 *jump_target = NULL_TREE;
4049 return NULL_TREE;
4050 }
4051
4052 /* Find the object of TYPE under initialization in CTX. */
4053
4054 static tree
lookup_placeholder(const constexpr_ctx * ctx,bool lval,tree type)4055 lookup_placeholder (const constexpr_ctx *ctx, bool lval, tree type)
4056 {
4057 if (!ctx)
4058 return NULL_TREE;
4059
4060 /* We could use ctx->object unconditionally, but using ctx->ctor when we
4061 can is a minor optimization. */
4062 if (!lval && ctx->ctor && same_type_p (TREE_TYPE (ctx->ctor), type))
4063 return ctx->ctor;
4064
4065 if (!ctx->object)
4066 return NULL_TREE;
4067
4068 /* Since an object cannot have a field of its own type, we can search outward
4069 from ctx->object to find the unique containing object of TYPE. */
4070 tree ob = ctx->object;
4071 while (ob)
4072 {
4073 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob), type))
4074 break;
4075 if (handled_component_p (ob))
4076 ob = TREE_OPERAND (ob, 0);
4077 else
4078 ob = NULL_TREE;
4079 }
4080
4081 return ob;
4082 }
4083
4084 /* Attempt to reduce the expression T to a constant value.
4085 On failure, issue diagnostic and return error_mark_node. */
4086 /* FIXME unify with c_fully_fold */
4087 /* FIXME overflow_p is too global */
4088
4089 static tree
cxx_eval_constant_expression(const constexpr_ctx * ctx,tree t,bool lval,bool * non_constant_p,bool * overflow_p,tree * jump_target)4090 cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
4091 bool lval,
4092 bool *non_constant_p, bool *overflow_p,
4093 tree *jump_target)
4094 {
4095 constexpr_ctx new_ctx;
4096 tree r = t;
4097
4098 if (jump_target && *jump_target)
4099 {
4100 /* If we are jumping, ignore all statements/expressions except those
4101 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */
4102 switch (TREE_CODE (t))
4103 {
4104 case BIND_EXPR:
4105 case STATEMENT_LIST:
4106 case LOOP_EXPR:
4107 case COND_EXPR:
4108 break;
4109 case LABEL_EXPR:
4110 case CASE_LABEL_EXPR:
4111 if (label_matches (ctx, jump_target, t))
4112 /* Found it. */
4113 *jump_target = NULL_TREE;
4114 return NULL_TREE;
4115 default:
4116 return NULL_TREE;
4117 }
4118 }
4119 if (t == error_mark_node)
4120 {
4121 *non_constant_p = true;
4122 return t;
4123 }
4124 if (CONSTANT_CLASS_P (t))
4125 {
4126 if (TREE_OVERFLOW (t))
4127 {
4128 if (!ctx->quiet)
4129 permerror (input_location, "overflow in constant expression");
4130 if (!flag_permissive || ctx->quiet)
4131 *overflow_p = true;
4132 }
4133
4134 if (TREE_CODE (t) == INTEGER_CST
4135 && TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
4136 && !integer_zerop (t))
4137 {
4138 if (!ctx->quiet)
4139 error ("value %qE of type %qT is not a constant expression",
4140 t, TREE_TYPE (t));
4141 *non_constant_p = true;
4142 }
4143
4144 return t;
4145 }
4146
4147 tree_code tcode = TREE_CODE (t);
4148 switch (tcode)
4149 {
4150 case RESULT_DECL:
4151 if (lval)
4152 return t;
4153 /* We ask for an rvalue for the RESULT_DECL when indirecting
4154 through an invisible reference, or in named return value
4155 optimization. */
4156 if (tree *p = ctx->values->get (t))
4157 return *p;
4158 else
4159 {
4160 if (!ctx->quiet)
4161 error ("%qE is not a constant expression", t);
4162 *non_constant_p = true;
4163 }
4164 break;
4165
4166 case VAR_DECL:
4167 if (DECL_HAS_VALUE_EXPR_P (t))
4168 {
4169 if (is_normal_capture_proxy (t)
4170 && current_function_decl == DECL_CONTEXT (t))
4171 {
4172 /* Function parms aren't constexpr within the function
4173 definition, so don't try to look at the closure. But if the
4174 captured variable is constant, try to evaluate it directly. */
4175 r = DECL_CAPTURED_VARIABLE (t);
4176 tree type = TREE_TYPE (t);
4177 if (TYPE_REF_P (type) != TYPE_REF_P (TREE_TYPE (r)))
4178 {
4179 /* Adjust r to match the reference-ness of t. */
4180 if (TYPE_REF_P (type))
4181 r = build_address (r);
4182 else
4183 r = convert_from_reference (r);
4184 }
4185 }
4186 else
4187 r = DECL_VALUE_EXPR (t);
4188 return cxx_eval_constant_expression (ctx, r, lval, non_constant_p,
4189 overflow_p);
4190 }
4191 /* fall through */
4192 case CONST_DECL:
4193 /* We used to not check lval for CONST_DECL, but darwin.c uses
4194 CONST_DECL for aggregate constants. */
4195 if (lval)
4196 return t;
4197 if (COMPLETE_TYPE_P (TREE_TYPE (t))
4198 && is_really_empty_class (TREE_TYPE (t)))
4199 {
4200 /* If the class is empty, we aren't actually loading anything. */
4201 r = build_constructor (TREE_TYPE (t), NULL);
4202 TREE_CONSTANT (r) = true;
4203 }
4204 else if (ctx->strict)
4205 r = decl_really_constant_value (t);
4206 else
4207 r = decl_constant_value (t);
4208 if (TREE_CODE (r) == TARGET_EXPR
4209 && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR)
4210 r = TARGET_EXPR_INITIAL (r);
4211 if (VAR_P (r))
4212 if (tree *p = ctx->values->get (r))
4213 if (*p != NULL_TREE)
4214 r = *p;
4215 if (DECL_P (r))
4216 {
4217 if (!ctx->quiet)
4218 non_const_var_error (r);
4219 *non_constant_p = true;
4220 }
4221 break;
4222
4223 case DEBUG_BEGIN_STMT:
4224 /* ??? It might be nice to retain this information somehow, so
4225 as to be able to step into a constexpr function call. */
4226 /* Fall through. */
4227
4228 case FUNCTION_DECL:
4229 case TEMPLATE_DECL:
4230 case LABEL_DECL:
4231 case LABEL_EXPR:
4232 case CASE_LABEL_EXPR:
4233 case PREDICT_EXPR:
4234 return t;
4235
4236 case PARM_DECL:
4237 if (lval && TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
4238 /* glvalue use. */;
4239 else if (tree *p = ctx->values->get (r))
4240 r = *p;
4241 else if (lval)
4242 /* Defer in case this is only used for its type. */;
4243 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4244 /* Defer, there's no lvalue->rvalue conversion. */;
4245 else if (COMPLETE_TYPE_P (TREE_TYPE (t))
4246 && is_really_empty_class (TREE_TYPE (t)))
4247 {
4248 /* If the class is empty, we aren't actually loading anything. */
4249 r = build_constructor (TREE_TYPE (t), NULL);
4250 TREE_CONSTANT (r) = true;
4251 }
4252 else
4253 {
4254 if (!ctx->quiet)
4255 error ("%qE is not a constant expression", t);
4256 *non_constant_p = true;
4257 }
4258 break;
4259
4260 case CALL_EXPR:
4261 case AGGR_INIT_EXPR:
4262 r = cxx_eval_call_expression (ctx, t, lval,
4263 non_constant_p, overflow_p);
4264 break;
4265
4266 case DECL_EXPR:
4267 {
4268 r = DECL_EXPR_DECL (t);
4269 if (AGGREGATE_TYPE_P (TREE_TYPE (r))
4270 || VECTOR_TYPE_P (TREE_TYPE (r)))
4271 {
4272 new_ctx = *ctx;
4273 new_ctx.object = r;
4274 new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL);
4275 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
4276 new_ctx.values->put (r, new_ctx.ctor);
4277 ctx = &new_ctx;
4278 }
4279
4280 if (tree init = DECL_INITIAL (r))
4281 {
4282 init = cxx_eval_constant_expression (ctx, init,
4283 false,
4284 non_constant_p, overflow_p);
4285 /* Don't share a CONSTRUCTOR that might be changed. */
4286 init = unshare_constructor (init);
4287 ctx->values->put (r, init);
4288 }
4289 else if (ctx == &new_ctx)
4290 /* We gave it a CONSTRUCTOR above. */;
4291 else
4292 ctx->values->put (r, NULL_TREE);
4293 }
4294 break;
4295
4296 case TARGET_EXPR:
4297 if (!literal_type_p (TREE_TYPE (t)))
4298 {
4299 if (!ctx->quiet)
4300 {
4301 error ("temporary of non-literal type %qT in a "
4302 "constant expression", TREE_TYPE (t));
4303 explain_non_literal_class (TREE_TYPE (t));
4304 }
4305 *non_constant_p = true;
4306 break;
4307 }
4308 if ((AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t))))
4309 {
4310 /* We're being expanded without an explicit target, so start
4311 initializing a new object; expansion with an explicit target
4312 strips the TARGET_EXPR before we get here. */
4313 new_ctx = *ctx;
4314 new_ctx.ctor = build_constructor (TREE_TYPE (t), NULL);
4315 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
4316 new_ctx.object = TARGET_EXPR_SLOT (t);
4317 ctx->values->put (new_ctx.object, new_ctx.ctor);
4318 ctx = &new_ctx;
4319 }
4320 /* Pass false for 'lval' because this indicates
4321 initialization of a temporary. */
4322 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
4323 false,
4324 non_constant_p, overflow_p);
4325 if (!*non_constant_p)
4326 /* Adjust the type of the result to the type of the temporary. */
4327 r = adjust_temp_type (TREE_TYPE (t), r);
4328 if (lval)
4329 {
4330 tree slot = TARGET_EXPR_SLOT (t);
4331 r = unshare_constructor (r);
4332 ctx->values->put (slot, r);
4333 return slot;
4334 }
4335 break;
4336
4337 case INIT_EXPR:
4338 case MODIFY_EXPR:
4339 gcc_assert (jump_target == NULL || *jump_target == NULL_TREE);
4340 r = cxx_eval_store_expression (ctx, t, lval,
4341 non_constant_p, overflow_p);
4342 break;
4343
4344 case SCOPE_REF:
4345 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
4346 lval,
4347 non_constant_p, overflow_p);
4348 break;
4349
4350 case RETURN_EXPR:
4351 if (TREE_OPERAND (t, 0) != NULL_TREE)
4352 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
4353 lval,
4354 non_constant_p, overflow_p);
4355 if (jump_target)
4356 *jump_target = t;
4357 else
4358 {
4359 /* Can happen with ({ return true; }) && false; passed to
4360 maybe_constant_value. There is nothing to jump over in this
4361 case, and the bug will be diagnosed later. */
4362 gcc_assert (ctx->quiet);
4363 *non_constant_p = true;
4364 }
4365 break;
4366
4367 case SAVE_EXPR:
4368 /* Avoid evaluating a SAVE_EXPR more than once. */
4369 if (tree *p = ctx->values->get (t))
4370 r = *p;
4371 else
4372 {
4373 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), false,
4374 non_constant_p, overflow_p);
4375 ctx->values->put (t, r);
4376 if (ctx->save_exprs)
4377 ctx->save_exprs->add (t);
4378 }
4379 break;
4380
4381 case NON_LVALUE_EXPR:
4382 case TRY_CATCH_EXPR:
4383 case TRY_BLOCK:
4384 case CLEANUP_POINT_EXPR:
4385 case MUST_NOT_THROW_EXPR:
4386 case EXPR_STMT:
4387 case EH_SPEC_BLOCK:
4388 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
4389 lval,
4390 non_constant_p, overflow_p,
4391 jump_target);
4392 break;
4393
4394 case TRY_FINALLY_EXPR:
4395 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval,
4396 non_constant_p, overflow_p,
4397 jump_target);
4398 if (!*non_constant_p)
4399 /* Also evaluate the cleanup. */
4400 cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), true,
4401 non_constant_p, overflow_p,
4402 jump_target);
4403 break;
4404
4405 /* These differ from cxx_eval_unary_expression in that this doesn't
4406 check for a constant operand or result; an address can be
4407 constant without its operand being, and vice versa. */
4408 case MEM_REF:
4409 case INDIRECT_REF:
4410 r = cxx_eval_indirect_ref (ctx, t, lval,
4411 non_constant_p, overflow_p);
4412 break;
4413
4414 case ADDR_EXPR:
4415 {
4416 tree oldop = TREE_OPERAND (t, 0);
4417 tree op = cxx_eval_constant_expression (ctx, oldop,
4418 /*lval*/true,
4419 non_constant_p, overflow_p);
4420 /* Don't VERIFY_CONSTANT here. */
4421 if (*non_constant_p)
4422 return t;
4423 gcc_checking_assert (TREE_CODE (op) != CONSTRUCTOR);
4424 /* This function does more aggressive folding than fold itself. */
4425 r = build_fold_addr_expr_with_type (op, TREE_TYPE (t));
4426 if (TREE_CODE (r) == ADDR_EXPR && TREE_OPERAND (r, 0) == oldop)
4427 return t;
4428 break;
4429 }
4430
4431 case REALPART_EXPR:
4432 case IMAGPART_EXPR:
4433 if (lval)
4434 {
4435 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval,
4436 non_constant_p, overflow_p);
4437 if (r == error_mark_node)
4438 ;
4439 else if (r == TREE_OPERAND (t, 0))
4440 r = t;
4441 else
4442 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), r);
4443 break;
4444 }
4445 /* FALLTHRU */
4446 case CONJ_EXPR:
4447 case FIX_TRUNC_EXPR:
4448 case FLOAT_EXPR:
4449 case NEGATE_EXPR:
4450 case ABS_EXPR:
4451 case BIT_NOT_EXPR:
4452 case TRUTH_NOT_EXPR:
4453 case FIXED_CONVERT_EXPR:
4454 r = cxx_eval_unary_expression (ctx, t, lval,
4455 non_constant_p, overflow_p);
4456 break;
4457
4458 case SIZEOF_EXPR:
4459 r = fold_sizeof_expr (t);
4460 VERIFY_CONSTANT (r);
4461 break;
4462
4463 case COMPOUND_EXPR:
4464 {
4465 /* check_return_expr sometimes wraps a TARGET_EXPR in a
4466 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
4467 introduced by build_call_a. */
4468 tree op0 = TREE_OPERAND (t, 0);
4469 tree op1 = TREE_OPERAND (t, 1);
4470 STRIP_NOPS (op1);
4471 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
4472 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
4473 r = cxx_eval_constant_expression (ctx, op0,
4474 lval, non_constant_p, overflow_p,
4475 jump_target);
4476 else
4477 {
4478 /* Check that the LHS is constant and then discard it. */
4479 cxx_eval_constant_expression (ctx, op0,
4480 true, non_constant_p, overflow_p,
4481 jump_target);
4482 if (*non_constant_p)
4483 return t;
4484 op1 = TREE_OPERAND (t, 1);
4485 r = cxx_eval_constant_expression (ctx, op1,
4486 lval, non_constant_p, overflow_p,
4487 jump_target);
4488 }
4489 }
4490 break;
4491
4492 case POINTER_PLUS_EXPR:
4493 case POINTER_DIFF_EXPR:
4494 case PLUS_EXPR:
4495 case MINUS_EXPR:
4496 case MULT_EXPR:
4497 case TRUNC_DIV_EXPR:
4498 case CEIL_DIV_EXPR:
4499 case FLOOR_DIV_EXPR:
4500 case ROUND_DIV_EXPR:
4501 case TRUNC_MOD_EXPR:
4502 case CEIL_MOD_EXPR:
4503 case ROUND_MOD_EXPR:
4504 case RDIV_EXPR:
4505 case EXACT_DIV_EXPR:
4506 case MIN_EXPR:
4507 case MAX_EXPR:
4508 case LSHIFT_EXPR:
4509 case RSHIFT_EXPR:
4510 case LROTATE_EXPR:
4511 case RROTATE_EXPR:
4512 case BIT_IOR_EXPR:
4513 case BIT_XOR_EXPR:
4514 case BIT_AND_EXPR:
4515 case TRUTH_XOR_EXPR:
4516 case LT_EXPR:
4517 case LE_EXPR:
4518 case GT_EXPR:
4519 case GE_EXPR:
4520 case EQ_EXPR:
4521 case NE_EXPR:
4522 case UNORDERED_EXPR:
4523 case ORDERED_EXPR:
4524 case UNLT_EXPR:
4525 case UNLE_EXPR:
4526 case UNGT_EXPR:
4527 case UNGE_EXPR:
4528 case UNEQ_EXPR:
4529 case LTGT_EXPR:
4530 case RANGE_EXPR:
4531 case COMPLEX_EXPR:
4532 r = cxx_eval_binary_expression (ctx, t, lval,
4533 non_constant_p, overflow_p);
4534 break;
4535
4536 /* fold can introduce non-IF versions of these; still treat them as
4537 short-circuiting. */
4538 case TRUTH_AND_EXPR:
4539 case TRUTH_ANDIF_EXPR:
4540 r = cxx_eval_logical_expression (ctx, t, boolean_false_node,
4541 boolean_true_node,
4542 lval,
4543 non_constant_p, overflow_p);
4544 break;
4545
4546 case TRUTH_OR_EXPR:
4547 case TRUTH_ORIF_EXPR:
4548 r = cxx_eval_logical_expression (ctx, t, boolean_true_node,
4549 boolean_false_node,
4550 lval,
4551 non_constant_p, overflow_p);
4552 break;
4553
4554 case ARRAY_REF:
4555 r = cxx_eval_array_reference (ctx, t, lval,
4556 non_constant_p, overflow_p);
4557 break;
4558
4559 case COMPONENT_REF:
4560 if (is_overloaded_fn (t))
4561 {
4562 /* We can only get here in checking mode via
4563 build_non_dependent_expr, because any expression that
4564 calls or takes the address of the function will have
4565 pulled a FUNCTION_DECL out of the COMPONENT_REF. */
4566 gcc_checking_assert (ctx->quiet || errorcount);
4567 *non_constant_p = true;
4568 return t;
4569 }
4570 r = cxx_eval_component_reference (ctx, t, lval,
4571 non_constant_p, overflow_p);
4572 break;
4573
4574 case BIT_FIELD_REF:
4575 r = cxx_eval_bit_field_ref (ctx, t, lval,
4576 non_constant_p, overflow_p);
4577 break;
4578
4579 case COND_EXPR:
4580 if (jump_target && *jump_target)
4581 {
4582 tree orig_jump = *jump_target;
4583 /* When jumping to a label, the label might be either in the
4584 then or else blocks, so process then block first in skipping
4585 mode first, and if we are still in the skipping mode at its end,
4586 process the else block too. */
4587 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
4588 lval, non_constant_p, overflow_p,
4589 jump_target);
4590 /* It's possible that we found the label in the then block. But
4591 it could have been followed by another jumping statement, e.g.
4592 say we're looking for case 1:
4593 if (cond)
4594 {
4595 // skipped statements
4596 case 1:; // clears up *jump_target
4597 return 1; // and sets it to a RETURN_EXPR
4598 }
4599 else { ... }
4600 in which case we need not go looking to the else block.
4601 (goto is not allowed in a constexpr function.) */
4602 if (*jump_target == orig_jump)
4603 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
4604 lval, non_constant_p, overflow_p,
4605 jump_target);
4606 break;
4607 }
4608 r = cxx_eval_conditional_expression (ctx, t, lval,
4609 non_constant_p, overflow_p,
4610 jump_target);
4611 break;
4612 case VEC_COND_EXPR:
4613 r = cxx_eval_vector_conditional_expression (ctx, t, non_constant_p,
4614 overflow_p);
4615 break;
4616
4617 case CONSTRUCTOR:
4618 if (TREE_CONSTANT (t) && reduced_constant_expression_p (t))
4619 {
4620 /* Don't re-process a constant CONSTRUCTOR, but do fold it to
4621 VECTOR_CST if applicable. */
4622 verify_constructor_flags (t);
4623 if (TREE_CONSTANT (t))
4624 return fold (t);
4625 }
4626 r = cxx_eval_bare_aggregate (ctx, t, lval,
4627 non_constant_p, overflow_p);
4628 break;
4629
4630 case VEC_INIT_EXPR:
4631 /* We can get this in a defaulted constructor for a class with a
4632 non-static data member of array type. Either the initializer will
4633 be NULL, meaning default-initialization, or it will be an lvalue
4634 or xvalue of the same type, meaning direct-initialization from the
4635 corresponding member. */
4636 r = cxx_eval_vec_init (ctx, t, lval,
4637 non_constant_p, overflow_p);
4638 break;
4639
4640 case FMA_EXPR:
4641 case VEC_PERM_EXPR:
4642 r = cxx_eval_trinary_expression (ctx, t, lval,
4643 non_constant_p, overflow_p);
4644 break;
4645
4646 case NOP_EXPR:
4647 if (REINTERPRET_CAST_P (t))
4648 {
4649 if (!ctx->quiet)
4650 error_at (EXPR_LOC_OR_LOC (t, input_location),
4651 "a reinterpret_cast is not a constant expression");
4652 *non_constant_p = true;
4653 return t;
4654 }
4655 /* FALLTHROUGH. */
4656 case CONVERT_EXPR:
4657 case VIEW_CONVERT_EXPR:
4658 case UNARY_PLUS_EXPR:
4659 {
4660 tree oldop = TREE_OPERAND (t, 0);
4661
4662 tree op = cxx_eval_constant_expression (ctx, oldop,
4663 lval,
4664 non_constant_p, overflow_p);
4665 if (*non_constant_p)
4666 return t;
4667 tree type = TREE_TYPE (t);
4668 if (TREE_CODE (op) == PTRMEM_CST
4669 && !TYPE_PTRMEM_P (type))
4670 op = cplus_expand_constant (op);
4671
4672 if (TREE_CODE (op) == PTRMEM_CST && tcode == NOP_EXPR)
4673 {
4674 if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (op))
4675 && !can_convert_qual (type, op))
4676 op = cplus_expand_constant (op);
4677 return cp_fold_convert (type, op);
4678 }
4679
4680 if (POINTER_TYPE_P (type) && TREE_CODE (op) == INTEGER_CST)
4681 {
4682 if (integer_zerop (op))
4683 {
4684 if (TREE_CODE (type) == REFERENCE_TYPE)
4685 {
4686 if (!ctx->quiet)
4687 error_at (EXPR_LOC_OR_LOC (t, input_location),
4688 "dereferencing a null pointer");
4689 *non_constant_p = true;
4690 return t;
4691 }
4692 else if (TREE_CODE (TREE_TYPE (op)) == POINTER_TYPE)
4693 {
4694 tree from = TREE_TYPE (op);
4695
4696 if (!can_convert (type, from, tf_none))
4697 {
4698 if (!ctx->quiet)
4699 error_at (EXPR_LOC_OR_LOC (t, input_location),
4700 "conversion of %qT null pointer to %qT "
4701 "is not a constant expression",
4702 from, type);
4703 *non_constant_p = true;
4704 return t;
4705 }
4706 }
4707 }
4708 else
4709 {
4710 /* This detects for example:
4711 reinterpret_cast<void*>(sizeof 0)
4712 */
4713 if (!ctx->quiet)
4714 error_at (EXPR_LOC_OR_LOC (t, input_location),
4715 "%<reinterpret_cast<%T>(%E)%> is not "
4716 "a constant expression",
4717 type, op);
4718 *non_constant_p = true;
4719 return t;
4720 }
4721 }
4722
4723 if (op == oldop && tcode != UNARY_PLUS_EXPR)
4724 /* We didn't fold at the top so we could check for ptr-int
4725 conversion. */
4726 return fold (t);
4727
4728 if (tcode == UNARY_PLUS_EXPR)
4729 r = fold_convert (TREE_TYPE (t), op);
4730 else
4731 r = fold_build1 (tcode, type, op);
4732
4733 /* Conversion of an out-of-range value has implementation-defined
4734 behavior; the language considers it different from arithmetic
4735 overflow, which is undefined. */
4736 if (TREE_OVERFLOW_P (r) && !TREE_OVERFLOW_P (op))
4737 TREE_OVERFLOW (r) = false;
4738 }
4739 break;
4740
4741 case EMPTY_CLASS_EXPR:
4742 /* This is good enough for a function argument that might not get
4743 used, and they can't do anything with it, so just return it. */
4744 return t;
4745
4746 case STATEMENT_LIST:
4747 new_ctx = *ctx;
4748 new_ctx.ctor = new_ctx.object = NULL_TREE;
4749 return cxx_eval_statement_list (&new_ctx, t,
4750 non_constant_p, overflow_p, jump_target);
4751
4752 case BIND_EXPR:
4753 return cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (t),
4754 lval,
4755 non_constant_p, overflow_p,
4756 jump_target);
4757
4758 case PREINCREMENT_EXPR:
4759 case POSTINCREMENT_EXPR:
4760 case PREDECREMENT_EXPR:
4761 case POSTDECREMENT_EXPR:
4762 return cxx_eval_increment_expression (ctx, t,
4763 lval, non_constant_p, overflow_p);
4764
4765 case LAMBDA_EXPR:
4766 case NEW_EXPR:
4767 case VEC_NEW_EXPR:
4768 case DELETE_EXPR:
4769 case VEC_DELETE_EXPR:
4770 case THROW_EXPR:
4771 case MODOP_EXPR:
4772 /* GCC internal stuff. */
4773 case VA_ARG_EXPR:
4774 case OBJ_TYPE_REF:
4775 case NON_DEPENDENT_EXPR:
4776 case BASELINK:
4777 case OFFSET_REF:
4778 if (!ctx->quiet)
4779 error_at (EXPR_LOC_OR_LOC (t, input_location),
4780 "expression %qE is not a constant expression", t);
4781 *non_constant_p = true;
4782 break;
4783
4784 case PLACEHOLDER_EXPR:
4785 /* Use of the value or address of the current object. */
4786 if (tree ctor = lookup_placeholder (ctx, lval, TREE_TYPE (t)))
4787 return cxx_eval_constant_expression (ctx, ctor, lval,
4788 non_constant_p, overflow_p);
4789 /* A placeholder without a referent. We can get here when
4790 checking whether NSDMIs are noexcept, or in massage_init_elt;
4791 just say it's non-constant for now. */
4792 gcc_assert (ctx->quiet);
4793 *non_constant_p = true;
4794 break;
4795
4796 case EXIT_EXPR:
4797 {
4798 tree cond = TREE_OPERAND (t, 0);
4799 cond = cxx_eval_constant_expression (ctx, cond, /*lval*/false,
4800 non_constant_p, overflow_p);
4801 VERIFY_CONSTANT (cond);
4802 if (integer_nonzerop (cond))
4803 *jump_target = t;
4804 }
4805 break;
4806
4807 case GOTO_EXPR:
4808 *jump_target = TREE_OPERAND (t, 0);
4809 gcc_assert (breaks (jump_target) || continues (jump_target)
4810 /* Allow for jumping to a cdtor_label. */
4811 || returns (jump_target));
4812 break;
4813
4814 case LOOP_EXPR:
4815 cxx_eval_loop_expr (ctx, t,
4816 non_constant_p, overflow_p, jump_target);
4817 break;
4818
4819 case SWITCH_EXPR:
4820 cxx_eval_switch_expr (ctx, t,
4821 non_constant_p, overflow_p, jump_target);
4822 break;
4823
4824 case REQUIRES_EXPR:
4825 /* It's possible to get a requires-expression in a constant
4826 expression. For example:
4827
4828 template<typename T> concept bool C() {
4829 return requires (T t) { t; };
4830 }
4831
4832 template<typename T> requires !C<T>() void f(T);
4833
4834 Normalization leaves f with the associated constraint
4835 '!requires (T t) { ... }' which is not transformed into
4836 a constraint. */
4837 if (!processing_template_decl)
4838 return evaluate_constraint_expression (t, NULL_TREE);
4839 else
4840 *non_constant_p = true;
4841 return t;
4842
4843 case ANNOTATE_EXPR:
4844 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
4845 lval,
4846 non_constant_p, overflow_p,
4847 jump_target);
4848 break;
4849
4850 case USING_STMT:
4851 r = void_node;
4852 break;
4853
4854 default:
4855 if (STATEMENT_CODE_P (TREE_CODE (t)))
4856 {
4857 /* This function doesn't know how to deal with pre-genericize
4858 statements; this can only happen with statement-expressions,
4859 so for now just fail. */
4860 if (!ctx->quiet)
4861 error_at (EXPR_LOCATION (t),
4862 "statement is not a constant expression");
4863 }
4864 else
4865 internal_error ("unexpected expression %qE of kind %s", t,
4866 get_tree_code_name (TREE_CODE (t)));
4867 *non_constant_p = true;
4868 break;
4869 }
4870
4871 if (r == error_mark_node)
4872 *non_constant_p = true;
4873
4874 if (*non_constant_p)
4875 return t;
4876 else
4877 return r;
4878 }
4879
4880 static tree
4881 cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
4882 bool strict = true, tree object = NULL_TREE)
4883 {
4884 auto_timevar time (TV_CONSTEXPR);
4885
4886 bool non_constant_p = false;
4887 bool overflow_p = false;
4888 hash_map<tree,tree> map;
4889
4890 constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL,
4891 allow_non_constant, strict };
4892
4893 tree type = initialized_type (t);
4894 tree r = t;
4895 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
4896 {
4897 /* In C++14 an NSDMI can participate in aggregate initialization,
4898 and can refer to the address of the object being initialized, so
4899 we need to pass in the relevant VAR_DECL if we want to do the
4900 evaluation in a single pass. The evaluation will dynamically
4901 update ctx.values for the VAR_DECL. We use the same strategy
4902 for C++11 constexpr constructors that refer to the object being
4903 initialized. */
4904 ctx.ctor = build_constructor (type, NULL);
4905 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx.ctor) = true;
4906 if (!object)
4907 {
4908 if (TREE_CODE (t) == TARGET_EXPR)
4909 object = TARGET_EXPR_SLOT (t);
4910 else if (TREE_CODE (t) == AGGR_INIT_EXPR)
4911 object = AGGR_INIT_EXPR_SLOT (t);
4912 }
4913 ctx.object = object;
4914 if (object)
4915 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4916 (type, TREE_TYPE (object)));
4917 if (object && DECL_P (object))
4918 map.put (object, ctx.ctor);
4919 if (TREE_CODE (r) == TARGET_EXPR)
4920 /* Avoid creating another CONSTRUCTOR when we expand the
4921 TARGET_EXPR. */
4922 r = TARGET_EXPR_INITIAL (r);
4923 }
4924
4925 r = cxx_eval_constant_expression (&ctx, r,
4926 false, &non_constant_p, &overflow_p);
4927
4928 verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);
4929
4930 /* Mutable logic is a bit tricky: we want to allow initialization of
4931 constexpr variables with mutable members, but we can't copy those
4932 members to another constexpr variable. */
4933 if (TREE_CODE (r) == CONSTRUCTOR
4934 && CONSTRUCTOR_MUTABLE_POISON (r))
4935 {
4936 if (!allow_non_constant)
4937 error ("%qE is not a constant expression because it refers to "
4938 "mutable subobjects of %qT", t, type);
4939 non_constant_p = true;
4940 }
4941
4942 if (TREE_CODE (r) == CONSTRUCTOR
4943 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r))
4944 {
4945 if (!allow_non_constant)
4946 error ("%qE is not a constant expression because it refers to "
4947 "an incompletely initialized variable", t);
4948 TREE_CONSTANT (r) = false;
4949 non_constant_p = true;
4950 }
4951
4952 /* Technically we should check this for all subexpressions, but that
4953 runs into problems with our internal representation of pointer
4954 subtraction and the 5.19 rules are still in flux. */
4955 if (CONVERT_EXPR_CODE_P (TREE_CODE (r))
4956 && ARITHMETIC_TYPE_P (TREE_TYPE (r))
4957 && TREE_CODE (TREE_OPERAND (r, 0)) == ADDR_EXPR)
4958 {
4959 if (!allow_non_constant)
4960 error ("conversion from pointer type %qT "
4961 "to arithmetic type %qT in a constant expression",
4962 TREE_TYPE (TREE_OPERAND (r, 0)), TREE_TYPE (r));
4963 non_constant_p = true;
4964 }
4965
4966 if (!non_constant_p && overflow_p)
4967 non_constant_p = true;
4968
4969 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already
4970 unshared. */
4971 bool should_unshare = true;
4972 if (r == t || TREE_CODE (r) == CONSTRUCTOR)
4973 should_unshare = false;
4974
4975 if (non_constant_p && !allow_non_constant)
4976 return error_mark_node;
4977 else if (non_constant_p && TREE_CONSTANT (r))
4978 {
4979 /* This isn't actually constant, so unset TREE_CONSTANT.
4980 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
4981 it to be set if it is invariant address, even when it is not
4982 a valid C++ constant expression. Wrap it with a NOP_EXPR
4983 instead. */
4984 if (EXPR_P (r) && TREE_CODE (r) != ADDR_EXPR)
4985 r = copy_node (r);
4986 else if (TREE_CODE (r) == CONSTRUCTOR)
4987 r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r);
4988 else
4989 r = build_nop (TREE_TYPE (r), r);
4990 TREE_CONSTANT (r) = false;
4991 }
4992 else if (non_constant_p || r == t)
4993 return t;
4994
4995 if (should_unshare)
4996 r = unshare_expr (r);
4997
4998 if (TREE_CODE (r) == CONSTRUCTOR && CLASS_TYPE_P (TREE_TYPE (r)))
4999 {
5000 if (TREE_CODE (t) == TARGET_EXPR
5001 && TARGET_EXPR_INITIAL (t) == r)
5002 return t;
5003 else if (TREE_CODE (t) != CONSTRUCTOR)
5004 {
5005 r = get_target_expr (r);
5006 TREE_CONSTANT (r) = true;
5007 }
5008 }
5009 return r;
5010 }
5011
5012 /* Returns true if T is a valid subexpression of a constant expression,
5013 even if it isn't itself a constant expression. */
5014
5015 bool
is_sub_constant_expr(tree t)5016 is_sub_constant_expr (tree t)
5017 {
5018 bool non_constant_p = false;
5019 bool overflow_p = false;
5020 hash_map <tree, tree> map;
5021
5022 constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL, true, true };
5023
5024 cxx_eval_constant_expression (&ctx, t, false, &non_constant_p,
5025 &overflow_p);
5026 return !non_constant_p && !overflow_p;
5027 }
5028
5029 /* If T represents a constant expression returns its reduced value.
5030 Otherwise return error_mark_node. If T is dependent, then
5031 return NULL. */
5032
5033 tree
cxx_constant_value(tree t,tree decl)5034 cxx_constant_value (tree t, tree decl)
5035 {
5036 return cxx_eval_outermost_constant_expr (t, false, true, decl);
5037 }
5038
5039 /* Helper routine for fold_simple function. Either return simplified
5040 expression T, otherwise NULL_TREE.
5041 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold
5042 even if we are within template-declaration. So be careful on call, as in
5043 such case types can be undefined. */
5044
5045 static tree
fold_simple_1(tree t)5046 fold_simple_1 (tree t)
5047 {
5048 tree op1;
5049 enum tree_code code = TREE_CODE (t);
5050
5051 switch (code)
5052 {
5053 case INTEGER_CST:
5054 case REAL_CST:
5055 case VECTOR_CST:
5056 case FIXED_CST:
5057 case COMPLEX_CST:
5058 return t;
5059
5060 case SIZEOF_EXPR:
5061 return fold_sizeof_expr (t);
5062
5063 case ABS_EXPR:
5064 case CONJ_EXPR:
5065 case REALPART_EXPR:
5066 case IMAGPART_EXPR:
5067 case NEGATE_EXPR:
5068 case BIT_NOT_EXPR:
5069 case TRUTH_NOT_EXPR:
5070 case NOP_EXPR:
5071 case VIEW_CONVERT_EXPR:
5072 case CONVERT_EXPR:
5073 case FLOAT_EXPR:
5074 case FIX_TRUNC_EXPR:
5075 case FIXED_CONVERT_EXPR:
5076 case ADDR_SPACE_CONVERT_EXPR:
5077
5078 op1 = TREE_OPERAND (t, 0);
5079
5080 t = const_unop (code, TREE_TYPE (t), op1);
5081 if (!t)
5082 return NULL_TREE;
5083
5084 if (CONVERT_EXPR_CODE_P (code)
5085 && TREE_OVERFLOW_P (t) && !TREE_OVERFLOW_P (op1))
5086 TREE_OVERFLOW (t) = false;
5087 return t;
5088
5089 default:
5090 return NULL_TREE;
5091 }
5092 }
5093
5094 /* If T is a simple constant expression, returns its simplified value.
5095 Otherwise returns T. In contrast to maybe_constant_value we
5096 simplify only few operations on constant-expressions, and we don't
5097 try to simplify constexpressions. */
5098
5099 tree
fold_simple(tree t)5100 fold_simple (tree t)
5101 {
5102 if (processing_template_decl)
5103 return t;
5104
5105 tree r = fold_simple_1 (t);
5106 if (r)
5107 return r;
5108
5109 return t;
5110 }
5111
5112 /* If T is a constant expression, returns its reduced value.
5113 Otherwise, if T does not have TREE_CONSTANT set, returns T.
5114 Otherwise, returns a version of T without TREE_CONSTANT. */
5115
5116 static GTY((deletable)) hash_map<tree, tree> *cv_cache;
5117
5118 tree
maybe_constant_value(tree t,tree decl)5119 maybe_constant_value (tree t, tree decl)
5120 {
5121 tree r;
5122
5123 if (!is_nondependent_constant_expression (t))
5124 {
5125 if (TREE_OVERFLOW_P (t))
5126 {
5127 t = build_nop (TREE_TYPE (t), t);
5128 TREE_CONSTANT (t) = false;
5129 }
5130 return t;
5131 }
5132 else if (CONSTANT_CLASS_P (t))
5133 /* No caching or evaluation needed. */
5134 return t;
5135
5136 if (cv_cache == NULL)
5137 cv_cache = hash_map<tree, tree>::create_ggc (101);
5138 if (tree *cached = cv_cache->get (t))
5139 {
5140 r = *cached;
5141 if (r != t)
5142 {
5143 r = unshare_expr_without_location (r);
5144 protected_set_expr_location (r, EXPR_LOCATION (t));
5145 }
5146 return r;
5147 }
5148
5149 r = cxx_eval_outermost_constant_expr (t, true, true, decl);
5150 gcc_checking_assert (r == t
5151 || CONVERT_EXPR_P (t)
5152 || TREE_CODE (t) == VIEW_CONVERT_EXPR
5153 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
5154 || !cp_tree_equal (r, t));
5155 cv_cache->put (t, r);
5156 return r;
5157 }
5158
5159 /* Dispose of the whole CV_CACHE. */
5160
5161 static void
clear_cv_cache(void)5162 clear_cv_cache (void)
5163 {
5164 if (cv_cache != NULL)
5165 cv_cache->empty ();
5166 }
5167
5168 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */
5169
5170 void
clear_cv_and_fold_caches(void)5171 clear_cv_and_fold_caches (void)
5172 {
5173 clear_cv_cache ();
5174 clear_fold_cache ();
5175 }
5176
5177 /* Like maybe_constant_value but first fully instantiate the argument.
5178
5179 Note: this is equivalent to instantiate_non_dependent_expr_sfinae
5180 (t, complain) followed by maybe_constant_value but is more efficient,
5181 because calls instantiation_dependent_expression_p and
5182 potential_constant_expression at most once. */
5183
5184 tree
fold_non_dependent_expr(tree t,tsubst_flags_t complain)5185 fold_non_dependent_expr (tree t, tsubst_flags_t complain /* = tf_none */)
5186 {
5187 if (t == NULL_TREE)
5188 return NULL_TREE;
5189
5190 /* If we're in a template, but T isn't value dependent, simplify
5191 it. We're supposed to treat:
5192
5193 template <typename T> void f(T[1 + 1]);
5194 template <typename T> void f(T[2]);
5195
5196 as two declarations of the same function, for example. */
5197 if (processing_template_decl)
5198 {
5199 if (is_nondependent_constant_expression (t))
5200 {
5201 processing_template_decl_sentinel s;
5202 t = instantiate_non_dependent_expr_internal (t, complain);
5203
5204 if (type_unknown_p (t)
5205 || BRACE_ENCLOSED_INITIALIZER_P (t))
5206 {
5207 if (TREE_OVERFLOW_P (t))
5208 {
5209 t = build_nop (TREE_TYPE (t), t);
5210 TREE_CONSTANT (t) = false;
5211 }
5212 return t;
5213 }
5214
5215 tree r = cxx_eval_outermost_constant_expr (t, true, true, NULL_TREE);
5216 /* cp_tree_equal looks through NOPs, so allow them. */
5217 gcc_checking_assert (r == t
5218 || CONVERT_EXPR_P (t)
5219 || TREE_CODE (t) == VIEW_CONVERT_EXPR
5220 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
5221 || !cp_tree_equal (r, t));
5222 return r;
5223 }
5224 else if (TREE_OVERFLOW_P (t))
5225 {
5226 t = build_nop (TREE_TYPE (t), t);
5227 TREE_CONSTANT (t) = false;
5228 }
5229 return t;
5230 }
5231
5232 return maybe_constant_value (t);
5233 }
5234
5235 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
5236 than wrapped in a TARGET_EXPR. */
5237
5238 static tree
maybe_constant_init_1(tree t,tree decl,bool allow_non_constant)5239 maybe_constant_init_1 (tree t, tree decl, bool allow_non_constant)
5240 {
5241 if (!t)
5242 return t;
5243 if (TREE_CODE (t) == EXPR_STMT)
5244 t = TREE_OPERAND (t, 0);
5245 if (TREE_CODE (t) == CONVERT_EXPR
5246 && VOID_TYPE_P (TREE_TYPE (t)))
5247 t = TREE_OPERAND (t, 0);
5248 if (TREE_CODE (t) == INIT_EXPR)
5249 t = TREE_OPERAND (t, 1);
5250 if (TREE_CODE (t) == TARGET_EXPR)
5251 t = TARGET_EXPR_INITIAL (t);
5252 if (!is_nondependent_static_init_expression (t))
5253 /* Don't try to evaluate it. */;
5254 else if (CONSTANT_CLASS_P (t) && allow_non_constant)
5255 /* No evaluation needed. */;
5256 else
5257 t = cxx_eval_outermost_constant_expr (t, allow_non_constant, false, decl);
5258 if (TREE_CODE (t) == TARGET_EXPR)
5259 {
5260 tree init = TARGET_EXPR_INITIAL (t);
5261 if (TREE_CODE (init) == CONSTRUCTOR)
5262 t = init;
5263 }
5264 return t;
5265 }
5266
5267 /* Wrapper for maybe_constant_init_1 which permits non constants. */
5268
5269 tree
maybe_constant_init(tree t,tree decl)5270 maybe_constant_init (tree t, tree decl)
5271 {
5272 return maybe_constant_init_1 (t, decl, true);
5273 }
5274
5275 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */
5276
5277 tree
cxx_constant_init(tree t,tree decl)5278 cxx_constant_init (tree t, tree decl)
5279 {
5280 return maybe_constant_init_1 (t, decl, false);
5281 }
5282
5283 #if 0
5284 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
5285 /* Return true if the object referred to by REF has automatic or thread
5286 local storage. */
5287
5288 enum { ck_ok, ck_bad, ck_unknown };
5289 static int
5290 check_automatic_or_tls (tree ref)
5291 {
5292 machine_mode mode;
5293 poly_int64 bitsize, bitpos;
5294 tree offset;
5295 int volatilep = 0, unsignedp = 0;
5296 tree decl = get_inner_reference (ref, &bitsize, &bitpos, &offset,
5297 &mode, &unsignedp, &volatilep, false);
5298 duration_kind dk;
5299
5300 /* If there isn't a decl in the middle, we don't know the linkage here,
5301 and this isn't a constant expression anyway. */
5302 if (!DECL_P (decl))
5303 return ck_unknown;
5304 dk = decl_storage_duration (decl);
5305 return (dk == dk_auto || dk == dk_thread) ? ck_bad : ck_ok;
5306 }
5307 #endif
5308
5309 /* Return true if T denotes a potentially constant expression. Issue
5310 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
5311 an lvalue-rvalue conversion is implied. If NOW is true, we want to
5312 consider the expression in the current context, independent of constexpr
5313 substitution.
5314
5315 C++0x [expr.const] used to say
5316
5317 6 An expression is a potential constant expression if it is
5318 a constant expression where all occurrences of function
5319 parameters are replaced by arbitrary constant expressions
5320 of the appropriate type.
5321
5322 2 A conditional expression is a constant expression unless it
5323 involves one of the following as a potentially evaluated
5324 subexpression (3.2), but subexpressions of logical AND (5.14),
5325 logical OR (5.15), and conditional (5.16) operations that are
5326 not evaluated are not considered. */
5327
5328 static bool
potential_constant_expression_1(tree t,bool want_rval,bool strict,bool now,tsubst_flags_t flags)5329 potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,
5330 tsubst_flags_t flags)
5331 {
5332 #define RECUR(T,RV) \
5333 potential_constant_expression_1 ((T), (RV), strict, now, flags)
5334
5335 enum { any = false, rval = true };
5336 int i;
5337 tree tmp;
5338
5339 if (t == error_mark_node)
5340 return false;
5341 if (t == NULL_TREE)
5342 return true;
5343 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
5344 if (TREE_THIS_VOLATILE (t) && !DECL_P (t))
5345 {
5346 if (flags & tf_error)
5347 error_at (loc, "expression %qE has side-effects", t);
5348 return false;
5349 }
5350 if (CONSTANT_CLASS_P (t))
5351 return true;
5352 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED)
5353 && TREE_TYPE (t) == error_mark_node)
5354 return false;
5355
5356 switch (TREE_CODE (t))
5357 {
5358 case FUNCTION_DECL:
5359 case BASELINK:
5360 case TEMPLATE_DECL:
5361 case OVERLOAD:
5362 case TEMPLATE_ID_EXPR:
5363 case LABEL_DECL:
5364 case LABEL_EXPR:
5365 case CASE_LABEL_EXPR:
5366 case CONST_DECL:
5367 case SIZEOF_EXPR:
5368 case ALIGNOF_EXPR:
5369 case OFFSETOF_EXPR:
5370 case NOEXCEPT_EXPR:
5371 case TEMPLATE_PARM_INDEX:
5372 case TRAIT_EXPR:
5373 case IDENTIFIER_NODE:
5374 case USERDEF_LITERAL:
5375 /* We can see a FIELD_DECL in a pointer-to-member expression. */
5376 case FIELD_DECL:
5377 case RESULT_DECL:
5378 case USING_DECL:
5379 case USING_STMT:
5380 case PLACEHOLDER_EXPR:
5381 case BREAK_STMT:
5382 case CONTINUE_STMT:
5383 case REQUIRES_EXPR:
5384 case STATIC_ASSERT:
5385 case DEBUG_BEGIN_STMT:
5386 return true;
5387
5388 case PARM_DECL:
5389 if (now && want_rval)
5390 {
5391 tree type = TREE_TYPE (t);
5392 if (dependent_type_p (type)
5393 || is_really_empty_class (type))
5394 /* An empty class has no data to read. */
5395 return true;
5396 if (flags & tf_error)
5397 error ("%qE is not a constant expression", t);
5398 return false;
5399 }
5400 return true;
5401
5402 case AGGR_INIT_EXPR:
5403 case CALL_EXPR:
5404 /* -- an invocation of a function other than a constexpr function
5405 or a constexpr constructor. */
5406 {
5407 tree fun = get_function_named_in_call (t);
5408 const int nargs = call_expr_nargs (t);
5409 i = 0;
5410
5411 if (fun == NULL_TREE)
5412 {
5413 /* Reset to allow the function to continue past the end
5414 of the block below. Otherwise return early. */
5415 bool bail = true;
5416
5417 if (TREE_CODE (t) == CALL_EXPR
5418 && CALL_EXPR_FN (t) == NULL_TREE)
5419 switch (CALL_EXPR_IFN (t))
5420 {
5421 /* These should be ignored, they are optimized away from
5422 constexpr functions. */
5423 case IFN_UBSAN_NULL:
5424 case IFN_UBSAN_BOUNDS:
5425 case IFN_UBSAN_VPTR:
5426 case IFN_FALLTHROUGH:
5427 return true;
5428
5429 case IFN_ADD_OVERFLOW:
5430 case IFN_SUB_OVERFLOW:
5431 case IFN_MUL_OVERFLOW:
5432 case IFN_LAUNDER:
5433 bail = false;
5434
5435 default:
5436 break;
5437 }
5438
5439 if (bail)
5440 {
5441 /* fold_call_expr can't do anything with IFN calls. */
5442 if (flags & tf_error)
5443 error_at (loc, "call to internal function %qE", t);
5444 return false;
5445 }
5446 }
5447
5448 if (fun && is_overloaded_fn (fun))
5449 {
5450 if (TREE_CODE (fun) == FUNCTION_DECL)
5451 {
5452 if (builtin_valid_in_constant_expr_p (fun))
5453 return true;
5454 if (!DECL_DECLARED_CONSTEXPR_P (fun)
5455 /* Allow any built-in function; if the expansion
5456 isn't constant, we'll deal with that then. */
5457 && !is_builtin_fn (fun))
5458 {
5459 if (flags & tf_error)
5460 {
5461 error_at (loc, "call to non-%<constexpr%> function %qD",
5462 fun);
5463 explain_invalid_constexpr_fn (fun);
5464 }
5465 return false;
5466 }
5467 /* A call to a non-static member function takes the address
5468 of the object as the first argument. But in a constant
5469 expression the address will be folded away, so look
5470 through it now. */
5471 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
5472 && !DECL_CONSTRUCTOR_P (fun))
5473 {
5474 tree x = get_nth_callarg (t, 0);
5475 if (is_this_parameter (x))
5476 return true;
5477 /* Don't require an immediately constant value, as
5478 constexpr substitution might not use the value. */
5479 bool sub_now = false;
5480 if (!potential_constant_expression_1 (x, rval, strict,
5481 sub_now, flags))
5482 return false;
5483 i = 1;
5484 }
5485 }
5486 else
5487 {
5488 if (!RECUR (fun, true))
5489 return false;
5490 fun = get_first_fn (fun);
5491 }
5492 /* Skip initial arguments to base constructors. */
5493 if (DECL_BASE_CONSTRUCTOR_P (fun))
5494 i = num_artificial_parms_for (fun);
5495 fun = DECL_ORIGIN (fun);
5496 }
5497 else if (fun)
5498 {
5499 if (RECUR (fun, rval))
5500 /* Might end up being a constant function pointer. */;
5501 else
5502 return false;
5503 }
5504 for (; i < nargs; ++i)
5505 {
5506 tree x = get_nth_callarg (t, i);
5507 /* In a template, reference arguments haven't been converted to
5508 REFERENCE_TYPE and we might not even know if the parameter
5509 is a reference, so accept lvalue constants too. */
5510 bool rv = processing_template_decl ? any : rval;
5511 /* Don't require an immediately constant value, as constexpr
5512 substitution might not use the value of the argument. */
5513 bool sub_now = false;
5514 if (!potential_constant_expression_1 (x, rv, strict,
5515 sub_now, flags))
5516 return false;
5517 }
5518 return true;
5519 }
5520
5521 case NON_LVALUE_EXPR:
5522 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
5523 -- an lvalue of integral type that refers to a non-volatile
5524 const variable or static data member initialized with
5525 constant expressions, or
5526
5527 -- an lvalue of literal type that refers to non-volatile
5528 object defined with constexpr, or that refers to a
5529 sub-object of such an object; */
5530 return RECUR (TREE_OPERAND (t, 0), rval);
5531
5532 case VAR_DECL:
5533 if (DECL_HAS_VALUE_EXPR_P (t))
5534 {
5535 if (now && is_normal_capture_proxy (t))
5536 {
5537 /* -- in a lambda-expression, a reference to this or to a
5538 variable with automatic storage duration defined outside that
5539 lambda-expression, where the reference would be an
5540 odr-use. */
5541 if (flags & tf_error)
5542 {
5543 tree cap = DECL_CAPTURED_VARIABLE (t);
5544 error ("lambda capture of %qE is not a constant expression",
5545 cap);
5546 if (!want_rval && decl_constant_var_p (cap))
5547 inform (input_location, "because it is used as a glvalue");
5548 }
5549 return false;
5550 }
5551 return RECUR (DECL_VALUE_EXPR (t), rval);
5552 }
5553 if (want_rval
5554 && !var_in_maybe_constexpr_fn (t)
5555 && !type_dependent_expression_p (t)
5556 && !decl_maybe_constant_var_p (t)
5557 && (strict
5558 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t))
5559 || (DECL_INITIAL (t)
5560 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t)))
5561 && COMPLETE_TYPE_P (TREE_TYPE (t))
5562 && !is_really_empty_class (TREE_TYPE (t)))
5563 {
5564 if (flags & tf_error)
5565 non_const_var_error (t);
5566 return false;
5567 }
5568 return true;
5569
5570 case NOP_EXPR:
5571 case CONVERT_EXPR:
5572 case VIEW_CONVERT_EXPR:
5573 /* -- a reinterpret_cast. FIXME not implemented, and this rule
5574 may change to something more specific to type-punning (DR 1312). */
5575 {
5576 tree from = TREE_OPERAND (t, 0);
5577 if (POINTER_TYPE_P (TREE_TYPE (t))
5578 && TREE_CODE (from) == INTEGER_CST
5579 && !integer_zerop (from))
5580 {
5581 if (flags & tf_error)
5582 error_at (loc, "reinterpret_cast from integer to pointer");
5583 return false;
5584 }
5585 return (RECUR (from, TREE_CODE (t) != VIEW_CONVERT_EXPR));
5586 }
5587
5588 case ADDRESSOF_EXPR:
5589 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
5590 t = TREE_OPERAND (t, 0);
5591 goto handle_addr_expr;
5592
5593 case ADDR_EXPR:
5594 /* -- a unary operator & that is applied to an lvalue that
5595 designates an object with thread or automatic storage
5596 duration; */
5597 t = TREE_OPERAND (t, 0);
5598
5599 if (TREE_CODE (t) == OFFSET_REF && PTRMEM_OK_P (t))
5600 /* A pointer-to-member constant. */
5601 return true;
5602
5603 handle_addr_expr:
5604 #if 0
5605 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
5606 any checking here, as we might dereference the pointer later. If
5607 we remove this code, also remove check_automatic_or_tls. */
5608 i = check_automatic_or_tls (t);
5609 if (i == ck_ok)
5610 return true;
5611 if (i == ck_bad)
5612 {
5613 if (flags & tf_error)
5614 error ("address-of an object %qE with thread local or "
5615 "automatic storage is not a constant expression", t);
5616 return false;
5617 }
5618 #endif
5619 return RECUR (t, any);
5620
5621 case REALPART_EXPR:
5622 case IMAGPART_EXPR:
5623 case COMPONENT_REF:
5624 case BIT_FIELD_REF:
5625 case ARROW_EXPR:
5626 case OFFSET_REF:
5627 /* -- a class member access unless its postfix-expression is
5628 of literal type or of pointer to literal type. */
5629 /* This test would be redundant, as it follows from the
5630 postfix-expression being a potential constant expression. */
5631 if (type_unknown_p (t))
5632 return true;
5633 return RECUR (TREE_OPERAND (t, 0), want_rval);
5634
5635 case EXPR_PACK_EXPANSION:
5636 return RECUR (PACK_EXPANSION_PATTERN (t), want_rval);
5637
5638 case INDIRECT_REF:
5639 {
5640 tree x = TREE_OPERAND (t, 0);
5641 STRIP_NOPS (x);
5642 if (is_this_parameter (x) && !is_capture_proxy (x))
5643 {
5644 if (!var_in_maybe_constexpr_fn (x))
5645 {
5646 if (flags & tf_error)
5647 error_at (loc, "use of %<this%> in a constant expression");
5648 return false;
5649 }
5650 return true;
5651 }
5652 return RECUR (x, rval);
5653 }
5654
5655 case STATEMENT_LIST:
5656 {
5657 tree_stmt_iterator i;
5658 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
5659 {
5660 if (!RECUR (tsi_stmt (i), any))
5661 return false;
5662 }
5663 return true;
5664 }
5665 break;
5666
5667 case MODIFY_EXPR:
5668 if (cxx_dialect < cxx14)
5669 goto fail;
5670 if (!RECUR (TREE_OPERAND (t, 0), any))
5671 return false;
5672 if (!RECUR (TREE_OPERAND (t, 1), rval))
5673 return false;
5674 return true;
5675
5676 case MODOP_EXPR:
5677 if (cxx_dialect < cxx14)
5678 goto fail;
5679 if (!RECUR (TREE_OPERAND (t, 0), rval))
5680 return false;
5681 if (!RECUR (TREE_OPERAND (t, 2), rval))
5682 return false;
5683 return true;
5684
5685 case DO_STMT:
5686 if (!RECUR (DO_COND (t), rval))
5687 return false;
5688 if (!RECUR (DO_BODY (t), any))
5689 return false;
5690 return true;
5691
5692 case FOR_STMT:
5693 if (!RECUR (FOR_INIT_STMT (t), any))
5694 return false;
5695 if (!RECUR (FOR_COND (t), rval))
5696 return false;
5697 if (!RECUR (FOR_EXPR (t), any))
5698 return false;
5699 if (!RECUR (FOR_BODY (t), any))
5700 return false;
5701 return true;
5702
5703 case RANGE_FOR_STMT:
5704 if (!RECUR (RANGE_FOR_EXPR (t), any))
5705 return false;
5706 if (!RECUR (RANGE_FOR_BODY (t), any))
5707 return false;
5708 return true;
5709
5710 case WHILE_STMT:
5711 if (!RECUR (WHILE_COND (t), rval))
5712 return false;
5713 if (!RECUR (WHILE_BODY (t), any))
5714 return false;
5715 return true;
5716
5717 case SWITCH_STMT:
5718 if (!RECUR (SWITCH_STMT_COND (t), rval))
5719 return false;
5720 /* FIXME we don't check SWITCH_STMT_BODY currently, because even
5721 unreachable labels would be checked. */
5722 return true;
5723
5724 case STMT_EXPR:
5725 return RECUR (STMT_EXPR_STMT (t), rval);
5726
5727 case LAMBDA_EXPR:
5728 if (cxx_dialect >= cxx17)
5729 /* In C++17 lambdas can be constexpr, don't give up yet. */
5730 return true;
5731 else if (flags & tf_error)
5732 error_at (loc, "lambda-expression is not a constant expression "
5733 "before C++17");
5734 return false;
5735
5736 case DYNAMIC_CAST_EXPR:
5737 case PSEUDO_DTOR_EXPR:
5738 case NEW_EXPR:
5739 case VEC_NEW_EXPR:
5740 case DELETE_EXPR:
5741 case VEC_DELETE_EXPR:
5742 case THROW_EXPR:
5743 case OMP_PARALLEL:
5744 case OMP_TASK:
5745 case OMP_FOR:
5746 case OMP_SIMD:
5747 case OMP_DISTRIBUTE:
5748 case OMP_TASKLOOP:
5749 case OMP_TEAMS:
5750 case OMP_TARGET_DATA:
5751 case OMP_TARGET:
5752 case OMP_SECTIONS:
5753 case OMP_ORDERED:
5754 case OMP_CRITICAL:
5755 case OMP_SINGLE:
5756 case OMP_SECTION:
5757 case OMP_MASTER:
5758 case OMP_TASKGROUP:
5759 case OMP_TARGET_UPDATE:
5760 case OMP_TARGET_ENTER_DATA:
5761 case OMP_TARGET_EXIT_DATA:
5762 case OMP_ATOMIC:
5763 case OMP_ATOMIC_READ:
5764 case OMP_ATOMIC_CAPTURE_OLD:
5765 case OMP_ATOMIC_CAPTURE_NEW:
5766 case OACC_PARALLEL:
5767 case OACC_KERNELS:
5768 case OACC_DATA:
5769 case OACC_HOST_DATA:
5770 case OACC_LOOP:
5771 case OACC_CACHE:
5772 case OACC_DECLARE:
5773 case OACC_ENTER_DATA:
5774 case OACC_EXIT_DATA:
5775 case OACC_UPDATE:
5776 /* GCC internal stuff. */
5777 case VA_ARG_EXPR:
5778 case OBJ_TYPE_REF:
5779 case TRANSACTION_EXPR:
5780 case ASM_EXPR:
5781 case AT_ENCODE_EXPR:
5782 fail:
5783 if (flags & tf_error)
5784 error_at (loc, "expression %qE is not a constant expression", t);
5785 return false;
5786
5787 case TYPEID_EXPR:
5788 /* -- a typeid expression whose operand is of polymorphic
5789 class type; */
5790 {
5791 tree e = TREE_OPERAND (t, 0);
5792 if (!TYPE_P (e) && !type_dependent_expression_p (e)
5793 && TYPE_POLYMORPHIC_P (TREE_TYPE (e)))
5794 {
5795 if (flags & tf_error)
5796 error_at (loc, "typeid-expression is not a constant expression "
5797 "because %qE is of polymorphic type", e);
5798 return false;
5799 }
5800 return true;
5801 }
5802
5803 case POINTER_DIFF_EXPR:
5804 case MINUS_EXPR:
5805 want_rval = true;
5806 goto binary;
5807
5808 case LT_EXPR:
5809 case LE_EXPR:
5810 case GT_EXPR:
5811 case GE_EXPR:
5812 case EQ_EXPR:
5813 case NE_EXPR:
5814 want_rval = true;
5815 goto binary;
5816
5817 case PREINCREMENT_EXPR:
5818 case POSTINCREMENT_EXPR:
5819 case PREDECREMENT_EXPR:
5820 case POSTDECREMENT_EXPR:
5821 if (cxx_dialect < cxx14)
5822 goto fail;
5823 goto unary;
5824
5825 case BIT_NOT_EXPR:
5826 /* A destructor. */
5827 if (TYPE_P (TREE_OPERAND (t, 0)))
5828 return true;
5829 /* fall through. */
5830
5831 case CONJ_EXPR:
5832 case SAVE_EXPR:
5833 case FIX_TRUNC_EXPR:
5834 case FLOAT_EXPR:
5835 case NEGATE_EXPR:
5836 case ABS_EXPR:
5837 case TRUTH_NOT_EXPR:
5838 case FIXED_CONVERT_EXPR:
5839 case UNARY_PLUS_EXPR:
5840 case UNARY_LEFT_FOLD_EXPR:
5841 case UNARY_RIGHT_FOLD_EXPR:
5842 unary:
5843 return RECUR (TREE_OPERAND (t, 0), rval);
5844
5845 case CAST_EXPR:
5846 case CONST_CAST_EXPR:
5847 case STATIC_CAST_EXPR:
5848 case REINTERPRET_CAST_EXPR:
5849 case IMPLICIT_CONV_EXPR:
5850 if (cxx_dialect < cxx11
5851 && !dependent_type_p (TREE_TYPE (t))
5852 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t)))
5853 /* In C++98, a conversion to non-integral type can't be part of a
5854 constant expression. */
5855 {
5856 if (flags & tf_error)
5857 error_at (loc,
5858 "cast to non-integral type %qT in a constant expression",
5859 TREE_TYPE (t));
5860 return false;
5861 }
5862 /* This might be a conversion from a class to a (potentially) literal
5863 type. Let's consider it potentially constant since the conversion
5864 might be a constexpr user-defined conversion. */
5865 else if (cxx_dialect >= cxx11
5866 && (dependent_type_p (TREE_TYPE (t))
5867 || !COMPLETE_TYPE_P (TREE_TYPE (t))
5868 || literal_type_p (TREE_TYPE (t)))
5869 && TREE_OPERAND (t, 0))
5870 {
5871 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
5872 /* If this is a dependent type, it could end up being a class
5873 with conversions. */
5874 if (type == NULL_TREE || WILDCARD_TYPE_P (type))
5875 return true;
5876 /* Or a non-dependent class which has conversions. */
5877 else if (CLASS_TYPE_P (type)
5878 && (TYPE_HAS_CONVERSION (type) || dependent_scope_p (type)))
5879 return true;
5880 }
5881
5882 return (RECUR (TREE_OPERAND (t, 0),
5883 TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE));
5884
5885 case BIND_EXPR:
5886 return RECUR (BIND_EXPR_BODY (t), want_rval);
5887
5888 case CLEANUP_POINT_EXPR:
5889 case MUST_NOT_THROW_EXPR:
5890 case TRY_CATCH_EXPR:
5891 case TRY_BLOCK:
5892 case EH_SPEC_BLOCK:
5893 case EXPR_STMT:
5894 case PAREN_EXPR:
5895 case NON_DEPENDENT_EXPR:
5896 /* For convenience. */
5897 case RETURN_EXPR:
5898 case LOOP_EXPR:
5899 case EXIT_EXPR:
5900 return RECUR (TREE_OPERAND (t, 0), want_rval);
5901
5902 case DECL_EXPR:
5903 tmp = DECL_EXPR_DECL (t);
5904 if (VAR_P (tmp) && !DECL_ARTIFICIAL (tmp))
5905 {
5906 if (TREE_STATIC (tmp))
5907 {
5908 if (flags & tf_error)
5909 error_at (DECL_SOURCE_LOCATION (tmp), "%qD declared "
5910 "%<static%> in %<constexpr%> context", tmp);
5911 return false;
5912 }
5913 else if (CP_DECL_THREAD_LOCAL_P (tmp))
5914 {
5915 if (flags & tf_error)
5916 error_at (DECL_SOURCE_LOCATION (tmp), "%qD declared "
5917 "%<thread_local%> in %<constexpr%> context", tmp);
5918 return false;
5919 }
5920 else if (!check_for_uninitialized_const_var
5921 (tmp, /*constexpr_context_p=*/true, flags))
5922 return false;
5923 }
5924 return RECUR (tmp, want_rval);
5925
5926 case TRY_FINALLY_EXPR:
5927 return (RECUR (TREE_OPERAND (t, 0), want_rval)
5928 && RECUR (TREE_OPERAND (t, 1), any));
5929
5930 case SCOPE_REF:
5931 return RECUR (TREE_OPERAND (t, 1), want_rval);
5932
5933 case TARGET_EXPR:
5934 if (!TARGET_EXPR_DIRECT_INIT_P (t)
5935 && !literal_type_p (TREE_TYPE (t)))
5936 {
5937 if (flags & tf_error)
5938 {
5939 error_at (loc, "temporary of non-literal type %qT in a "
5940 "constant expression", TREE_TYPE (t));
5941 explain_non_literal_class (TREE_TYPE (t));
5942 }
5943 return false;
5944 }
5945 /* FALLTHRU */
5946 case INIT_EXPR:
5947 return RECUR (TREE_OPERAND (t, 1), rval);
5948
5949 case CONSTRUCTOR:
5950 {
5951 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
5952 constructor_elt *ce;
5953 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
5954 if (!RECUR (ce->value, want_rval))
5955 return false;
5956 return true;
5957 }
5958
5959 case TREE_LIST:
5960 {
5961 gcc_assert (TREE_PURPOSE (t) == NULL_TREE
5962 || DECL_P (TREE_PURPOSE (t)));
5963 if (!RECUR (TREE_VALUE (t), want_rval))
5964 return false;
5965 if (TREE_CHAIN (t) == NULL_TREE)
5966 return true;
5967 return RECUR (TREE_CHAIN (t), want_rval);
5968 }
5969
5970 case TRUNC_DIV_EXPR:
5971 case CEIL_DIV_EXPR:
5972 case FLOOR_DIV_EXPR:
5973 case ROUND_DIV_EXPR:
5974 case TRUNC_MOD_EXPR:
5975 case CEIL_MOD_EXPR:
5976 case ROUND_MOD_EXPR:
5977 {
5978 tree denom = TREE_OPERAND (t, 1);
5979 if (!RECUR (denom, rval))
5980 return false;
5981 /* We can't call cxx_eval_outermost_constant_expr on an expression
5982 that hasn't been through instantiate_non_dependent_expr yet. */
5983 if (!processing_template_decl)
5984 denom = cxx_eval_outermost_constant_expr (denom, true);
5985 if (integer_zerop (denom))
5986 {
5987 if (flags & tf_error)
5988 error ("division by zero is not a constant expression");
5989 return false;
5990 }
5991 else
5992 {
5993 want_rval = true;
5994 return RECUR (TREE_OPERAND (t, 0), want_rval);
5995 }
5996 }
5997
5998 case COMPOUND_EXPR:
5999 {
6000 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6001 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6002 introduced by build_call_a. */
6003 tree op0 = TREE_OPERAND (t, 0);
6004 tree op1 = TREE_OPERAND (t, 1);
6005 STRIP_NOPS (op1);
6006 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
6007 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
6008 return RECUR (op0, want_rval);
6009 else
6010 goto binary;
6011 }
6012
6013 /* If the first operand is the non-short-circuit constant, look at
6014 the second operand; otherwise we only care about the first one for
6015 potentiality. */
6016 case TRUTH_AND_EXPR:
6017 case TRUTH_ANDIF_EXPR:
6018 tmp = boolean_true_node;
6019 goto truth;
6020 case TRUTH_OR_EXPR:
6021 case TRUTH_ORIF_EXPR:
6022 tmp = boolean_false_node;
6023 truth:
6024 {
6025 tree op = TREE_OPERAND (t, 0);
6026 if (!RECUR (op, rval))
6027 return false;
6028 if (!processing_template_decl)
6029 op = cxx_eval_outermost_constant_expr (op, true);
6030 if (tree_int_cst_equal (op, tmp))
6031 return RECUR (TREE_OPERAND (t, 1), rval);
6032 else
6033 return true;
6034 }
6035
6036 case PLUS_EXPR:
6037 case MULT_EXPR:
6038 case POINTER_PLUS_EXPR:
6039 case RDIV_EXPR:
6040 case EXACT_DIV_EXPR:
6041 case MIN_EXPR:
6042 case MAX_EXPR:
6043 case LSHIFT_EXPR:
6044 case RSHIFT_EXPR:
6045 case LROTATE_EXPR:
6046 case RROTATE_EXPR:
6047 case BIT_IOR_EXPR:
6048 case BIT_XOR_EXPR:
6049 case BIT_AND_EXPR:
6050 case TRUTH_XOR_EXPR:
6051 case UNORDERED_EXPR:
6052 case ORDERED_EXPR:
6053 case UNLT_EXPR:
6054 case UNLE_EXPR:
6055 case UNGT_EXPR:
6056 case UNGE_EXPR:
6057 case UNEQ_EXPR:
6058 case LTGT_EXPR:
6059 case RANGE_EXPR:
6060 case COMPLEX_EXPR:
6061 want_rval = true;
6062 /* Fall through. */
6063 case ARRAY_REF:
6064 case ARRAY_RANGE_REF:
6065 case MEMBER_REF:
6066 case DOTSTAR_EXPR:
6067 case MEM_REF:
6068 case BINARY_LEFT_FOLD_EXPR:
6069 case BINARY_RIGHT_FOLD_EXPR:
6070 binary:
6071 for (i = 0; i < 2; ++i)
6072 if (!RECUR (TREE_OPERAND (t, i), want_rval))
6073 return false;
6074 return true;
6075
6076 case FMA_EXPR:
6077 case VEC_PERM_EXPR:
6078 for (i = 0; i < 3; ++i)
6079 if (!RECUR (TREE_OPERAND (t, i), true))
6080 return false;
6081 return true;
6082
6083 case COND_EXPR:
6084 if (COND_EXPR_IS_VEC_DELETE (t))
6085 {
6086 if (flags & tf_error)
6087 error_at (loc, "%<delete[]%> is not a constant expression");
6088 return false;
6089 }
6090 /* Fall through. */
6091 case IF_STMT:
6092 case VEC_COND_EXPR:
6093 /* If the condition is a known constant, we know which of the legs we
6094 care about; otherwise we only require that the condition and
6095 either of the legs be potentially constant. */
6096 tmp = TREE_OPERAND (t, 0);
6097 if (!RECUR (tmp, rval))
6098 return false;
6099 if (!processing_template_decl)
6100 tmp = cxx_eval_outermost_constant_expr (tmp, true);
6101 if (integer_zerop (tmp))
6102 return RECUR (TREE_OPERAND (t, 2), want_rval);
6103 else if (TREE_CODE (tmp) == INTEGER_CST)
6104 return RECUR (TREE_OPERAND (t, 1), want_rval);
6105 for (i = 1; i < 3; ++i)
6106 if (potential_constant_expression_1 (TREE_OPERAND (t, i),
6107 want_rval, strict, now, tf_none))
6108 return true;
6109 if (flags & tf_error)
6110 error_at (loc, "expression %qE is not a constant expression", t);
6111 return false;
6112
6113 case VEC_INIT_EXPR:
6114 if (VEC_INIT_EXPR_IS_CONSTEXPR (t))
6115 return true;
6116 if (flags & tf_error)
6117 {
6118 error_at (loc, "non-constant array initialization");
6119 diagnose_non_constexpr_vec_init (t);
6120 }
6121 return false;
6122
6123 case TYPE_DECL:
6124 case TAG_DEFN:
6125 /* We can see these in statement-expressions. */
6126 return true;
6127
6128 case CLEANUP_STMT:
6129 case EMPTY_CLASS_EXPR:
6130 case PREDICT_EXPR:
6131 return false;
6132
6133 case GOTO_EXPR:
6134 {
6135 tree *target = &TREE_OPERAND (t, 0);
6136 /* Gotos representing break and continue are OK. */
6137 if (breaks (target) || continues (target))
6138 return true;
6139 if (flags & tf_error)
6140 error_at (loc, "%<goto%> is not a constant expression");
6141 return false;
6142 }
6143
6144 case ANNOTATE_EXPR:
6145 return RECUR (TREE_OPERAND (t, 0), rval);
6146
6147 default:
6148 if (objc_is_property_ref (t))
6149 return false;
6150
6151 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t)));
6152 gcc_unreachable ();
6153 return false;
6154 }
6155 #undef RECUR
6156 }
6157
6158 /* The main entry point to the above. */
6159
6160 bool
potential_constant_expression(tree t)6161 potential_constant_expression (tree t)
6162 {
6163 return potential_constant_expression_1 (t, false, true, false, tf_none);
6164 }
6165
6166 /* As above, but require a constant rvalue. */
6167
6168 bool
potential_rvalue_constant_expression(tree t)6169 potential_rvalue_constant_expression (tree t)
6170 {
6171 return potential_constant_expression_1 (t, true, true, false, tf_none);
6172 }
6173
6174 /* Like above, but complain about non-constant expressions. */
6175
6176 bool
require_potential_constant_expression(tree t)6177 require_potential_constant_expression (tree t)
6178 {
6179 return potential_constant_expression_1 (t, false, true, false,
6180 tf_warning_or_error);
6181 }
6182
6183 /* Cross product of the above. */
6184
6185 bool
require_potential_rvalue_constant_expression(tree t)6186 require_potential_rvalue_constant_expression (tree t)
6187 {
6188 return potential_constant_expression_1 (t, true, true, false,
6189 tf_warning_or_error);
6190 }
6191
6192 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */
6193
6194 bool
require_rvalue_constant_expression(tree t)6195 require_rvalue_constant_expression (tree t)
6196 {
6197 return potential_constant_expression_1 (t, true, true, true,
6198 tf_warning_or_error);
6199 }
6200
6201 /* Like potential_constant_expression, but don't consider possible constexpr
6202 substitution of the current function. That is, PARM_DECL qualifies under
6203 potential_constant_expression, but not here.
6204
6205 This is basically what you can check when any actual constant values might
6206 be value-dependent. */
6207
6208 bool
is_constant_expression(tree t)6209 is_constant_expression (tree t)
6210 {
6211 return potential_constant_expression_1 (t, false, true, true, tf_none);
6212 }
6213
6214 /* Like above, but complain about non-constant expressions. */
6215
6216 bool
require_constant_expression(tree t)6217 require_constant_expression (tree t)
6218 {
6219 return potential_constant_expression_1 (t, false, true, true,
6220 tf_warning_or_error);
6221 }
6222
6223 /* Like is_constant_expression, but allow const variables that are not allowed
6224 under constexpr rules. */
6225
6226 bool
is_static_init_expression(tree t)6227 is_static_init_expression (tree t)
6228 {
6229 return potential_constant_expression_1 (t, false, false, true, tf_none);
6230 }
6231
6232 /* Returns true if T is a potential constant expression that is not
6233 instantiation-dependent, and therefore a candidate for constant folding even
6234 in a template. */
6235
6236 bool
is_nondependent_constant_expression(tree t)6237 is_nondependent_constant_expression (tree t)
6238 {
6239 return (!type_unknown_p (t)
6240 && !BRACE_ENCLOSED_INITIALIZER_P (t)
6241 && is_constant_expression (t)
6242 && !instantiation_dependent_expression_p (t));
6243 }
6244
6245 /* Returns true if T is a potential static initializer expression that is not
6246 instantiation-dependent. */
6247
6248 bool
is_nondependent_static_init_expression(tree t)6249 is_nondependent_static_init_expression (tree t)
6250 {
6251 return (!type_unknown_p (t)
6252 && !BRACE_ENCLOSED_INITIALIZER_P (t)
6253 && is_static_init_expression (t)
6254 && !instantiation_dependent_expression_p (t));
6255 }
6256
6257 /* Finalize constexpr processing after parsing. */
6258
6259 void
fini_constexpr(void)6260 fini_constexpr (void)
6261 {
6262 /* The contexpr call and fundef copies tables are no longer needed. */
6263 constexpr_call_table = NULL;
6264 fundef_copies_table = NULL;
6265 }
6266
6267 #include "gt-cp-constexpr.h"
6268