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