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-2017 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
19You should have received a copy of the GNU General Public License
20along 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
37static bool verify_constant (tree, bool, bool *, bool *);
38#define VERIFY_CONSTANT(X) \
39do { \
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
47bool
48is_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
58bool
59literal_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 the DECL if OK, otherwise NULL. */
79
80tree
81ensure_literal_type_for_constexpr_object (tree decl)
82{
83 tree type = TREE_TYPE (decl);
84 if (VAR_P (decl)
85 && (DECL_DECLARED_CONSTEXPR_P (decl)
86 || var_in_constexpr_fn (decl))
87 && !processing_template_decl)
88 {
89 tree stype = strip_array_types (type);
90 if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype)))
91 /* Don't complain here, we'll complain about incompleteness
92 when we try to initialize the variable. */;
93 else if (!literal_type_p (type))
94 {
95 if (DECL_DECLARED_CONSTEXPR_P (decl))
96 {
97 error ("the type %qT of %<constexpr%> variable %qD "
98 "is not literal", type, decl);
99 explain_non_literal_class (type);
100 }
101 else
102 {
103 if (!is_instantiation_of_constexpr (current_function_decl))
104 {
105 error ("variable %qD of non-literal type %qT in %<constexpr%> "
106 "function", decl, type);
107 explain_non_literal_class (type);
108 }
109 cp_function_chain->invalid_constexpr = true;
110 }
111 return NULL;
112 }
113 }
114 return decl;
115}
116
117/* Representation of entries in the constexpr function definition table. */
118
119struct GTY((for_user)) constexpr_fundef {
120 tree decl;
121 tree body;
122};
123
124struct constexpr_fundef_hasher : ggc_ptr_hash<constexpr_fundef>
125{
126 static hashval_t hash (constexpr_fundef *);
127 static bool equal (constexpr_fundef *, constexpr_fundef *);
128};
129
130/* This table holds all constexpr function definitions seen in
131 the current translation unit. */
132
133static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table;
134
135/* Utility function used for managing the constexpr function table.
136 Return true if the entries pointed to by P and Q are for the
137 same constexpr function. */
138
139inline bool
140constexpr_fundef_hasher::equal (constexpr_fundef *lhs, constexpr_fundef *rhs)
141{
142 return lhs->decl == rhs->decl;
143}
144
145/* Utility function used for managing the constexpr function table.
146 Return a hash value for the entry pointed to by Q. */
147
148inline hashval_t
149constexpr_fundef_hasher::hash (constexpr_fundef *fundef)
150{
151 return DECL_UID (fundef->decl);
152}
153
154/* Return a previously saved definition of function FUN. */
155
156static constexpr_fundef *
157retrieve_constexpr_fundef (tree fun)
158{
159 constexpr_fundef fundef = { NULL, NULL };
160 if (constexpr_fundef_table == NULL)
161 return NULL;
162
163 fundef.decl = fun;
164 return constexpr_fundef_table->find (&fundef);
165}
166
167/* Check whether the parameter and return types of FUN are valid for a
168 constexpr function, and complain if COMPLAIN. */
169
170bool
171is_valid_constexpr_fn (tree fun, bool complain)
172{
173 bool ret = true;
174
175 if (DECL_INHERITED_CTOR (fun)
176 && TREE_CODE (fun) == TEMPLATE_DECL)
177 {
178 ret = false;
179 if (complain)
180 error ("inherited constructor %qD is not %<constexpr%>",
181 DECL_INHERITED_CTOR (fun));
182 }
183 else
184 {
185 for (tree parm = FUNCTION_FIRST_USER_PARM (fun);
186 parm != NULL_TREE; parm = TREE_CHAIN (parm))
187 if (!literal_type_p (TREE_TYPE (parm)))
188 {
189 ret = false;
190 if (complain)
191 {
192 error ("invalid type for parameter %d of %<constexpr%> "
193 "function %q+#D", DECL_PARM_INDEX (parm), fun);
194 explain_non_literal_class (TREE_TYPE (parm));
195 }
196 }
197 }
198
199 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)) && cxx_dialect < cxx17)
200 {
201 ret = false;
202 if (complain)
203 inform (DECL_SOURCE_LOCATION (fun),
204 "lambdas are implicitly %<constexpr%> only in C++17 and later");
205 }
206 else if (!DECL_CONSTRUCTOR_P (fun))
207 {
208 tree rettype = TREE_TYPE (TREE_TYPE (fun));
209 if (!literal_type_p (rettype))
210 {
211 ret = false;
212 if (complain)
213 {
214 error ("invalid return type %qT of %<constexpr%> function %q+D",
215 rettype, fun);
216 explain_non_literal_class (rettype);
217 }
218 }
219
220 /* C++14 DR 1684 removed this restriction. */
221 if (cxx_dialect < cxx14
222 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
223 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
224 {
225 ret = false;
226 if (complain
227 && pedwarn (DECL_SOURCE_LOCATION (fun), OPT_Wpedantic,
228 "enclosing class of %<constexpr%> non-static member "
229 "function %q+#D is not a literal type", fun))
230 explain_non_literal_class (DECL_CONTEXT (fun));
231 }
232 }
233 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
234 {
235 ret = false;
236 if (complain)
237 error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
238 }
239
240 return ret;
241}
242
243/* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
244 for a member of an anonymous aggregate, INIT is the initializer for that
245 member, and VEC_OUTER is the vector of constructor elements for the class
246 whose constructor we are processing. Add the initializer to the vector
247 and return true to indicate success. */
248
249static bool
250build_anon_member_initialization (tree member, tree init,
251 vec<constructor_elt, va_gc> **vec_outer)
252{
253 /* MEMBER presents the relevant fields from the inside out, but we need
254 to build up the initializer from the outside in so that we can reuse
255 previously built CONSTRUCTORs if this is, say, the second field in an
256 anonymous struct. So we use a vec as a stack. */
257 auto_vec<tree, 2> fields;
258 do
259 {
260 fields.safe_push (TREE_OPERAND (member, 1));
261 member = TREE_OPERAND (member, 0);
262 }
263 while (ANON_AGGR_TYPE_P (TREE_TYPE (member))
264 && TREE_CODE (member) == COMPONENT_REF);
265
266 /* VEC has the constructor elements vector for the context of FIELD.
267 If FIELD is an anonymous aggregate, we will push inside it. */
268 vec<constructor_elt, va_gc> **vec = vec_outer;
269 tree field;
270 while (field = fields.pop(),
271 ANON_AGGR_TYPE_P (TREE_TYPE (field)))
272 {
273 tree ctor;
274 /* If there is already an outer constructor entry for the anonymous
275 aggregate FIELD, use it; otherwise, insert one. */
276 if (vec_safe_is_empty (*vec)
277 || (*vec)->last().index != field)
278 {
279 ctor = build_constructor (TREE_TYPE (field), NULL);
280 CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
281 }
282 else
283 ctor = (*vec)->last().value;
284 vec = &CONSTRUCTOR_ELTS (ctor);
285 }
286
287 /* Now we're at the innermost field, the one that isn't an anonymous
288 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
289 gcc_assert (fields.is_empty());
290 CONSTRUCTOR_APPEND_ELT (*vec, field, init);
291
292 return true;
293}
294
295/* Subroutine of build_constexpr_constructor_member_initializers.
296 The expression tree T represents a data member initialization
297 in a (constexpr) constructor definition. Build a pairing of
298 the data member with its initializer, and prepend that pair
299 to the existing initialization pair INITS. */
300
301static bool
302build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
303{
304 tree member, init;
305 if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
306 t = TREE_OPERAND (t, 0);
307 if (TREE_CODE (t) == EXPR_STMT)
308 t = TREE_OPERAND (t, 0);
309 if (t == error_mark_node)
310 return false;
311 if (TREE_CODE (t) == STATEMENT_LIST)
312 {
313 tree_stmt_iterator i;
314 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
315 {
316 if (! build_data_member_initialization (tsi_stmt (i), vec))
317 return false;
318 }
319 return true;
320 }
321 if (TREE_CODE (t) == CLEANUP_STMT)
322 {
323 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
324 but we can in a constexpr constructor for a non-literal class. Just
325 ignore it; either all the initialization will be constant, in which
326 case the cleanup can't run, or it can't be constexpr.
327 Still recurse into CLEANUP_BODY. */
328 return build_data_member_initialization (CLEANUP_BODY (t), vec);
329 }
330 if (TREE_CODE (t) == CONVERT_EXPR)
331 t = TREE_OPERAND (t, 0);
332 if (TREE_CODE (t) == INIT_EXPR
333 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
334 use what this function builds for cx_check_missing_mem_inits, and
335 assignment in the ctor body doesn't count. */
336 || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR))
337 {
338 member = TREE_OPERAND (t, 0);
339 init = break_out_target_exprs (TREE_OPERAND (t, 1));
340 }
341 else if (TREE_CODE (t) == CALL_EXPR)
342 {
343 tree fn = get_callee_fndecl (t);
344 if (!fn || !DECL_CONSTRUCTOR_P (fn))
345 /* We're only interested in calls to subobject constructors. */
346 return true;
347 member = CALL_EXPR_ARG (t, 0);
348 /* We don't use build_cplus_new here because it complains about
349 abstract bases. Leaving the call unwrapped means that it has the
350 wrong type, but cxx_eval_constant_expression doesn't care. */
351 init = break_out_target_exprs (t);
352 }
353 else if (TREE_CODE (t) == BIND_EXPR)
354 return build_data_member_initialization (BIND_EXPR_BODY (t), vec);
355 else
356 /* Don't add anything else to the CONSTRUCTOR. */
357 return true;
358 if (INDIRECT_REF_P (member))
359 member = TREE_OPERAND (member, 0);
360 if (TREE_CODE (member) == NOP_EXPR)
361 {
362 tree op = member;
363 STRIP_NOPS (op);
364 if (TREE_CODE (op) == ADDR_EXPR)
365 {
366 gcc_assert (same_type_ignoring_top_level_qualifiers_p
367 (TREE_TYPE (TREE_TYPE (op)),
368 TREE_TYPE (TREE_TYPE (member))));
369 /* Initializing a cv-qualified member; we need to look through
370 the const_cast. */
371 member = op;
372 }
373 else if (op == current_class_ptr
374 && (same_type_ignoring_top_level_qualifiers_p
375 (TREE_TYPE (TREE_TYPE (member)),
376 current_class_type)))
377 /* Delegating constructor. */
378 member = op;
379 else
380 {
381 /* This is an initializer for an empty base; keep it for now so
382 we can check it in cxx_eval_bare_aggregate. */
383 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
384 }
385 }
386 if (TREE_CODE (member) == ADDR_EXPR)
387 member = TREE_OPERAND (member, 0);
388 if (TREE_CODE (member) == COMPONENT_REF)
389 {
390 tree aggr = TREE_OPERAND (member, 0);
391 if (TREE_CODE (aggr) == VAR_DECL)
392 /* Initializing a local variable, don't add anything. */
393 return true;
394 if (TREE_CODE (aggr) != COMPONENT_REF)
395 /* Normal member initialization. */
396 member = TREE_OPERAND (member, 1);
397 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
398 /* Initializing a member of an anonymous union. */
399 return build_anon_member_initialization (member, init, vec);
400 else
401 /* We're initializing a vtable pointer in a base. Leave it as
402 COMPONENT_REF so we remember the path to get to the vfield. */
403 gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
404 }
405
406 /* Value-initialization can produce multiple initializers for the
407 same field; use the last one. */
408 if (!vec_safe_is_empty (*vec) && (*vec)->last().index == member)
409 (*vec)->last().value = init;
410 else
411 CONSTRUCTOR_APPEND_ELT (*vec, member, init);
412 return true;
413}
414
415/* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
416 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
417 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
418
419static bool
420check_constexpr_bind_expr_vars (tree t)
421{
422 gcc_assert (TREE_CODE (t) == BIND_EXPR);
423
424 for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var))
425 if (TREE_CODE (var) == TYPE_DECL
426 && DECL_IMPLICIT_TYPEDEF_P (var)
427 && !LAMBDA_TYPE_P (TREE_TYPE (var)))
428 return false;
429 return true;
430}
431
432/* Subroutine of check_constexpr_ctor_body. */
433
434static bool
435check_constexpr_ctor_body_1 (tree last, tree list)
436{
437 switch (TREE_CODE (list))
438 {
439 case DECL_EXPR:
440 if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL
441 || TREE_CODE (DECL_EXPR_DECL (list)) == TYPE_DECL)
442 return true;
443 return false;
444
445 case CLEANUP_POINT_EXPR:
446 return check_constexpr_ctor_body (last, TREE_OPERAND (list, 0),
447 /*complain=*/false);
448
449 case BIND_EXPR:
450 if (!check_constexpr_bind_expr_vars (list)
451 || !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list),
452 /*complain=*/false))
453 return false;
454 return true;
455
456 case USING_STMT:
457 case STATIC_ASSERT:
458 case DEBUG_BEGIN_STMT:
459 return true;
460
461 default:
462 return false;
463 }
464}
465
466/* Make sure that there are no statements after LAST in the constructor
467 body represented by LIST. */
468
469bool
470check_constexpr_ctor_body (tree last, tree list, bool complain)
471{
472 /* C++14 doesn't require a constexpr ctor to have an empty body. */
473 if (cxx_dialect >= cxx14)
474 return true;
475
476 bool ok = true;
477 if (TREE_CODE (list) == STATEMENT_LIST)
478 {
479 tree_stmt_iterator i = tsi_last (list);
480 for (; !tsi_end_p (i); tsi_prev (&i))
481 {
482 tree t = tsi_stmt (i);
483 if (t == last)
484 break;
485 if (!check_constexpr_ctor_body_1 (last, t))
486 {
487 ok = false;
488 break;
489 }
490 }
491 }
492 else if (list != last
493 && !check_constexpr_ctor_body_1 (last, list))
494 ok = false;
495 if (!ok)
496 {
497 if (complain)
498 error ("%<constexpr%> constructor does not have empty body");
499 DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
500 }
501 return ok;
502}
503
504/* V is a vector of constructor elements built up for the base and member
505 initializers of a constructor for TYPE. They need to be in increasing
506 offset order, which they might not be yet if TYPE has a primary base
507 which is not first in the base-clause or a vptr and at least one base
508 all of which are non-primary. */
509
510static vec<constructor_elt, va_gc> *
511sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
512{
513 tree pri = CLASSTYPE_PRIMARY_BINFO (type);
514 tree field_type;
515 unsigned i;
516 constructor_elt *ce;
517
518 if (pri)
519 field_type = BINFO_TYPE (pri);
520 else if (TYPE_CONTAINS_VPTR_P (type))
521 field_type = vtbl_ptr_type_node;
522 else
523 return v;
524
525 /* Find the element for the primary base or vptr and move it to the
526 beginning of the vec. */
527 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
528 if (TREE_TYPE (ce->index) == field_type)
529 break;
530
531 if (i > 0 && i < vec_safe_length (v))
532 {
533 vec<constructor_elt, va_gc> &vref = *v;
534 constructor_elt elt = vref[i];
535 for (; i > 0; --i)
536 vref[i] = vref[i-1];
537 vref[0] = elt;
538 }
539
540 return v;
541}
542
543/* Build compile-time evalable representations of member-initializer list
544 for a constexpr constructor. */
545
546static tree
547build_constexpr_constructor_member_initializers (tree type, tree body)
548{
549 vec<constructor_elt, va_gc> *vec = NULL;
550 bool ok = true;
551 while (true)
552 switch (TREE_CODE (body))
553 {
554 case MUST_NOT_THROW_EXPR:
555 case EH_SPEC_BLOCK:
556 body = TREE_OPERAND (body, 0);
557 break;
558
559 case STATEMENT_LIST:
560 for (tree_stmt_iterator i = tsi_start (body);
561 !tsi_end_p (i); tsi_next (&i))
562 {
563 body = tsi_stmt (i);
564 if (TREE_CODE (body) == BIND_EXPR)
565 break;
566 }
567 break;
568
569 case BIND_EXPR:
570 body = BIND_EXPR_BODY (body);
571 goto found;
572
573 default:
574 gcc_unreachable ();
575 }
576 found:
577 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
578 {
579 body = TREE_OPERAND (body, 0);
580 if (TREE_CODE (body) == EXPR_STMT)
581 body = TREE_OPERAND (body, 0);
582 if (TREE_CODE (body) == INIT_EXPR
583 && (same_type_ignoring_top_level_qualifiers_p
584 (TREE_TYPE (TREE_OPERAND (body, 0)),
585 current_class_type)))
586 {
587 /* Trivial copy. */
588 return TREE_OPERAND (body, 1);
589 }
590 ok = build_data_member_initialization (body, &vec);
591 }
592 else if (TREE_CODE (body) == STATEMENT_LIST)
593 {
594 tree_stmt_iterator i;
595 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
596 {
597 ok = build_data_member_initialization (tsi_stmt (i), &vec);
598 if (!ok)
599 break;
600 }
601 }
602 else if (TREE_CODE (body) == TRY_BLOCK)
603 {
604 error ("body of %<constexpr%> constructor cannot be "
605 "a function-try-block");
606 return error_mark_node;
607 }
608 else if (EXPR_P (body))
609 ok = build_data_member_initialization (body, &vec);
610 else
611 gcc_assert (errorcount > 0);
612 if (ok)
613 {
614 if (vec_safe_length (vec) > 0)
615 {
616 /* In a delegating constructor, return the target. */
617 constructor_elt *ce = &(*vec)[0];
618 if (ce->index == current_class_ptr)
619 {
620 body = ce->value;
621 vec_free (vec);
622 return body;
623 }
624 }
625 vec = sort_constexpr_mem_initializers (type, vec);
626 return build_constructor (type, vec);
627 }
628 else
629 return error_mark_node;
630}
631
632/* We have an expression tree T that represents a call, either CALL_EXPR
633 or AGGR_INIT_EXPR. If the call is lexically to a named function,
634 retrun the _DECL for that function. */
635
636static tree
637get_function_named_in_call (tree t)
638{
639 tree fun = cp_get_callee (t);
640 if (fun && TREE_CODE (fun) == ADDR_EXPR
641 && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
642 fun = TREE_OPERAND (fun, 0);
643 return fun;
644}
645
646/* Subroutine of register_constexpr_fundef. BODY is the body of a function
647 declared to be constexpr, or a sub-statement thereof. Returns the
648 return value if suitable, error_mark_node for a statement not allowed in
649 a constexpr function, or NULL_TREE if no return value was found. */
650
651static tree
652constexpr_fn_retval (tree body)
653{
654 switch (TREE_CODE (body))
655 {
656 case STATEMENT_LIST:
657 {
658 tree_stmt_iterator i;
659 tree expr = NULL_TREE;
660 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
661 {
662 tree s = constexpr_fn_retval (tsi_stmt (i));
663 if (s == error_mark_node)
664 return error_mark_node;
665 else if (s == NULL_TREE)
666 /* Keep iterating. */;
667 else if (expr)
668 /* Multiple return statements. */
669 return error_mark_node;
670 else
671 expr = s;
672 }
673 return expr;
674 }
675
676 case RETURN_EXPR:
677 return break_out_target_exprs (TREE_OPERAND (body, 0));
678
679 case DECL_EXPR:
680 {
681 tree decl = DECL_EXPR_DECL (body);
682 if (TREE_CODE (decl) == USING_DECL
683 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
684 || DECL_ARTIFICIAL (decl))
685 return NULL_TREE;
686 return error_mark_node;
687 }
688
689 case CLEANUP_POINT_EXPR:
690 return constexpr_fn_retval (TREE_OPERAND (body, 0));
691
692 case BIND_EXPR:
693 if (!check_constexpr_bind_expr_vars (body))
694 return error_mark_node;
695 return constexpr_fn_retval (BIND_EXPR_BODY (body));
696
697 case USING_STMT:
698 case DEBUG_BEGIN_STMT:
699 return NULL_TREE;
700
701 case CALL_EXPR:
702 {
703 tree fun = get_function_named_in_call (body);
704 if (fun != NULL_TREE
705 && DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE)
706 return NULL_TREE;
707 }
708 /* Fallthru. */
709
710 default:
711 return error_mark_node;
712 }
713}
714
715/* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
716 FUN; do the necessary transformations to turn it into a single expression
717 that we can store in the hash table. */
718
719static tree
720massage_constexpr_body (tree fun, tree body)
721{
722 if (DECL_CONSTRUCTOR_P (fun))
723 body = build_constexpr_constructor_member_initializers
724 (DECL_CONTEXT (fun), body);
725 else if (cxx_dialect < cxx14)
726 {
727 if (TREE_CODE (body) == EH_SPEC_BLOCK)
728 body = EH_SPEC_STMTS (body);
729 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
730 body = TREE_OPERAND (body, 0);
731 body = constexpr_fn_retval (body);
732 }
733 return body;
734}
735
736/* CTYPE is a type constructed from BODY. Return true if some
737 bases/fields are uninitialized, and complain if COMPLAIN. */
738
739static bool
740cx_check_missing_mem_inits (tree ctype, tree body, bool complain)
741{
742 unsigned nelts = 0;
743
744 if (body)
745 {
746 if (TREE_CODE (body) != CONSTRUCTOR)
747 return false;
748 nelts = CONSTRUCTOR_NELTS (body);
749 }
750 tree field = TYPE_FIELDS (ctype);
751
752 if (TREE_CODE (ctype) == UNION_TYPE)
753 {
754 if (nelts == 0 && next_initializable_field (field))
755 {
756 if (complain)
757 error ("%<constexpr%> constructor for union %qT must "
758 "initialize exactly one non-static data member", ctype);
759 return true;
760 }
761 return false;
762 }
763
764 /* Iterate over the CONSTRUCTOR, checking any missing fields don't
765 need an explicit initialization. */
766 bool bad = false;
767 for (unsigned i = 0; i <= nelts; ++i)
768 {
769 tree index = NULL_TREE;
770 if (i < nelts)
771 {
772 index = CONSTRUCTOR_ELT (body, i)->index;
773 /* Skip base and vtable inits. */
774 if (TREE_CODE (index) != FIELD_DECL
775 || DECL_ARTIFICIAL (index))
776 continue;
777 }
778
779 for (; field != index; field = DECL_CHAIN (field))
780 {
781 tree ftype;
782 if (TREE_CODE (field) != FIELD_DECL)
783 continue;
784 if (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
785 continue;
786 if (DECL_ARTIFICIAL (field))
787 continue;
788 if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
789 {
790 /* Recurse to check the anonummous aggregate member. */
791 bad |= cx_check_missing_mem_inits
792 (TREE_TYPE (field), NULL_TREE, complain);
793 if (bad && !complain)
794 return true;
795 continue;
796 }
797 ftype = strip_array_types (TREE_TYPE (field));
798 if (type_has_constexpr_default_constructor (ftype))
799 {
800 /* It's OK to skip a member with a trivial constexpr ctor.
801 A constexpr ctor that isn't trivial should have been
802 added in by now. */
803 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
804 || errorcount != 0);
805 continue;
806 }
807 if (!complain)
808 return true;
809 error ("member %qD must be initialized by mem-initializer "
810 "in %<constexpr%> constructor", field);
811 inform (DECL_SOURCE_LOCATION (field), "declared here");
812 bad = true;
813 }
814 if (field == NULL_TREE)
815 break;
816
817 if (ANON_AGGR_TYPE_P (TREE_TYPE (index)))
818 {
819 /* Check the anonymous aggregate initializer is valid. */
820 bad |= cx_check_missing_mem_inits
821 (TREE_TYPE (index), CONSTRUCTOR_ELT (body, i)->value, complain);
822 if (bad && !complain)
823 return true;
824 }
825 field = DECL_CHAIN (field);
826 }
827
828 return bad;
829}
830
831/* We are processing the definition of the constexpr function FUN.
832 Check that its BODY fulfills the propriate requirements and
833 enter it in the constexpr function definition table.
834 For constructor BODY is actually the TREE_LIST of the
835 member-initializer list. */
836
837tree
838register_constexpr_fundef (tree fun, tree body)
839{
840 constexpr_fundef entry;
841 constexpr_fundef **slot;
842
843 if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
844 return NULL;
845
846 tree massaged = massage_constexpr_body (fun, body);
847 if (massaged == NULL_TREE || massaged == error_mark_node)
848 {
849 if (!DECL_CONSTRUCTOR_P (fun))
850 error ("body of %<constexpr%> function %qD not a return-statement",
851 fun);
852 return NULL;
853 }
854
855 if (!potential_rvalue_constant_expression (massaged))
856 {
857 if (!DECL_GENERATED_P (fun))
858 require_potential_rvalue_constant_expression (massaged);
859 return NULL;
860 }
861
862 if (DECL_CONSTRUCTOR_P (fun)
863 && cx_check_missing_mem_inits (DECL_CONTEXT (fun),
864 massaged, !DECL_GENERATED_P (fun)))
865 return NULL;
866
867 /* Create the constexpr function table if necessary. */
868 if (constexpr_fundef_table == NULL)
869 constexpr_fundef_table
870 = hash_table<constexpr_fundef_hasher>::create_ggc (101);
871
872 entry.decl = fun;
873 entry.body = body;
874 slot = constexpr_fundef_table->find_slot (&entry, INSERT);
875
876 gcc_assert (*slot == NULL);
877 *slot = ggc_alloc<constexpr_fundef> ();
878 **slot = entry;
879
880 return fun;
881}
882
883/* FUN is a non-constexpr function called in a context that requires a
884 constant expression. If it comes from a constexpr template, explain why
885 the instantiation isn't constexpr. */
886
887void
888explain_invalid_constexpr_fn (tree fun)
889{
890 static hash_set<tree> *diagnosed;
891 tree body;
892 location_t save_loc;
893 /* Only diagnose defaulted functions, lambdas, or instantiations. */
894 if (!DECL_DEFAULTED_FN (fun)
895 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun))
896 && !is_instantiation_of_constexpr (fun))
897 return;
898 if (diagnosed == NULL)
899 diagnosed = new hash_set<tree>;
900 if (diagnosed->add (fun))
901 /* Already explained. */
902 return;
903
904 save_loc = input_location;
905 if (!lambda_static_thunk_p (fun))
906 {
907 /* Diagnostics should completely ignore the static thunk, so leave
908 input_location set to our caller's location. */
909 input_location = DECL_SOURCE_LOCATION (fun);
910 inform (input_location,
911 "%qD is not usable as a %<constexpr%> function because:", fun);
912 }
913 /* First check the declaration. */
914 if (is_valid_constexpr_fn (fun, true))
915 {
916 /* Then if it's OK, the body. */
917 if (!DECL_DECLARED_CONSTEXPR_P (fun)
918 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)))
919 explain_implicit_non_constexpr (fun);
920 else
921 {
922 body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
923 require_potential_rvalue_constant_expression (body);
924 if (DECL_CONSTRUCTOR_P (fun))
925 cx_check_missing_mem_inits (DECL_CONTEXT (fun), body, true);
926 }
927 }
928 input_location = save_loc;
929}
930
931/* Objects of this type represent calls to constexpr functions
932 along with the bindings of parameters to their arguments, for
933 the purpose of compile time evaluation. */
934
935struct GTY((for_user)) constexpr_call {
936 /* Description of the constexpr function definition. */
937 constexpr_fundef *fundef;
938 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
939 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
940 Note: This arrangement is made to accommodate the use of
941 iterative_hash_template_arg (see pt.c). If you change this
942 representation, also change the hash calculation in
943 cxx_eval_call_expression. */
944 tree bindings;
945 /* Result of the call.
946 NULL means the call is being evaluated.
947 error_mark_node means that the evaluation was erroneous;
948 otherwise, the actuall value of the call. */
949 tree result;
950 /* The hash of this call; we remember it here to avoid having to
951 recalculate it when expanding the hash table. */
952 hashval_t hash;
953};
954
955struct constexpr_call_hasher : ggc_ptr_hash<constexpr_call>
956{
957 static hashval_t hash (constexpr_call *);
958 static bool equal (constexpr_call *, constexpr_call *);
959};
960
961enum constexpr_switch_state {
962 /* Used when processing a switch for the first time by cxx_eval_switch_expr
963 and default: label for that switch has not been seen yet. */
964 css_default_not_seen,
965 /* Used when processing a switch for the first time by cxx_eval_switch_expr
966 and default: label for that switch has been seen already. */
967 css_default_seen,
968 /* Used when processing a switch for the second time by
969 cxx_eval_switch_expr, where default: label should match. */
970 css_default_processing
971};
972
973/* The constexpr expansion context. CALL is the current function
974 expansion, CTOR is the current aggregate initializer, OBJECT is the
975 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
976 is a map of values of variables initialized within the expression. */
977
978struct constexpr_ctx {
979 /* The innermost call we're evaluating. */
980 constexpr_call *call;
981 /* Values for any temporaries or local variables within the
982 constant-expression. */
983 hash_map<tree,tree> *values;
984 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we
985 aren't inside a loop. */
986 hash_set<tree> *save_exprs;
987 /* The CONSTRUCTOR we're currently building up for an aggregate
988 initializer. */
989 tree ctor;
990 /* The object we're building the CONSTRUCTOR for. */
991 tree object;
992 /* If inside SWITCH_EXPR. */
993 constexpr_switch_state *css_state;
994 /* Whether we should error on a non-constant expression or fail quietly. */
995 bool quiet;
996 /* Whether we are strictly conforming to constant expression rules or
997 trying harder to get a constant value. */
998 bool strict;
999};
1000
1001/* A table of all constexpr calls that have been evaluated by the
1002 compiler in this translation unit. */
1003
1004static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
1005
1006static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
1007 bool, bool *, bool *, tree * = NULL);
1008
1009/* Compute a hash value for a constexpr call representation. */
1010
1011inline hashval_t
1012constexpr_call_hasher::hash (constexpr_call *info)
1013{
1014 return info->hash;
1015}
1016
1017/* Return true if the objects pointed to by P and Q represent calls
1018 to the same constexpr function with the same arguments.
1019 Otherwise, return false. */
1020
1021bool
1022constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs)
1023{
1024 tree lhs_bindings;
1025 tree rhs_bindings;
1026 if (lhs == rhs)
1027 return 1;
1028 if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef))
1029 return 0;
1030 lhs_bindings = lhs->bindings;
1031 rhs_bindings = rhs->bindings;
1032 while (lhs_bindings != NULL && rhs_bindings != NULL)
1033 {
1034 tree lhs_arg = TREE_VALUE (lhs_bindings);
1035 tree rhs_arg = TREE_VALUE (rhs_bindings);
1036 gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
1037 if (!cp_tree_equal (lhs_arg, rhs_arg))
1038 return 0;
1039 lhs_bindings = TREE_CHAIN (lhs_bindings);
1040 rhs_bindings = TREE_CHAIN (rhs_bindings);
1041 }
1042 return lhs_bindings == rhs_bindings;
1043}
1044
1045/* Initialize the constexpr call table, if needed. */
1046
1047static void
1048maybe_initialize_constexpr_call_table (void)
1049{
1050 if (constexpr_call_table == NULL)
1051 constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101);
1052}
1053
1054/* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1055 a function happens to get called recursively, we unshare the callee
1056 function's body and evaluate this unshared copy instead of evaluating the
1057 original body.
1058
1059 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1060 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1061 that's keyed off of the original FUNCTION_DECL and whose value is a
1062 TREE_LIST of this function's unused copies awaiting reuse.
1063
1064 This is not GC-deletable to avoid GC affecting UID generation. */
1065
1066static GTY(()) hash_map<tree, tree> *fundef_copies_table;
1067
1068/* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */
1069
1070static void
1071maybe_initialize_fundef_copies_table ()
1072{
1073 if (fundef_copies_table == NULL)
1074 fundef_copies_table = hash_map<tree,tree>::create_ggc (101);
1075}
1076
1077/* Reuse a copy or create a new unshared copy of the function FUN.
1078 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1079 is parms, TYPE is result. */
1080
1081static tree
1082get_fundef_copy (tree fun)
1083{
1084 maybe_initialize_fundef_copies_table ();
1085
1086 tree copy;
1087 bool existed;
1088 tree *slot = &fundef_copies_table->get_or_insert (fun, &existed);
1089
1090 if (!existed)
1091 {
1092 /* There is no cached function available, or in use. We can use
1093 the function directly. That the slot is now created records
1094 that this function is now in use. */
1095 copy = build_tree_list (DECL_SAVED_TREE (fun), DECL_ARGUMENTS (fun));
1096 TREE_TYPE (copy) = DECL_RESULT (fun);
1097 }
1098 else if (*slot == NULL_TREE)
1099 {
1100 /* We've already used the function itself, so make a copy. */
1101 copy = build_tree_list (NULL, NULL);
1102 TREE_PURPOSE (copy) = copy_fn (fun, TREE_VALUE (copy), TREE_TYPE (copy));
1103 }
1104 else
1105 {
1106 /* We have a cached function available. */
1107 copy = *slot;
1108 *slot = TREE_CHAIN (copy);
1109 }
1110
1111 return copy;
1112}
1113
1114/* Save the copy COPY of function FUN for later reuse by
1115 get_fundef_copy(). By construction, there will always be an entry
1116 to find. */
1117
1118static void
1119save_fundef_copy (tree fun, tree copy)
1120{
1121 tree *slot = fundef_copies_table->get (fun);
1122 TREE_CHAIN (copy) = *slot;
1123 *slot = copy;
1124}
1125
1126/* We have an expression tree T that represents a call, either CALL_EXPR
1127 or AGGR_INIT_EXPR. Return the Nth argument. */
1128
1129static inline tree
1130get_nth_callarg (tree t, int n)
1131{
1132 switch (TREE_CODE (t))
1133 {
1134 case CALL_EXPR:
1135 return CALL_EXPR_ARG (t, n);
1136
1137 case AGGR_INIT_EXPR:
1138 return AGGR_INIT_EXPR_ARG (t, n);
1139
1140 default:
1141 gcc_unreachable ();
1142 return NULL;
1143 }
1144}
1145
1146/* Attempt to evaluate T which represents a call to a builtin function.
1147 We assume here that all builtin functions evaluate to scalar types
1148 represented by _CST nodes. */
1149
1150static tree
1151cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,
1152 bool lval,
1153 bool *non_constant_p, bool *overflow_p)
1154{
1155 const int nargs = call_expr_nargs (t);
1156 tree *args = (tree *) alloca (nargs * sizeof (tree));
1157 tree new_call;
1158 int i;
1159
1160 /* Don't fold __builtin_constant_p within a constexpr function. */
1161 bool bi_const_p = (DECL_FUNCTION_CODE (fun) == BUILT_IN_CONSTANT_P);
1162
1163 if (bi_const_p
1164 && current_function_decl
1165 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
1166 {
1167 *non_constant_p = true;
1168 return t;
1169 }
1170
1171 /* Be permissive for arguments to built-ins; __builtin_constant_p should
1172 return constant false for a non-constant argument. */
1173 constexpr_ctx new_ctx = *ctx;
1174 new_ctx.quiet = true;
1175 bool dummy1 = false, dummy2 = false;
1176 for (i = 0; i < nargs; ++i)
1177 {
1178 args[i] = cxx_eval_constant_expression (&new_ctx, CALL_EXPR_ARG (t, i),
1179 false, &dummy1, &dummy2);
1180 if (bi_const_p)
1181 /* For __built_in_constant_p, fold all expressions with constant values
1182 even if they aren't C++ constant-expressions. */
1183 args[i] = cp_fully_fold (args[i]);
1184 }
1185
1186 bool save_ffbcp = force_folding_builtin_constant_p;
1187 force_folding_builtin_constant_p = true;
1188 new_call = fold_builtin_call_array (EXPR_LOCATION (t), TREE_TYPE (t),
1189 CALL_EXPR_FN (t), nargs, args);
1190 force_folding_builtin_constant_p = save_ffbcp;
1191 if (new_call == NULL)
1192 {
1193 if (!*non_constant_p && !ctx->quiet)
1194 {
1195 /* Do not allow__builtin_unreachable in constexpr function.
1196 The __builtin_unreachable call with BUILTINS_LOCATION
1197 comes from cp_maybe_instrument_return. */
1198 if (DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE
1199 && EXPR_LOCATION (t) == BUILTINS_LOCATION)
1200 error ("%<constexpr%> call flows off the end of the function");
1201 else
1202 {
1203 new_call = build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
1204 CALL_EXPR_FN (t), nargs, args);
1205 error ("%q+E is not a constant expression", new_call);
1206 }
1207 }
1208 *non_constant_p = true;
1209 return t;
1210 }
1211
1212 if (!is_constant_expression (new_call))
1213 {
1214 if (!*non_constant_p && !ctx->quiet)
1215 error ("%q+E is not a constant expression", new_call);
1216 *non_constant_p = true;
1217 return t;
1218 }
1219
1220 return cxx_eval_constant_expression (&new_ctx, new_call, lval,
1221 non_constant_p, overflow_p);
1222}
1223
1224/* TEMP is the constant value of a temporary object of type TYPE. Adjust
1225 the type of the value to match. */
1226
1227static tree
1228adjust_temp_type (tree type, tree temp)
1229{
1230 if (TREE_TYPE (temp) == type)
1231 return temp;
1232 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1233 if (TREE_CODE (temp) == CONSTRUCTOR)
1234 return build_constructor (type, CONSTRUCTOR_ELTS (temp));
1235 gcc_assert (scalarish_type_p (type));
1236 return cp_fold_convert (type, temp);
1237}
1238
1239/* Callback for walk_tree used by unshare_constructor. */
1240
1241static tree
1242find_constructor (tree *tp, int *walk_subtrees, void *)
1243{
1244 if (TYPE_P (*tp))
1245 *walk_subtrees = 0;
1246 if (TREE_CODE (*tp) == CONSTRUCTOR)
1247 return *tp;
1248 return NULL_TREE;
1249}
1250
1251/* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a
1252 subexpression, return an unshared copy of T. Otherwise return T. */
1253
1254static tree
1255unshare_constructor (tree t)
1256{
1257 tree ctor = walk_tree (&t, find_constructor, NULL, NULL);
1258 if (ctor != NULL_TREE)
1259 return unshare_expr (t);
1260 return t;
1261}
1262
1263/* Subroutine of cxx_eval_call_expression.
1264 We are processing a call expression (either CALL_EXPR or
1265 AGGR_INIT_EXPR) in the context of CTX. Evaluate
1266 all arguments and bind their values to correspondings
1267 parameters, making up the NEW_CALL context. */
1268
1269static void
1270cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
1271 constexpr_call *new_call,
1272 bool *non_constant_p, bool *overflow_p,
1273 bool *non_constant_args)
1274{
1275 const int nargs = call_expr_nargs (t);
1276 tree fun = new_call->fundef->decl;
1277 tree parms = DECL_ARGUMENTS (fun);
1278 int i;
1279 tree *p = &new_call->bindings;
1280 for (i = 0; i < nargs; ++i)
1281 {
1282 tree x, arg;
1283 tree type = parms ? TREE_TYPE (parms) : void_type_node;
1284 x = get_nth_callarg (t, i);
1285 /* For member function, the first argument is a pointer to the implied
1286 object. For a constructor, it might still be a dummy object, in
1287 which case we get the real argument from ctx. */
1288 if (i == 0 && DECL_CONSTRUCTOR_P (fun)
1289 && is_dummy_object (x))
1290 {
1291 x = ctx->object;
1292 x = build_address (x);
1293 }
1294 bool lval = false;
1295 arg = cxx_eval_constant_expression (ctx, x, lval,
1296 non_constant_p, overflow_p);
1297 /* Don't VERIFY_CONSTANT here. */
1298 if (*non_constant_p && ctx->quiet)
1299 return;
1300 /* Just discard ellipsis args after checking their constantitude. */
1301 if (!parms)
1302 continue;
1303
1304 if (!*non_constant_p)
1305 {
1306 /* Make sure the binding has the same type as the parm. But
1307 only for constant args. */
1308 if (TREE_CODE (type) != REFERENCE_TYPE)
1309 arg = adjust_temp_type (type, arg);
1310 if (!TREE_CONSTANT (arg))
1311 *non_constant_args = true;
1312 *p = build_tree_list (parms, arg);
1313 p = &TREE_CHAIN (*p);
1314 }
1315 parms = TREE_CHAIN (parms);
1316 }
1317}
1318
1319/* Variables and functions to manage constexpr call expansion context.
1320 These do not need to be marked for PCH or GC. */
1321
1322/* FIXME remember and print actual constant arguments. */
1323static vec<tree> call_stack;
1324static int call_stack_tick;
1325static int last_cx_error_tick;
1326
1327static bool
1328push_cx_call_context (tree call)
1329{
1330 ++call_stack_tick;
1331 if (!EXPR_HAS_LOCATION (call))
1332 SET_EXPR_LOCATION (call, input_location);
1333 call_stack.safe_push (call);
1334 if (call_stack.length () > (unsigned) max_constexpr_depth)
1335 return false;
1336 return true;
1337}
1338
1339static void
1340pop_cx_call_context (void)
1341{
1342 ++call_stack_tick;
1343 call_stack.pop ();
1344}
1345
1346vec<tree>
1347cx_error_context (void)
1348{
1349 vec<tree> r = vNULL;
1350 if (call_stack_tick != last_cx_error_tick
1351 && !call_stack.is_empty ())
1352 r = call_stack;
1353 last_cx_error_tick = call_stack_tick;
1354 return r;
1355}
1356
1357/* Evaluate a call T to a GCC internal function when possible and return
1358 the evaluated result or, under the control of CTX, give an error, set
1359 NON_CONSTANT_P, and return the unevaluated call T otherwise. */
1360
1361static tree
1362cxx_eval_internal_function (const constexpr_ctx *ctx, tree t,
1363 bool lval,
1364 bool *non_constant_p, bool *overflow_p)
1365{
1366 enum tree_code opcode = ERROR_MARK;
1367
1368 switch (CALL_EXPR_IFN (t))
1369 {
1370 case IFN_UBSAN_NULL:
1371 case IFN_UBSAN_BOUNDS:
1372 case IFN_UBSAN_VPTR:
1373 case IFN_FALLTHROUGH:
1374 return void_node;
1375
1376 case IFN_ADD_OVERFLOW:
1377 opcode = PLUS_EXPR;
1378 break;
1379 case IFN_SUB_OVERFLOW:
1380 opcode = MINUS_EXPR;
1381 break;
1382 case IFN_MUL_OVERFLOW:
1383 opcode = MULT_EXPR;
1384 break;
1385
1386 case IFN_LAUNDER:
1387 return cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0),
1388 false, non_constant_p, overflow_p);
1389
1390 default:
1391 if (!ctx->quiet)
1392 error_at (EXPR_LOC_OR_LOC (t, input_location),
1393 "call to internal function %qE", t);
1394 *non_constant_p = true;
1395 return t;
1396 }
1397
1398 /* Evaluate constant arguments using OPCODE and return a complex
1399 number containing the result and the overflow bit. */
1400 tree arg0 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0), lval,
1401 non_constant_p, overflow_p);
1402 tree arg1 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 1), lval,
1403 non_constant_p, overflow_p);
1404
1405 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1406 {
1407 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1408 tree type = TREE_TYPE (TREE_TYPE (t));
1409 tree result = fold_binary_loc (loc, opcode, type,
1410 fold_convert_loc (loc, type, arg0),
1411 fold_convert_loc (loc, type, arg1));
1412 tree ovf
1413 = build_int_cst (type, arith_overflowed_p (opcode, type, arg0, arg1));
1414 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
1415 if (TREE_OVERFLOW (result))
1416 TREE_OVERFLOW (result) = 0;
1417
1418 return build_complex (TREE_TYPE (t), result, ovf);
1419 }
1420
1421 *non_constant_p = true;
1422 return t;
1423}
1424
1425/* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */
1426
1427static void
1428clear_no_implicit_zero (tree ctor)
1429{
1430 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor))
1431 {
1432 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = false;
1433 tree elt; unsigned HOST_WIDE_INT idx;
1434 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), idx, elt)
1435 if (TREE_CODE (elt) == CONSTRUCTOR)
1436 clear_no_implicit_zero (elt);
1437 }
1438}
1439
1440/* Subroutine of cxx_eval_constant_expression.
1441 Evaluate the call expression tree T in the context of OLD_CALL expression
1442 evaluation. */
1443
1444static tree
1445cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
1446 bool lval,
1447 bool *non_constant_p, bool *overflow_p)
1448{
1449 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1450 tree fun = get_function_named_in_call (t);
1451 constexpr_call new_call = { NULL, NULL, NULL, 0 };
1452 bool depth_ok;
1453
1454 if (fun == NULL_TREE)
1455 return cxx_eval_internal_function (ctx, t, lval,
1456 non_constant_p, overflow_p);
1457
1458 if (TREE_CODE (fun) != FUNCTION_DECL)
1459 {
1460 /* Might be a constexpr function pointer. */
1461 fun = cxx_eval_constant_expression (ctx, fun,
1462 /*lval*/false, non_constant_p,
1463 overflow_p);
1464 STRIP_NOPS (fun);
1465 if (TREE_CODE (fun) == ADDR_EXPR)
1466 fun = TREE_OPERAND (fun, 0);
1467 }
1468 if (TREE_CODE (fun) != FUNCTION_DECL)
1469 {
1470 if (!ctx->quiet && !*non_constant_p)
1471 error_at (loc, "expression %qE does not designate a %<constexpr%> "
1472 "function", fun);
1473 *non_constant_p = true;
1474 return t;
1475 }
1476 if (DECL_CLONED_FUNCTION_P (fun))
1477 fun = DECL_CLONED_FUNCTION (fun);
1478
1479 if (is_ubsan_builtin_p (fun))
1480 return void_node;
1481
1482 if (is_builtin_fn (fun))
1483 return cxx_eval_builtin_function_call (ctx, t, fun,
1484 lval, non_constant_p, overflow_p);
1485 if (!DECL_DECLARED_CONSTEXPR_P (fun))
1486 {
1487 if (!ctx->quiet)
1488 {
1489 if (!lambda_static_thunk_p (fun))
1490 error_at (loc, "call to non-%<constexpr%> function %qD", fun);
1491 explain_invalid_constexpr_fn (fun);
1492 }
1493 *non_constant_p = true;
1494 return t;
1495 }
1496
1497 constexpr_ctx new_ctx = *ctx;
1498 if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
1499 && TREE_CODE (t) == AGGR_INIT_EXPR)
1500 {
1501 /* We want to have an initialization target for an AGGR_INIT_EXPR.
1502 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
1503 new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
1504 tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
1505 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true;
1506 ctx->values->put (new_ctx.object, ctor);
1507 ctx = &new_ctx;
1508 }
1509
1510 /* Shortcut trivial constructor/op=. */
1511 if (trivial_fn_p (fun))
1512 {
1513 tree init = NULL_TREE;
1514 if (call_expr_nargs (t) == 2)
1515 init = convert_from_reference (get_nth_callarg (t, 1));
1516 else if (TREE_CODE (t) == AGGR_INIT_EXPR
1517 && AGGR_INIT_ZERO_FIRST (t))
1518 init = build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false);
1519 if (init)
1520 {
1521 tree op = get_nth_callarg (t, 0);
1522 if (is_dummy_object (op))
1523 op = ctx->object;
1524 else
1525 op = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (op)), op);
1526 tree set = build2 (MODIFY_EXPR, TREE_TYPE (op), op, init);
1527 new_ctx.call = &new_call;
1528 return cxx_eval_constant_expression (&new_ctx, set, lval,
1529 non_constant_p, overflow_p);
1530 }
1531 }
1532
1533 /* We can't defer instantiating the function any longer. */
1534 if (!DECL_INITIAL (fun)
1535 && DECL_TEMPLOID_INSTANTIATION (fun))
1536 {
1537 location_t save_loc = input_location;
1538 input_location = loc;
1539 ++function_depth;
1540 instantiate_decl (fun, /*defer_ok*/false, /*expl_inst*/false);
1541 --function_depth;
1542 input_location = save_loc;
1543 }
1544
1545 /* If in direct recursive call, optimize definition search. */
1546 if (ctx && ctx->call && ctx->call->fundef && ctx->call->fundef->decl == fun)
1547 new_call.fundef = ctx->call->fundef;
1548 else
1549 {
1550 new_call.fundef = retrieve_constexpr_fundef (fun);
1551 if (new_call.fundef == NULL || new_call.fundef->body == NULL
1552 || fun == current_function_decl)
1553 {
1554 if (!ctx->quiet)
1555 {
1556 /* We need to check for current_function_decl here in case we're
1557 being called during cp_fold_function, because at that point
1558 DECL_INITIAL is set properly and we have a fundef but we
1559 haven't lowered invisirefs yet (c++/70344). */
1560 if (DECL_INITIAL (fun) == error_mark_node
1561 || fun == current_function_decl)
1562 error_at (loc, "%qD called in a constant expression before its "
1563 "definition is complete", fun);
1564 else if (DECL_INITIAL (fun))
1565 {
1566 /* The definition of fun was somehow unsuitable. But pretend
1567 that lambda static thunks don't exist. */
1568 if (!lambda_static_thunk_p (fun))
1569 error_at (loc, "%qD called in a constant expression", fun);
1570 explain_invalid_constexpr_fn (fun);
1571 }
1572 else
1573 error_at (loc, "%qD used before its definition", fun);
1574 }
1575 *non_constant_p = true;
1576 return t;
1577 }
1578 }
1579
1580 bool non_constant_args = false;
1581 cxx_bind_parameters_in_call (ctx, t, &new_call,
1582 non_constant_p, overflow_p, &non_constant_args);
1583 if (*non_constant_p)
1584 return t;
1585
1586 depth_ok = push_cx_call_context (t);
1587
1588 tree result = NULL_TREE;
1589
1590 constexpr_call *entry = NULL;
1591 if (depth_ok && !non_constant_args)
1592 {
1593 new_call.hash = iterative_hash_template_arg
1594 (new_call.bindings, constexpr_fundef_hasher::hash (new_call.fundef));
1595
1596 /* If we have seen this call before, we are done. */
1597 maybe_initialize_constexpr_call_table ();
1598 constexpr_call **slot
1599 = constexpr_call_table->find_slot (&new_call, INSERT);
1600 entry = *slot;
1601 if (entry == NULL)
1602 {
1603 /* We need to keep a pointer to the entry, not just the slot, as the
1604 slot can move in the call to cxx_eval_builtin_function_call. */
1605 *slot = entry = ggc_alloc<constexpr_call> ();
1606 *entry = new_call;
1607 }
1608 /* Calls that are in progress have their result set to NULL,
1609 so that we can detect circular dependencies. */
1610 else if (entry->result == NULL)
1611 {
1612 if (!ctx->quiet)
1613 error ("call has circular dependency");
1614 *non_constant_p = true;
1615 entry->result = result = error_mark_node;
1616 }
1617 else
1618 result = entry->result;
1619 }
1620
1621 if (!depth_ok)
1622 {
1623 if (!ctx->quiet)
1624 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1625 "-fconstexpr-depth= to increase the maximum)",
1626 max_constexpr_depth);
1627 *non_constant_p = true;
1628 result = error_mark_node;
1629 }
1630 else
1631 {
1632 if (result && result != error_mark_node)
1633 /* OK */;
1634 else if (!DECL_SAVED_TREE (fun))
1635 {
1636 /* When at_eof >= 2, cgraph has started throwing away
1637 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1638 late code generation for VEC_INIT_EXPR, which needs to be
1639 completely reconsidered. */
1640 gcc_assert (at_eof >= 2 && ctx->quiet);
1641 *non_constant_p = true;
1642 }
1643 else
1644 {
1645 tree body, parms, res;
1646
1647 /* Reuse or create a new unshared copy of this function's body. */
1648 tree copy = get_fundef_copy (fun);
1649 body = TREE_PURPOSE (copy);
1650 parms = TREE_VALUE (copy);
1651 res = TREE_TYPE (copy);
1652
1653 /* Associate the bindings with the remapped parms. */
1654 tree bound = new_call.bindings;
1655 tree remapped = parms;
1656 while (bound)
1657 {
1658 tree oparm = TREE_PURPOSE (bound);
1659 tree arg = TREE_VALUE (bound);
1660 gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm));
1661 /* Don't share a CONSTRUCTOR that might be changed. */
1662 arg = unshare_constructor (arg);
1663 ctx->values->put (remapped, arg);
1664 bound = TREE_CHAIN (bound);
1665 remapped = DECL_CHAIN (remapped);
1666 }
1667 /* Add the RESULT_DECL to the values map, too. */
1668 tree slot = NULL_TREE;
1669 if (DECL_BY_REFERENCE (res))
1670 {
1671 slot = AGGR_INIT_EXPR_SLOT (t);
1672 tree addr = build_address (slot);
1673 addr = build_nop (TREE_TYPE (res), addr);
1674 ctx->values->put (res, addr);
1675 ctx->values->put (slot, NULL_TREE);
1676 }
1677 else
1678 ctx->values->put (res, NULL_TREE);
1679
1680 /* Track the callee's evaluated SAVE_EXPRs so that we can forget
1681 their values after the call. */
1682 constexpr_ctx ctx_with_save_exprs = *ctx;
1683 hash_set<tree> save_exprs;
1684 ctx_with_save_exprs.save_exprs = &save_exprs;
1685 ctx_with_save_exprs.call = &new_call;
1686
1687 tree jump_target = NULL_TREE;
1688 cxx_eval_constant_expression (&ctx_with_save_exprs, body,
1689 lval, non_constant_p, overflow_p,
1690 &jump_target);
1691
1692 if (DECL_CONSTRUCTOR_P (fun))
1693 /* This can be null for a subobject constructor call, in
1694 which case what we care about is the initialization
1695 side-effects rather than the value. We could get at the
1696 value by evaluating *this, but we don't bother; there's
1697 no need to put such a call in the hash table. */
1698 result = lval ? ctx->object : ctx->ctor;
1699 else if (VOID_TYPE_P (TREE_TYPE (res)))
1700 result = void_node;
1701 else
1702 {
1703 result = *ctx->values->get (slot ? slot : res);
1704 if (result == NULL_TREE && !*non_constant_p)
1705 {
1706 if (!ctx->quiet)
1707 error ("%<constexpr%> call flows off the end "
1708 "of the function");
1709 *non_constant_p = true;
1710 }
1711 }
1712
1713 /* Forget the saved values of the callee's SAVE_EXPRs. */
1714 for (hash_set<tree>::iterator iter = save_exprs.begin();
1715 iter != save_exprs.end(); ++iter)
1716 ctx_with_save_exprs.values->remove (*iter);
1717
1718 /* Remove the parms/result from the values map. Is it worth
1719 bothering to do this when the map itself is only live for
1720 one constexpr evaluation? If so, maybe also clear out
1721 other vars from call, maybe in BIND_EXPR handling? */
1722 ctx->values->remove (res);
1723 if (slot)
1724 ctx->values->remove (slot);
1725 for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
1726 ctx->values->remove (parm);
1727
1728 /* Make the unshared function copy we used available for re-use. */
1729 save_fundef_copy (fun, copy);
1730 }
1731
1732 if (result == error_mark_node)
1733 *non_constant_p = true;
1734 if (*non_constant_p || *overflow_p)
1735 result = error_mark_node;
1736 else if (!result)
1737 result = void_node;
1738 if (entry)
1739 entry->result = result;
1740 }
1741
1742 /* The result of a constexpr function must be completely initialized. */
1743 if (TREE_CODE (result) == CONSTRUCTOR)
1744 clear_no_implicit_zero (result);
1745
1746 pop_cx_call_context ();
1747 return unshare_constructor (result);
1748}
1749
1750/* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
1751
1752bool
1753reduced_constant_expression_p (tree t)
1754{
1755 switch (TREE_CODE (t))
1756 {
1757 case PTRMEM_CST:
1758 /* Even if we can't lower this yet, it's constant. */
1759 return true;
1760
1761 case CONSTRUCTOR:
1762 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
1763 tree idx, val, field; unsigned HOST_WIDE_INT i;
1764 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t))
1765 field = next_initializable_field (TYPE_FIELDS (TREE_TYPE (t)));
1766 else
1767 field = NULL_TREE;
1768 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, idx, val)
1769 {
1770 if (!val)
1771 /* We're in the middle of initializing this element. */
1772 return false;
1773 if (!reduced_constant_expression_p (val))
1774 return false;
1775 if (field)
1776 {
1777 if (idx != field)
1778 return false;
1779 field = next_initializable_field (DECL_CHAIN (field));
1780 }
1781 }
1782 if (field)
1783 return false;
1784 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t))
1785 /* All the fields are initialized. */
1786 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
1787 return true;
1788
1789 default:
1790 /* FIXME are we calling this too much? */
1791 return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
1792 }
1793}
1794
1795/* Some expressions may have constant operands but are not constant
1796 themselves, such as 1/0. Call this function (or rather, the macro
1797 following it) to check for that condition.
1798
1799 We only call this in places that require an arithmetic constant, not in
1800 places where we might have a non-constant expression that can be a
1801 component of a constant expression, such as the address of a constexpr
1802 variable that might be dereferenced later. */
1803
1804static bool
1805verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
1806 bool *overflow_p)
1807{
1808 if (!*non_constant_p && !reduced_constant_expression_p (t))
1809 {
1810 if (!allow_non_constant)
1811 error ("%q+E is not a constant expression", t);
1812 *non_constant_p = true;
1813 }
1814 if (TREE_OVERFLOW_P (t))
1815 {
1816 if (!allow_non_constant)
1817 {
1818 permerror (input_location, "overflow in constant expression");
1819 /* If we're being permissive (and are in an enforcing
1820 context), ignore the overflow. */
1821 if (flag_permissive)
1822 return *non_constant_p;
1823 }
1824 *overflow_p = true;
1825 }
1826 return *non_constant_p;
1827}
1828
1829/* Check whether the shift operation with code CODE and type TYPE on LHS
1830 and RHS is undefined. If it is, give an error with an explanation,
1831 and return true; return false otherwise. */
1832
1833static bool
1834cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx,
1835 enum tree_code code, tree type, tree lhs, tree rhs)
1836{
1837 if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR)
1838 || TREE_CODE (lhs) != INTEGER_CST
1839 || TREE_CODE (rhs) != INTEGER_CST)
1840 return false;
1841
1842 tree lhstype = TREE_TYPE (lhs);
1843 unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs));
1844
1845 /* [expr.shift] The behavior is undefined if the right operand
1846 is negative, or greater than or equal to the length in bits
1847 of the promoted left operand. */
1848 if (tree_int_cst_sgn (rhs) == -1)
1849 {
1850 if (!ctx->quiet)
1851 permerror (loc, "right operand of shift expression %q+E is negative",
1852 build2_loc (loc, code, type, lhs, rhs));
1853 return (!flag_permissive || ctx->quiet);
1854 }
1855 if (compare_tree_int (rhs, uprec) >= 0)
1856 {
1857 if (!ctx->quiet)
1858 permerror (loc, "right operand of shift expression %q+E is >= than "
1859 "the precision of the left operand",
1860 build2_loc (loc, code, type, lhs, rhs));
1861 return (!flag_permissive || ctx->quiet);
1862 }
1863
1864 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1865 if E1 has a signed type and non-negative value, and E1x2^E2 is
1866 representable in the corresponding unsigned type of the result type,
1867 then that value, converted to the result type, is the resulting value;
1868 otherwise, the behavior is undefined. */
1869 if (code == LSHIFT_EXPR && !TYPE_UNSIGNED (lhstype)
1870 && (cxx_dialect >= cxx11))
1871 {
1872 if (tree_int_cst_sgn (lhs) == -1)
1873 {
1874 if (!ctx->quiet)
1875 permerror (loc,
1876 "left operand of shift expression %q+E is negative",
1877 build2_loc (loc, code, type, lhs, rhs));
1878 return (!flag_permissive || ctx->quiet);
1879 }
1880 /* For signed x << y the following:
1881 (unsigned) x >> ((prec (lhs) - 1) - y)
1882 if > 1, is undefined. The right-hand side of this formula
1883 is the highest bit of the LHS that can be set (starting from 0),
1884 so that the shift doesn't overflow. We then right-shift the LHS
1885 to see whether any other bit is set making the original shift
1886 undefined -- the result is not representable in the corresponding
1887 unsigned type. */
1888 tree t = build_int_cst (unsigned_type_node, uprec - 1);
1889 t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs);
1890 tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs);
1891 t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t);
1892 if (tree_int_cst_lt (integer_one_node, t))
1893 {
1894 if (!ctx->quiet)
1895 permerror (loc, "shift expression %q+E overflows",
1896 build2_loc (loc, code, type, lhs, rhs));
1897 return (!flag_permissive || ctx->quiet);
1898 }
1899 }
1900 return false;
1901}
1902
1903/* Subroutine of cxx_eval_constant_expression.
1904 Attempt to reduce the unary expression tree T to a compile time value.
1905 If successful, return the value. Otherwise issue a diagnostic
1906 and return error_mark_node. */
1907
1908static tree
1909cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
1910 bool /*lval*/,
1911 bool *non_constant_p, bool *overflow_p)
1912{
1913 tree r;
1914 tree orig_arg = TREE_OPERAND (t, 0);
1915 tree arg = cxx_eval_constant_expression (ctx, orig_arg, /*lval*/false,
1916 non_constant_p, overflow_p);
1917 VERIFY_CONSTANT (arg);
1918 location_t loc = EXPR_LOCATION (t);
1919 enum tree_code code = TREE_CODE (t);
1920 tree type = TREE_TYPE (t);
1921 r = fold_unary_loc (loc, code, type, arg);
1922 if (r == NULL_TREE)
1923 {
1924 if (arg == orig_arg)
1925 r = t;
1926 else
1927 r = build1_loc (loc, code, type, arg);
1928 }
1929 VERIFY_CONSTANT (r);
1930 return r;
1931}
1932
1933/* Helper function for cxx_eval_binary_expression. Try to optimize
1934 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1935 generic folding should be used. */
1936
1937static tree
1938cxx_fold_pointer_plus_expression (const constexpr_ctx *ctx, tree t,
1939 tree lhs, tree rhs, bool *non_constant_p,
1940 bool *overflow_p)
1941{
1942 STRIP_NOPS (lhs);
1943 if (TREE_CODE (lhs) != ADDR_EXPR)
1944 return NULL_TREE;
1945
1946 lhs = TREE_OPERAND (lhs, 0);
1947
1948 /* &A[i] p+ j => &A[i + j] */
1949 if (TREE_CODE (lhs) == ARRAY_REF
1950 && TREE_CODE (TREE_OPERAND (lhs, 1)) == INTEGER_CST
1951 && TREE_CODE (rhs) == INTEGER_CST
1952 && TYPE_SIZE_UNIT (TREE_TYPE (lhs))
1953 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST)
1954 {
1955 tree orig_type = TREE_TYPE (t);
1956 location_t loc = EXPR_LOCATION (t);
1957 tree type = TREE_TYPE (lhs);
1958
1959 t = fold_convert_loc (loc, ssizetype, TREE_OPERAND (lhs, 1));
1960 tree nelts = array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs, 0)));
1961 nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
1962 overflow_p);
1963 if (*non_constant_p)
1964 return NULL_TREE;
1965 /* Don't fold an out-of-bound access. */
1966 if (!tree_int_cst_le (t, nelts))
1967 return NULL_TREE;
1968 rhs = cp_fold_convert (ssizetype, rhs);
1969 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
1970 constexpr int A[1]; ... (char *)&A[0] + 1 */
1971 if (!integer_zerop (fold_build2_loc (loc, TRUNC_MOD_EXPR, sizetype,
1972 rhs, TYPE_SIZE_UNIT (type))))
1973 return NULL_TREE;
1974 /* Make sure to treat the second operand of POINTER_PLUS_EXPR
1975 as signed. */
1976 rhs = fold_build2_loc (loc, EXACT_DIV_EXPR, ssizetype, rhs,
1977 TYPE_SIZE_UNIT (type));
1978 t = size_binop_loc (loc, PLUS_EXPR, rhs, t);
1979 t = build4_loc (loc, ARRAY_REF, type, TREE_OPERAND (lhs, 0),
1980 t, NULL_TREE, NULL_TREE);
1981 t = cp_build_addr_expr (t, tf_warning_or_error);
1982 t = cp_fold_convert (orig_type, t);
1983 return cxx_eval_constant_expression (ctx, t, /*lval*/false,
1984 non_constant_p, overflow_p);
1985 }
1986
1987 return NULL_TREE;
1988}
1989
1990/* Subroutine of cxx_eval_constant_expression.
1991 Like cxx_eval_unary_expression, except for binary expressions. */
1992
1993static tree
1994cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
1995 bool /*lval*/,
1996 bool *non_constant_p, bool *overflow_p)
1997{
1998 tree r = NULL_TREE;
1999 tree orig_lhs = TREE_OPERAND (t, 0);
2000 tree orig_rhs = TREE_OPERAND (t, 1);
2001 tree lhs, rhs;
2002 lhs = cxx_eval_constant_expression (ctx, orig_lhs, /*lval*/false,
2003 non_constant_p, overflow_p);
2004 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
2005 subtraction. */
2006 if (*non_constant_p)
2007 return t;
2008 rhs = cxx_eval_constant_expression (ctx, orig_rhs, /*lval*/false,
2009 non_constant_p, overflow_p);
2010 if (*non_constant_p)
2011 return t;
2012
2013 location_t loc = EXPR_LOCATION (t);
2014 enum tree_code code = TREE_CODE (t);
2015 tree type = TREE_TYPE (t);
2016
2017 if (code == EQ_EXPR || code == NE_EXPR)
2018 {
2019 bool is_code_eq = (code == EQ_EXPR);
2020
2021 if (TREE_CODE (lhs) == PTRMEM_CST
2022 && TREE_CODE (rhs) == PTRMEM_CST)
2023 r = constant_boolean_node (cp_tree_equal (lhs, rhs) == is_code_eq,
2024 type);
2025 else if ((TREE_CODE (lhs) == PTRMEM_CST
2026 || TREE_CODE (rhs) == PTRMEM_CST)
2027 && (null_member_pointer_value_p (lhs)
2028 || null_member_pointer_value_p (rhs)))
2029 r = constant_boolean_node (!is_code_eq, type);
2030 else if (TREE_CODE (lhs) == PTRMEM_CST)
2031 lhs = cplus_expand_constant (lhs);
2032 else if (TREE_CODE (rhs) == PTRMEM_CST)
2033 rhs = cplus_expand_constant (rhs);
2034 }
2035 if (code == POINTER_PLUS_EXPR && !*non_constant_p
2036 && integer_zerop (lhs) && !integer_zerop (rhs))
2037 {
2038 if (!ctx->quiet)
2039 error ("arithmetic involving a null pointer in %qE", lhs);
2040 return t;
2041 }
2042 else if (code == POINTER_PLUS_EXPR)
2043 r = cxx_fold_pointer_plus_expression (ctx, t, lhs, rhs, non_constant_p,
2044 overflow_p);
2045
2046 if (r == NULL_TREE)
2047 r = fold_binary_loc (loc, code, type, lhs, rhs);
2048
2049 if (r == NULL_TREE)
2050 {
2051 if (lhs == orig_lhs && rhs == orig_rhs)
2052 r = t;
2053 else
2054 r = build2_loc (loc, code, type, lhs, rhs);
2055 }
2056 else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs))
2057 *non_constant_p = true;
2058 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2059 a local array in a constexpr function. */
2060 bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs));
2061 if (!ptr)
2062 VERIFY_CONSTANT (r);
2063 return r;
2064}
2065
2066/* Subroutine of cxx_eval_constant_expression.
2067 Attempt to evaluate condition expressions. Dead branches are not
2068 looked into. */
2069
2070static tree
2071cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
2072 bool lval,
2073 bool *non_constant_p, bool *overflow_p,
2074 tree *jump_target)
2075{
2076 tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
2077 /*lval*/false,
2078 non_constant_p, overflow_p);
2079 VERIFY_CONSTANT (val);
2080 /* Don't VERIFY_CONSTANT the other operands. */
2081 if (integer_zerop (val))
2082 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
2083 lval,
2084 non_constant_p, overflow_p,
2085 jump_target);
2086 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
2087 lval,
2088 non_constant_p, overflow_p,
2089 jump_target);
2090}
2091
2092/* Subroutine of cxx_eval_constant_expression.
2093 Attempt to evaluate vector condition expressions. Unlike
2094 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2095 ternary arithmetics operation, where all 3 arguments have to be
2096 evaluated as constants and then folding computes the result from
2097 them. */
2098
2099static tree
2100cxx_eval_vector_conditional_expression (const constexpr_ctx *ctx, tree t,
2101 bool *non_constant_p, bool *overflow_p)
2102{
2103 tree arg1 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
2104 /*lval*/false,
2105 non_constant_p, overflow_p);
2106 VERIFY_CONSTANT (arg1);
2107 tree arg2 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
2108 /*lval*/false,
2109 non_constant_p, overflow_p);
2110 VERIFY_CONSTANT (arg2);
2111 tree arg3 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
2112 /*lval*/false,
2113 non_constant_p, overflow_p);
2114 VERIFY_CONSTANT (arg3);
2115 location_t loc = EXPR_LOCATION (t);
2116 tree type = TREE_TYPE (t);
2117 tree r = fold_ternary_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3);
2118 if (r == NULL_TREE)
2119 {
2120 if (arg1 == TREE_OPERAND (t, 0)
2121 && arg2 == TREE_OPERAND (t, 1)
2122 && arg3 == TREE_OPERAND (t, 2))
2123 r = t;
2124 else
2125 r = build3_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3);
2126 }
2127 VERIFY_CONSTANT (r);
2128 return r;
2129}
2130
2131/* Returns less than, equal to, or greater than zero if KEY is found to be
2132 less than, to match, or to be greater than the constructor_elt's INDEX. */
2133
2134static int
2135array_index_cmp (tree key, tree index)
2136{
2137 gcc_assert (TREE_CODE (key) == INTEGER_CST);
2138
2139 switch (TREE_CODE (index))
2140 {
2141 case INTEGER_CST:
2142 return tree_int_cst_compare (key, index);
2143 case RANGE_EXPR:
2144 {
2145 tree lo = TREE_OPERAND (index, 0);
2146 tree hi = TREE_OPERAND (index, 1);
2147 if (tree_int_cst_lt (key, lo))
2148 return -1;
2149 else if (tree_int_cst_lt (hi, key))
2150 return 1;
2151 else
2152 return 0;
2153 }
2154 default:
2155 gcc_unreachable ();
2156 }
2157}
2158
2159/* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
2160 if none. If INSERT is true, insert a matching element rather than fail. */
2161
2162static HOST_WIDE_INT
2163find_array_ctor_elt (tree ary, tree dindex, bool insert = false)
2164{
2165 if (tree_int_cst_sgn (dindex) < 0)
2166 return -1;
2167
2168 unsigned HOST_WIDE_INT i = tree_to_uhwi (dindex);
2169 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ary);
2170 unsigned HOST_WIDE_INT len = vec_safe_length (elts);
2171
2172 unsigned HOST_WIDE_INT end = len;
2173 unsigned HOST_WIDE_INT begin = 0;
2174
2175 /* If the last element of the CONSTRUCTOR has its own index, we can assume
2176 that the same is true of the other elements and index directly. */
2177 if (end > 0)
2178 {
2179 tree cindex = (*elts)[end-1].index;
2180 if (TREE_CODE (cindex) == INTEGER_CST
2181 && compare_tree_int (cindex, end-1) == 0)
2182 {
2183 if (i < end)
2184 return i;
2185 else
2186 begin = end;
2187 }
2188 }
2189
2190 /* Otherwise, find a matching index by means of a binary search. */
2191 while (begin != end)
2192 {
2193 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
2194 constructor_elt &elt = (*elts)[middle];
2195 tree idx = elt.index;
2196
2197 int cmp = array_index_cmp (dindex, idx);
2198 if (cmp < 0)
2199 end = middle;
2200 else if (cmp > 0)
2201 begin = middle + 1;
2202 else
2203 {
2204 if (insert && TREE_CODE (idx) == RANGE_EXPR)
2205 {
2206 /* We need to split the range. */
2207 constructor_elt e;
2208 tree lo = TREE_OPERAND (idx, 0);
2209 tree hi = TREE_OPERAND (idx, 1);
2210 if (tree_int_cst_lt (lo, dindex))
2211 {
2212 /* There are still some lower elts; shorten the range. */
2213 tree new_hi = int_const_binop (MINUS_EXPR, dindex,
2214 size_one_node);
2215 if (tree_int_cst_equal (lo, new_hi))
2216 /* Only one element left, no longer a range. */
2217 elt.index = lo;
2218 else
2219 TREE_OPERAND (idx, 1) = new_hi;
2220 /* Append the element we want to insert. */
2221 ++middle;
2222 e.index = dindex;
2223 e.value = unshare_constructor (elt.value);
2224 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle, e);
2225 }
2226 else
2227 /* No lower elts, the range elt is now ours. */
2228 elt.index = dindex;
2229
2230 if (tree_int_cst_lt (dindex, hi))
2231 {
2232 /* There are still some higher elts; append a range. */
2233 tree new_lo = int_const_binop (PLUS_EXPR, dindex,
2234 size_one_node);
2235 if (tree_int_cst_equal (new_lo, hi))
2236 e.index = hi;
2237 else
2238 e.index = build2 (RANGE_EXPR, sizetype, new_lo, hi);
2239 e.value = unshare_constructor (elt.value);
2240 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle+1, e);
2241 }
2242 }
2243 return middle;
2244 }
2245 }
2246
2247 if (insert)
2248 {
2249 constructor_elt e = { dindex, NULL_TREE };
2250 vec_safe_insert (CONSTRUCTOR_ELTS (ary), end, e);
2251 return end;
2252 }
2253
2254 return -1;
2255}
2256
2257/* Under the control of CTX, issue a detailed diagnostic for
2258 an out-of-bounds subscript INDEX into the expression ARRAY. */
2259
2260static void
2261diag_array_subscript (const constexpr_ctx *ctx, tree array, tree index)
2262{
2263 if (!ctx->quiet)
2264 {
2265 tree arraytype = TREE_TYPE (array);
2266
2267 /* Convert the unsigned array subscript to a signed integer to avoid
2268 printing huge numbers for small negative values. */
2269 tree sidx = fold_convert (ssizetype, index);
2270 if (DECL_P (array))
2271 {
2272 error ("array subscript value %qE is outside the bounds "
2273 "of array %qD of type %qT", sidx, array, arraytype);
2274 inform (DECL_SOURCE_LOCATION (array), "declared here");
2275 }
2276 else
2277 error ("array subscript value %qE is outside the bounds "
2278 "of array type %qT", sidx, arraytype);
2279 }
2280}
2281
2282/* Extract element INDEX consisting of CHARS_PER_ELT chars from
2283 STRING_CST STRING. */
2284
2285static tree
2286extract_string_elt (tree string, unsigned chars_per_elt, unsigned index)
2287{
2288 tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (string)));
2289 tree r;
2290
2291 if (chars_per_elt == 1)
2292 r = build_int_cst (type, TREE_STRING_POINTER (string)[index]);
2293 else
2294 {
2295 const unsigned char *ptr
2296 = ((const unsigned char *)TREE_STRING_POINTER (string)
2297 + index * chars_per_elt);
2298 r = native_interpret_expr (type, ptr, chars_per_elt);
2299 }
2300 return r;
2301}
2302
2303/* Subroutine of cxx_eval_constant_expression.
2304 Attempt to reduce a reference to an array slot. */
2305
2306static tree
2307cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
2308 bool lval,
2309 bool *non_constant_p, bool *overflow_p)
2310{
2311 tree oldary = TREE_OPERAND (t, 0);
2312 tree ary = cxx_eval_constant_expression (ctx, oldary,
2313 lval,
2314 non_constant_p, overflow_p);
2315 tree index, oldidx;
2316 HOST_WIDE_INT i = 0;
2317 tree elem_type = NULL_TREE;
2318 unsigned len = 0, elem_nchars = 1;
2319 if (*non_constant_p)
2320 return t;
2321 oldidx = TREE_OPERAND (t, 1);
2322 index = cxx_eval_constant_expression (ctx, oldidx,
2323 false,
2324 non_constant_p, overflow_p);
2325 VERIFY_CONSTANT (index);
2326 if (!lval)
2327 {
2328 elem_type = TREE_TYPE (TREE_TYPE (ary));
2329 if (TREE_CODE (ary) == VIEW_CONVERT_EXPR
2330 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary, 0)))
2331 && TREE_TYPE (t) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary, 0))))
2332 ary = TREE_OPERAND (ary, 0);
2333 if (TREE_CODE (ary) == CONSTRUCTOR)
2334 len = CONSTRUCTOR_NELTS (ary);
2335 else if (TREE_CODE (ary) == STRING_CST)
2336 {
2337 elem_nchars = (TYPE_PRECISION (elem_type)
2338 / TYPE_PRECISION (char_type_node));
2339 len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
2340 }
2341 else if (TREE_CODE (ary) == VECTOR_CST)
2342 len = VECTOR_CST_NELTS (ary);
2343 else
2344 {
2345 /* We can't do anything with other tree codes, so use
2346 VERIFY_CONSTANT to complain and fail. */
2347 VERIFY_CONSTANT (ary);
2348 gcc_unreachable ();
2349 }
2350
2351 if (!tree_fits_shwi_p (index)
2352 || (i = tree_to_shwi (index)) < 0)
2353 {
2354 diag_array_subscript (ctx, ary, index);
2355 *non_constant_p = true;
2356 return t;
2357 }
2358 }
2359
2360 tree nelts;
2361 if (TREE_CODE (TREE_TYPE (ary)) == ARRAY_TYPE)
2362 nelts = array_type_nelts_top (TREE_TYPE (ary));
2363 else if (VECTOR_TYPE_P (TREE_TYPE (ary)))
2364 nelts = size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary)));
2365 else
2366 gcc_unreachable ();
2367
2368 /* For VLAs, the number of elements won't be an integer constant. */
2369 nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
2370 overflow_p);
2371 VERIFY_CONSTANT (nelts);
2372 if ((lval
2373 ? !tree_int_cst_le (index, nelts)
2374 : !tree_int_cst_lt (index, nelts))
2375 || tree_int_cst_sgn (index) < 0)
2376 {
2377 diag_array_subscript (ctx, ary, index);
2378 *non_constant_p = true;
2379 return t;
2380 }
2381
2382 if (lval && ary == oldary && index == oldidx)
2383 return t;
2384 else if (lval)
2385 return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
2386
2387 bool found;
2388 if (TREE_CODE (ary) == CONSTRUCTOR)
2389 {
2390 HOST_WIDE_INT ix = find_array_ctor_elt (ary, index);
2391 found = (ix >= 0);
2392 if (found)
2393 i = ix;
2394 }
2395 else
2396 found = (i < len);
2397
2398 if (found)
2399 {
2400 tree r;
2401 if (TREE_CODE (ary) == CONSTRUCTOR)
2402 r = (*CONSTRUCTOR_ELTS (ary))[i].value;
2403 else if (TREE_CODE (ary) == VECTOR_CST)
2404 r = VECTOR_CST_ELT (ary, i);
2405 else
2406 r = extract_string_elt (ary, elem_nchars, i);
2407
2408 if (r)
2409 /* Don't VERIFY_CONSTANT here. */
2410 return r;
2411
2412 /* Otherwise the element doesn't have a value yet. */
2413 }
2414
2415 /* Not found. */
2416
2417 if (TREE_CODE (ary) == CONSTRUCTOR
2418 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary))
2419 {
2420 /* 'ary' is part of the aggregate initializer we're currently
2421 building; if there's no initializer for this element yet,
2422 that's an error. */
2423 if (!ctx->quiet)
2424 error ("accessing uninitialized array element");
2425 *non_constant_p = true;
2426 return t;
2427 }
2428
2429 /* If it's within the array bounds but doesn't have an explicit
2430 initializer, it's value-initialized. */
2431 tree val = build_value_init (elem_type, tf_warning_or_error);
2432 return cxx_eval_constant_expression (ctx, val, lval, non_constant_p,
2433 overflow_p);
2434}
2435
2436/* Subroutine of cxx_eval_constant_expression.
2437 Attempt to reduce a field access of a value of class type. */
2438
2439static tree
2440cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
2441 bool lval,
2442 bool *non_constant_p, bool *overflow_p)
2443{
2444 unsigned HOST_WIDE_INT i;
2445 tree field;
2446 tree value;
2447 tree part = TREE_OPERAND (t, 1);
2448 tree orig_whole = TREE_OPERAND (t, 0);
2449 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2450 lval,
2451 non_constant_p, overflow_p);
2452 if (TREE_CODE (whole) == INDIRECT_REF
2453 && integer_zerop (TREE_OPERAND (whole, 0))
2454 && !ctx->quiet)
2455 error ("dereferencing a null pointer in %qE", orig_whole);
2456
2457 if (TREE_CODE (whole) == PTRMEM_CST)
2458 whole = cplus_expand_constant (whole);
2459 if (whole == orig_whole)
2460 return t;
2461 if (lval)
2462 return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
2463 whole, part, NULL_TREE);
2464 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2465 CONSTRUCTOR. */
2466 if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
2467 {
2468 if (!ctx->quiet)
2469 error ("%qE is not a constant expression", orig_whole);
2470 *non_constant_p = true;
2471 }
2472 if (DECL_MUTABLE_P (part))
2473 {
2474 if (!ctx->quiet)
2475 error ("mutable %qD is not usable in a constant expression", part);
2476 *non_constant_p = true;
2477 }
2478 if (*non_constant_p)
2479 return t;
2480 bool pmf = TYPE_PTRMEMFUNC_P (TREE_TYPE (whole));
2481 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2482 {
2483 /* Use name match for PMF fields, as a variant will have a
2484 different FIELD_DECL with a different type. */
2485 if (pmf ? DECL_NAME (field) == DECL_NAME (part)
2486 : field == part)
2487 {
2488 if (value)
2489 return value;
2490 else
2491 /* We're in the middle of initializing it. */
2492 break;
2493 }
2494 }
2495 if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
2496 && CONSTRUCTOR_NELTS (whole) > 0)
2497 {
2498 /* DR 1188 says we don't have to deal with this. */
2499 if (!ctx->quiet)
2500 error ("accessing %qD member instead of initialized %qD member in "
2501 "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
2502 *non_constant_p = true;
2503 return t;
2504 }
2505
2506 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
2507 classes never get represented; throw together a value now. */
2508 if (is_really_empty_class (TREE_TYPE (t)))
2509 return build_constructor (TREE_TYPE (t), NULL);
2510
2511 gcc_assert (DECL_CONTEXT (part) == TYPE_MAIN_VARIANT (TREE_TYPE (whole)));
2512
2513 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole))
2514 {
2515 /* 'whole' is part of the aggregate initializer we're currently
2516 building; if there's no initializer for this member yet, that's an
2517 error. */
2518 if (!ctx->quiet)
2519 error ("accessing uninitialized member %qD", part);
2520 *non_constant_p = true;
2521 return t;
2522 }
2523
2524 /* If there's no explicit init for this field, it's value-initialized. */
2525 value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
2526 return cxx_eval_constant_expression (ctx, value,
2527 lval,
2528 non_constant_p, overflow_p);
2529}
2530
2531/* Subroutine of cxx_eval_constant_expression.
2532 Attempt to reduce a field access of a value of class type that is
2533 expressed as a BIT_FIELD_REF. */
2534
2535static tree
2536cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
2537 bool lval,
2538 bool *non_constant_p, bool *overflow_p)
2539{
2540 tree orig_whole = TREE_OPERAND (t, 0);
2541 tree retval, fldval, utype, mask;
2542 bool fld_seen = false;
2543 HOST_WIDE_INT istart, isize;
2544 tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2545 lval,
2546 non_constant_p, overflow_p);
2547 tree start, field, value;
2548 unsigned HOST_WIDE_INT i;
2549
2550 if (whole == orig_whole)
2551 return t;
2552 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
2553 CONSTRUCTOR. */
2554 if (!*non_constant_p
2555 && TREE_CODE (whole) != VECTOR_CST
2556 && TREE_CODE (whole) != CONSTRUCTOR)
2557 {
2558 if (!ctx->quiet)
2559 error ("%qE is not a constant expression", orig_whole);
2560 *non_constant_p = true;
2561 }
2562 if (*non_constant_p)
2563 return t;
2564
2565 if (TREE_CODE (whole) == VECTOR_CST)
2566 return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
2567 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
2568
2569 start = TREE_OPERAND (t, 2);
2570 istart = tree_to_shwi (start);
2571 isize = tree_to_shwi (TREE_OPERAND (t, 1));
2572 utype = TREE_TYPE (t);
2573 if (!TYPE_UNSIGNED (utype))
2574 utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
2575 retval = build_int_cst (utype, 0);
2576 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2577 {
2578 tree bitpos = bit_position (field);
2579 if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
2580 return value;
2581 if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
2582 && TREE_CODE (value) == INTEGER_CST
2583 && tree_fits_shwi_p (bitpos)
2584 && tree_fits_shwi_p (DECL_SIZE (field)))
2585 {
2586 HOST_WIDE_INT bit = tree_to_shwi (bitpos);
2587 HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field));
2588 HOST_WIDE_INT shift;
2589 if (bit >= istart && bit + sz <= istart + isize)
2590 {
2591 fldval = fold_convert (utype, value);
2592 mask = build_int_cst_type (utype, -1);
2593 mask = fold_build2 (LSHIFT_EXPR, utype, mask,
2594 size_int (TYPE_PRECISION (utype) - sz));
2595 mask = fold_build2 (RSHIFT_EXPR, utype, mask,
2596 size_int (TYPE_PRECISION (utype) - sz));
2597 fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
2598 shift = bit - istart;
2599 if (BYTES_BIG_ENDIAN)
2600 shift = TYPE_PRECISION (utype) - shift - sz;
2601 fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
2602 size_int (shift));
2603 retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
2604 fld_seen = true;
2605 }
2606 }
2607 }
2608 if (fld_seen)
2609 return fold_convert (TREE_TYPE (t), retval);
2610 gcc_unreachable ();
2611 return error_mark_node;
2612}
2613
2614/* Subroutine of cxx_eval_constant_expression.
2615 Evaluate a short-circuited logical expression T in the context
2616 of a given constexpr CALL. BAILOUT_VALUE is the value for
2617 early return. CONTINUE_VALUE is used here purely for
2618 sanity check purposes. */
2619
2620static tree
2621cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
2622 tree bailout_value, tree continue_value,
2623 bool lval,
2624 bool *non_constant_p, bool *overflow_p)
2625{
2626 tree r;
2627 tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
2628 lval,
2629 non_constant_p, overflow_p);
2630 VERIFY_CONSTANT (lhs);
2631 if (tree_int_cst_equal (lhs, bailout_value))
2632 return lhs;
2633 gcc_assert (tree_int_cst_equal (lhs, continue_value));
2634 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
2635 lval, non_constant_p,
2636 overflow_p);
2637 VERIFY_CONSTANT (r);
2638 return r;
2639}
2640
2641/* REF is a COMPONENT_REF designating a particular field. V is a vector of
2642 CONSTRUCTOR elements to initialize (part of) an object containing that
2643 field. Return a pointer to the constructor_elt corresponding to the
2644 initialization of the field. */
2645
2646static constructor_elt *
2647base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
2648{
2649 tree aggr = TREE_OPERAND (ref, 0);
2650 tree field = TREE_OPERAND (ref, 1);
2651 HOST_WIDE_INT i;
2652 constructor_elt *ce;
2653
2654 gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
2655
2656 if (TREE_CODE (aggr) == COMPONENT_REF)
2657 {
2658 constructor_elt *base_ce
2659 = base_field_constructor_elt (v, aggr);
2660 v = CONSTRUCTOR_ELTS (base_ce->value);
2661 }
2662
2663 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
2664 if (ce->index == field)
2665 return ce;
2666
2667 gcc_unreachable ();
2668 return NULL;
2669}
2670
2671/* Some of the expressions fed to the constexpr mechanism are calls to
2672 constructors, which have type void. In that case, return the type being
2673 initialized by the constructor. */
2674
2675static tree
2676initialized_type (tree t)
2677{
2678 if (TYPE_P (t))
2679 return t;
2680 tree type = cv_unqualified (TREE_TYPE (t));
2681 if (TREE_CODE (t) == CALL_EXPR || TREE_CODE (t) == AGGR_INIT_EXPR)
2682 {
2683 /* A constructor call has void type, so we need to look deeper. */
2684 tree fn = get_function_named_in_call (t);
2685 if (fn && TREE_CODE (fn) == FUNCTION_DECL
2686 && DECL_CXX_CONSTRUCTOR_P (fn))
2687 type = DECL_CONTEXT (fn);
2688 }
2689 return type;
2690}
2691
2692/* We're about to initialize element INDEX of an array or class from VALUE.
2693 Set up NEW_CTX appropriately by adjusting .object to refer to the
2694 subobject and creating a new CONSTRUCTOR if the element is itself
2695 a class or array. */
2696
2697static void
2698init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
2699 tree index, tree &value)
2700{
2701 new_ctx = *ctx;
2702
2703 if (index && TREE_CODE (index) != INTEGER_CST
2704 && TREE_CODE (index) != FIELD_DECL)
2705 /* This won't have an element in the new CONSTRUCTOR. */
2706 return;
2707
2708 tree type = initialized_type (value);
2709 if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type))
2710 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
2711 return;
2712
2713 /* The sub-aggregate initializer might contain a placeholder;
2714 update object to refer to the subobject and ctor to refer to
2715 the (newly created) sub-initializer. */
2716 if (ctx->object)
2717 new_ctx.object = build_ctor_subob_ref (index, type, ctx->object);
2718 tree elt = build_constructor (type, NULL);
2719 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt) = true;
2720 new_ctx.ctor = elt;
2721
2722 if (TREE_CODE (value) == TARGET_EXPR)
2723 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
2724 value = TARGET_EXPR_INITIAL (value);
2725}
2726
2727/* We're about to process an initializer for a class or array TYPE. Make
2728 sure that CTX is set up appropriately. */
2729
2730static void
2731verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
2732{
2733 /* We don't bother building a ctor for an empty base subobject. */
2734 if (is_empty_class (type))
2735 return;
2736
2737 /* We're in the middle of an initializer that might involve placeholders;
2738 our caller should have created a CONSTRUCTOR for us to put the
2739 initializer into. We will either return that constructor or T. */
2740 gcc_assert (ctx->ctor);
2741 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2742 (type, TREE_TYPE (ctx->ctor)));
2743 /* We used to check that ctx->ctor was empty, but that isn't the case when
2744 the object is zero-initialized before calling the constructor. */
2745 if (ctx->object)
2746 {
2747 tree otype = TREE_TYPE (ctx->object);
2748 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, otype)
2749 /* Handle flexible array members. */
2750 || (TREE_CODE (otype) == ARRAY_TYPE
2751 && TYPE_DOMAIN (otype) == NULL_TREE
2752 && TREE_CODE (type) == ARRAY_TYPE
2753 && (same_type_ignoring_top_level_qualifiers_p
2754 (TREE_TYPE (type), TREE_TYPE (otype)))));
2755 }
2756 gcc_assert (!ctx->object || !DECL_P (ctx->object)
2757 || *(ctx->values->get (ctx->object)) == ctx->ctor);
2758}
2759
2760/* Subroutine of cxx_eval_constant_expression.
2761 The expression tree T denotes a C-style array or a C-style
2762 aggregate. Reduce it to a constant expression. */
2763
2764static tree
2765cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
2766 bool lval,
2767 bool *non_constant_p, bool *overflow_p)
2768{
2769 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
2770 bool changed = false;
2771 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
2772 tree type = TREE_TYPE (t);
2773
2774 constexpr_ctx new_ctx;
2775 if (TYPE_PTRMEMFUNC_P (type) || VECTOR_TYPE_P (type))
2776 {
2777 /* We don't really need the ctx->ctor business for a PMF or
2778 vector, but it's simpler to use the same code. */
2779 new_ctx = *ctx;
2780 new_ctx.ctor = build_constructor (type, NULL);
2781 new_ctx.object = NULL_TREE;
2782 ctx = &new_ctx;
2783 };
2784 verify_ctor_sanity (ctx, type);
2785 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2786 vec_alloc (*p, vec_safe_length (v));
2787
2788 unsigned i;
2789 tree index, value;
2790 bool constant_p = true;
2791 bool side_effects_p = false;
2792 FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value)
2793 {
2794 tree orig_value = value;
2795 init_subob_ctx (ctx, new_ctx, index, value);
2796 if (new_ctx.ctor != ctx->ctor)
2797 /* If we built a new CONSTRUCTOR, attach it now so that other
2798 initializers can refer to it. */
2799 CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor);
2800 tree elt = cxx_eval_constant_expression (&new_ctx, value,
2801 lval,
2802 non_constant_p, overflow_p);
2803 /* Don't VERIFY_CONSTANT here. */
2804 if (ctx->quiet && *non_constant_p)
2805 break;
2806 if (elt != orig_value)
2807 changed = true;
2808
2809 if (!TREE_CONSTANT (elt))
2810 constant_p = false;
2811 if (TREE_SIDE_EFFECTS (elt))
2812 side_effects_p = true;
2813 if (index && TREE_CODE (index) == COMPONENT_REF)
2814 {
2815 /* This is an initialization of a vfield inside a base
2816 subaggregate that we already initialized; push this
2817 initialization into the previous initialization. */
2818 constructor_elt *inner = base_field_constructor_elt (*p, index);
2819 inner->value = elt;
2820 changed = true;
2821 }
2822 else if (index
2823 && (TREE_CODE (index) == NOP_EXPR
2824 || TREE_CODE (index) == POINTER_PLUS_EXPR))
2825 {
2826 /* This is an initializer for an empty base; now that we've
2827 checked that it's constant, we can ignore it. */
2828 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index))));
2829 changed = true;
2830 }
2831 else if (new_ctx.ctor != ctx->ctor)
2832 {
2833 /* We appended this element above; update the value. */
2834 gcc_assert ((*p)->last().index == index);
2835 (*p)->last().value = elt;
2836 }
2837 else
2838 CONSTRUCTOR_APPEND_ELT (*p, index, elt);
2839 }
2840 if (*non_constant_p || !changed)
2841 return t;
2842 t = ctx->ctor;
2843 /* We're done building this CONSTRUCTOR, so now we can interpret an
2844 element without an explicit initializer as value-initialized. */
2845 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
2846 TREE_CONSTANT (t) = constant_p;
2847 TREE_SIDE_EFFECTS (t) = side_effects_p;
2848 if (VECTOR_TYPE_P (type))
2849 t = fold (t);
2850 return t;
2851}
2852
2853/* Subroutine of cxx_eval_constant_expression.
2854 The expression tree T is a VEC_INIT_EXPR which denotes the desired
2855 initialization of a non-static data member of array type. Reduce it to a
2856 CONSTRUCTOR.
2857
2858 Note that apart from value-initialization (when VALUE_INIT is true),
2859 this is only intended to support value-initialization and the
2860 initializations done by defaulted constructors for classes with
2861 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2862 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2863 for the copy/move constructor. */
2864
2865static tree
2866cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
2867 bool value_init, bool lval,
2868 bool *non_constant_p, bool *overflow_p)
2869{
2870 tree elttype = TREE_TYPE (atype);
2871 unsigned HOST_WIDE_INT max = tree_to_uhwi (array_type_nelts_top (atype));
2872 verify_ctor_sanity (ctx, atype);
2873 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2874 vec_alloc (*p, max + 1);
2875 bool pre_init = false;
2876 unsigned HOST_WIDE_INT i;
2877
2878 /* For the default constructor, build up a call to the default
2879 constructor of the element type. We only need to handle class types
2880 here, as for a constructor to be constexpr, all members must be
2881 initialized, which for a defaulted default constructor means they must
2882 be of a class type with a constexpr default constructor. */
2883 if (TREE_CODE (elttype) == ARRAY_TYPE)
2884 /* We only do this at the lowest level. */;
2885 else if (value_init)
2886 {
2887 init = build_value_init (elttype, tf_warning_or_error);
2888 pre_init = true;
2889 }
2890 else if (!init)
2891 {
2892 vec<tree, va_gc> *argvec = make_tree_vector ();
2893 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
2894 &argvec, elttype, LOOKUP_NORMAL,
2895 tf_warning_or_error);
2896 release_tree_vector (argvec);
2897 init = build_aggr_init_expr (TREE_TYPE (init), init);
2898 pre_init = true;
2899 }
2900
2901 for (i = 0; i < max; ++i)
2902 {
2903 tree idx = build_int_cst (size_type_node, i);
2904 tree eltinit;
2905 bool reuse = false;
2906 constexpr_ctx new_ctx;
2907 init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype);
2908 if (new_ctx.ctor != ctx->ctor)
2909 CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor);
2910 if (TREE_CODE (elttype) == ARRAY_TYPE)
2911 {
2912 /* A multidimensional array; recurse. */
2913 if (value_init || init == NULL_TREE)
2914 {
2915 eltinit = NULL_TREE;
2916 reuse = i == 0;
2917 }
2918 else
2919 eltinit = cp_build_array_ref (input_location, init, idx,
2920 tf_warning_or_error);
2921 eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
2922 lval,
2923 non_constant_p, overflow_p);
2924 }
2925 else if (pre_init)
2926 {
2927 /* Initializing an element using value or default initialization
2928 we just pre-built above. */
2929 eltinit = cxx_eval_constant_expression (&new_ctx, init, lval,
2930 non_constant_p, overflow_p);
2931 reuse = i == 0;
2932 }
2933 else
2934 {
2935 /* Copying an element. */
2936 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2937 (atype, TREE_TYPE (init)));
2938 eltinit = cp_build_array_ref (input_location, init, idx,
2939 tf_warning_or_error);
2940 if (!lvalue_p (init))
2941 eltinit = move (eltinit);
2942 eltinit = force_rvalue (eltinit, tf_warning_or_error);
2943 eltinit = (cxx_eval_constant_expression
2944 (&new_ctx, eltinit, lval,
2945 non_constant_p, overflow_p));
2946 }
2947 if (*non_constant_p && !ctx->quiet)
2948 break;
2949 if (new_ctx.ctor != ctx->ctor)
2950 {
2951 /* We appended this element above; update the value. */
2952 gcc_assert ((*p)->last().index == idx);
2953 (*p)->last().value = eltinit;
2954 }
2955 else
2956 CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit);
2957 /* Reuse the result of cxx_eval_constant_expression call
2958 from the first iteration to all others if it is a constant
2959 initializer that doesn't require relocations. */
2960 if (reuse
2961 && max > 1
2962 && (initializer_constant_valid_p (eltinit, TREE_TYPE (eltinit))
2963 == null_pointer_node))
2964 {
2965 if (new_ctx.ctor != ctx->ctor)
2966 eltinit = new_ctx.ctor;
2967 for (i = 1; i < max; ++i)
2968 {
2969 idx = build_int_cst (size_type_node, i);
2970 CONSTRUCTOR_APPEND_ELT (*p, idx, unshare_constructor (eltinit));
2971 }
2972 break;
2973 }
2974 }
2975
2976 if (!*non_constant_p)
2977 {
2978 init = ctx->ctor;
2979 CONSTRUCTOR_NO_IMPLICIT_ZERO (init) = false;
2980 }
2981 return init;
2982}
2983
2984static tree
2985cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
2986 bool lval,
2987 bool *non_constant_p, bool *overflow_p)
2988{
2989 tree atype = TREE_TYPE (t);
2990 tree init = VEC_INIT_EXPR_INIT (t);
2991 tree r = cxx_eval_vec_init_1 (ctx, atype, init,
2992 VEC_INIT_EXPR_VALUE_INIT (t),
2993 lval, non_constant_p, overflow_p);
2994 if (*non_constant_p)
2995 return t;
2996 else
2997 return r;
2998}
2999
3000/* A less strict version of fold_indirect_ref_1, which requires cv-quals to
3001 match. We want to be less strict for simple *& folding; if we have a
3002 non-const temporary that we access through a const pointer, that should
3003 work. We handle this here rather than change fold_indirect_ref_1
3004 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3005 don't really make sense outside of constant expression evaluation. Also
3006 we want to allow folding to COMPONENT_REF, which could cause trouble
3007 with TBAA in fold_indirect_ref_1.
3008
3009 Try to keep this function synced with fold_indirect_ref_1. */
3010
3011static tree
3012cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
3013{
3014 tree sub, subtype;
3015
3016 sub = op0;
3017 STRIP_NOPS (sub);
3018 subtype = TREE_TYPE (sub);
3019 if (!POINTER_TYPE_P (subtype))
3020 return NULL_TREE;
3021
3022 if (TREE_CODE (sub) == ADDR_EXPR)
3023 {
3024 tree op = TREE_OPERAND (sub, 0);
3025 tree optype = TREE_TYPE (op);
3026
3027 /* *&CONST_DECL -> to the value of the const decl. */
3028 if (TREE_CODE (op) == CONST_DECL)
3029 return DECL_INITIAL (op);
3030 /* *&p => p; make sure to handle *&"str"[cst] here. */
3031 if (same_type_ignoring_top_level_qualifiers_p (optype, type)
3032 /* Also handle the case where the desired type is an array of unknown
3033 bounds because the variable has had its bounds deduced since the
3034 ADDR_EXPR was created. */
3035 || (TREE_CODE (type) == ARRAY_TYPE
3036 && TREE_CODE (optype) == ARRAY_TYPE
3037 && TYPE_DOMAIN (type) == NULL_TREE
3038 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype),
3039 TREE_TYPE (type))))
3040 {
3041 tree fop = fold_read_from_constant_string (op);
3042 if (fop)
3043 return fop;
3044 else
3045 return op;
3046 }
3047 /* *(foo *)&fooarray => fooarray[0] */
3048 else if (TREE_CODE (optype) == ARRAY_TYPE
3049 && (same_type_ignoring_top_level_qualifiers_p
3050 (type, TREE_TYPE (optype))))
3051 {
3052 tree type_domain = TYPE_DOMAIN (optype);
3053 tree min_val = size_zero_node;
3054 if (type_domain && TYPE_MIN_VALUE (type_domain))
3055 min_val = TYPE_MIN_VALUE (type_domain);
3056 return build4_loc (loc, ARRAY_REF, type, op, min_val,
3057 NULL_TREE, NULL_TREE);
3058 }
3059 /* *(foo *)&complexfoo => __real__ complexfoo */
3060 else if (TREE_CODE (optype) == COMPLEX_TYPE
3061 && (same_type_ignoring_top_level_qualifiers_p
3062 (type, TREE_TYPE (optype))))
3063 return fold_build1_loc (loc, REALPART_EXPR, type, op);
3064 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
3065 else if (VECTOR_TYPE_P (optype)
3066 && (same_type_ignoring_top_level_qualifiers_p
3067 (type, TREE_TYPE (optype))))
3068 {
3069 tree part_width = TYPE_SIZE (type);
3070 tree index = bitsize_int (0);
3071 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
3072 }
3073 /* Also handle conversion to an empty base class, which
3074 is represented with a NOP_EXPR. */
3075 else if (is_empty_class (type)
3076 && CLASS_TYPE_P (optype)
3077 && DERIVED_FROM_P (type, optype))
3078 {
3079 *empty_base = true;
3080 return op;
3081 }
3082 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
3083 else if (RECORD_OR_UNION_TYPE_P (optype))
3084 {
3085 tree field = TYPE_FIELDS (optype);
3086 for (; field; field = DECL_CHAIN (field))
3087 if (TREE_CODE (field) == FIELD_DECL
3088 && TREE_TYPE (field) != error_mark_node
3089 && integer_zerop (byte_position (field))
3090 && (same_type_ignoring_top_level_qualifiers_p
3091 (TREE_TYPE (field), type)))
3092 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
3093 }
3094 }
3095 else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
3096 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
3097 {
3098 tree op00 = TREE_OPERAND (sub, 0);
3099 tree op01 = TREE_OPERAND (sub, 1);
3100
3101 STRIP_NOPS (op00);
3102 if (TREE_CODE (op00) == ADDR_EXPR)
3103 {
3104 tree op00type;
3105 op00 = TREE_OPERAND (op00, 0);
3106 op00type = TREE_TYPE (op00);
3107
3108 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
3109 if (VECTOR_TYPE_P (op00type)
3110 && (same_type_ignoring_top_level_qualifiers_p
3111 (type, TREE_TYPE (op00type))))
3112 {
3113 HOST_WIDE_INT offset = tree_to_shwi (op01);
3114 tree part_width = TYPE_SIZE (type);
3115 unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
3116 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
3117 tree index = bitsize_int (indexi);
3118
3119 if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
3120 return fold_build3_loc (loc,
3121 BIT_FIELD_REF, type, op00,
3122 part_width, index);
3123
3124 }
3125 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
3126 else if (TREE_CODE (op00type) == COMPLEX_TYPE
3127 && (same_type_ignoring_top_level_qualifiers_p
3128 (type, TREE_TYPE (op00type))))
3129 {
3130 tree size = TYPE_SIZE_UNIT (type);
3131 if (tree_int_cst_equal (size, op01))
3132 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
3133 }
3134 /* ((foo *)&fooarray)[1] => fooarray[1] */
3135 else if (TREE_CODE (op00type) == ARRAY_TYPE
3136 && (same_type_ignoring_top_level_qualifiers_p
3137 (type, TREE_TYPE (op00type))))
3138 {
3139 tree type_domain = TYPE_DOMAIN (op00type);
3140 tree min_val = size_zero_node;
3141 if (type_domain && TYPE_MIN_VALUE (type_domain))
3142 min_val = TYPE_MIN_VALUE (type_domain);
3143 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
3144 TYPE_SIZE_UNIT (type));
3145 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
3146 return build4_loc (loc, ARRAY_REF, type, op00, op01,
3147 NULL_TREE, NULL_TREE);
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 (op00type)
3153 && DERIVED_FROM_P (type, op00type))
3154 {
3155 *empty_base = true;
3156 return op00;
3157 }
3158 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
3159 else if (RECORD_OR_UNION_TYPE_P (op00type))
3160 {
3161 tree field = TYPE_FIELDS (op00type);
3162 for (; field; field = DECL_CHAIN (field))
3163 if (TREE_CODE (field) == FIELD_DECL
3164 && TREE_TYPE (field) != error_mark_node
3165 && tree_int_cst_equal (byte_position (field), op01)
3166 && (same_type_ignoring_top_level_qualifiers_p
3167 (TREE_TYPE (field), type)))
3168 return fold_build3 (COMPONENT_REF, type, op00,
3169 field, NULL_TREE);
3170 }
3171 }
3172 }
3173 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3174 else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
3175 && (same_type_ignoring_top_level_qualifiers_p
3176 (type, TREE_TYPE (TREE_TYPE (subtype)))))
3177 {
3178 tree type_domain;
3179 tree min_val = size_zero_node;
3180 tree newsub = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
3181 if (newsub)
3182 sub = newsub;
3183 else
3184 sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
3185 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
3186 if (type_domain && TYPE_MIN_VALUE (type_domain))
3187 min_val = TYPE_MIN_VALUE (type_domain);
3188 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
3189 NULL_TREE);
3190 }
3191
3192 return NULL_TREE;
3193}
3194
3195static tree
3196cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
3197 bool lval,
3198 bool *non_constant_p, bool *overflow_p)
3199{
3200 tree orig_op0 = TREE_OPERAND (t, 0);
3201 bool empty_base = false;
3202
3203 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
3204 operand is an integer-zero. Otherwise reject the MEM_REF for now. */
3205
3206 if (TREE_CODE (t) == MEM_REF
3207 && (!TREE_OPERAND (t, 1) || !integer_zerop (TREE_OPERAND (t, 1))))
3208 {
3209 gcc_assert (ctx->quiet);
3210 *non_constant_p = true;
3211 return t;
3212 }
3213
3214 /* First try to simplify it directly. */
3215 tree r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), orig_op0,
3216 &empty_base);
3217 if (!r)
3218 {
3219 /* If that didn't work, evaluate the operand first. */
3220 tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
3221 /*lval*/false, non_constant_p,
3222 overflow_p);
3223 /* Don't VERIFY_CONSTANT here. */
3224 if (*non_constant_p)
3225 return t;
3226
3227 if (!lval && integer_zerop (op0))
3228 {
3229 if (!ctx->quiet)
3230 error ("dereferencing a null pointer");
3231 *non_constant_p = true;
3232 return t;
3233 }
3234
3235 r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
3236 &empty_base);
3237 if (r == NULL_TREE)
3238 {
3239 /* We couldn't fold to a constant value. Make sure it's not
3240 something we should have been able to fold. */
3241 tree sub = op0;
3242 STRIP_NOPS (sub);
3243 if (TREE_CODE (sub) == ADDR_EXPR)
3244 {
3245 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3246 (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
3247 /* DR 1188 says we don't have to deal with this. */
3248 if (!ctx->quiet)
3249 error ("accessing value of %qE through a %qT glvalue in a "
3250 "constant expression", build_fold_indirect_ref (sub),
3251 TREE_TYPE (t));
3252 *non_constant_p = true;
3253 return t;
3254 }
3255
3256 if (lval && op0 != orig_op0)
3257 return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
3258 if (!lval)
3259 VERIFY_CONSTANT (t);
3260 return t;
3261 }
3262 }
3263
3264 r = cxx_eval_constant_expression (ctx, r,
3265 lval, non_constant_p, overflow_p);
3266 if (*non_constant_p)
3267 return t;
3268
3269 /* If we're pulling out the value of an empty base, just return an empty
3270 CONSTRUCTOR. */
3271 if (empty_base && !lval)
3272 {
3273 r = build_constructor (TREE_TYPE (t), NULL);
3274 TREE_CONSTANT (r) = true;
3275 }
3276
3277 return r;
3278}
3279
3280/* Complain about R, a VAR_DECL, not being usable in a constant expression.
3281 Shared between potential_constant_expression and
3282 cxx_eval_constant_expression. */
3283
3284static void
3285non_const_var_error (tree r)
3286{
3287 tree type = TREE_TYPE (r);
3288 error ("the value of %qD is not usable in a constant "
3289 "expression", r);
3290 /* Avoid error cascade. */
3291 if (DECL_INITIAL (r) == error_mark_node)
3292 return;
3293 if (DECL_DECLARED_CONSTEXPR_P (r))
3294 inform (DECL_SOURCE_LOCATION (r),
3295 "%qD used in its own initializer", r);
3296 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
3297 {
3298 if (!CP_TYPE_CONST_P (type))
3299 inform (DECL_SOURCE_LOCATION (r),
3300 "%q#D is not const", r);
3301 else if (CP_TYPE_VOLATILE_P (type))
3302 inform (DECL_SOURCE_LOCATION (r),
3303 "%q#D is volatile", r);
3304 else if (!DECL_INITIAL (r)
3305 || !TREE_CONSTANT (DECL_INITIAL (r))
3306 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r))
3307 inform (DECL_SOURCE_LOCATION (r),
3308 "%qD was not initialized with a constant "
3309 "expression", r);
3310 else
3311 gcc_unreachable ();
3312 }
3313 else if (TREE_CODE (type) == REFERENCE_TYPE)
3314 inform (DECL_SOURCE_LOCATION (r),
3315 "%qD was not initialized with a constant "
3316 "expression", r);
3317 else
3318 {
3319 if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
3320 inform (DECL_SOURCE_LOCATION (r),
3321 "%qD was not declared %<constexpr%>", r);
3322 else
3323 inform (DECL_SOURCE_LOCATION (r),
3324 "%qD does not have integral or enumeration type",
3325 r);
3326 }
3327}
3328
3329/* Subroutine of cxx_eval_constant_expression.
3330 Like cxx_eval_unary_expression, except for trinary expressions. */
3331
3332static tree
3333cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
3334 bool lval,
3335 bool *non_constant_p, bool *overflow_p)
3336{
3337 int i;
3338 tree args[3];
3339 tree val;
3340
3341 for (i = 0; i < 3; i++)
3342 {
3343 args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
3344 lval,
3345 non_constant_p, overflow_p);
3346 VERIFY_CONSTANT (args[i]);
3347 }
3348
3349 val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
3350 args[0], args[1], args[2]);
3351 if (val == NULL_TREE)
3352 return t;
3353 VERIFY_CONSTANT (val);
3354 return val;
3355}
3356
3357/* True if T was declared in a function declared to be constexpr, and
3358 therefore potentially constant in C++14. */
3359
3360bool
3361var_in_constexpr_fn (tree t)
3362{
3363 tree ctx = DECL_CONTEXT (t);
3364 return (ctx && TREE_CODE (ctx) == FUNCTION_DECL
3365 && DECL_DECLARED_CONSTEXPR_P (ctx));
3366}
3367
3368/* True if T was declared in a function that might be constexpr: either a
3369 function that was declared constexpr, or a C++17 lambda op(). */
3370
3371bool
3372var_in_maybe_constexpr_fn (tree t)
3373{
3374 if (cxx_dialect >= cxx17
3375 && DECL_FUNCTION_SCOPE_P (t)
3376 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t)))
3377 return true;
3378 return var_in_constexpr_fn (t);
3379}
3380
3381/* We're assigning INIT to TARGET. In do_build_copy_constructor and
3382 build_over_call we implement trivial copy of a class with tail padding using
3383 assignment of character arrays, which is valid in normal code, but not in
3384 constexpr evaluation. We don't need to worry about clobbering tail padding
3385 in constexpr evaluation, so strip the type punning. */
3386
3387static void
3388maybe_simplify_trivial_copy (tree &target, tree &init)
3389{
3390 if (TREE_CODE (target) == MEM_REF
3391 && TREE_CODE (init) == MEM_REF
3392 && TREE_TYPE (target) == TREE_TYPE (init)
3393 && TREE_CODE (TREE_TYPE (target)) == ARRAY_TYPE
3394 && TREE_TYPE (TREE_TYPE (target)) == unsigned_char_type_node)
3395 {
3396 target = build_fold_indirect_ref (TREE_OPERAND (target, 0));
3397 init = build_fold_indirect_ref (TREE_OPERAND (init, 0));
3398 }
3399}
3400
3401/* Evaluate an INIT_EXPR or MODIFY_EXPR. */
3402
3403static tree
3404cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
3405 bool lval,
3406 bool *non_constant_p, bool *overflow_p)
3407{
3408 constexpr_ctx new_ctx = *ctx;
3409
3410 tree init = TREE_OPERAND (t, 1);
3411 if (TREE_CLOBBER_P (init))
3412 /* Just ignore clobbers. */
3413 return void_node;
3414
3415 /* First we figure out where we're storing to. */
3416 tree target = TREE_OPERAND (t, 0);
3417
3418 maybe_simplify_trivial_copy (target, init);
3419
3420 tree type = TREE_TYPE (target);
3421 target = cxx_eval_constant_expression (ctx, target,
3422 true,
3423 non_constant_p, overflow_p);
3424 if (*non_constant_p)
3425 return t;
3426
3427 /* cxx_eval_array_reference for lval = true allows references one past
3428 end of array, because it does not know if it is just taking address
3429 (which is valid), or actual dereference. Here we know it is
3430 a dereference, so diagnose it here. */
3431 for (tree probe = target; probe; )
3432 {
3433 switch (TREE_CODE (probe))
3434 {
3435 case ARRAY_REF:
3436 tree nelts, ary;
3437 ary = TREE_OPERAND (probe, 0);
3438 if (TREE_CODE (TREE_TYPE (ary)) == ARRAY_TYPE)
3439 nelts = array_type_nelts_top (TREE_TYPE (ary));
3440 else if (VECTOR_TYPE_P (TREE_TYPE (ary)))
3441 nelts = size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary)));
3442 else
3443 gcc_unreachable ();
3444 nelts = cxx_eval_constant_expression (ctx, nelts, false,
3445 non_constant_p, overflow_p);
3446 VERIFY_CONSTANT (nelts);
3447 gcc_assert (TREE_CODE (nelts) == INTEGER_CST
3448 && TREE_CODE (TREE_OPERAND (probe, 1)) == INTEGER_CST);
3449 if (wi::to_widest (TREE_OPERAND (probe, 1)) == wi::to_widest (nelts))
3450 {
3451 diag_array_subscript (ctx, ary, TREE_OPERAND (probe, 1));
3452 *non_constant_p = true;
3453 return t;
3454 }
3455 /* FALLTHRU */
3456
3457 case BIT_FIELD_REF:
3458 case COMPONENT_REF:
3459 probe = TREE_OPERAND (probe, 0);
3460 continue;
3461
3462 default:
3463 probe = NULL_TREE;
3464 continue;
3465 }
3466 }
3467
3468 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target), type))
3469 {
3470 /* For initialization of an empty base, the original target will be
3471 *(base*)this, which the above evaluation resolves to the object
3472 argument, which has the derived type rather than the base type. In
3473 this situation, just evaluate the initializer and return, since
3474 there's no actual data to store. */
3475 gcc_assert (is_empty_class (type));
3476 return cxx_eval_constant_expression (ctx, init, false,
3477 non_constant_p, overflow_p);
3478 }
3479
3480 /* And then find the underlying variable. */
3481 vec<tree,va_gc> *refs = make_tree_vector();
3482 tree object = NULL_TREE;
3483 for (tree probe = target; object == NULL_TREE; )
3484 {
3485 switch (TREE_CODE (probe))
3486 {
3487 case BIT_FIELD_REF:
3488 case COMPONENT_REF:
3489 case ARRAY_REF:
3490 vec_safe_push (refs, TREE_OPERAND (probe, 1));
3491 vec_safe_push (refs, TREE_TYPE (probe));
3492 probe = TREE_OPERAND (probe, 0);
3493 break;
3494
3495 default:
3496 object = probe;
3497 }
3498 }
3499
3500 /* And then find/build up our initializer for the path to the subobject
3501 we're initializing. */
3502 tree *valp;
3503 if (object == ctx->object && VAR_P (object)
3504 && DECL_NAME (object) && ctx->call == NULL)
3505 /* The variable we're building up an aggregate initializer for is outside
3506 the constant-expression, so don't evaluate the store. We check
3507 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */
3508 valp = NULL;
3509 else if (DECL_P (object))
3510 valp = ctx->values->get (object);
3511 else
3512 valp = NULL;
3513 if (!valp)
3514 {
3515 /* A constant-expression cannot modify objects from outside the
3516 constant-expression. */
3517 if (!ctx->quiet)
3518 error ("modification of %qE is not a constant expression", object);
3519 *non_constant_p = true;
3520 return t;
3521 }
3522 type = TREE_TYPE (object);
3523 bool no_zero_init = true;
3524
3525 vec<tree,va_gc> *ctors = make_tree_vector ();
3526 while (!refs->is_empty())
3527 {
3528 if (*valp == NULL_TREE)
3529 {
3530 *valp = build_constructor (type, NULL);
3531 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init;
3532 }
3533 else if (TREE_CODE (*valp) == STRING_CST)
3534 {
3535 /* An array was initialized with a string constant, and now
3536 we're writing into one of its elements. Explode the
3537 single initialization into a set of element
3538 initializations. */
3539 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
3540
3541 tree string = *valp;
3542 tree elt_type = TREE_TYPE (type);
3543 unsigned chars_per_elt = (TYPE_PRECISION (elt_type)
3544 / TYPE_PRECISION (char_type_node));
3545 unsigned num_elts = TREE_STRING_LENGTH (string) / chars_per_elt;
3546 tree ary_ctor = build_constructor (type, NULL);
3547
3548 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor), num_elts);
3549 for (unsigned ix = 0; ix != num_elts; ix++)
3550 {
3551 constructor_elt elt =
3552 {
3553 build_int_cst (size_type_node, ix),
3554 extract_string_elt (string, chars_per_elt, ix)
3555 };
3556 CONSTRUCTOR_ELTS (ary_ctor)->quick_push (elt);
3557 }
3558
3559 *valp = ary_ctor;
3560 }
3561
3562 /* If the value of object is already zero-initialized, any new ctors for
3563 subobjects will also be zero-initialized. */
3564 no_zero_init = CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp);
3565
3566 vec_safe_push (ctors, *valp);
3567
3568 enum tree_code code = TREE_CODE (type);
3569 type = refs->pop();
3570 tree index = refs->pop();
3571
3572 constructor_elt *cep = NULL;
3573 if (code == ARRAY_TYPE)
3574 {
3575 HOST_WIDE_INT i
3576 = find_array_ctor_elt (*valp, index, /*insert*/true);
3577 gcc_assert (i >= 0);
3578 cep = CONSTRUCTOR_ELT (*valp, i);
3579 gcc_assert (TREE_CODE (cep->index) != RANGE_EXPR);
3580 }
3581 else
3582 {
3583 gcc_assert (TREE_CODE (index) == FIELD_DECL);
3584
3585 /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
3586 Usually we meet initializers in that order, but it is
3587 possible for base types to be placed not in program
3588 order. */
3589 tree fields = TYPE_FIELDS (DECL_CONTEXT (index));
3590 unsigned HOST_WIDE_INT idx;
3591
3592 if (code == UNION_TYPE && CONSTRUCTOR_NELTS (*valp)
3593 && CONSTRUCTOR_ELT (*valp, 0)->index != index)
3594 /* Changing active member. */
3595 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp), 0);
3596
3597 for (idx = 0;
3598 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep);
3599 idx++, fields = DECL_CHAIN (fields))
3600 {
3601 if (index == cep->index)
3602 goto found;
3603
3604 /* The field we're initializing must be on the field
3605 list. Look to see if it is present before the
3606 field the current ELT initializes. */
3607 for (; fields != cep->index; fields = DECL_CHAIN (fields))
3608 if (index == fields)
3609 goto insert;
3610 }
3611
3612 /* We fell off the end of the CONSTRUCTOR, so insert a new
3613 entry at the end. */
3614 insert:
3615 {
3616 constructor_elt ce = { index, NULL_TREE };
3617
3618 vec_safe_insert (CONSTRUCTOR_ELTS (*valp), idx, ce);
3619 cep = CONSTRUCTOR_ELT (*valp, idx);
3620 }
3621 found:;
3622 }
3623 valp = &cep->value;
3624 }
3625 release_tree_vector (refs);
3626
3627 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
3628 {
3629 /* Create a new CONSTRUCTOR in case evaluation of the initializer
3630 wants to modify it. */
3631 if (*valp == NULL_TREE)
3632 {
3633 *valp = build_constructor (type, NULL);
3634 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init;
3635 }
3636 else if (TREE_CODE (*valp) == PTRMEM_CST)
3637 *valp = cplus_expand_constant (*valp);
3638 new_ctx.ctor = *valp;
3639 new_ctx.object = target;
3640 }
3641
3642 init = cxx_eval_constant_expression (&new_ctx, init, false,
3643 non_constant_p, overflow_p);
3644 /* Don't share a CONSTRUCTOR that might be changed later. */
3645 init = unshare_constructor (init);
3646 if (target == object)
3647 /* The hash table might have moved since the get earlier. */
3648 valp = ctx->values->get (object);
3649
3650 if (TREE_CODE (init) == CONSTRUCTOR)
3651 {
3652 /* An outer ctx->ctor might be pointing to *valp, so replace
3653 its contents. */
3654 CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init);
3655 TREE_CONSTANT (*valp) = TREE_CONSTANT (init);
3656 TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init);
3657 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp)
3658 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init);
3659 }
3660 else
3661 *valp = init;
3662
3663 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
3664 CONSTRUCTORs, if any. */
3665 tree elt;
3666 unsigned i;
3667 bool c = TREE_CONSTANT (init);
3668 bool s = TREE_SIDE_EFFECTS (init);
3669 if (!c || s)
3670 FOR_EACH_VEC_SAFE_ELT (ctors, i, elt)
3671 {
3672 if (!c)
3673 TREE_CONSTANT (elt) = false;
3674 if (s)
3675 TREE_SIDE_EFFECTS (elt) = true;
3676 }
3677 release_tree_vector (ctors);
3678
3679 if (*non_constant_p)
3680 return t;
3681 else if (lval)
3682 return target;
3683 else
3684 return init;
3685}
3686
3687/* Evaluate a ++ or -- expression. */
3688
3689static tree
3690cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
3691 bool lval,
3692 bool *non_constant_p, bool *overflow_p)
3693{
3694 enum tree_code code = TREE_CODE (t);
3695 tree type = TREE_TYPE (t);
3696 tree op = TREE_OPERAND (t, 0);
3697 tree offset = TREE_OPERAND (t, 1);
3698 gcc_assert (TREE_CONSTANT (offset));
3699
3700 /* The operand as an lvalue. */
3701 op = cxx_eval_constant_expression (ctx, op, true,
3702 non_constant_p, overflow_p);
3703
3704 /* The operand as an rvalue. */
3705 tree val
3706 = cxx_eval_constant_expression (ctx, op, false,
3707 non_constant_p, overflow_p);
3708 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3709 a local array in a constexpr function. */
3710 bool ptr = POINTER_TYPE_P (TREE_TYPE (val));
3711 if (!ptr)
3712 VERIFY_CONSTANT (val);
3713
3714 /* The modified value. */
3715 bool inc = (code ==