Branch data Line data Source code
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-2024 Free Software Foundation, Inc.
6 : :
7 : : This file is part of GCC.
8 : :
9 : : GCC is free software; you can redistribute it and/or modify it
10 : : under the terms of the GNU General Public License as published by
11 : : the Free Software Foundation; either version 3, or (at your option)
12 : : any later version.
13 : :
14 : : GCC is distributed in the hope that it will be useful, but
15 : : WITHOUT ANY WARRANTY; without even the implied warranty of
16 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 : : General Public License for more details.
18 : :
19 : : You should have received a copy of the GNU General Public License
20 : : along with GCC; see the file COPYING3. If not see
21 : : <http://www.gnu.org/licenses/>. */
22 : :
23 : : #include "config.h"
24 : : #include "system.h"
25 : : #include "coretypes.h"
26 : : #include "cp-tree.h"
27 : : #include "varasm.h"
28 : : #include "c-family/c-objc.h"
29 : : #include "tree-iterator.h"
30 : : #include "gimplify.h"
31 : : #include "builtins.h"
32 : : #include "tree-inline.h"
33 : : #include "ubsan.h"
34 : : #include "timevar.h"
35 : : #include "fold-const-call.h"
36 : : #include "stor-layout.h"
37 : : #include "cgraph.h"
38 : : #include "opts.h"
39 : : #include "stringpool.h"
40 : : #include "attribs.h"
41 : : #include "fold-const.h"
42 : : #include "intl.h"
43 : : #include "toplev.h"
44 : :
45 : : static bool verify_constant (tree, bool, bool *, bool *);
46 : : #define VERIFY_CONSTANT(X) \
47 : : do { \
48 : : if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
49 : : return t; \
50 : : } while (0)
51 : :
52 : : static HOST_WIDE_INT find_array_ctor_elt (tree ary, tree dindex,
53 : : bool insert = false);
54 : : static int array_index_cmp (tree key, tree index);
55 : :
56 : : /* Returns true iff FUN is an instantiation of a constexpr function
57 : : template or a defaulted constexpr function. */
58 : :
59 : : bool
60 : 47899307 : is_instantiation_of_constexpr (tree fun)
61 : : {
62 : 64025469 : return ((DECL_TEMPLOID_INSTANTIATION (fun)
63 : 31853957 : && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun)))
64 : 70002158 : || (DECL_DEFAULTED_FN (fun)
65 : 1118702 : && DECL_DECLARED_CONSTEXPR_P (fun)));
66 : : }
67 : :
68 : : /* Return true if T is a literal type. */
69 : :
70 : : bool
71 : 88879484 : literal_type_p (tree t)
72 : : {
73 : 86554616 : if (SCALAR_TYPE_P (t)
74 : 35483246 : || VECTOR_TYPE_P (t)
75 : 35471632 : || TYPE_REF_P (t)
76 : 117786206 : || (VOID_TYPE_P (t) && cxx_dialect >= cxx14))
77 : : return true;
78 : 26546007 : if (CLASS_TYPE_P (t))
79 : : {
80 : 25376053 : t = complete_type (t);
81 : 25376053 : gcc_assert (COMPLETE_TYPE_P (t) || errorcount);
82 : 25376053 : return CLASSTYPE_LITERAL_P (t);
83 : : }
84 : 1169954 : if (TREE_CODE (t) == ARRAY_TYPE)
85 : 1169780 : return literal_type_p (strip_array_types (t));
86 : : return false;
87 : : }
88 : :
89 : : /* If DECL is a variable declared `constexpr', require its type
90 : : be literal. Return error_mark_node if we give an error, the
91 : : DECL otherwise. */
92 : :
93 : : tree
94 : 258003640 : ensure_literal_type_for_constexpr_object (tree decl)
95 : : {
96 : 258003640 : tree type = TREE_TYPE (decl);
97 : 258003640 : if (VAR_P (decl)
98 : 90076651 : && (DECL_DECLARED_CONSTEXPR_P (decl)
99 : 72041269 : || var_in_constexpr_fn (decl))
100 : 281993672 : && !processing_template_decl)
101 : : {
102 : 15701000 : tree stype = strip_array_types (type);
103 : 15701000 : if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype)))
104 : : /* Don't complain here, we'll complain about incompleteness
105 : : when we try to initialize the variable. */;
106 : 15700994 : else if (!literal_type_p (type))
107 : : {
108 : 5109 : if (DECL_DECLARED_CONSTEXPR_P (decl))
109 : : {
110 : 42 : auto_diagnostic_group d;
111 : 42 : error_at (DECL_SOURCE_LOCATION (decl),
112 : : "the type %qT of %<constexpr%> variable %qD "
113 : : "is not literal", type, decl);
114 : 42 : explain_non_literal_class (type);
115 : 42 : decl = error_mark_node;
116 : 42 : }
117 : 5067 : else if (cxx_dialect < cxx23)
118 : : {
119 : 2294 : if (!is_instantiation_of_constexpr (current_function_decl))
120 : : {
121 : 8 : auto_diagnostic_group d;
122 : 8 : error_at (DECL_SOURCE_LOCATION (decl),
123 : : "variable %qD of non-literal type %qT in "
124 : : "%<constexpr%> function only available with "
125 : : "%<-std=c++2b%> or %<-std=gnu++2b%>", decl, type);
126 : 8 : explain_non_literal_class (type);
127 : 8 : decl = error_mark_node;
128 : 8 : }
129 : 2294 : cp_function_chain->invalid_constexpr = true;
130 : : }
131 : : }
132 : 15695885 : else if (DECL_DECLARED_CONSTEXPR_P (decl)
133 : 15695885 : && variably_modified_type_p (type, NULL_TREE))
134 : : {
135 : 4 : error_at (DECL_SOURCE_LOCATION (decl),
136 : : "%<constexpr%> variable %qD has variably-modified "
137 : : "type %qT", decl, type);
138 : 4 : decl = error_mark_node;
139 : : }
140 : : }
141 : 258003640 : return decl;
142 : : }
143 : :
144 : : /* Issue a diagnostic with text GMSGID for constructs that are invalid in
145 : : constexpr functions. CONSTEXPR_FUNDEF_P is true if we're checking
146 : : a constexpr function body; if so, don't report hard errors and issue
147 : : a pedwarn pre-C++23, or a warning in C++23, if requested by
148 : : -Winvalid-constexpr. Otherwise, we're not in the context where we are
149 : : checking if a function can be marked 'constexpr', so give a hard error. */
150 : :
151 : : ATTRIBUTE_GCC_DIAG(3,4)
152 : : static bool
153 : 784 : constexpr_error (location_t location, bool constexpr_fundef_p,
154 : : const char *gmsgid, ...)
155 : : {
156 : 784 : diagnostic_info diagnostic;
157 : 784 : va_list ap;
158 : 784 : rich_location richloc (line_table, location);
159 : 784 : va_start (ap, gmsgid);
160 : 784 : bool ret;
161 : 784 : if (!constexpr_fundef_p)
162 : : {
163 : : /* Report an error that cannot be suppressed. */
164 : 557 : diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc, DK_ERROR);
165 : 557 : ret = diagnostic_report_diagnostic (global_dc, &diagnostic);
166 : : }
167 : 227 : else if (warn_invalid_constexpr)
168 : : {
169 : 199 : diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc,
170 : 199 : cxx_dialect < cxx23 ? DK_PEDWARN : DK_WARNING);
171 : 199 : diagnostic.option_index = OPT_Winvalid_constexpr;
172 : 199 : ret = diagnostic_report_diagnostic (global_dc, &diagnostic);
173 : : }
174 : : else
175 : : ret = false;
176 : 784 : va_end (ap);
177 : 1568 : return ret;
178 : 784 : }
179 : :
180 : : struct constexpr_fundef_hasher : ggc_ptr_hash<constexpr_fundef>
181 : : {
182 : : static hashval_t hash (const constexpr_fundef *);
183 : : static bool equal (const constexpr_fundef *, const constexpr_fundef *);
184 : : };
185 : :
186 : : /* This table holds all constexpr function definitions seen in
187 : : the current translation unit. */
188 : :
189 : : static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table;
190 : :
191 : : /* Utility function used for managing the constexpr function table.
192 : : Return true if the entries pointed to by P and Q are for the
193 : : same constexpr function. */
194 : :
195 : : inline bool
196 : 485983084 : constexpr_fundef_hasher::equal (const constexpr_fundef *lhs,
197 : : const constexpr_fundef *rhs)
198 : : {
199 : 473171692 : return lhs->decl == rhs->decl;
200 : : }
201 : :
202 : : /* Utility function used for managing the constexpr function table.
203 : : Return a hash value for the entry pointed to by Q. */
204 : :
205 : : inline hashval_t
206 : 468557914 : constexpr_fundef_hasher::hash (const constexpr_fundef *fundef)
207 : : {
208 : 468557914 : return DECL_UID (fundef->decl);
209 : : }
210 : :
211 : : /* Return a previously saved definition of function FUN. */
212 : :
213 : : constexpr_fundef *
214 : 46531592 : retrieve_constexpr_fundef (tree fun)
215 : : {
216 : 46531592 : if (constexpr_fundef_table == NULL)
217 : : return NULL;
218 : :
219 : 46529184 : constexpr_fundef fundef = { fun, NULL_TREE, NULL_TREE, NULL_TREE };
220 : 46529184 : return constexpr_fundef_table->find (&fundef);
221 : : }
222 : :
223 : : /* Check whether the parameter and return types of FUN are valid for a
224 : : constexpr function, and complain if COMPLAIN. */
225 : :
226 : : bool
227 : 16238925 : is_valid_constexpr_fn (tree fun, bool complain)
228 : : {
229 : 16238925 : bool ret = true;
230 : :
231 : 32477850 : if (DECL_INHERITED_CTOR (fun)
232 : 1769275 : && TREE_CODE (fun) == TEMPLATE_DECL)
233 : : {
234 : 0 : ret = false;
235 : 0 : if (complain)
236 : 0 : error ("inherited constructor %qD is not %<constexpr%>",
237 : 0 : DECL_INHERITED_CTOR (fun));
238 : : }
239 : : else
240 : : {
241 : 16238925 : for (tree parm = FUNCTION_FIRST_USER_PARM (fun);
242 : 31928587 : parm != NULL_TREE; parm = TREE_CHAIN (parm))
243 : 15689662 : if (!literal_type_p (TREE_TYPE (parm)))
244 : : {
245 : 8177 : ret = false;
246 : 8177 : if (complain)
247 : : {
248 : 22 : auto_diagnostic_group d;
249 : 22 : if (constexpr_error (input_location, /*constexpr_fundef_p*/true,
250 : : "invalid type for parameter %d of "
251 : : "%<constexpr%> function %q+#D",
252 : 22 : DECL_PARM_INDEX (parm), fun))
253 : 20 : explain_non_literal_class (TREE_TYPE (parm));
254 : 22 : }
255 : : }
256 : : }
257 : :
258 : 25695751 : if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)) && cxx_dialect < cxx17)
259 : : {
260 : 2 : ret = false;
261 : 2 : if (complain)
262 : 2 : inform (DECL_SOURCE_LOCATION (fun),
263 : : "lambdas are implicitly %<constexpr%> only in C++17 and later");
264 : : }
265 : 32477846 : else if (DECL_DESTRUCTOR_P (fun) && cxx_dialect < cxx20)
266 : : {
267 : 72 : ret = false;
268 : 72 : if (complain)
269 : 0 : error_at (DECL_SOURCE_LOCATION (fun),
270 : : "%<constexpr%> destructors only available with "
271 : : "%<-std=c++20%> or %<-std=gnu++20%>");
272 : : }
273 : 16238851 : else if (!DECL_CONSTRUCTOR_P (fun) && !DECL_DESTRUCTOR_P (fun))
274 : : {
275 : 14326832 : tree rettype = TREE_TYPE (TREE_TYPE (fun));
276 : 14326832 : if (!literal_type_p (rettype))
277 : : {
278 : 49427 : ret = false;
279 : 49427 : if (complain)
280 : : {
281 : 12 : auto_diagnostic_group d;
282 : 12 : if (constexpr_error (input_location, /*constexpr_fundef_p*/true,
283 : : "invalid return type %qT of %<constexpr%> "
284 : : "function %q+D", rettype, fun))
285 : 12 : explain_non_literal_class (rettype);
286 : 12 : }
287 : : }
288 : :
289 : : /* C++14 DR 1684 removed this restriction. */
290 : 14326832 : if (cxx_dialect < cxx14
291 : 30555 : && DECL_IOBJ_MEMBER_FUNCTION_P (fun)
292 : 14327645 : && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
293 : : {
294 : 1 : ret = false;
295 : 1 : if (complain)
296 : : {
297 : 1 : auto_diagnostic_group d;
298 : 1 : if (pedwarn (DECL_SOURCE_LOCATION (fun), OPT_Wpedantic,
299 : : "enclosing class of %<constexpr%> non-static"
300 : : " member function %q+#D is not a literal type",
301 : : fun))
302 : 1 : explain_non_literal_class (DECL_CONTEXT (fun));
303 : 1 : }
304 : : }
305 : : }
306 : 1912019 : else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
307 : : {
308 : 99 : ret = false;
309 : 99 : if (complain)
310 : 8 : error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
311 : : }
312 : :
313 : 16238925 : return ret;
314 : : }
315 : :
316 : : /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
317 : : for a member of an anonymous aggregate, INIT is the initializer for that
318 : : member, and VEC_OUTER is the vector of constructor elements for the class
319 : : whose constructor we are processing. Add the initializer to the vector
320 : : and return true to indicate success. */
321 : :
322 : : static bool
323 : 837 : build_anon_member_initialization (tree member, tree init,
324 : : vec<constructor_elt, va_gc> **vec_outer)
325 : : {
326 : : /* MEMBER presents the relevant fields from the inside out, but we need
327 : : to build up the initializer from the outside in so that we can reuse
328 : : previously built CONSTRUCTORs if this is, say, the second field in an
329 : : anonymous struct. So we use a vec as a stack. */
330 : 837 : auto_vec<tree, 2> fields;
331 : 1770 : do
332 : : {
333 : 1770 : fields.safe_push (TREE_OPERAND (member, 1));
334 : 1770 : member = TREE_OPERAND (member, 0);
335 : : }
336 : 1770 : while (ANON_AGGR_TYPE_P (TREE_TYPE (member))
337 : 3543 : && TREE_CODE (member) == COMPONENT_REF);
338 : :
339 : : /* VEC has the constructor elements vector for the context of FIELD.
340 : : If FIELD is an anonymous aggregate, we will push inside it. */
341 : : vec<constructor_elt, va_gc> **vec = vec_outer;
342 : : tree field;
343 : 1770 : while (field = fields.pop(),
344 : 1770 : ANON_AGGR_TYPE_P (TREE_TYPE (field)))
345 : : {
346 : 933 : tree ctor;
347 : : /* If there is already an outer constructor entry for the anonymous
348 : : aggregate FIELD, use it; otherwise, insert one. */
349 : 933 : if (vec_safe_is_empty (*vec)
350 : 198 : || (*vec)->last().index != field)
351 : : {
352 : 831 : ctor = build_constructor (TREE_TYPE (field), NULL);
353 : 831 : CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
354 : : }
355 : : else
356 : 102 : ctor = (*vec)->last().value;
357 : 933 : vec = &CONSTRUCTOR_ELTS (ctor);
358 : : }
359 : :
360 : : /* Now we're at the innermost field, the one that isn't an anonymous
361 : : aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
362 : 837 : gcc_assert (fields.is_empty());
363 : 837 : CONSTRUCTOR_APPEND_ELT (*vec, field, init);
364 : :
365 : 837 : return true;
366 : 837 : }
367 : :
368 : : /* Subroutine of build_constexpr_constructor_member_initializers.
369 : : The expression tree T represents a data member initialization
370 : : in a (constexpr) constructor definition. Build a pairing of
371 : : the data member with its initializer, and prepend that pair
372 : : to the existing initialization pair INITS. */
373 : :
374 : : static bool
375 : 2517078 : build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
376 : : {
377 : 2729701 : tree member, init;
378 : 2729701 : if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
379 : 1101157 : t = TREE_OPERAND (t, 0);
380 : 2729701 : if (TREE_CODE (t) == EXPR_STMT)
381 : 1101219 : t = TREE_OPERAND (t, 0);
382 : 2729701 : if (t == error_mark_node)
383 : : return false;
384 : 2729694 : if (TREE_CODE (t) == STATEMENT_LIST)
385 : : {
386 : 2902078 : for (tree stmt : tsi_range (t))
387 : 173577 : if (! build_data_member_initialization (stmt, vec))
388 : 7 : return false;
389 : : return true;
390 : : }
391 : 2517427 : if (TREE_CODE (t) == CLEANUP_STMT)
392 : : {
393 : : /* We can't see a CLEANUP_STMT in a constructor for a literal class,
394 : : but we can in a constexpr constructor for a non-literal class. Just
395 : : ignore it; either all the initialization will be constant, in which
396 : : case the cleanup can't run, or it can't be constexpr.
397 : : Still recurse into CLEANUP_BODY. */
398 : 202365 : return build_data_member_initialization (CLEANUP_BODY (t), vec);
399 : : }
400 : 2315062 : if (TREE_CODE (t) == CONVERT_EXPR)
401 : 1435202 : t = TREE_OPERAND (t, 0);
402 : 2315062 : if (TREE_CODE (t) == INIT_EXPR
403 : : /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only
404 : : use what this function builds for cx_check_missing_mem_inits, and
405 : : assignment in the ctor body doesn't count. */
406 : 925777 : || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR))
407 : : {
408 : 1389750 : member = TREE_OPERAND (t, 0);
409 : 1389750 : init = break_out_target_exprs (TREE_OPERAND (t, 1));
410 : : }
411 : 925312 : else if (TREE_CODE (t) == CALL_EXPR)
412 : : {
413 : 829500 : tree fn = get_callee_fndecl (t);
414 : 1659000 : if (!fn || !DECL_CONSTRUCTOR_P (fn))
415 : : /* We're only interested in calls to subobject constructors. */
416 : : return true;
417 : 732846 : member = CALL_EXPR_ARG (t, 0);
418 : : /* We don't use build_cplus_new here because it complains about
419 : : abstract bases. Leaving the call unwrapped means that it has the
420 : : wrong type, but cxx_eval_constant_expression doesn't care. */
421 : 732846 : init = break_out_target_exprs (t);
422 : : }
423 : 95812 : else if (TREE_CODE (t) == BIND_EXPR)
424 : 10258 : return build_data_member_initialization (BIND_EXPR_BODY (t), vec);
425 : : else
426 : : /* Don't add anything else to the CONSTRUCTOR. */
427 : : return true;
428 : 2122596 : if (INDIRECT_REF_P (member))
429 : 27740 : member = TREE_OPERAND (member, 0);
430 : 2122596 : if (TREE_CODE (member) == NOP_EXPR)
431 : : {
432 : 197448 : tree op = member;
433 : 197448 : STRIP_NOPS (op);
434 : 197448 : if (TREE_CODE (op) == ADDR_EXPR)
435 : : {
436 : 238 : gcc_assert (same_type_ignoring_top_level_qualifiers_p
437 : : (TREE_TYPE (TREE_TYPE (op)),
438 : : TREE_TYPE (TREE_TYPE (member))));
439 : : /* Initializing a cv-qualified member; we need to look through
440 : : the const_cast. */
441 : : member = op;
442 : : }
443 : 197210 : else if (op == current_class_ptr
444 : 394320 : && (same_type_ignoring_top_level_qualifiers_p
445 : 197110 : (TREE_TYPE (TREE_TYPE (member)),
446 : : current_class_type)))
447 : : /* Delegating constructor. */
448 : : member = op;
449 : : else
450 : : {
451 : : /* This is an initializer for an empty base; keep it for now so
452 : : we can check it in cxx_eval_bare_aggregate. */
453 : 173278 : gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
454 : : }
455 : : }
456 : 2122596 : if (TREE_CODE (member) == ADDR_EXPR)
457 : 563376 : member = TREE_OPERAND (member, 0);
458 : 2122596 : if (TREE_CODE (member) == COMPONENT_REF)
459 : : {
460 : 1916815 : tree aggr = TREE_OPERAND (member, 0);
461 : 1916815 : if (TREE_CODE (aggr) == VAR_DECL)
462 : : /* Initializing a local variable, don't add anything. */
463 : : return true;
464 : 1916813 : if (TREE_CODE (aggr) != COMPONENT_REF)
465 : : /* Normal member initialization. */
466 : 1915719 : member = TREE_OPERAND (member, 1);
467 : 1094 : else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
468 : : /* Initializing a member of an anonymous union. */
469 : 837 : return build_anon_member_initialization (member, init, vec);
470 : : else
471 : : /* We're initializing a vtable pointer in a base. Leave it as
472 : : COMPONENT_REF so we remember the path to get to the vfield. */
473 : 257 : gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
474 : : }
475 : :
476 : : /* Value-initialization can produce multiple initializers for the
477 : : same field; use the last one. */
478 : 2562626 : if (!vec_safe_is_empty (*vec) && (*vec)->last().index == member)
479 : 32 : (*vec)->last().value = init;
480 : : else
481 : 2121725 : CONSTRUCTOR_APPEND_ELT (*vec, member, init);
482 : : return true;
483 : : }
484 : :
485 : : /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
486 : : In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
487 : : BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */
488 : :
489 : : static bool
490 : 2348 : check_constexpr_bind_expr_vars (tree t)
491 : : {
492 : 2348 : gcc_assert (TREE_CODE (t) == BIND_EXPR);
493 : :
494 : 3153 : for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var))
495 : 817 : if (TREE_CODE (var) == TYPE_DECL
496 : 805 : && DECL_IMPLICIT_TYPEDEF_P (var)
497 : 839 : && !LAMBDA_TYPE_P (TREE_TYPE (var)))
498 : : return false;
499 : : return true;
500 : : }
501 : :
502 : : /* Subroutine of check_constexpr_ctor_body. */
503 : :
504 : : static bool
505 : 4049 : check_constexpr_ctor_body_1 (tree last, tree list)
506 : : {
507 : 4049 : switch (TREE_CODE (list))
508 : : {
509 : 6 : case DECL_EXPR:
510 : 6 : if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL
511 : 6 : || TREE_CODE (DECL_EXPR_DECL (list)) == TYPE_DECL)
512 : : return true;
513 : : return false;
514 : :
515 : 3 : case CLEANUP_POINT_EXPR:
516 : 3 : return check_constexpr_ctor_body (last, TREE_OPERAND (list, 0),
517 : 3 : /*complain=*/false);
518 : :
519 : 2016 : case BIND_EXPR:
520 : 2016 : if (!check_constexpr_bind_expr_vars (list)
521 : 2016 : || !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list),
522 : : /*complain=*/false))
523 : 11 : return false;
524 : : return true;
525 : :
526 : : case USING_STMT:
527 : : case STATIC_ASSERT:
528 : : case DEBUG_BEGIN_STMT:
529 : : return true;
530 : :
531 : : default:
532 : : return false;
533 : : }
534 : : }
535 : :
536 : : /* Make sure that there are no statements after LAST in the constructor
537 : : body represented by LIST. */
538 : :
539 : : bool
540 : 2921704 : check_constexpr_ctor_body (tree last, tree list, bool complain)
541 : : {
542 : : /* C++14 doesn't require a constexpr ctor to have an empty body. */
543 : 2921704 : if (cxx_dialect >= cxx14)
544 : : return true;
545 : :
546 : 12227 : bool ok = true;
547 : 12227 : if (TREE_CODE (list) == STATEMENT_LIST)
548 : : {
549 : 12214 : tree_stmt_iterator i = tsi_last (list);
550 : 16232 : for (; !tsi_end_p (i); tsi_prev (&i))
551 : : {
552 : 14134 : tree t = tsi_stmt (i);
553 : 14134 : if (t == last)
554 : : break;
555 : 4036 : if (!check_constexpr_ctor_body_1 (last, t))
556 : : {
557 : : ok = false;
558 : : break;
559 : : }
560 : : }
561 : : }
562 : 13 : else if (list != last
563 : 13 : && !check_constexpr_ctor_body_1 (last, list))
564 : : ok = false;
565 : 12214 : if (!ok)
566 : : {
567 : 22 : if (complain)
568 : 16 : error ("%<constexpr%> constructor does not have empty body");
569 : 22 : DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
570 : : }
571 : : return ok;
572 : : }
573 : :
574 : : /* V is a vector of constructor elements built up for the base and member
575 : : initializers of a constructor for TYPE. They need to be in increasing
576 : : offset order, which they might not be yet if TYPE has a primary base
577 : : which is not first in the base-clause or a vptr and at least one base
578 : : all of which are non-primary. */
579 : :
580 : : static vec<constructor_elt, va_gc> *
581 : 1744604 : sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
582 : : {
583 : 1744604 : tree pri = CLASSTYPE_PRIMARY_BINFO (type);
584 : 1744604 : tree field_type;
585 : 1744604 : unsigned i;
586 : 1744604 : constructor_elt *ce;
587 : :
588 : 1744604 : if (pri)
589 : 6877 : field_type = BINFO_TYPE (pri);
590 : 1737727 : else if (TYPE_CONTAINS_VPTR_P (type))
591 : 20613 : field_type = vtbl_ptr_type_node;
592 : : else
593 : : return v;
594 : :
595 : : /* Find the element for the primary base or vptr and move it to the
596 : : beginning of the vec. */
597 : 40552 : for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
598 : 20144 : if (TREE_TYPE (ce->index) == field_type)
599 : : break;
600 : :
601 : 36208 : if (i > 0 && i < vec_safe_length (v))
602 : : {
603 : 16 : vec<constructor_elt, va_gc> &vref = *v;
604 : 16 : constructor_elt elt = vref[i];
605 : 32 : for (; i > 0; --i)
606 : 16 : vref[i] = vref[i-1];
607 : 16 : vref[0] = elt;
608 : : }
609 : :
610 : : return v;
611 : : }
612 : :
613 : : /* Build compile-time evalable representations of member-initializer list
614 : : for a constexpr constructor. */
615 : :
616 : : static tree
617 : 1768539 : build_constexpr_constructor_member_initializers (tree type, tree body)
618 : : {
619 : 1768539 : vec<constructor_elt, va_gc> *vec = NULL;
620 : 1768539 : bool ok = true;
621 : 4008810 : while (true)
622 : 4008810 : switch (TREE_CODE (body))
623 : : {
624 : 886965 : case MUST_NOT_THROW_EXPR:
625 : 886965 : case EH_SPEC_BLOCK:
626 : 886965 : body = TREE_OPERAND (body, 0);
627 : 886965 : break;
628 : :
629 : 1353306 : case STATEMENT_LIST:
630 : 5362152 : for (tree stmt : tsi_range (body))
631 : : {
632 : 2706642 : body = stmt;
633 : 2706642 : if (TREE_CODE (body) == BIND_EXPR)
634 : : break;
635 : : }
636 : : break;
637 : :
638 : 1768539 : case BIND_EXPR:
639 : 1768539 : body = BIND_EXPR_BODY (body);
640 : 1768539 : goto found;
641 : :
642 : 0 : default:
643 : 0 : gcc_unreachable ();
644 : : }
645 : 1768539 : found:
646 : 1768539 : if (TREE_CODE (body) == TRY_BLOCK)
647 : : {
648 : 24 : body = TREE_OPERAND (body, 0);
649 : 24 : if (TREE_CODE (body) == BIND_EXPR)
650 : 24 : body = BIND_EXPR_BODY (body);
651 : : }
652 : 1768539 : if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
653 : : {
654 : 1150877 : body = TREE_OPERAND (body, 0);
655 : 1150877 : if (TREE_CODE (body) == EXPR_STMT)
656 : 1150877 : body = TREE_OPERAND (body, 0);
657 : 1150877 : if (TREE_CODE (body) == INIT_EXPR
658 : 1150877 : && (same_type_ignoring_top_level_qualifiers_p
659 : 0 : (TREE_TYPE (TREE_OPERAND (body, 0)),
660 : : current_class_type)))
661 : : {
662 : : /* Trivial copy. */
663 : 0 : return TREE_OPERAND (body, 1);
664 : : }
665 : 1150877 : ok = build_data_member_initialization (body, &vec);
666 : : }
667 : 617662 : else if (TREE_CODE (body) == STATEMENT_LIST)
668 : : {
669 : 1810024 : for (tree stmt : tsi_range (body))
670 : : {
671 : 1192493 : ok = build_data_member_initialization (stmt, &vec);
672 : 1192493 : if (!ok)
673 : : break;
674 : : }
675 : : }
676 : 131 : else if (EXPR_P (body))
677 : 131 : ok = build_data_member_initialization (body, &vec);
678 : : else
679 : 0 : gcc_assert (errorcount > 0);
680 : 1768539 : if (ok)
681 : : {
682 : 1768532 : if (vec_safe_length (vec) > 0)
683 : : {
684 : : /* In a delegating constructor, return the target. */
685 : 1681599 : constructor_elt *ce = &(*vec)[0];
686 : 1681599 : if (ce->index == current_class_ptr)
687 : : {
688 : 23928 : body = ce->value;
689 : 23928 : vec_free (vec);
690 : 23928 : return body;
691 : : }
692 : : }
693 : 1744604 : vec = sort_constexpr_mem_initializers (type, vec);
694 : 1744604 : return build_constructor (type, vec);
695 : : }
696 : : else
697 : 7 : return error_mark_node;
698 : : }
699 : :
700 : : /* We have an expression tree T that represents a call, either CALL_EXPR
701 : : or AGGR_INIT_EXPR. If the call is lexically to a named function,
702 : : return the _DECL for that function. */
703 : :
704 : : static tree
705 : 263872140 : get_function_named_in_call (tree t)
706 : : {
707 : 263872140 : tree callee = cp_get_callee (t);
708 : 263872140 : tree fun = cp_get_fndecl_from_callee (callee, /*fold*/false);
709 : 263872140 : return fun ? fun : callee;
710 : : }
711 : :
712 : : /* Subroutine of check_constexpr_fundef. BODY is the body of a function
713 : : declared to be constexpr, or a sub-statement thereof. Returns the
714 : : return value if suitable, error_mark_node for a statement not allowed in
715 : : a constexpr function, or NULL_TREE if no return value was found. */
716 : :
717 : : tree
718 : 67176 : constexpr_fn_retval (tree body)
719 : : {
720 : 73252 : switch (TREE_CODE (body))
721 : : {
722 : 18275 : case STATEMENT_LIST:
723 : 18275 : {
724 : 18275 : tree expr = NULL_TREE;
725 : 54765 : for (tree stmt : tsi_range (body))
726 : : {
727 : 36513 : tree s = constexpr_fn_retval (stmt);
728 : 36513 : if (s == error_mark_node)
729 : 23 : return error_mark_node;
730 : 36490 : else if (s == NULL_TREE)
731 : : /* Keep iterating. */;
732 : 18242 : else if (expr)
733 : : /* Multiple return statements. */
734 : 0 : return error_mark_node;
735 : : else
736 : : expr = s;
737 : : }
738 : : return expr;
739 : : }
740 : :
741 : 30615 : case RETURN_EXPR:
742 : 30615 : return break_out_target_exprs (TREE_OPERAND (body, 0));
743 : :
744 : 13 : case DECL_EXPR:
745 : 13 : {
746 : 13 : tree decl = DECL_EXPR_DECL (body);
747 : 13 : if (TREE_CODE (decl) == USING_DECL
748 : : /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */
749 : 13 : || DECL_ARTIFICIAL (decl))
750 : : return NULL_TREE;
751 : 2 : return error_mark_node;
752 : : }
753 : :
754 : 5750 : case CLEANUP_POINT_EXPR:
755 : 5750 : return constexpr_fn_retval (TREE_OPERAND (body, 0));
756 : :
757 : 332 : case BIND_EXPR:
758 : 332 : if (!check_constexpr_bind_expr_vars (body))
759 : 6 : return error_mark_node;
760 : 326 : return constexpr_fn_retval (BIND_EXPR_BODY (body));
761 : :
762 : : case USING_STMT:
763 : : case DEBUG_BEGIN_STMT:
764 : : return NULL_TREE;
765 : :
766 : 1 : case CALL_EXPR:
767 : 1 : {
768 : 1 : tree fun = get_function_named_in_call (body);
769 : 1 : if (fun != NULL_TREE
770 : 1 : && fndecl_built_in_p (fun, BUILT_IN_UNREACHABLE))
771 : : return NULL_TREE;
772 : : }
773 : : /* Fallthru. */
774 : :
775 : 30 : default:
776 : 30 : return error_mark_node;
777 : : }
778 : : }
779 : :
780 : : /* Subroutine of check_constexpr_fundef. BODY is the DECL_SAVED_TREE of
781 : : FUN; do the necessary transformations to turn it into a single expression
782 : : that we can store in the hash table. */
783 : :
784 : : static tree
785 : 15769162 : massage_constexpr_body (tree fun, tree body)
786 : : {
787 : 31538324 : if (DECL_CONSTRUCTOR_P (fun))
788 : 1768539 : body = build_constexpr_constructor_member_initializers
789 : 1768539 : (DECL_CONTEXT (fun), body);
790 : 14000623 : else if (cxx_dialect < cxx14)
791 : : {
792 : 30434 : if (TREE_CODE (body) == EH_SPEC_BLOCK)
793 : 1 : body = EH_SPEC_STMTS (body);
794 : 30434 : if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
795 : 20332 : body = TREE_OPERAND (body, 0);
796 : 30434 : body = constexpr_fn_retval (body);
797 : : }
798 : 15769162 : return body;
799 : : }
800 : :
801 : : /* CTYPE is a type constructed from BODY. Return true if some
802 : : bases/fields are uninitialized, and complain if COMPLAIN. */
803 : :
804 : : static bool
805 : 1494495 : cx_check_missing_mem_inits (tree ctype, tree body, bool complain)
806 : : {
807 : : /* We allow uninitialized bases/fields in C++20. */
808 : 1494495 : if (cxx_dialect >= cxx20)
809 : : return false;
810 : :
811 : 792825 : unsigned nelts = 0;
812 : :
813 : 792825 : if (body)
814 : : {
815 : 792821 : if (TREE_CODE (body) != CONSTRUCTOR)
816 : : return false;
817 : 792582 : nelts = CONSTRUCTOR_NELTS (body);
818 : : }
819 : 792586 : tree field = TYPE_FIELDS (ctype);
820 : :
821 : 792586 : if (TREE_CODE (ctype) == UNION_TYPE)
822 : : {
823 : 8226 : if (nelts == 0 && next_aggregate_field (field))
824 : : {
825 : 2 : if (complain)
826 : 2 : error ("%<constexpr%> constructor for union %qT must "
827 : : "initialize exactly one non-static data member", ctype);
828 : 2 : return true;
829 : : }
830 : 8224 : return false;
831 : : }
832 : :
833 : : /* Iterate over the CONSTRUCTOR, checking any missing fields don't
834 : : need an explicit initialization. */
835 : : bool bad = false;
836 : 1695413 : for (unsigned i = 0; i <= nelts; ++i)
837 : : {
838 : 1695413 : tree index = NULL_TREE;
839 : 1695413 : if (i < nelts)
840 : : {
841 : 911053 : index = CONSTRUCTOR_ELT (body, i)->index;
842 : : /* Skip base and vtable inits. */
843 : 1179503 : if (TREE_CODE (index) != FIELD_DECL
844 : 911053 : || DECL_ARTIFICIAL (index))
845 : 268450 : continue;
846 : : }
847 : :
848 : 39584949 : for (; field != index; field = DECL_CHAIN (field))
849 : : {
850 : 38158055 : tree ftype;
851 : 38158055 : if (TREE_CODE (field) != FIELD_DECL)
852 : 75980867 : continue;
853 : 335157 : if (DECL_UNNAMED_BIT_FIELD (field))
854 : 16 : continue;
855 : 335141 : if (DECL_ARTIFICIAL (field))
856 : 335046 : continue;
857 : 95 : if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
858 : : {
859 : : /* Recurse to check the anonymous aggregate member. */
860 : 8 : bad |= cx_check_missing_mem_inits
861 : 4 : (TREE_TYPE (field), NULL_TREE, complain);
862 : 4 : if (bad && !complain)
863 : 69 : return true;
864 : 4 : continue;
865 : : }
866 : 91 : ftype = TREE_TYPE (field);
867 : 91 : if (!ftype || !TYPE_P (ftype) || !COMPLETE_TYPE_P (ftype))
868 : : /* A flexible array can't be intialized here, so don't complain
869 : : that it isn't. */
870 : 2 : continue;
871 : 89 : if (is_empty_field (field))
872 : : /* An empty field doesn't need an initializer. */
873 : 1 : continue;
874 : 88 : ftype = strip_array_types (ftype);
875 : 88 : if (type_has_constexpr_default_constructor (ftype))
876 : : {
877 : : /* It's OK to skip a member with a trivial constexpr ctor.
878 : : A constexpr ctor that isn't trivial should have been
879 : : added in by now. */
880 : 2 : gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
881 : : || errorcount != 0);
882 : 2 : continue;
883 : : }
884 : 86 : if (!complain)
885 : : return true;
886 : 17 : auto_diagnostic_group d;
887 : 17 : error ("member %qD must be initialized by mem-initializer "
888 : : "in %<constexpr%> constructor", field);
889 : 17 : inform (DECL_SOURCE_LOCATION (field), "declared here");
890 : 17 : bad = true;
891 : 17 : }
892 : 1426894 : if (field == NULL_TREE)
893 : : break;
894 : :
895 : 642603 : if (ANON_AGGR_TYPE_P (TREE_TYPE (index)))
896 : : {
897 : : /* Check the anonymous aggregate initializer is valid. */
898 : 448 : bad |= cx_check_missing_mem_inits
899 : 224 : (TREE_TYPE (index), CONSTRUCTOR_ELT (body, i)->value, complain);
900 : 224 : if (bad && !complain)
901 : : return true;
902 : : }
903 : 642603 : field = DECL_CHAIN (field);
904 : : }
905 : :
906 : : return bad;
907 : : }
908 : :
909 : : /* We are processing the definition of the constexpr function FUN.
910 : : Check that its body fulfills the apropriate requirements and
911 : : enter it in the constexpr function definition table. */
912 : :
913 : : void
914 : 132608248 : maybe_save_constexpr_fundef (tree fun)
915 : : {
916 : 132608248 : if (processing_template_decl
917 : 52341567 : || cp_function_chain->invalid_constexpr
918 : 184837658 : || (DECL_CLONED_FUNCTION_P (fun) && !DECL_DELETING_DESTRUCTOR_P (fun)))
919 : 116839343 : return;
920 : :
921 : : /* With -fimplicit-constexpr, try to make inlines constexpr. We'll
922 : : actually set DECL_DECLARED_CONSTEXPR_P below if the checks pass. */
923 : 39441578 : bool implicit = false;
924 : 39441578 : if (flag_implicit_constexpr)
925 : : {
926 : 8 : if (DECL_DELETING_DESTRUCTOR_P (fun)
927 : 8 : && decl_implicit_constexpr_p (DECL_CLONED_FUNCTION (fun)))
928 : : /* Don't inherit implicit constexpr from the non-deleting
929 : : destructor. */
930 : 0 : DECL_DECLARED_CONSTEXPR_P (fun) = false;
931 : :
932 : 8 : if (!DECL_DECLARED_CONSTEXPR_P (fun)
933 : 7 : && DECL_DECLARED_INLINE_P (fun)
934 : 14 : && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fun)))
935 : : implicit = true;
936 : : }
937 : :
938 : 39441578 : if (!DECL_DECLARED_CONSTEXPR_P (fun) && !implicit)
939 : : return;
940 : :
941 : 15821367 : bool complain = !DECL_GENERATED_P (fun) && !implicit;
942 : :
943 : 15821367 : if (!is_valid_constexpr_fn (fun, complain))
944 : : return;
945 : :
946 : 15769123 : tree massaged = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
947 : 15769123 : if (massaged == NULL_TREE || massaged == error_mark_node)
948 : : {
949 : 56 : if (!DECL_CONSTRUCTOR_P (fun) && complain)
950 : 18 : error ("body of %<constexpr%> function %qD not a return-statement",
951 : : fun);
952 : 28 : return;
953 : : }
954 : :
955 : 15769095 : bool potential = potential_rvalue_constant_expression (massaged);
956 : 15769095 : if (!potential && complain)
957 : 181 : require_potential_rvalue_constant_expression_fncheck (massaged);
958 : :
959 : 17537619 : if (DECL_CONSTRUCTOR_P (fun) && potential
960 : 17535994 : && !DECL_DEFAULTED_FN (fun))
961 : : {
962 : 1494259 : if (cx_check_missing_mem_inits (DECL_CONTEXT (fun),
963 : : massaged, complain))
964 : : potential = false;
965 : 1494175 : else if (cxx_dialect > cxx11)
966 : : {
967 : : /* What we got from massage_constexpr_body is pretty much just the
968 : : ctor-initializer, also check the body. */
969 : 1489623 : massaged = DECL_SAVED_TREE (fun);
970 : 1489623 : potential = potential_rvalue_constant_expression (massaged);
971 : 1489623 : if (!potential && complain)
972 : 14 : require_potential_rvalue_constant_expression_fncheck (massaged);
973 : : }
974 : : }
975 : :
976 : 15769095 : if (!potential && complain
977 : : /* If -Wno-invalid-constexpr was specified, we haven't complained
978 : : about non-constant expressions yet. Register the function and
979 : : complain in explain_invalid_constexpr_fn if the function is
980 : : called. */
981 : 210 : && warn_invalid_constexpr != 0)
982 : : return;
983 : :
984 : 15768910 : if (implicit)
985 : : {
986 : 6 : if (potential)
987 : : {
988 : 1 : DECL_DECLARED_CONSTEXPR_P (fun) = true;
989 : 1 : DECL_LANG_SPECIFIC (fun)->u.fn.implicit_constexpr = true;
990 : 2 : if (DECL_CONSTRUCTOR_P (fun))
991 : 0 : TYPE_HAS_CONSTEXPR_CTOR (DECL_CONTEXT (fun)) = true;
992 : : }
993 : : else
994 : : /* Don't bother keeping the pre-generic body of unsuitable functions
995 : : not explicitly declared constexpr. */
996 : : return;
997 : : }
998 : :
999 : 15768905 : constexpr_fundef entry = {fun, NULL_TREE, NULL_TREE, NULL_TREE};
1000 : 15768905 : bool clear_ctx = false;
1001 : 15768905 : if (DECL_RESULT (fun) && DECL_CONTEXT (DECL_RESULT (fun)) == NULL_TREE)
1002 : : {
1003 : 15768905 : clear_ctx = true;
1004 : 15768905 : DECL_CONTEXT (DECL_RESULT (fun)) = fun;
1005 : : }
1006 : 15768905 : tree saved_fn = current_function_decl;
1007 : 15768905 : current_function_decl = fun;
1008 : 15768905 : entry.body = copy_fn (entry.decl, entry.parms, entry.result);
1009 : 15768905 : current_function_decl = saved_fn;
1010 : 15768905 : if (clear_ctx)
1011 : 15768905 : DECL_CONTEXT (DECL_RESULT (entry.decl)) = NULL_TREE;
1012 : 15768905 : if (!potential)
1013 : : /* For a template instantiation, we want to remember the pre-generic body
1014 : : for explain_invalid_constexpr_fn, but do tell cxx_eval_call_expression
1015 : : that it doesn't need to bother trying to expand the function. */
1016 : 70355 : entry.result = error_mark_node;
1017 : :
1018 : 15768905 : register_constexpr_fundef (entry);
1019 : : }
1020 : :
1021 : : /* BODY is a validated and massaged definition of a constexpr
1022 : : function. Register it in the hash table. */
1023 : :
1024 : : void
1025 : 15803588 : register_constexpr_fundef (const constexpr_fundef &value)
1026 : : {
1027 : : /* Create the constexpr function table if necessary. */
1028 : 15803588 : if (constexpr_fundef_table == NULL)
1029 : 23999 : constexpr_fundef_table
1030 : 23999 : = hash_table<constexpr_fundef_hasher>::create_ggc (101);
1031 : :
1032 : 15803588 : constexpr_fundef **slot = constexpr_fundef_table->find_slot
1033 : 15803588 : (const_cast<constexpr_fundef *> (&value), INSERT);
1034 : :
1035 : 15803588 : gcc_assert (*slot == NULL);
1036 : 15803588 : *slot = ggc_alloc<constexpr_fundef> ();
1037 : 15803588 : **slot = value;
1038 : 15803588 : }
1039 : :
1040 : : /* FUN is a non-constexpr (or, with -Wno-invalid-constexpr, a constexpr
1041 : : function called in a context that requires a constant expression).
1042 : : If it comes from a constexpr template, explain why the instantiation
1043 : : isn't constexpr. Otherwise, explain why the function cannot be used
1044 : : in a constexpr context. */
1045 : :
1046 : : void
1047 : 309 : explain_invalid_constexpr_fn (tree fun)
1048 : : {
1049 : 309 : static hash_set<tree> *diagnosed;
1050 : 309 : tree body;
1051 : : /* In C++23, a function marked 'constexpr' may not actually be a constant
1052 : : expression. We haven't diagnosed the problem yet: -Winvalid-constexpr
1053 : : wasn't enabled. The function was called, so diagnose why it cannot be
1054 : : used in a constant expression. */
1055 : 309 : if (warn_invalid_constexpr == 0 && DECL_DECLARED_CONSTEXPR_P (fun))
1056 : : /* Go on. */;
1057 : : /* Only diagnose defaulted functions, lambdas, or instantiations. */
1058 : 289 : else if (!DECL_DEFAULTED_FN (fun)
1059 : 415 : && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun))
1060 : 557 : && !is_instantiation_of_constexpr (fun))
1061 : : {
1062 : 253 : inform (DECL_SOURCE_LOCATION (fun), "%qD declared here", fun);
1063 : 253 : return;
1064 : : }
1065 : 56 : if (diagnosed == NULL)
1066 : 49 : diagnosed = new hash_set<tree>;
1067 : 56 : if (diagnosed->add (fun))
1068 : : /* Already explained. */
1069 : : return;
1070 : :
1071 : 55 : iloc_sentinel ils = input_location;
1072 : 55 : if (!lambda_static_thunk_p (fun))
1073 : : {
1074 : : /* Diagnostics should completely ignore the static thunk, so leave
1075 : : input_location set to our caller's location. */
1076 : 55 : input_location = DECL_SOURCE_LOCATION (fun);
1077 : 55 : inform (input_location,
1078 : : "%qD is not usable as a %<constexpr%> function because:", fun);
1079 : : }
1080 : : /* First check the declaration. */
1081 : 55 : if (is_valid_constexpr_fn (fun, true))
1082 : : {
1083 : : /* Then if it's OK, the body. */
1084 : 49 : if (!DECL_DECLARED_CONSTEXPR_P (fun)
1085 : 49 : && DECL_DEFAULTED_FN (fun))
1086 : 10 : explain_implicit_non_constexpr (fun);
1087 : : else
1088 : : {
1089 : 39 : if (constexpr_fundef *fd = retrieve_constexpr_fundef (fun))
1090 : 35 : body = fd->body;
1091 : : else
1092 : 4 : body = DECL_SAVED_TREE (fun);
1093 : 39 : body = massage_constexpr_body (fun, body);
1094 : 39 : require_potential_rvalue_constant_expression (body);
1095 : 78 : if (DECL_CONSTRUCTOR_P (fun))
1096 : : {
1097 : 8 : cx_check_missing_mem_inits (DECL_CONTEXT (fun), body, true);
1098 : 8 : if (cxx_dialect > cxx11)
1099 : : {
1100 : : /* Also check the body, not just the ctor-initializer. */
1101 : 6 : body = DECL_SAVED_TREE (fun);
1102 : 6 : require_potential_rvalue_constant_expression (body);
1103 : : }
1104 : : }
1105 : : }
1106 : : }
1107 : 55 : }
1108 : :
1109 : : /* Objects of this type represent calls to constexpr functions
1110 : : along with the bindings of parameters to their arguments, for
1111 : : the purpose of compile time evaluation. */
1112 : :
1113 : : struct GTY((for_user)) constexpr_call {
1114 : : /* Description of the constexpr function definition. */
1115 : : constexpr_fundef *fundef;
1116 : : /* Parameter bindings environment. A TREE_VEC of arguments. */
1117 : : tree bindings;
1118 : : /* Result of the call.
1119 : : NULL means the call is being evaluated.
1120 : : error_mark_node means that the evaluation was erroneous;
1121 : : otherwise, the actuall value of the call. */
1122 : : tree result;
1123 : : /* The hash of this call; we remember it here to avoid having to
1124 : : recalculate it when expanding the hash table. */
1125 : : hashval_t hash;
1126 : : /* The value of constexpr_ctx::manifestly_const_eval. */
1127 : : enum mce_value manifestly_const_eval;
1128 : : };
1129 : :
1130 : : struct constexpr_call_hasher : ggc_ptr_hash<constexpr_call>
1131 : : {
1132 : : static hashval_t hash (constexpr_call *);
1133 : : static bool equal (constexpr_call *, constexpr_call *);
1134 : : };
1135 : :
1136 : : enum constexpr_switch_state {
1137 : : /* Used when processing a switch for the first time by cxx_eval_switch_expr
1138 : : and default: label for that switch has not been seen yet. */
1139 : : css_default_not_seen,
1140 : : /* Used when processing a switch for the first time by cxx_eval_switch_expr
1141 : : and default: label for that switch has been seen already. */
1142 : : css_default_seen,
1143 : : /* Used when processing a switch for the second time by
1144 : : cxx_eval_switch_expr, where default: label should match. */
1145 : : css_default_processing
1146 : : };
1147 : :
1148 : : /* The constexpr expansion context part which needs one instance per
1149 : : cxx_eval_outermost_constant_expr invocation. VALUES is a map of values of
1150 : : variables initialized within the expression. */
1151 : :
1152 : 329361977 : class constexpr_global_ctx {
1153 : : /* Values for any temporaries or local variables within the
1154 : : constant-expression. Objects outside their lifetime have
1155 : : value 'void_node'. */
1156 : : hash_map<tree,tree> values;
1157 : : public:
1158 : : /* Number of cxx_eval_constant_expression calls (except skipped ones,
1159 : : on simple constants or location wrappers) encountered during current
1160 : : cxx_eval_outermost_constant_expr call. */
1161 : : HOST_WIDE_INT constexpr_ops_count;
1162 : : /* Heap VAR_DECLs created during the evaluation of the outermost constant
1163 : : expression. */
1164 : : auto_vec<tree, 16> heap_vars;
1165 : : /* Cleanups that need to be evaluated at the end of CLEANUP_POINT_EXPR. */
1166 : : vec<tree> *cleanups;
1167 : : /* If non-null, only allow modification of existing values of the variables
1168 : : in this set. Set by modifiable_tracker, below. */
1169 : : hash_set<tree> *modifiable;
1170 : : /* Number of heap VAR_DECL deallocations. */
1171 : : unsigned heap_dealloc_count;
1172 : : /* Constructor. */
1173 : 329364674 : constexpr_global_ctx ()
1174 : 658729348 : : constexpr_ops_count (0), cleanups (NULL), modifiable (nullptr),
1175 : 329364674 : heap_dealloc_count (0) {}
1176 : :
1177 : 182076502 : bool is_outside_lifetime (tree t)
1178 : : {
1179 : 182076502 : if (tree *p = values.get (t))
1180 : 38841777 : if (*p == void_node)
1181 : 178 : return true;
1182 : : return false;
1183 : : }
1184 : 221499174 : tree get_value (tree t)
1185 : : {
1186 : 221499174 : if (tree *p = values.get (t))
1187 : 69884277 : if (*p != void_node)
1188 : 69459167 : return *p;
1189 : : return NULL_TREE;
1190 : : }
1191 : 31723037 : tree *get_value_ptr (tree t, bool initializing)
1192 : : {
1193 : 31723037 : if (modifiable && !modifiable->contains (t))
1194 : : return nullptr;
1195 : 31723015 : if (tree *p = values.get (t))
1196 : : {
1197 : 31720404 : if (*p != void_node)
1198 : : return p;
1199 : 42 : else if (initializing)
1200 : : {
1201 : 12 : *p = NULL_TREE;
1202 : 12 : return p;
1203 : : }
1204 : : }
1205 : : return nullptr;
1206 : : }
1207 : 89575434 : void put_value (tree t, tree v)
1208 : : {
1209 : 89575434 : bool already_in_map = values.put (t, v);
1210 : 89575434 : if (!already_in_map && modifiable)
1211 : 40 : modifiable->add (t);
1212 : 89575434 : }
1213 : 74267706 : void destroy_value (tree t)
1214 : : {
1215 : 74267706 : if (TREE_CODE (t) == VAR_DECL
1216 : 74267706 : || TREE_CODE (t) == PARM_DECL
1217 : : || TREE_CODE (t) == RESULT_DECL)
1218 : 74262057 : values.put (t, void_node);
1219 : : else
1220 : 5649 : values.remove (t);
1221 : 74267706 : }
1222 : 3196625 : void clear_value (tree t)
1223 : : {
1224 : 6393250 : values.remove (t);
1225 : : }
1226 : : };
1227 : :
1228 : : /* Helper class for constexpr_global_ctx. In some cases we want to avoid
1229 : : side-effects from evaluation of a particular subexpression of a
1230 : : constant-expression. In such cases we use modifiable_tracker to prevent
1231 : : modification of variables created outside of that subexpression.
1232 : :
1233 : : ??? We could change the hash_set to a hash_map, allow and track external
1234 : : modifications, and roll them back in the destructor. It's not clear to me
1235 : : that this would be worthwhile. */
1236 : :
1237 : : class modifiable_tracker
1238 : : {
1239 : : hash_set<tree> set;
1240 : : constexpr_global_ctx *global;
1241 : : public:
1242 : 151461 : modifiable_tracker (constexpr_global_ctx *g): global(g)
1243 : : {
1244 : 151461 : global->modifiable = &set;
1245 : 151461 : }
1246 : 151461 : ~modifiable_tracker ()
1247 : : {
1248 : 151501 : for (tree t: set)
1249 : 40 : global->clear_value (t);
1250 : 151461 : global->modifiable = nullptr;
1251 : 151461 : }
1252 : : };
1253 : :
1254 : : /* The constexpr expansion context. CALL is the current function
1255 : : expansion, CTOR is the current aggregate initializer, OBJECT is the
1256 : : object being initialized by CTOR, either a VAR_DECL or a _REF. */
1257 : :
1258 : : struct constexpr_ctx {
1259 : : /* The part of the context that needs to be unique to the whole
1260 : : cxx_eval_outermost_constant_expr invocation. */
1261 : : constexpr_global_ctx *global;
1262 : : /* The innermost call we're evaluating. */
1263 : : constexpr_call *call;
1264 : : /* SAVE_EXPRs and TARGET_EXPR_SLOT vars of TARGET_EXPRs that we've seen
1265 : : within the current LOOP_EXPR. NULL if we aren't inside a loop. */
1266 : : vec<tree> *save_exprs;
1267 : : /* The CONSTRUCTOR we're currently building up for an aggregate
1268 : : initializer. */
1269 : : tree ctor;
1270 : : /* The object we're building the CONSTRUCTOR for. */
1271 : : tree object;
1272 : : /* If inside SWITCH_EXPR. */
1273 : : constexpr_switch_state *css_state;
1274 : : /* The aggregate initialization context inside which this one is nested. This
1275 : : is used by lookup_placeholder to resolve PLACEHOLDER_EXPRs. */
1276 : : const constexpr_ctx *parent;
1277 : :
1278 : : /* Whether we should error on a non-constant expression or fail quietly.
1279 : : This flag needs to be here, but some of the others could move to global
1280 : : if they get larger than a word. */
1281 : : bool quiet;
1282 : : /* Whether we are strictly conforming to constant expression rules or
1283 : : trying harder to get a constant value. */
1284 : : bool strict;
1285 : : /* Whether __builtin_is_constant_evaluated () should be true. */
1286 : : mce_value manifestly_const_eval;
1287 : : };
1288 : :
1289 : : /* Remove T from the global values map, checking for attempts to destroy
1290 : : a value that has already finished its lifetime. */
1291 : :
1292 : : static void
1293 : 74260206 : destroy_value_checked (const constexpr_ctx* ctx, tree t, bool *non_constant_p)
1294 : : {
1295 : 74260206 : if (t == error_mark_node || TREE_TYPE (t) == error_mark_node)
1296 : : return;
1297 : :
1298 : : /* Don't error again here if we've already reported a problem. */
1299 : 74260206 : if (!*non_constant_p
1300 : 39008827 : && DECL_P (t)
1301 : : /* Non-trivial destructors have their lifetimes ended explicitly
1302 : : with a clobber, so don't worry about it here. */
1303 : 39003413 : && (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (t))
1304 : : /* ...except parameters are remapped in cxx_eval_call_expression,
1305 : : and the destructor call during cleanup won't be able to tell that
1306 : : this value has already been destroyed, so complain now. This is
1307 : : not quite unobservable, but is extremely unlikely to crop up in
1308 : : practice; see g++.dg/cpp2a/constexpr-lifetime2.C. */
1309 : 151336 : || TREE_CODE (t) == PARM_DECL)
1310 : 113112483 : && ctx->global->is_outside_lifetime (t))
1311 : : {
1312 : 54 : if (!ctx->quiet)
1313 : : {
1314 : 18 : auto_diagnostic_group d;
1315 : 18 : error ("destroying %qE outside its lifetime", t);
1316 : 18 : inform (DECL_SOURCE_LOCATION (t), "declared here");
1317 : 18 : }
1318 : 54 : *non_constant_p = true;
1319 : : }
1320 : 74260206 : ctx->global->destroy_value (t);
1321 : : }
1322 : :
1323 : : /* This internal flag controls whether we should avoid doing anything during
1324 : : constexpr evaluation that would cause extra DECL_UID generation, such as
1325 : : template instantiation and function body copying. */
1326 : :
1327 : : static bool uid_sensitive_constexpr_evaluation_value;
1328 : :
1329 : : /* An internal counter that keeps track of the number of times
1330 : : uid_sensitive_constexpr_evaluation_p returned true. */
1331 : :
1332 : : static unsigned uid_sensitive_constexpr_evaluation_true_counter;
1333 : :
1334 : : /* The accessor for uid_sensitive_constexpr_evaluation_value which also
1335 : : increments the corresponding counter. */
1336 : :
1337 : : static bool
1338 : 6205886 : uid_sensitive_constexpr_evaluation_p ()
1339 : : {
1340 : 6201583 : if (uid_sensitive_constexpr_evaluation_value)
1341 : : {
1342 : 1654686 : ++uid_sensitive_constexpr_evaluation_true_counter;
1343 : 1654686 : return true;
1344 : : }
1345 : : else
1346 : : return false;
1347 : : }
1348 : :
1349 : : /* The default constructor for uid_sensitive_constexpr_evaluation_sentinel
1350 : : enables the internal flag for uid_sensitive_constexpr_evaluation_p
1351 : : during the lifetime of the sentinel object. Upon its destruction, the
1352 : : previous value of uid_sensitive_constexpr_evaluation_p is restored. */
1353 : :
1354 : 61546728 : uid_sensitive_constexpr_evaluation_sentinel
1355 : 61546728 : ::uid_sensitive_constexpr_evaluation_sentinel ()
1356 : 61546728 : : ovr (uid_sensitive_constexpr_evaluation_value, true)
1357 : : {
1358 : 61546728 : }
1359 : :
1360 : : /* The default constructor for uid_sensitive_constexpr_evaluation_checker
1361 : : records the current number of times that uid_sensitive_constexpr_evaluation_p
1362 : : has been called and returned true. */
1363 : :
1364 : 1781880201 : uid_sensitive_constexpr_evaluation_checker
1365 : 1781880201 : ::uid_sensitive_constexpr_evaluation_checker ()
1366 : 1781880201 : : saved_counter (uid_sensitive_constexpr_evaluation_true_counter)
1367 : : {
1368 : 1781880201 : }
1369 : :
1370 : : /* Returns true iff uid_sensitive_constexpr_evaluation_p is true, and
1371 : : some constexpr evaluation was restricted due to u_s_c_e_p being called
1372 : : and returning true during the lifetime of this checker object. */
1373 : :
1374 : : bool
1375 : 1255501447 : uid_sensitive_constexpr_evaluation_checker::evaluation_restricted_p () const
1376 : : {
1377 : 1255501447 : return (uid_sensitive_constexpr_evaluation_value
1378 : 1255501447 : && saved_counter != uid_sensitive_constexpr_evaluation_true_counter);
1379 : : }
1380 : :
1381 : :
1382 : : /* A table of all constexpr calls that have been evaluated by the
1383 : : compiler in this translation unit. */
1384 : :
1385 : : static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
1386 : :
1387 : : /* Compute a hash value for a constexpr call representation. */
1388 : :
1389 : : inline hashval_t
1390 : 94132101 : constexpr_call_hasher::hash (constexpr_call *info)
1391 : : {
1392 : 94132101 : return info->hash;
1393 : : }
1394 : :
1395 : : /* Return true if the objects pointed to by P and Q represent calls
1396 : : to the same constexpr function with the same arguments.
1397 : : Otherwise, return false. */
1398 : :
1399 : : bool
1400 : 101751315 : constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs)
1401 : : {
1402 : 101751315 : if (lhs == rhs)
1403 : : return true;
1404 : 101751315 : if (lhs->hash != rhs->hash)
1405 : : return false;
1406 : 12811392 : if (lhs->manifestly_const_eval != rhs->manifestly_const_eval)
1407 : : return false;
1408 : 12811392 : if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef))
1409 : : return false;
1410 : 12811392 : return cp_tree_equal (lhs->bindings, rhs->bindings);
1411 : : }
1412 : :
1413 : : /* Initialize the constexpr call table, if needed. */
1414 : :
1415 : : static void
1416 : 16060431 : maybe_initialize_constexpr_call_table (void)
1417 : : {
1418 : 16060431 : if (constexpr_call_table == NULL)
1419 : 16163 : constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101);
1420 : 16060431 : }
1421 : :
1422 : : /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when
1423 : : a function happens to get called recursively, we unshare the callee
1424 : : function's body and evaluate this unshared copy instead of evaluating the
1425 : : original body.
1426 : :
1427 : : FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1428 : : copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1429 : : that's keyed off of the original FUNCTION_DECL and whose value is a
1430 : : TREE_LIST of this function's unused copies awaiting reuse.
1431 : :
1432 : : This is not GC-deletable to avoid GC affecting UID generation. */
1433 : :
1434 : : static GTY(()) decl_tree_map *fundef_copies_table;
1435 : :
1436 : : /* Reuse a copy or create a new unshared copy of the function FUN.
1437 : : Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1438 : : is parms, TYPE is result. */
1439 : :
1440 : : static tree
1441 : 32378430 : get_fundef_copy (constexpr_fundef *fundef)
1442 : : {
1443 : 32378430 : tree copy;
1444 : 32378430 : bool existed;
1445 : 32378430 : tree *slot = &(hash_map_safe_get_or_insert<hm_ggc>
1446 : 32378430 : (fundef_copies_table, fundef->decl, &existed, 127));
1447 : :
1448 : 32378430 : if (!existed)
1449 : : {
1450 : : /* There is no cached function available, or in use. We can use
1451 : : the function directly. That the slot is now created records
1452 : : that this function is now in use. */
1453 : 5180625 : copy = build_tree_list (fundef->body, fundef->parms);
1454 : 5180625 : TREE_TYPE (copy) = fundef->result;
1455 : : }
1456 : 27197805 : else if (*slot == NULL_TREE)
1457 : : {
1458 : 4303 : if (uid_sensitive_constexpr_evaluation_p ())
1459 : 0 : return NULL_TREE;
1460 : :
1461 : : /* We've already used the function itself, so make a copy. */
1462 : 4303 : copy = build_tree_list (NULL, NULL);
1463 : 4303 : tree saved_body = DECL_SAVED_TREE (fundef->decl);
1464 : 4303 : tree saved_parms = DECL_ARGUMENTS (fundef->decl);
1465 : 4303 : tree saved_result = DECL_RESULT (fundef->decl);
1466 : 4303 : tree saved_fn = current_function_decl;
1467 : 4303 : DECL_SAVED_TREE (fundef->decl) = fundef->body;
1468 : 4303 : DECL_ARGUMENTS (fundef->decl) = fundef->parms;
1469 : 4303 : DECL_RESULT (fundef->decl) = fundef->result;
1470 : 4303 : current_function_decl = fundef->decl;
1471 : 4303 : TREE_PURPOSE (copy) = copy_fn (fundef->decl, TREE_VALUE (copy),
1472 : 4303 : TREE_TYPE (copy));
1473 : 4303 : current_function_decl = saved_fn;
1474 : 4303 : DECL_RESULT (fundef->decl) = saved_result;
1475 : 4303 : DECL_ARGUMENTS (fundef->decl) = saved_parms;
1476 : 4303 : DECL_SAVED_TREE (fundef->decl) = saved_body;
1477 : : }
1478 : : else
1479 : : {
1480 : : /* We have a cached function available. */
1481 : 27193502 : copy = *slot;
1482 : 27193502 : *slot = TREE_CHAIN (copy);
1483 : : }
1484 : :
1485 : : return copy;
1486 : : }
1487 : :
1488 : : /* Save the copy COPY of function FUN for later reuse by
1489 : : get_fundef_copy(). By construction, there will always be an entry
1490 : : to find. */
1491 : :
1492 : : static void
1493 : 32378430 : save_fundef_copy (tree fun, tree copy)
1494 : : {
1495 : 32378430 : tree *slot = fundef_copies_table->get (fun);
1496 : 32378430 : TREE_CHAIN (copy) = *slot;
1497 : 32378430 : *slot = copy;
1498 : 32378430 : }
1499 : :
1500 : : /* Whether our evaluation wants a prvalue (e.g. CONSTRUCTOR or _CST),
1501 : : a glvalue (e.g. VAR_DECL or _REF), or nothing. */
1502 : :
1503 : : enum value_cat {
1504 : : vc_prvalue = 0,
1505 : : vc_glvalue = 1,
1506 : : vc_discard = 2
1507 : : };
1508 : :
1509 : : static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
1510 : : value_cat, bool *, bool *, tree * = NULL);
1511 : : static tree cxx_eval_bare_aggregate (const constexpr_ctx *, tree,
1512 : : value_cat, bool *, bool *);
1513 : : static tree cxx_fold_indirect_ref (const constexpr_ctx *, location_t, tree, tree,
1514 : : bool * = NULL);
1515 : : static tree find_heap_var_refs (tree *, int *, void *);
1516 : :
1517 : : /* Attempt to evaluate T which represents a call to a builtin function.
1518 : : We assume here that all builtin functions evaluate to scalar types
1519 : : represented by _CST nodes. */
1520 : :
1521 : : static tree
1522 : 10688691 : cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,
1523 : : value_cat lval,
1524 : : bool *non_constant_p, bool *overflow_p)
1525 : : {
1526 : 10688691 : const int nargs = call_expr_nargs (t);
1527 : 10688691 : tree *args = (tree *) alloca (nargs * sizeof (tree));
1528 : 10688691 : tree new_call;
1529 : 10688691 : int i;
1530 : :
1531 : : /* Don't fold __builtin_constant_p within a constexpr function. */
1532 : 10688691 : bool bi_const_p = DECL_IS_BUILTIN_CONSTANT_P (fun);
1533 : :
1534 : : /* If we aren't requiring a constant expression, defer __builtin_constant_p
1535 : : in a constexpr function until we have values for the parameters. */
1536 : 630278 : if (bi_const_p
1537 : 630278 : && ctx->manifestly_const_eval != mce_true
1538 : 620885 : && current_function_decl
1539 : 618759 : && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
1540 : : {
1541 : 324056 : *non_constant_p = true;
1542 : 324056 : return t;
1543 : : }
1544 : :
1545 : : /* For __builtin_is_constant_evaluated, defer it if not
1546 : : ctx->manifestly_const_eval (as sometimes we try to constant evaluate
1547 : : without manifestly_const_eval even expressions or parts thereof which
1548 : : will later be manifestly const_eval evaluated), otherwise fold it to
1549 : : true. */
1550 : 10364635 : if (fndecl_built_in_p (fun, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
1551 : : BUILT_IN_FRONTEND))
1552 : : {
1553 : 859797 : if (ctx->manifestly_const_eval == mce_unknown)
1554 : : {
1555 : 844086 : *non_constant_p = true;
1556 : 844086 : return t;
1557 : : }
1558 : 15711 : return constant_boolean_node (ctx->manifestly_const_eval == mce_true,
1559 : 15711 : boolean_type_node);
1560 : : }
1561 : :
1562 : 9504838 : if (fndecl_built_in_p (fun, CP_BUILT_IN_SOURCE_LOCATION, BUILT_IN_FRONTEND))
1563 : : {
1564 : 409 : temp_override<tree> ovr (current_function_decl);
1565 : 409 : if (ctx->call && ctx->call->fundef)
1566 : 143 : current_function_decl = ctx->call->fundef->decl;
1567 : 409 : return fold_builtin_source_location (t);
1568 : 409 : }
1569 : :
1570 : 9504429 : int strops = 0;
1571 : 9504429 : int strret = 0;
1572 : 9504429 : if (fndecl_built_in_p (fun, BUILT_IN_NORMAL))
1573 : 8858560 : switch (DECL_FUNCTION_CODE (fun))
1574 : : {
1575 : : case BUILT_IN_STRLEN:
1576 : : case BUILT_IN_STRNLEN:
1577 : 9504371 : strops = 1;
1578 : : break;
1579 : 102775 : case BUILT_IN_MEMCHR:
1580 : 102775 : case BUILT_IN_STRCHR:
1581 : 102775 : case BUILT_IN_STRRCHR:
1582 : 102775 : strops = 1;
1583 : 102775 : strret = 1;
1584 : 102775 : break;
1585 : 23919 : case BUILT_IN_MEMCMP:
1586 : 23919 : case BUILT_IN_STRCMP:
1587 : 23919 : strops = 2;
1588 : 23919 : break;
1589 : 29565 : case BUILT_IN_STRSTR:
1590 : 29565 : strops = 2;
1591 : 29565 : strret = 1;
1592 : 29565 : break;
1593 : 42 : case BUILT_IN_ASAN_POINTER_COMPARE:
1594 : 42 : case BUILT_IN_ASAN_POINTER_SUBTRACT:
1595 : : /* These builtins shall be ignored during constant expression
1596 : : evaluation. */
1597 : 42 : return void_node;
1598 : 16 : case BUILT_IN_UNREACHABLE:
1599 : 16 : case BUILT_IN_TRAP:
1600 : 16 : if (!*non_constant_p && !ctx->quiet)
1601 : : {
1602 : : /* Do not allow__builtin_unreachable in constexpr function.
1603 : : The __builtin_unreachable call with BUILTINS_LOCATION
1604 : : comes from cp_maybe_instrument_return. */
1605 : 1 : if (EXPR_LOCATION (t) == BUILTINS_LOCATION)
1606 : 0 : error ("%<constexpr%> call flows off the end of the function");
1607 : : else
1608 : 1 : error ("%q+E is not a constant expression", t);
1609 : : }
1610 : 16 : *non_constant_p = true;
1611 : 16 : return t;
1612 : : default:
1613 : : break;
1614 : : }
1615 : :
1616 : : /* Be permissive for arguments to built-ins; __builtin_constant_p should
1617 : : return constant false for a non-constant argument. */
1618 : 9504371 : constexpr_ctx new_ctx = *ctx;
1619 : 9504371 : new_ctx.quiet = true;
1620 : 25945747 : for (i = 0; i < nargs; ++i)
1621 : : {
1622 : 16441376 : tree arg = CALL_EXPR_ARG (t, i);
1623 : 16441376 : tree oarg = arg;
1624 : :
1625 : : /* To handle string built-ins we need to pass ADDR_EXPR<STRING_CST> since
1626 : : expand_builtin doesn't know how to look in the values table. */
1627 : 16441376 : bool strop = i < strops;
1628 : 16441376 : if (strop)
1629 : : {
1630 : 286821 : STRIP_NOPS (arg);
1631 : 286821 : if (TREE_CODE (arg) == ADDR_EXPR)
1632 : 7792 : arg = TREE_OPERAND (arg, 0);
1633 : : else
1634 : : strop = false;
1635 : : }
1636 : :
1637 : : /* If builtin_valid_in_constant_expr_p is true,
1638 : : potential_constant_expression_1 has not recursed into the arguments
1639 : : of the builtin, verify it here. */
1640 : 16441376 : if (!builtin_valid_in_constant_expr_p (fun)
1641 : 16441376 : || potential_constant_expression (arg))
1642 : : {
1643 : 16441254 : bool dummy1 = false, dummy2 = false;
1644 : 16441254 : arg = cxx_eval_constant_expression (&new_ctx, arg, vc_prvalue,
1645 : : &dummy1, &dummy2);
1646 : : }
1647 : :
1648 : 16441376 : if (bi_const_p)
1649 : : /* For __builtin_constant_p, fold all expressions with constant values
1650 : : even if they aren't C++ constant-expressions. */
1651 : 306222 : arg = cp_fold_rvalue (arg);
1652 : 16135154 : else if (strop)
1653 : : {
1654 : 7792 : if (TREE_CODE (arg) == CONSTRUCTOR)
1655 : 113 : arg = braced_lists_to_strings (TREE_TYPE (arg), arg);
1656 : 7792 : if (TREE_CODE (arg) == STRING_CST)
1657 : 3092 : arg = build_address (arg);
1658 : : else
1659 : : arg = oarg;
1660 : : }
1661 : :
1662 : 16441376 : args[i] = arg;
1663 : : }
1664 : :
1665 : 9504371 : bool save_ffbcp = force_folding_builtin_constant_p;
1666 : 9504371 : force_folding_builtin_constant_p |= ctx->manifestly_const_eval == mce_true;
1667 : 9504371 : tree save_cur_fn = current_function_decl;
1668 : : /* Return name of ctx->call->fundef->decl for __builtin_FUNCTION (). */
1669 : 9504371 : if (fndecl_built_in_p (fun, BUILT_IN_FUNCTION)
1670 : 35 : && ctx->call
1671 : 9504375 : && ctx->call->fundef)
1672 : 4 : current_function_decl = ctx->call->fundef->decl;
1673 : 9504371 : if (fndecl_built_in_p (fun,
1674 : : CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
1675 : : BUILT_IN_FRONTEND))
1676 : : {
1677 : 400 : location_t loc = EXPR_LOCATION (t);
1678 : 400 : if (nargs >= 1)
1679 : 397 : VERIFY_CONSTANT (args[0]);
1680 : 195 : new_call
1681 : 195 : = fold_builtin_is_pointer_inverconvertible_with_class (loc, nargs,
1682 : : args);
1683 : : }
1684 : 9503971 : else if (fndecl_built_in_p (fun,
1685 : : CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
1686 : : BUILT_IN_FRONTEND))
1687 : : {
1688 : 575 : location_t loc = EXPR_LOCATION (t);
1689 : 575 : if (nargs >= 2)
1690 : : {
1691 : 569 : VERIFY_CONSTANT (args[0]);
1692 : 347 : VERIFY_CONSTANT (args[1]);
1693 : : }
1694 : 353 : new_call = fold_builtin_is_corresponding_member (loc, nargs, args);
1695 : : }
1696 : : else
1697 : 19006792 : new_call = fold_builtin_call_array (EXPR_LOCATION (t), TREE_TYPE (t),
1698 : 9503396 : CALL_EXPR_FN (t), nargs, args);
1699 : 9503944 : current_function_decl = save_cur_fn;
1700 : 9503944 : force_folding_builtin_constant_p = save_ffbcp;
1701 : 9503944 : if (new_call == NULL)
1702 : : {
1703 : 6926219 : if (!*non_constant_p && !ctx->quiet)
1704 : : {
1705 : 0 : new_call = build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
1706 : 0 : CALL_EXPR_FN (t), nargs, args);
1707 : 0 : error ("%q+E is not a constant expression", new_call);
1708 : : }
1709 : 6926219 : *non_constant_p = true;
1710 : 6926219 : return t;
1711 : : }
1712 : :
1713 : 2577725 : if (!potential_constant_expression (new_call))
1714 : : {
1715 : 575 : if (!*non_constant_p && !ctx->quiet)
1716 : 4 : error ("%q+E is not a constant expression", new_call);
1717 : 575 : *non_constant_p = true;
1718 : 575 : return t;
1719 : : }
1720 : :
1721 : 2577150 : if (strret)
1722 : : {
1723 : : /* memchr returns a pointer into the first argument, but we replaced the
1724 : : argument above with a STRING_CST; put it back it now. */
1725 : 219 : tree op = CALL_EXPR_ARG (t, strret-1);
1726 : 219 : STRIP_NOPS (new_call);
1727 : 219 : if (TREE_CODE (new_call) == POINTER_PLUS_EXPR)
1728 : 107 : TREE_OPERAND (new_call, 0) = op;
1729 : 112 : else if (TREE_CODE (new_call) == ADDR_EXPR)
1730 : 2577150 : new_call = op;
1731 : : }
1732 : :
1733 : 2577150 : return cxx_eval_constant_expression (&new_ctx, new_call, lval,
1734 : 2577150 : non_constant_p, overflow_p);
1735 : : }
1736 : :
1737 : : /* TEMP is the constant value of a temporary object of type TYPE. Adjust
1738 : : the type of the value to match. */
1739 : :
1740 : : static tree
1741 : 42054040 : adjust_temp_type (tree type, tree temp)
1742 : : {
1743 : 42054040 : if (same_type_p (TREE_TYPE (temp), type))
1744 : : return temp;
1745 : : /* Avoid wrapping an aggregate value in a NOP_EXPR. */
1746 : 25555144 : if (TREE_CODE (temp) == CONSTRUCTOR)
1747 : : {
1748 : : /* build_constructor wouldn't retain various CONSTRUCTOR flags. */
1749 : 789094 : tree t = copy_node (temp);
1750 : 789094 : TREE_TYPE (t) = type;
1751 : 789094 : return t;
1752 : : }
1753 : 24766050 : if (TREE_CODE (temp) == EMPTY_CLASS_EXPR)
1754 : 0 : return build0 (EMPTY_CLASS_EXPR, type);
1755 : 24766050 : gcc_assert (scalarish_type_p (type));
1756 : : /* Now we know we're dealing with a scalar, and a prvalue of non-class
1757 : : type is cv-unqualified. */
1758 : 24766050 : return cp_fold_convert (cv_unqualified (type), temp);
1759 : : }
1760 : :
1761 : : /* If T is a CONSTRUCTOR, return an unshared copy of T and any
1762 : : sub-CONSTRUCTORs. Otherwise return T.
1763 : :
1764 : : We use this whenever we initialize an object as a whole, whether it's a
1765 : : parameter, a local variable, or a subobject, so that subsequent
1766 : : modifications don't affect other places where it was used. */
1767 : :
1768 : : tree
1769 : 30274196 : unshare_constructor (tree t MEM_STAT_DECL)
1770 : : {
1771 : 30274196 : if (!t || TREE_CODE (t) != CONSTRUCTOR)
1772 : : return t;
1773 : 6422374 : auto_vec <tree*, 4> ptrs;
1774 : 6422374 : ptrs.safe_push (&t);
1775 : 6422374 : while (!ptrs.is_empty ())
1776 : : {
1777 : 7165040 : tree *p = ptrs.pop ();
1778 : 7165040 : tree n = copy_node (*p PASS_MEM_STAT);
1779 : 10105903 : CONSTRUCTOR_ELTS (n) = vec_safe_copy (CONSTRUCTOR_ELTS (*p) PASS_MEM_STAT);
1780 : 7165040 : *p = n;
1781 : 7165040 : vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (n);
1782 : 7165040 : constructor_elt *ce;
1783 : 28451383 : for (HOST_WIDE_INT i = 0; vec_safe_iterate (v, i, &ce); ++i)
1784 : 7698929 : if (ce->value && TREE_CODE (ce->value) == CONSTRUCTOR)
1785 : 742666 : ptrs.safe_push (&ce->value);
1786 : : }
1787 : 6422374 : return t;
1788 : 6422374 : }
1789 : :
1790 : : /* If T is a CONSTRUCTOR, ggc_free T and any sub-CONSTRUCTORs. */
1791 : :
1792 : : static void
1793 : 684313 : free_constructor (tree t)
1794 : : {
1795 : 684313 : if (!t || TREE_CODE (t) != CONSTRUCTOR)
1796 : 0 : return;
1797 : 684313 : releasing_vec ctors;
1798 : 684313 : vec_safe_push (ctors, t);
1799 : 1375922 : while (!ctors->is_empty ())
1800 : : {
1801 : 691609 : tree c = ctors->pop ();
1802 : 691609 : if (vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (c))
1803 : : {
1804 : : constructor_elt *ce;
1805 : 111027 : for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i)
1806 : 74214 : if (ce->value && TREE_CODE (ce->value) == CONSTRUCTOR)
1807 : 7296 : vec_safe_push (ctors, ce->value);
1808 : 36813 : ggc_free (elts);
1809 : : }
1810 : 691609 : ggc_free (c);
1811 : : }
1812 : 684313 : }
1813 : :
1814 : : /* Helper function of cxx_bind_parameters_in_call. Return non-NULL
1815 : : if *TP is address of a static variable (or part of it) currently being
1816 : : constructed or of a heap artificial variable. */
1817 : :
1818 : : static tree
1819 : 7465187 : addr_of_non_const_var (tree *tp, int *walk_subtrees, void *data)
1820 : : {
1821 : 7465187 : if (TREE_CODE (*tp) == ADDR_EXPR)
1822 : 758245 : if (tree var = get_base_address (TREE_OPERAND (*tp, 0)))
1823 : 758245 : if (VAR_P (var) && TREE_STATIC (var))
1824 : : {
1825 : 516567 : if (DECL_NAME (var) == heap_uninit_identifier
1826 : 516567 : || DECL_NAME (var) == heap_identifier
1827 : 436875 : || DECL_NAME (var) == heap_vec_uninit_identifier
1828 : 953442 : || DECL_NAME (var) == heap_vec_identifier)
1829 : : return var;
1830 : :
1831 : 436864 : constexpr_global_ctx *global = (constexpr_global_ctx *) data;
1832 : 436864 : if (global->get_value (var))
1833 : : return var;
1834 : : }
1835 : 7282696 : if (TYPE_P (*tp))
1836 : 1505 : *walk_subtrees = false;
1837 : : return NULL_TREE;
1838 : : }
1839 : :
1840 : : /* Subroutine of cxx_eval_call_expression.
1841 : : We are processing a call expression (either CALL_EXPR or
1842 : : AGGR_INIT_EXPR) in the context of CTX. Evaluate
1843 : : all arguments and bind their values to correspondings
1844 : : parameters, making up the NEW_CALL context. */
1845 : :
1846 : : static tree
1847 : 59782026 : cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t, tree fun,
1848 : : bool *non_constant_p, bool *overflow_p,
1849 : : bool *non_constant_args)
1850 : : {
1851 : 59782026 : const int nargs = call_expr_nargs (t);
1852 : 59782026 : tree parms = DECL_ARGUMENTS (fun);
1853 : 59782026 : int i;
1854 : : /* We don't record ellipsis args below. */
1855 : 59782026 : int nparms = list_length (parms);
1856 : 59782026 : int nbinds = nargs < nparms ? nargs : nparms;
1857 : 59782026 : tree binds = make_tree_vec (nbinds);
1858 : 105757459 : for (i = 0; i < nargs; ++i)
1859 : : {
1860 : 59725594 : tree x, arg;
1861 : 59725594 : tree type = parms ? TREE_TYPE (parms) : void_type_node;
1862 : 59725594 : if (parms && DECL_BY_REFERENCE (parms))
1863 : 6975 : type = TREE_TYPE (type);
1864 : 59725594 : x = get_nth_callarg (t, i);
1865 : : /* For member function, the first argument is a pointer to the implied
1866 : : object. For a constructor, it might still be a dummy object, in
1867 : : which case we get the real argument from ctx. */
1868 : 94467798 : if (i == 0 && DECL_CONSTRUCTOR_P (fun)
1869 : 66434435 : && is_dummy_object (x))
1870 : : {
1871 : 2306978 : x = ctx->object;
1872 : 2306978 : x = build_address (x);
1873 : : }
1874 : 59725594 : if (TREE_ADDRESSABLE (type))
1875 : : {
1876 : : /* Undo convert_for_arg_passing work here. */
1877 : 9210 : x = convert_from_reference (x);
1878 : 9210 : arg = cxx_eval_constant_expression (ctx, x, vc_glvalue,
1879 : : non_constant_p, overflow_p);
1880 : : }
1881 : : else
1882 : : /* Normally we would strip a TARGET_EXPR in an initialization context
1883 : : such as this, but here we do the elision differently: we keep the
1884 : : TARGET_EXPR, and use its CONSTRUCTOR as the value of the parm. */
1885 : 59716384 : arg = cxx_eval_constant_expression (ctx, x, vc_prvalue,
1886 : : non_constant_p, overflow_p);
1887 : : /* Check we aren't dereferencing a null pointer when calling a non-static
1888 : : member function, which is undefined behaviour. */
1889 : 47233899 : if (i == 0 && DECL_OBJECT_MEMBER_FUNCTION_P (fun)
1890 : 24726309 : && integer_zerop (arg)
1891 : : /* But ignore calls from within compiler-generated code, to handle
1892 : : cases like lambda function pointer conversion operator thunks
1893 : : which pass NULL as the 'this' pointer. */
1894 : 59744795 : && !(TREE_CODE (t) == CALL_EXPR && CALL_FROM_THUNK_P (t)))
1895 : : {
1896 : 96 : if (!ctx->quiet)
1897 : 6 : error_at (cp_expr_loc_or_input_loc (x),
1898 : : "dereferencing a null pointer");
1899 : 96 : *non_constant_p = true;
1900 : : }
1901 : : /* Don't VERIFY_CONSTANT here. */
1902 : 59725594 : if (*non_constant_p && ctx->quiet)
1903 : : break;
1904 : : /* Just discard ellipsis args after checking their constantitude. */
1905 : 45975433 : if (!parms)
1906 : 448 : continue;
1907 : :
1908 : 45974985 : if (!*non_constant_p)
1909 : : {
1910 : : /* Make sure the binding has the same type as the parm. But
1911 : : only for constant args. */
1912 : 45974754 : if (TREE_ADDRESSABLE (type))
1913 : : {
1914 : 7164 : if (!same_type_p (type, TREE_TYPE (arg)))
1915 : : {
1916 : 9 : arg = build_fold_addr_expr (arg);
1917 : 9 : arg = cp_fold_convert (build_reference_type (type), arg);
1918 : 9 : arg = convert_from_reference (arg);
1919 : : }
1920 : : }
1921 : 45967590 : else if (!TYPE_REF_P (type))
1922 : 32426242 : arg = adjust_temp_type (type, arg);
1923 : 45974754 : if (!TREE_CONSTANT (arg))
1924 : 37594636 : *non_constant_args = true;
1925 : 8380118 : else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
1926 : : /* The destructor needs to see any modifications the callee makes
1927 : : to the argument. */
1928 : 0 : *non_constant_args = true;
1929 : : /* If arg is or contains address of a heap artificial variable or
1930 : : of a static variable being constructed, avoid caching the
1931 : : function call, as those variables might be modified by the
1932 : : function, or might be modified by the callers in between
1933 : : the cached function and just read by the function. */
1934 : 8380118 : else if (!*non_constant_args
1935 : 8380118 : && cp_walk_tree (&arg, addr_of_non_const_var, ctx->global,
1936 : : NULL))
1937 : 182491 : *non_constant_args = true;
1938 : :
1939 : : /* For virtual calls, adjust the this argument, so that it is
1940 : : the object on which the method is called, rather than
1941 : : one of its bases. */
1942 : 45974754 : if (i == 0 && DECL_VIRTUAL_P (fun))
1943 : : {
1944 : 5835 : tree addr = arg;
1945 : 5835 : STRIP_NOPS (addr);
1946 : 5835 : if (TREE_CODE (addr) == ADDR_EXPR)
1947 : : {
1948 : 5829 : tree obj = TREE_OPERAND (addr, 0);
1949 : 5829 : while (TREE_CODE (obj) == COMPONENT_REF
1950 : 2825 : && DECL_FIELD_IS_BASE (TREE_OPERAND (obj, 1))
1951 : 8650 : && !same_type_ignoring_top_level_qualifiers_p
1952 : 2802 : (TREE_TYPE (obj), DECL_CONTEXT (fun)))
1953 : 19 : obj = TREE_OPERAND (obj, 0);
1954 : 5829 : if (obj != TREE_OPERAND (addr, 0))
1955 : 19 : arg = build_fold_addr_expr_with_type (obj,
1956 : : TREE_TYPE (arg));
1957 : : }
1958 : : }
1959 : 45974754 : TREE_VEC_ELT (binds, i) = arg;
1960 : : }
1961 : 45974985 : parms = TREE_CHAIN (parms);
1962 : : }
1963 : :
1964 : 59782026 : return binds;
1965 : : }
1966 : :
1967 : : /* Variables and functions to manage constexpr call expansion context.
1968 : : These do not need to be marked for PCH or GC. */
1969 : :
1970 : : /* FIXME remember and print actual constant arguments. */
1971 : : static vec<tree> call_stack;
1972 : : static int call_stack_tick;
1973 : : static int last_cx_error_tick;
1974 : :
1975 : : static int
1976 : 43870981 : push_cx_call_context (tree call)
1977 : : {
1978 : 43870981 : ++call_stack_tick;
1979 : 43870981 : if (!EXPR_HAS_LOCATION (call))
1980 : 6584 : SET_EXPR_LOCATION (call, input_location);
1981 : 43870981 : call_stack.safe_push (call);
1982 : 43870981 : int len = call_stack.length ();
1983 : 43870981 : if (len > max_constexpr_depth)
1984 : 24 : return false;
1985 : : return len;
1986 : : }
1987 : :
1988 : : static void
1989 : 43870981 : pop_cx_call_context (void)
1990 : : {
1991 : 43870981 : ++call_stack_tick;
1992 : 43870981 : call_stack.pop ();
1993 : 43870981 : }
1994 : :
1995 : : vec<tree>
1996 : 188959 : cx_error_context (void)
1997 : : {
1998 : 188959 : vec<tree> r = vNULL;
1999 : 188959 : if (call_stack_tick != last_cx_error_tick
2000 : 188959 : && !call_stack.is_empty ())
2001 : : r = call_stack;
2002 : 188959 : last_cx_error_tick = call_stack_tick;
2003 : 188959 : return r;
2004 : : }
2005 : :
2006 : : /* E is an operand of a failed assertion, fold it either with or without
2007 : : constexpr context. */
2008 : :
2009 : : static tree
2010 : 550 : fold_operand (tree e, const constexpr_ctx *ctx)
2011 : : {
2012 : 550 : if (ctx)
2013 : : {
2014 : 70 : bool new_non_constant_p = false, new_overflow_p = false;
2015 : 70 : e = cxx_eval_constant_expression (ctx, e, vc_prvalue,
2016 : : &new_non_constant_p,
2017 : : &new_overflow_p);
2018 : : }
2019 : : else
2020 : 480 : e = fold_non_dependent_expr (e, tf_none, /*manifestly_const_eval=*/true);
2021 : 550 : return e;
2022 : : }
2023 : :
2024 : : /* If we have a condition in conjunctive normal form (CNF), find the first
2025 : : failing clause. In other words, given an expression like
2026 : :
2027 : : true && true && false && true && false
2028 : :
2029 : : return the first 'false'. EXPR is the expression. */
2030 : :
2031 : : static tree
2032 : 360 : find_failing_clause_r (const constexpr_ctx *ctx, tree expr)
2033 : : {
2034 : 464 : if (TREE_CODE (expr) == TRUTH_ANDIF_EXPR)
2035 : : {
2036 : : /* First check the left side... */
2037 : 206 : tree e = find_failing_clause_r (ctx, TREE_OPERAND (expr, 0));
2038 : 206 : if (e == NULL_TREE)
2039 : : /* ...if we didn't find a false clause, check the right side. */
2040 : 104 : e = find_failing_clause_r (ctx, TREE_OPERAND (expr, 1));
2041 : 102 : return e;
2042 : : }
2043 : 258 : tree e = contextual_conv_bool (expr, tf_none);
2044 : 258 : e = fold_operand (e, ctx);
2045 : 258 : if (integer_zerop (e))
2046 : : /* This is the failing clause. */
2047 : 154 : return expr;
2048 : : return NULL_TREE;
2049 : : }
2050 : :
2051 : : /* Wrapper for find_failing_clause_r. */
2052 : :
2053 : : tree
2054 : 1153 : find_failing_clause (const constexpr_ctx *ctx, tree expr)
2055 : : {
2056 : 1153 : if (TREE_CODE (expr) == TRUTH_ANDIF_EXPR)
2057 : 154 : if (tree e = find_failing_clause_r (ctx, expr))
2058 : 1153 : expr = e;
2059 : 1153 : return expr;
2060 : : }
2061 : :
2062 : : /* Emit additional diagnostics for failing condition BAD.
2063 : : Used by finish_static_assert and IFN_ASSUME constexpr diagnostics.
2064 : : If SHOW_EXPR_P is true, print the condition (because it was
2065 : : instantiation-dependent). */
2066 : :
2067 : : void
2068 : 1153 : diagnose_failing_condition (tree bad, location_t cloc, bool show_expr_p,
2069 : : const constexpr_ctx *ctx /* = nullptr */)
2070 : : {
2071 : : /* Nobody wants to see the artificial (bool) cast. */
2072 : 1153 : bad = tree_strip_nop_conversions (bad);
2073 : 1153 : if (TREE_CODE (bad) == CLEANUP_POINT_EXPR)
2074 : 4 : bad = TREE_OPERAND (bad, 0);
2075 : :
2076 : : /* Actually explain the failure if this is a concept check or a
2077 : : requires-expression. */
2078 : 1153 : if (concept_check_p (bad) || TREE_CODE (bad) == REQUIRES_EXPR)
2079 : 176 : diagnose_constraints (cloc, bad, NULL_TREE);
2080 : 977 : else if (COMPARISON_CLASS_P (bad)
2081 : 977 : && ARITHMETIC_TYPE_P (TREE_TYPE (TREE_OPERAND (bad, 0))))
2082 : : {
2083 : 146 : tree op0 = fold_operand (TREE_OPERAND (bad, 0), ctx);
2084 : 146 : tree op1 = fold_operand (TREE_OPERAND (bad, 1), ctx);
2085 : 146 : tree cond = build2 (TREE_CODE (bad), boolean_type_node, op0, op1);
2086 : 146 : inform (cloc, "the comparison reduces to %qE", cond);
2087 : : }
2088 : 831 : else if (show_expr_p)
2089 : 649 : inform (cloc, "%qE evaluates to false", bad);
2090 : 1153 : }
2091 : :
2092 : : /* Process an assert/assume of ORIG_ARG. If it's not supposed to be evaluated,
2093 : : do it without changing the current evaluation state. If it evaluates to
2094 : : false, complain and return false; otherwise, return true. */
2095 : :
2096 : : static bool
2097 : 151574 : cxx_eval_assert (const constexpr_ctx *ctx, tree arg, const char *msg,
2098 : : location_t loc, bool evaluated,
2099 : : bool *non_constant_p, bool *overflow_p)
2100 : : {
2101 : 151574 : if (*non_constant_p)
2102 : : return true;
2103 : :
2104 : 151574 : tree eval;
2105 : 151574 : if (!evaluated)
2106 : : {
2107 : 151503 : if (!potential_rvalue_constant_expression (arg))
2108 : 42 : return true;
2109 : :
2110 : 151461 : constexpr_ctx new_ctx = *ctx;
2111 : 151461 : new_ctx.quiet = true;
2112 : 151461 : bool new_non_constant_p = false, new_overflow_p = false;
2113 : : /* Avoid modification of existing values. */
2114 : 151461 : modifiable_tracker ms (new_ctx.global);
2115 : 151461 : eval = cxx_eval_constant_expression (&new_ctx, arg, vc_prvalue,
2116 : : &new_non_constant_p,
2117 : : &new_overflow_p);
2118 : 151461 : }
2119 : : else
2120 : 71 : eval = cxx_eval_constant_expression (ctx, arg, vc_prvalue,
2121 : : non_constant_p,
2122 : : overflow_p);
2123 : 151532 : if (!*non_constant_p && integer_zerop (eval))
2124 : : {
2125 : 99 : if (!ctx->quiet)
2126 : : {
2127 : : /* See if we can find which clause was failing
2128 : : (for logical AND). */
2129 : 32 : tree bad = find_failing_clause (ctx, arg);
2130 : : /* If not, or its location is unusable, fall back to the
2131 : : previous location. */
2132 : 32 : location_t cloc = cp_expr_loc_or_loc (bad, loc);
2133 : :
2134 : : /* Report the error. */
2135 : 32 : auto_diagnostic_group d;
2136 : 32 : error_at (cloc, msg);
2137 : 32 : diagnose_failing_condition (bad, cloc, true, ctx);
2138 : 32 : return bad;
2139 : 32 : }
2140 : 67 : *non_constant_p = true;
2141 : 67 : return false;
2142 : : }
2143 : :
2144 : : return true;
2145 : : }
2146 : :
2147 : : /* Evaluate a call T to a GCC internal function when possible and return
2148 : : the evaluated result or, under the control of CTX, give an error, set
2149 : : NON_CONSTANT_P, and return the unevaluated call T otherwise. */
2150 : :
2151 : : static tree
2152 : 191726 : cxx_eval_internal_function (const constexpr_ctx *ctx, tree t,
2153 : : value_cat lval,
2154 : : bool *non_constant_p, bool *overflow_p)
2155 : : {
2156 : 191726 : enum tree_code opcode = ERROR_MARK;
2157 : :
2158 : 191726 : switch (CALL_EXPR_IFN (t))
2159 : : {
2160 : 30 : case IFN_UBSAN_NULL:
2161 : 30 : case IFN_UBSAN_BOUNDS:
2162 : 30 : case IFN_UBSAN_VPTR:
2163 : 30 : case IFN_FALLTHROUGH:
2164 : 30 : return void_node;
2165 : :
2166 : 151484 : case IFN_ASSUME:
2167 : 151484 : if (!cxx_eval_assert (ctx, CALL_EXPR_ARG (t, 0),
2168 : : G_("failed %<assume%> attribute assumption"),
2169 : : EXPR_LOCATION (t), /*eval*/false,
2170 : : non_constant_p, overflow_p))
2171 : : return t;
2172 : 151455 : return void_node;
2173 : :
2174 : : case IFN_ADD_OVERFLOW:
2175 : : opcode = PLUS_EXPR;
2176 : : break;
2177 : 332 : case IFN_SUB_OVERFLOW:
2178 : 332 : opcode = MINUS_EXPR;
2179 : 332 : break;
2180 : 39327 : case IFN_MUL_OVERFLOW:
2181 : 39327 : opcode = MULT_EXPR;
2182 : 39327 : break;
2183 : :
2184 : 73 : case IFN_LAUNDER:
2185 : 73 : return cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0),
2186 : : vc_prvalue, non_constant_p,
2187 : 73 : overflow_p);
2188 : :
2189 : 30 : case IFN_VEC_CONVERT:
2190 : 30 : {
2191 : 30 : tree arg = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0),
2192 : : vc_prvalue, non_constant_p,
2193 : : overflow_p);
2194 : 30 : if (TREE_CODE (arg) == VECTOR_CST)
2195 : 19 : if (tree r = fold_const_call (CFN_VEC_CONVERT, TREE_TYPE (t), arg))
2196 : : return r;
2197 : : }
2198 : : /* FALLTHRU */
2199 : :
2200 : 16 : default:
2201 : 16 : if (!ctx->quiet)
2202 : 0 : error_at (cp_expr_loc_or_input_loc (t),
2203 : : "call to internal function %qE", t);
2204 : 16 : *non_constant_p = true;
2205 : 16 : return t;
2206 : : }
2207 : :
2208 : : /* Evaluate constant arguments using OPCODE and return a complex
2209 : : number containing the result and the overflow bit. */
2210 : 40109 : tree arg0 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0), lval,
2211 : : non_constant_p, overflow_p);
2212 : 40109 : tree arg1 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 1), lval,
2213 : : non_constant_p, overflow_p);
2214 : :
2215 : 40109 : if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2216 : : {
2217 : 2 : location_t loc = cp_expr_loc_or_input_loc (t);
2218 : 2 : tree type = TREE_TYPE (TREE_TYPE (t));
2219 : 2 : tree result = fold_binary_loc (loc, opcode, type,
2220 : : fold_convert_loc (loc, type, arg0),
2221 : : fold_convert_loc (loc, type, arg1));
2222 : 2 : tree ovf
2223 : 2 : = build_int_cst (type, arith_overflowed_p (opcode, type, arg0, arg1));
2224 : : /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */
2225 : 2 : if (TREE_OVERFLOW (result))
2226 : 0 : TREE_OVERFLOW (result) = 0;
2227 : :
2228 : 2 : return build_complex (TREE_TYPE (t), result, ovf);
2229 : : }
2230 : :
2231 : 40107 : *non_constant_p = true;
2232 : 40107 : return t;
2233 : : }
2234 : :
2235 : : /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */
2236 : :
2237 : : static void
2238 : 3054545 : clear_no_implicit_zero (tree ctor)
2239 : : {
2240 : 3054545 : if (CONSTRUCTOR_NO_CLEARING (ctor))
2241 : : {
2242 : 569988 : CONSTRUCTOR_NO_CLEARING (ctor) = false;
2243 : 2649046 : for (auto &e: CONSTRUCTOR_ELTS (ctor))
2244 : 969054 : if (TREE_CODE (e.value) == CONSTRUCTOR)
2245 : 188279 : clear_no_implicit_zero (e.value);
2246 : : }
2247 : 3054545 : }
2248 : :
2249 : : /* Complain about a const object OBJ being modified in a constant expression.
2250 : : EXPR is the MODIFY_EXPR expression performing the modification. */
2251 : :
2252 : : static void
2253 : 63 : modifying_const_object_error (tree expr, tree obj)
2254 : : {
2255 : 63 : location_t loc = cp_expr_loc_or_input_loc (expr);
2256 : 63 : auto_diagnostic_group d;
2257 : 126 : error_at (loc, "modifying a const object %qE is not allowed in "
2258 : 63 : "a constant expression", TREE_OPERAND (expr, 0));
2259 : :
2260 : : /* Find the underlying object that was declared as const. */
2261 : 63 : location_t decl_loc = UNKNOWN_LOCATION;
2262 : 138 : for (tree probe = obj; decl_loc == UNKNOWN_LOCATION; )
2263 : 75 : switch (TREE_CODE (probe))
2264 : : {
2265 : 39 : case BIT_FIELD_REF:
2266 : 39 : case COMPONENT_REF:
2267 : 39 : {
2268 : 39 : tree elt = TREE_OPERAND (probe, 1);
2269 : 39 : if (CP_TYPE_CONST_P (TREE_TYPE (elt)))
2270 : 27 : decl_loc = DECL_SOURCE_LOCATION (elt);
2271 : 39 : probe = TREE_OPERAND (probe, 0);
2272 : : }
2273 : 39 : break;
2274 : :
2275 : 0 : case ARRAY_REF:
2276 : 0 : case REALPART_EXPR:
2277 : 0 : case IMAGPART_EXPR:
2278 : 0 : probe = TREE_OPERAND (probe, 0);
2279 : 0 : break;
2280 : :
2281 : 36 : default:
2282 : 36 : decl_loc = location_of (probe);
2283 : 36 : break;
2284 : : }
2285 : 63 : inform (decl_loc, "originally declared %<const%> here");
2286 : 63 : }
2287 : :
2288 : : /* Return true if FNDECL is a replaceable global allocation function that
2289 : : should be useable during constant expression evaluation. */
2290 : :
2291 : : static inline bool
2292 : 24402625 : cxx_replaceable_global_alloc_fn (tree fndecl)
2293 : : {
2294 : 24402625 : return (cxx_dialect >= cxx20
2295 : 5384027 : && IDENTIFIER_NEWDEL_OP_P (DECL_NAME (fndecl))
2296 : 149130 : && CP_DECL_CONTEXT (fndecl) == global_namespace
2297 : 24551630 : && (DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl)
2298 : 54985 : || DECL_IS_OPERATOR_DELETE_P (fndecl)));
2299 : : }
2300 : :
2301 : : /* Return true if FNDECL is a placement new function that should be
2302 : : useable during constant expression evaluation of std::construct_at. */
2303 : :
2304 : : static inline bool
2305 : 24339625 : cxx_placement_new_fn (tree fndecl)
2306 : : {
2307 : 24339625 : if (cxx_dialect >= cxx20
2308 : 5321027 : && IDENTIFIER_NEW_OP_P (DECL_NAME (fndecl))
2309 : 85051 : && CP_DECL_CONTEXT (fndecl) == global_namespace
2310 : 84926 : && !DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl)
2311 : 24370918 : && TREE_CODE (TREE_TYPE (fndecl)) == FUNCTION_TYPE)
2312 : : {
2313 : 31293 : tree first_arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
2314 : 31293 : if (TREE_VALUE (first_arg) == ptr_type_node
2315 : 31293 : && TREE_CHAIN (first_arg) == void_list_node)
2316 : 31151 : return true;
2317 : : }
2318 : : return false;
2319 : : }
2320 : :
2321 : : /* Return true if FNDECL is std::construct_at. */
2322 : :
2323 : : static inline bool
2324 : 54138 : is_std_construct_at (tree fndecl)
2325 : : {
2326 : 54138 : if (!decl_in_std_namespace_p (fndecl))
2327 : : return false;
2328 : :
2329 : 52155 : tree name = DECL_NAME (fndecl);
2330 : 52155 : return name && id_equal (name, "construct_at");
2331 : : }
2332 : :
2333 : : /* Overload for the above taking constexpr_call*. */
2334 : :
2335 : : static inline bool
2336 : 38638 : is_std_construct_at (const constexpr_call *call)
2337 : : {
2338 : 38638 : return (call
2339 : 38052 : && call->fundef
2340 : 76690 : && is_std_construct_at (call->fundef->decl));
2341 : : }
2342 : :
2343 : : /* True if CTX is an instance of std::allocator. */
2344 : :
2345 : : bool
2346 : 91439 : is_std_allocator (tree ctx)
2347 : : {
2348 : 91439 : if (ctx == NULL_TREE || !CLASS_TYPE_P (ctx) || !TYPE_MAIN_DECL (ctx))
2349 : : return false;
2350 : :
2351 : 90959 : tree decl = TYPE_MAIN_DECL (ctx);
2352 : 90959 : tree name = DECL_NAME (decl);
2353 : 90959 : if (name == NULL_TREE || !id_equal (name, "allocator"))
2354 : : return false;
2355 : :
2356 : 58045 : return decl_in_std_namespace_p (decl);
2357 : : }
2358 : :
2359 : : /* Return true if FNDECL is std::allocator<T>::{,de}allocate. */
2360 : :
2361 : : static inline bool
2362 : 94299 : is_std_allocator_allocate (tree fndecl)
2363 : : {
2364 : 94299 : tree name = DECL_NAME (fndecl);
2365 : 94299 : if (name == NULL_TREE
2366 : 94299 : || !(id_equal (name, "allocate") || id_equal (name, "deallocate")))
2367 : : return false;
2368 : :
2369 : 87756 : return is_std_allocator (DECL_CONTEXT (fndecl));
2370 : : }
2371 : :
2372 : : /* Overload for the above taking constexpr_call*. */
2373 : :
2374 : : static inline bool
2375 : 19778 : is_std_allocator_allocate (const constexpr_call *call)
2376 : : {
2377 : 19778 : return (call
2378 : 2771 : && call->fundef
2379 : 22549 : && is_std_allocator_allocate (call->fundef->decl));
2380 : : }
2381 : :
2382 : : /* Return true if FNDECL is std::source_location::current. */
2383 : :
2384 : : static inline bool
2385 : 1095 : is_std_source_location_current (tree fndecl)
2386 : : {
2387 : 1095 : if (!decl_in_std_namespace_p (fndecl))
2388 : : return false;
2389 : :
2390 : 373 : tree name = DECL_NAME (fndecl);
2391 : 373 : if (name == NULL_TREE || !id_equal (name, "current"))
2392 : : return false;
2393 : :
2394 : 255 : tree ctx = DECL_CONTEXT (fndecl);
2395 : 255 : if (ctx == NULL_TREE || !CLASS_TYPE_P (ctx) || !TYPE_MAIN_DECL (ctx))
2396 : : return false;
2397 : :
2398 : 255 : name = DECL_NAME (TYPE_MAIN_DECL (ctx));
2399 : 255 : return name && id_equal (name, "source_location");
2400 : : }
2401 : :
2402 : : /* Overload for the above taking constexpr_call*. */
2403 : :
2404 : : static inline bool
2405 : 1681 : is_std_source_location_current (const constexpr_call *call)
2406 : : {
2407 : 1681 : return (call
2408 : 1095 : && call->fundef
2409 : 2776 : && is_std_source_location_current (call->fundef->decl));
2410 : : }
2411 : :
2412 : : /* Return true if FNDECL is __dynamic_cast. */
2413 : :
2414 : : static inline bool
2415 : 24309835 : cxx_dynamic_cast_fn_p (tree fndecl)
2416 : : {
2417 : 24309835 : return (cxx_dialect >= cxx20
2418 : 5291229 : && id_equal (DECL_NAME (fndecl), "__dynamic_cast")
2419 : 24313551 : && CP_DECL_CONTEXT (fndecl) == abi_node);
2420 : : }
2421 : :
2422 : : /* Often, we have an expression in the form of address + offset, e.g.
2423 : : "&_ZTV1A + 16". Extract the object from it, i.e. "_ZTV1A". */
2424 : :
2425 : : static tree
2426 : 3251 : extract_obj_from_addr_offset (tree expr)
2427 : : {
2428 : 3251 : if (TREE_CODE (expr) == POINTER_PLUS_EXPR)
2429 : 1516 : expr = TREE_OPERAND (expr, 0);
2430 : 3251 : STRIP_NOPS (expr);
2431 : 3251 : if (TREE_CODE (expr) == ADDR_EXPR)
2432 : 3189 : expr = TREE_OPERAND (expr, 0);
2433 : 3251 : return expr;
2434 : : }
2435 : :
2436 : : /* Given a PATH like
2437 : :
2438 : : g.D.2181.D.2154.D.2102.D.2093
2439 : :
2440 : : find a component with type TYPE. Return NULL_TREE if not found, and
2441 : : error_mark_node if the component is not accessible. If STOP is non-null,
2442 : : this function will return NULL_TREE if STOP is found before TYPE. */
2443 : :
2444 : : static tree
2445 : 1561 : get_component_with_type (tree path, tree type, tree stop)
2446 : : {
2447 : 4779 : while (true)
2448 : : {
2449 : 3170 : if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (path), type))
2450 : : /* Found it. */
2451 : 679 : return path;
2452 : 2491 : else if (stop
2453 : 2491 : && (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (path),
2454 : : stop)))
2455 : : return NULL_TREE;
2456 : 2446 : else if (TREE_CODE (path) == COMPONENT_REF
2457 : 2446 : && DECL_FIELD_IS_BASE (TREE_OPERAND (path, 1)))
2458 : : {
2459 : : /* We need to check that the component we're accessing is in fact
2460 : : accessible. */
2461 : 2446 : if (TREE_PRIVATE (TREE_OPERAND (path, 1))
2462 : 2446 : || TREE_PROTECTED (TREE_OPERAND (path, 1)))
2463 : 837 : return error_mark_node;
2464 : 1609 : path = TREE_OPERAND (path, 0);
2465 : : }
2466 : : else
2467 : : return NULL_TREE;
2468 : : }
2469 : : }
2470 : :
2471 : : /* Evaluate a call to __dynamic_cast (permitted by P1327R1).
2472 : :
2473 : : The declaration of __dynamic_cast is:
2474 : :
2475 : : void* __dynamic_cast (const void* __src_ptr,
2476 : : const __class_type_info* __src_type,
2477 : : const __class_type_info* __dst_type,
2478 : : ptrdiff_t __src2dst);
2479 : :
2480 : : where src2dst has the following possible values
2481 : :
2482 : : >-1: src_type is a unique public non-virtual base of dst_type
2483 : : dst_ptr + src2dst == src_ptr
2484 : : -1: unspecified relationship
2485 : : -2: src_type is not a public base of dst_type
2486 : : -3: src_type is a multiple public non-virtual base of dst_type
2487 : :
2488 : : Since literal types can't have virtual bases, we only expect hint >=0,
2489 : : -2, or -3. */
2490 : :
2491 : : static tree
2492 : 1756 : cxx_eval_dynamic_cast_fn (const constexpr_ctx *ctx, tree call,
2493 : : bool *non_constant_p, bool *overflow_p)
2494 : : {
2495 : : /* T will be something like
2496 : : __dynamic_cast ((B*) b, &_ZTI1B, &_ZTI1D, 8)
2497 : : dismantle it. */
2498 : 1756 : gcc_assert (call_expr_nargs (call) == 4);
2499 : 1756 : tsubst_flags_t complain = ctx->quiet ? tf_none : tf_warning_or_error;
2500 : 1756 : tree obj = CALL_EXPR_ARG (call, 0);
2501 : 1756 : tree type = CALL_EXPR_ARG (call, 2);
2502 : 1756 : HOST_WIDE_INT hint = int_cst_value (CALL_EXPR_ARG (call, 3));
2503 : 1756 : location_t loc = cp_expr_loc_or_input_loc (call);
2504 : :
2505 : : /* Get the target type of the dynamic_cast. */
2506 : 1756 : gcc_assert (TREE_CODE (type) == ADDR_EXPR);
2507 : 1756 : type = TREE_OPERAND (type, 0);
2508 : 1756 : type = TREE_TYPE (DECL_NAME (type));
2509 : :
2510 : : /* TYPE can only be either T* or T&. We can't know which of these it
2511 : : is by looking at TYPE, but OBJ will be "(T*) x" in the first case,
2512 : : and something like "(T*)(T&)(T*) x" in the second case. */
2513 : 1756 : bool reference_p = false;
2514 : 9686 : while (CONVERT_EXPR_P (obj) || TREE_CODE (obj) == SAVE_EXPR)
2515 : : {
2516 : 7930 : reference_p |= TYPE_REF_P (TREE_TYPE (obj));
2517 : 7930 : obj = TREE_OPERAND (obj, 0);
2518 : : }
2519 : :
2520 : : /* Evaluate the object so that we know its dynamic type. */
2521 : 1756 : obj = cxx_eval_constant_expression (ctx, obj, vc_prvalue, non_constant_p,
2522 : : overflow_p);
2523 : 1756 : if (*non_constant_p)
2524 : : return call;
2525 : :
2526 : : /* We expect OBJ to be in form of &d.D.2102 when HINT == 0,
2527 : : but when HINT is > 0, it can also be something like
2528 : : &d.D.2102 + 18446744073709551608, which includes the BINFO_OFFSET. */
2529 : 1735 : obj = extract_obj_from_addr_offset (obj);
2530 : 1735 : const tree objtype = TREE_TYPE (obj);
2531 : : /* If OBJ doesn't refer to a base field, we're done. */
2532 : 3392 : if (tree t = (TREE_CODE (obj) == COMPONENT_REF
2533 : 1735 : ? TREE_OPERAND (obj, 1) : obj))
2534 : 1735 : if (TREE_CODE (t) != FIELD_DECL || !DECL_FIELD_IS_BASE (t))
2535 : : {
2536 : 78 : if (reference_p)
2537 : : {
2538 : 72 : if (!ctx->quiet)
2539 : : {
2540 : 3 : auto_diagnostic_group d;
2541 : 3 : error_at (loc, "reference %<dynamic_cast%> failed");
2542 : 3 : inform (loc, "dynamic type %qT of its operand does "
2543 : : "not have a base class of type %qT",
2544 : : objtype, type);
2545 : 3 : }
2546 : 72 : *non_constant_p = true;
2547 : : }
2548 : 78 : return integer_zero_node;
2549 : : }
2550 : :
2551 : : /* [class.cdtor] When a dynamic_cast is used in a constructor ...
2552 : : or in a destructor ... if the operand of the dynamic_cast refers
2553 : : to the object under construction or destruction, this object is
2554 : : considered to be a most derived object that has the type of the
2555 : : constructor or destructor's class. */
2556 : 1657 : tree vtable = build_vfield_ref (obj, objtype);
2557 : 1657 : vtable = cxx_eval_constant_expression (ctx, vtable, vc_prvalue,
2558 : : non_constant_p, overflow_p);
2559 : 1657 : if (*non_constant_p)
2560 : : return call;
2561 : : /* With -fsanitize=vptr, we initialize all vtable pointers to null,
2562 : : so it's possible that we got a null pointer now. */
2563 : 1528 : if (integer_zerop (vtable))
2564 : : {
2565 : 12 : if (!ctx->quiet)
2566 : 3 : error_at (loc, "virtual table pointer is used uninitialized");
2567 : 12 : *non_constant_p = true;
2568 : 12 : return integer_zero_node;
2569 : : }
2570 : : /* VTABLE will be &_ZTV1A + 16 or similar, get _ZTV1A. */
2571 : 1516 : vtable = extract_obj_from_addr_offset (vtable);
2572 : 1516 : const tree mdtype = DECL_CONTEXT (vtable);
2573 : :
2574 : : /* Given dynamic_cast<T>(v),
2575 : :
2576 : : [expr.dynamic.cast] If C is the class type to which T points or refers,
2577 : : the runtime check logically executes as follows:
2578 : :
2579 : : If, in the most derived object pointed (referred) to by v, v points
2580 : : (refers) to a public base class subobject of a C object, and if only
2581 : : one object of type C is derived from the subobject pointed (referred)
2582 : : to by v the result points (refers) to that C object.
2583 : :
2584 : : In this case, HINT >= 0 or -3. */
2585 : 1516 : if (hint >= 0 || hint == -3)
2586 : : {
2587 : : /* Look for a component with type TYPE. */
2588 : 601 : tree t = get_component_with_type (obj, type, mdtype);
2589 : : /* If not accessible, give an error. */
2590 : 601 : if (t == error_mark_node)
2591 : : {
2592 : 198 : if (reference_p)
2593 : : {
2594 : 162 : if (!ctx->quiet)
2595 : : {
2596 : 18 : auto_diagnostic_group d;
2597 : 18 : error_at (loc, "reference %<dynamic_cast%> failed");
2598 : 18 : inform (loc, "static type %qT of its operand is a "
2599 : : "non-public base class of dynamic type %qT",
2600 : : objtype, type);
2601 : :
2602 : 18 : }
2603 : 162 : *non_constant_p = true;
2604 : : }
2605 : 198 : return integer_zero_node;
2606 : : }
2607 : 403 : else if (t)
2608 : : /* The result points to the TYPE object. */
2609 : 358 : return cp_build_addr_expr (t, complain);
2610 : : /* Else, TYPE was not found, because the HINT turned out to be wrong.
2611 : : Fall through to the normal processing. */
2612 : : }
2613 : :
2614 : : /* Otherwise, if v points (refers) to a public base class subobject of the
2615 : : most derived object, and the type of the most derived object has a base
2616 : : class, of type C, that is unambiguous and public, the result points
2617 : : (refers) to the C subobject of the most derived object.
2618 : :
2619 : : But it can also be an invalid case. */
2620 : :
2621 : : /* Get the most derived object. */
2622 : 960 : obj = get_component_with_type (obj, mdtype, NULL_TREE);
2623 : 960 : if (obj == error_mark_node)
2624 : : {
2625 : 639 : if (reference_p)
2626 : : {
2627 : 525 : if (!ctx->quiet)
2628 : : {
2629 : 57 : auto_diagnostic_group d;
2630 : 57 : error_at (loc, "reference %<dynamic_cast%> failed");
2631 : 57 : inform (loc, "static type %qT of its operand is a non-public"
2632 : : " base class of dynamic type %qT", objtype, mdtype);
2633 : 57 : }
2634 : 525 : *non_constant_p = true;
2635 : : }
2636 : 639 : return integer_zero_node;
2637 : : }
2638 : : else
2639 : 321 : gcc_assert (obj);
2640 : :
2641 : : /* Check that the type of the most derived object has a base class
2642 : : of type TYPE that is unambiguous and public. */
2643 : 321 : base_kind b_kind;
2644 : 321 : tree binfo = lookup_base (mdtype, type, ba_check, &b_kind, tf_none);
2645 : 321 : if (!binfo || binfo == error_mark_node)
2646 : : {
2647 : 237 : if (reference_p)
2648 : : {
2649 : 201 : if (!ctx->quiet)
2650 : : {
2651 : 24 : auto_diagnostic_group d;
2652 : 24 : error_at (loc, "reference %<dynamic_cast%> failed");
2653 : 24 : if (b_kind == bk_ambig)
2654 : 9 : inform (loc, "%qT is an ambiguous base class of dynamic "
2655 : : "type %qT of its operand", type, mdtype);
2656 : : else
2657 : 15 : inform (loc, "dynamic type %qT of its operand does not "
2658 : : "have an unambiguous public base class %qT",
2659 : : mdtype, type);
2660 : 24 : }
2661 : 201 : *non_constant_p = true;
2662 : : }
2663 : 237 : return integer_zero_node;
2664 : : }
2665 : : /* If so, return the TYPE subobject of the most derived object. */
2666 : 84 : obj = convert_to_base_statically (obj, binfo);
2667 : 84 : return cp_build_addr_expr (obj, complain);
2668 : : }
2669 : :
2670 : : /* Data structure used by replace_decl and replace_decl_r. */
2671 : :
2672 : : struct replace_decl_data
2673 : : {
2674 : : /* The _DECL we want to replace. */
2675 : : tree decl;
2676 : : /* The replacement for DECL. */
2677 : : tree replacement;
2678 : : /* Trees we've visited. */
2679 : : hash_set<tree> *pset;
2680 : : /* Whether we've performed any replacements. */
2681 : : bool changed;
2682 : : };
2683 : :
2684 : : /* Helper function for replace_decl, called through cp_walk_tree. */
2685 : :
2686 : : static tree
2687 : 2154246 : replace_decl_r (tree *tp, int *walk_subtrees, void *data)
2688 : : {
2689 : 2154246 : replace_decl_data *d = (replace_decl_data *) data;
2690 : :
2691 : 2154246 : if (*tp == d->decl)
2692 : : {
2693 : 297 : *tp = unshare_expr (d->replacement);
2694 : 297 : d->changed = true;
2695 : 297 : *walk_subtrees = 0;
2696 : : }
2697 : 2153949 : else if (TYPE_P (*tp)
2698 : 2153949 : || d->pset->add (*tp))
2699 : 528296 : *walk_subtrees = 0;
2700 : :
2701 : 2154246 : return NULL_TREE;
2702 : : }
2703 : :
2704 : : /* Replace every occurrence of DECL with (an unshared copy of)
2705 : : REPLACEMENT within the expression *TP. Returns true iff a
2706 : : replacement was performed. */
2707 : :
2708 : : bool
2709 : 304524 : replace_decl (tree *tp, tree decl, tree replacement)
2710 : : {
2711 : 304524 : gcc_checking_assert (same_type_ignoring_top_level_qualifiers_p
2712 : : (TREE_TYPE (decl), TREE_TYPE (replacement)));
2713 : 304524 : hash_set<tree> pset;
2714 : 304524 : replace_decl_data data = { decl, replacement, &pset, false };
2715 : 304524 : cp_walk_tree (tp, replace_decl_r, &data, NULL);
2716 : 304524 : return data.changed;
2717 : 304524 : }
2718 : :
2719 : : /* Evaluate the call T to virtual function thunk THUNK_FNDECL. */
2720 : :
2721 : : static tree
2722 : 23 : cxx_eval_thunk_call (const constexpr_ctx *ctx, tree t, tree thunk_fndecl,
2723 : : value_cat lval,
2724 : : bool *non_constant_p, bool *overflow_p)
2725 : : {
2726 : 23 : tree function = THUNK_TARGET (thunk_fndecl);
2727 : :
2728 : 23 : if (THUNK_VIRTUAL_OFFSET (thunk_fndecl))
2729 : : {
2730 : 11 : if (!ctx->quiet)
2731 : : {
2732 : 3 : if (!DECL_DECLARED_CONSTEXPR_P (function))
2733 : : {
2734 : 0 : error ("call to non-%<constexpr%> function %qD", function);
2735 : 0 : explain_invalid_constexpr_fn (function);
2736 : : }
2737 : : else
2738 : : /* virtual_offset is only set for virtual bases, which make the
2739 : : class non-literal, so we don't need to handle it here. */
2740 : 3 : error ("calling constexpr member function %qD through virtual "
2741 : : "base subobject", function);
2742 : : }
2743 : 11 : *non_constant_p = true;
2744 : 11 : return t;
2745 : : }
2746 : :
2747 : 12 : tree new_call = copy_node (t);
2748 : 12 : CALL_EXPR_FN (new_call) = function;
2749 : 12 : TREE_TYPE (new_call) = TREE_TYPE (TREE_TYPE (function));
2750 : :
2751 : 12 : tree offset = size_int (THUNK_FIXED_OFFSET (thunk_fndecl));
2752 : :
2753 : 12 : if (DECL_THIS_THUNK_P (thunk_fndecl))
2754 : : {
2755 : : /* 'this'-adjusting thunk. */
2756 : 6 : tree this_arg = CALL_EXPR_ARG (t, 0);
2757 : 6 : this_arg = build2 (POINTER_PLUS_EXPR, TREE_TYPE (this_arg),
2758 : : this_arg, offset);
2759 : 6 : CALL_EXPR_ARG (new_call, 0) = this_arg;
2760 : : }
2761 : : else
2762 : : /* Return-adjusting thunk. */
2763 : 6 : new_call = build2 (POINTER_PLUS_EXPR, TREE_TYPE (new_call),
2764 : : new_call, offset);
2765 : :
2766 : 12 : return cxx_eval_constant_expression (ctx, new_call, lval,
2767 : 12 : non_constant_p, overflow_p);
2768 : : }
2769 : :
2770 : : /* If OBJECT is of const class type, evaluate it to a CONSTRUCTOR and set
2771 : : its TREE_READONLY flag according to READONLY_P. Used for constexpr
2772 : : 'tors to detect modifying const objects in a constexpr context. */
2773 : :
2774 : : static void
2775 : 3990855 : cxx_set_object_constness (const constexpr_ctx *ctx, tree object,
2776 : : bool readonly_p, bool *non_constant_p,
2777 : : bool *overflow_p)
2778 : : {
2779 : 7981710 : if (CLASS_TYPE_P (TREE_TYPE (object))
2780 : 7981710 : && CP_TYPE_CONST_P (TREE_TYPE (object)))
2781 : : {
2782 : : /* Subobjects might not be stored in ctx->global->values but we
2783 : : can get its CONSTRUCTOR by evaluating *this. */
2784 : 657101 : tree e = cxx_eval_constant_expression (ctx, object, vc_prvalue,
2785 : : non_constant_p, overflow_p);
2786 : 657101 : if (TREE_CODE (e) == CONSTRUCTOR && !*non_constant_p)
2787 : 655167 : TREE_READONLY (e) = readonly_p;
2788 : : }
2789 : 3990855 : }
2790 : :
2791 : : /* Subroutine of cxx_eval_constant_expression.
2792 : : Evaluate the call expression tree T in the context of OLD_CALL expression
2793 : : evaluation. */
2794 : :
2795 : : static tree
2796 : 70764814 : cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
2797 : : value_cat lval,
2798 : : bool *non_constant_p, bool *overflow_p)
2799 : : {
2800 : 70764814 : location_t loc = cp_expr_loc_or_input_loc (t);
2801 : 70764814 : tree fun = get_function_named_in_call (t);
2802 : 70764814 : constexpr_call new_call
2803 : 70764814 : = { NULL, NULL, NULL, 0, ctx->manifestly_const_eval };
2804 : 70764814 : int depth_ok;
2805 : :
2806 : 70764814 : if (fun == NULL_TREE)
2807 : 191726 : return cxx_eval_internal_function (ctx, t, lval,
2808 : 191726 : non_constant_p, overflow_p);
2809 : :
2810 : 70573088 : if (TREE_CODE (fun) != FUNCTION_DECL)
2811 : : {
2812 : : /* Might be a constexpr function pointer. */
2813 : 67870 : fun = cxx_eval_constant_expression (ctx, fun, vc_prvalue,
2814 : : non_constant_p, overflow_p);
2815 : 67870 : STRIP_NOPS (fun);
2816 : 67870 : if (TREE_CODE (fun) == ADDR_EXPR)
2817 : 7743 : fun = TREE_OPERAND (fun, 0);
2818 : : /* For TARGET_VTABLE_USES_DESCRIPTORS targets, there is no
2819 : : indirection, the called expression is a pointer into the
2820 : : virtual table which should contain FDESC_EXPR. Extract the
2821 : : FUNCTION_DECL from there. */
2822 : : else if (TARGET_VTABLE_USES_DESCRIPTORS
2823 : : && TREE_CODE (fun) == POINTER_PLUS_EXPR
2824 : : && TREE_CODE (TREE_OPERAND (fun, 0)) == ADDR_EXPR
2825 : : && TREE_CODE (TREE_OPERAND (fun, 1)) == INTEGER_CST)
2826 : : {
2827 : : tree d = TREE_OPERAND (TREE_OPERAND (fun, 0), 0);
2828 : : if (VAR_P (d)
2829 : : && DECL_VTABLE_OR_VTT_P (d)
2830 : : && TREE_CODE (TREE_TYPE (d)) == ARRAY_TYPE
2831 : : && TREE_TYPE (TREE_TYPE (d)) == vtable_entry_type
2832 : : && DECL_INITIAL (d)
2833 : : && TREE_CODE (DECL_INITIAL (d)) == CONSTRUCTOR)
2834 : : {
2835 : : tree i = int_const_binop (TRUNC_DIV_EXPR, TREE_OPERAND (fun, 1),
2836 : : TYPE_SIZE_UNIT (vtable_entry_type));
2837 : : HOST_WIDE_INT idx = find_array_ctor_elt (DECL_INITIAL (d), i);
2838 : : if (idx >= 0)
2839 : : {
2840 : : tree fdesc
2841 : : = (*CONSTRUCTOR_ELTS (DECL_INITIAL (d)))[idx].value;
2842 : : if (TREE_CODE (fdesc) == FDESC_EXPR
2843 : : && integer_zerop (TREE_OPERAND (fdesc, 1)))
2844 : : fun = TREE_OPERAND (fdesc, 0);
2845 : : }
2846 : : }
2847 : : }
2848 : : }
2849 : 70573088 : if (TREE_CODE (fun) != FUNCTION_DECL)
2850 : : {
2851 : 60127 : if (!ctx->quiet && !*non_constant_p)
2852 : 0 : error_at (loc, "expression %qE does not designate a %<constexpr%> "
2853 : : "function", fun);
2854 : 60127 : *non_constant_p = true;
2855 : 60127 : return t;
2856 : : }
2857 : 70512961 : if (DECL_CLONED_FUNCTION_P (fun) && !DECL_DELETING_DESTRUCTOR_P (fun))
2858 : 6898851 : fun = DECL_CLONED_FUNCTION (fun);
2859 : :
2860 : 70512961 : if (is_ubsan_builtin_p (fun))
2861 : 58 : return void_node;
2862 : :
2863 : 70512903 : if (fndecl_built_in_p (fun))
2864 : 10688691 : return cxx_eval_builtin_function_call (ctx, t, fun,
2865 : 10688691 : lval, non_constant_p, overflow_p);
2866 : 59824212 : if (DECL_THUNK_P (fun))
2867 : 23 : return cxx_eval_thunk_call (ctx, t, fun, lval, non_constant_p, overflow_p);
2868 : 59824189 : if (!maybe_constexpr_fn (fun))
2869 : : {
2870 : 42163 : if (TREE_CODE (t) == CALL_EXPR
2871 : 42098 : && cxx_replaceable_global_alloc_fn (fun)
2872 : 60766 : && (CALL_FROM_NEW_OR_DELETE_P (t)
2873 : 17534 : || is_std_allocator_allocate (ctx->call)))
2874 : : {
2875 : 2182 : const bool new_op_p = IDENTIFIER_NEW_OP_P (DECL_NAME (fun));
2876 : 2182 : const int nargs = call_expr_nargs (t);
2877 : 2182 : tree arg0 = NULL_TREE;
2878 : 4570 : for (int i = 0; i < nargs; ++i)
2879 : : {
2880 : 2417 : tree arg = CALL_EXPR_ARG (t, i);
2881 : 2417 : arg = cxx_eval_constant_expression (ctx, arg, vc_prvalue,
2882 : : non_constant_p, overflow_p);
2883 : : /* Deleting a non-constant pointer has a better error message
2884 : : below. */
2885 : 2417 : if (new_op_p || i != 0)
2886 : 1544 : VERIFY_CONSTANT (arg);
2887 : 1515 : if (i == 0)
2888 : : arg0 = arg;
2889 : : }
2890 : 2153 : gcc_assert (arg0);
2891 : 2153 : if (new_op_p)
2892 : : {
2893 : 2560 : tree type = build_array_type_nelts (char_type_node,
2894 : 1280 : tree_to_uhwi (arg0));
2895 : 1280 : tree var = build_decl (loc, VAR_DECL,
2896 : 1280 : (IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun))
2897 : : & OVL_OP_FLAG_VEC)
2898 : : ? heap_vec_uninit_identifier
2899 : : : heap_uninit_identifier,
2900 : 1280 : type);
2901 : 1280 : DECL_ARTIFICIAL (var) = 1;
2902 : 1280 : TREE_STATIC (var) = 1;
2903 : : // Temporarily register the artificial var in varpool,
2904 : : // so that comparisons of its address against NULL are folded
2905 : : // through nonzero_address even with
2906 : : // -fno-delete-null-pointer-checks or that comparison of
2907 : : // addresses of different heap artificial vars is folded too.
2908 : : // See PR98988 and PR99031.
2909 : 1280 : varpool_node::finalize_decl (var);
2910 : 1280 : ctx->global->heap_vars.safe_push (var);
2911 : 1280 : ctx->global->put_value (var, NULL_TREE);
2912 : 1280 : return fold_convert (ptr_type_node, build_address (var));
2913 : : }
2914 : : else
2915 : : {
2916 : 873 : STRIP_NOPS (arg0);
2917 : 873 : if (TREE_CODE (arg0) == ADDR_EXPR
2918 : 873 : && VAR_P (TREE_OPERAND (arg0, 0)))
2919 : : {
2920 : 873 : tree var = TREE_OPERAND (arg0, 0);
2921 : 873 : if (DECL_NAME (var) == heap_uninit_identifier
2922 : 873 : || DECL_NAME (var) == heap_identifier)
2923 : : {
2924 : 749 : if (IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun))
2925 : : & OVL_OP_FLAG_VEC)
2926 : : {
2927 : 9 : if (!ctx->quiet)
2928 : : {
2929 : 3 : auto_diagnostic_group d;
2930 : 3 : error_at (loc, "array deallocation of object "
2931 : : "allocated with non-array "
2932 : : "allocation");
2933 : 3 : inform (DECL_SOURCE_LOCATION (var),
2934 : : "allocation performed here");
2935 : 3 : }
2936 : 9 : *non_constant_p = true;
2937 : 9 : return t;
2938 : : }
2939 : 740 : DECL_NAME (var) = heap_deleted_identifier;
2940 : 740 : ctx->global->destroy_value (var);
2941 : 740 : ctx->global->heap_dealloc_count++;
2942 : 740 : return void_node;
2943 : : }
2944 : 124 : else if (DECL_NAME (var) == heap_vec_uninit_identifier
2945 : 124 : || DECL_NAME (var) == heap_vec_identifier)
2946 : : {
2947 : 100 : if ((IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun))
2948 : : & OVL_OP_FLAG_VEC) == 0)
2949 : : {
2950 : 9 : if (!ctx->quiet)
2951 : : {
2952 : 3 : auto_diagnostic_group d;
2953 : 3 : error_at (loc, "non-array deallocation of "
2954 : : "object allocated with array "
2955 : : "allocation");
2956 : 3 : inform (DECL_SOURCE_LOCATION (var),
2957 : : "allocation performed here");
2958 : 3 : }
2959 : 9 : *non_constant_p = true;
2960 : 9 : return t;
2961 : : }
2962 : 91 : DECL_NAME (var) = heap_deleted_identifier;
2963 : 91 : ctx->global->destroy_value (var);
2964 : 91 : ctx->global->heap_dealloc_count++;
2965 : 91 : return void_node;
2966 : : }
2967 : 24 : else if (DECL_NAME (var) == heap_deleted_identifier)
2968 : : {
2969 : 15 : if (!ctx->quiet)
2970 : 6 : error_at (loc, "deallocation of already deallocated "
2971 : : "storage");
2972 : 15 : *non_constant_p = true;
2973 : 15 : return t;
2974 : : }
2975 : : }
2976 : 9 : if (!ctx->quiet)
2977 : 3 : error_at (loc, "deallocation of storage that was "
2978 : : "not previously allocated");
2979 : 9 : *non_constant_p = true;
2980 : 9 : return t;
2981 : : }
2982 : : }
2983 : : /* Allow placement new in std::construct_at, just return the second
2984 : : argument. */
2985 : 39981 : if (TREE_CODE (t) == CALL_EXPR
2986 : 39916 : && cxx_placement_new_fn (fun)
2987 : 55040 : && is_std_construct_at (ctx->call))
2988 : : {
2989 : 15030 : const int nargs = call_expr_nargs (t);
2990 : 15030 : tree arg1 = NULL_TREE;
2991 : 45090 : for (int i = 0; i < nargs; ++i)
2992 : : {
2993 : 30060 : tree arg = CALL_EXPR_ARG (t, i);
2994 : 30060 : arg = cxx_eval_constant_expression (ctx, arg, vc_prvalue,
2995 : : non_constant_p, overflow_p);
2996 : 30060 : if (i == 1)
2997 : : arg1 = arg;
2998 : : else
2999 : 30060 : VERIFY_CONSTANT (arg);
3000 : : }
3001 : 15030 : gcc_assert (arg1);
3002 : : return arg1;
3003 : : }
3004 : 24951 : else if (cxx_dynamic_cast_fn_p (fun))
3005 : 1756 : return cxx_eval_dynamic_cast_fn (ctx, t, non_constant_p, overflow_p);
3006 : :
3007 : 23195 : if (!ctx->quiet)
3008 : : {
3009 : 52 : if (!lambda_static_thunk_p (fun))
3010 : 52 : error_at (loc, "call to non-%<constexpr%> function %qD", fun);
3011 : 52 : explain_invalid_constexpr_fn (fun);
3012 : : }
3013 : 23195 : *non_constant_p = true;
3014 : 23195 : return t;
3015 : : }
3016 : :
3017 : 59782026 : constexpr_ctx new_ctx = *ctx;
3018 : 66490867 : if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
3019 : 61572698 : && TREE_CODE (t) == AGGR_INIT_EXPR)
3020 : : {
3021 : : /* We want to have an initialization target for an AGGR_INIT_EXPR.
3022 : : If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */
3023 : 133 : new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
3024 : 133 : tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
3025 : 133 : CONSTRUCTOR_NO_CLEARING (ctor) = true;
3026 : 133 : ctx->global->put_value (new_ctx.object, ctor);
3027 : 133 : ctx = &new_ctx;
3028 : : }
3029 : :
3030 : : /* We used to shortcut trivial constructor/op= here, but nowadays
3031 : : we can only get a trivial function here with -fno-elide-constructors. */
3032 : 59782026 : gcc_checking_assert (!trivial_fn_p (fun)
3033 : : || !flag_elide_constructors
3034 : : /* We don't elide constructors when processing
3035 : : a noexcept-expression. */
3036 : : || cp_noexcept_operand);
3037 : :
3038 : 59782026 : bool non_constant_args = false;
3039 : 59782026 : new_call.bindings
3040 : 59782026 : = cxx_bind_parameters_in_call (ctx, t, fun, non_constant_p,
3041 : : overflow_p, &non_constant_args);
3042 : :
3043 : : /* We build up the bindings list before we know whether we already have this
3044 : : call cached. If we don't end up saving these bindings, ggc_free them when
3045 : : this function exits. */
3046 : 59782026 : class free_bindings
3047 : : {
3048 : : tree *bindings;
3049 : : public:
3050 : 59782026 : free_bindings (tree &b): bindings (&b) { }
3051 : 59782026 : ~free_bindings () { if (bindings) ggc_free (*bindings); }
3052 : 3172236 : void preserve () { bindings = NULL; }
3053 : 59782026 : } fb (new_call.bindings);
3054 : :
3055 : 59782026 : if (*non_constant_p)
3056 : : return t;
3057 : :
3058 : : /* We can't defer instantiating the function any longer. */
3059 : 46031629 : if (!DECL_INITIAL (fun)
3060 : 4120900 : && (DECL_TEMPLOID_INSTANTIATION (fun) || DECL_DEFAULTED_FN (fun))
3061 : 46031629 : && !uid_sensitive_constexpr_evaluation_p ())
3062 : : {
3063 : 2460224 : location_t save_loc = input_location;
3064 : 2460224 : input_location = loc;
3065 : 2460224 : ++function_depth;
3066 : 2460224 : if (ctx->manifestly_const_eval == mce_true)
3067 : 62441 : FNDECL_MANIFESTLY_CONST_EVALUATED (fun) = true;
3068 : 2460224 : if (DECL_TEMPLOID_INSTANTIATION (fun))
3069 : 2460219 : instantiate_decl (fun, /*defer_ok*/false, /*expl_inst*/false);
3070 : : else
3071 : 5 : synthesize_method (fun);
3072 : 2460224 : --function_depth;
3073 : 2460224 : input_location = save_loc;
3074 : : }
3075 : :
3076 : : /* If in direct recursive call, optimize definition search. */
3077 : 46031629 : if (ctx && ctx->call && ctx->call->fundef && ctx->call->fundef->decl == fun)
3078 : 49371 : new_call.fundef = ctx->call->fundef;
3079 : : else
3080 : : {
3081 : 45982258 : new_call.fundef = retrieve_constexpr_fundef (fun);
3082 : 45982258 : if (new_call.fundef == NULL || new_call.fundef->body == NULL
3083 : 43913947 : || new_call.fundef->result == error_mark_node
3084 : 43821613 : || fun == current_function_decl)
3085 : : {
3086 : 2160648 : if (!ctx->quiet)
3087 : : {
3088 : : /* We need to check for current_function_decl here in case we're
3089 : : being called during cp_fold_function, because at that point
3090 : : DECL_INITIAL is set properly and we have a fundef but we
3091 : : haven't lowered invisirefs yet (c++/70344). */
3092 : 122 : if (DECL_INITIAL (fun) == error_mark_node
3093 : 122 : || fun == current_function_decl)
3094 : 15 : error_at (loc, "%qD called in a constant expression before its "
3095 : : "definition is complete", fun);
3096 : 107 : else if (DECL_INITIAL (fun))
3097 : : {
3098 : : /* The definition of fun was somehow unsuitable. But pretend
3099 : : that lambda static thunks don't exist. */
3100 : 70 : if (!lambda_static_thunk_p (fun))
3101 : 70 : error_at (loc, "%qD called in a constant expression", fun);
3102 : 70 : explain_invalid_constexpr_fn (fun);
3103 : : }
3104 : : else
3105 : 37 : error_at (loc, "%qD used before its definition", fun);
3106 : : }
3107 : 2160648 : *non_constant_p = true;
3108 : 2160648 : return t;
3109 : : }
3110 : : }
3111 : :
3112 : 43870981 : depth_ok = push_cx_call_context (t);
3113 : :
3114 : : /* Remember the object we are constructing or destructing. */
3115 : 43870981 : tree new_obj = NULL_TREE;
3116 : 87741962 : if (DECL_CONSTRUCTOR_P (fun) || DECL_DESTRUCTOR_P (fun))
3117 : : {
3118 : : /* In a cdtor, it should be the first `this' argument.
3119 : : At this point it has already been evaluated in the call
3120 : : to cxx_bind_parameters_in_call. */
3121 : 5571810 : new_obj = TREE_VEC_ELT (new_call.bindings, 0);
3122 : 5571810 : bool empty_base = false;
3123 : 5571810 : new_obj = cxx_fold_indirect_ref (ctx, loc, DECL_CONTEXT (fun), new_obj,
3124 : : &empty_base);
3125 : : /* If we're initializing an empty class, don't set constness, because
3126 : : cxx_fold_indirect_ref will return the wrong object to set constness
3127 : : of. */
3128 : 5571810 : if (empty_base)
3129 : : new_obj = NULL_TREE;
3130 : 1787984 : else if (ctx->call && ctx->call->fundef
3131 : 7941622 : && DECL_CONSTRUCTOR_P (ctx->call->fundef->decl))
3132 : : {
3133 : 1230189 : tree cur_obj = TREE_VEC_ELT (ctx->call->bindings, 0);
3134 : 1230189 : STRIP_NOPS (cur_obj);
3135 : 1230189 : if (TREE_CODE (cur_obj) == ADDR_EXPR)
3136 : 1129719 : cur_obj = TREE_OPERAND (cur_obj, 0);
3137 : 1230189 : if (new_obj == cur_obj)
3138 : : /* We're calling the target constructor of a delegating
3139 : : constructor, or accessing a base subobject through a
3140 : : NOP_EXPR as part of a call to a base constructor, so
3141 : : there is no new (sub)object. */
3142 : 1232570 : new_obj = NULL_TREE;
3143 : : }
3144 : : }
3145 : :
3146 : 43870981 : tree result = NULL_TREE;
3147 : :
3148 : 43870981 : constexpr_call *entry = NULL;
3149 : 43870981 : if (depth_ok && !non_constant_args && ctx->strict)
3150 : : {
3151 : 16060431 : new_call.hash = constexpr_fundef_hasher::hash (new_call.fundef);
3152 : 16060431 : new_call.hash
3153 : 16060431 : = iterative_hash_template_arg (new_call.bindings, new_call.hash);
3154 : 16060431 : new_call.hash
3155 : 16060431 : = iterative_hash_object (ctx->manifestly_const_eval, new_call.hash);
3156 : :
3157 : : /* If we have seen this call before, we are done. */
3158 : 16060431 : maybe_initialize_constexpr_call_table ();
3159 : 16060431 : bool insert = depth_ok < constexpr_cache_depth;
3160 : 16060431 : constexpr_call **slot
3161 : 16166570 : = constexpr_call_table->find_slot (&new_call,
3162 : : insert ? INSERT : NO_INSERT);
3163 : 16060431 : entry = slot ? *slot : NULL;
3164 : 15983628 : if (entry == NULL)
3165 : : {
3166 : : /* Only cache up to constexpr_cache_depth to limit memory use. */
3167 : 3249039 : if (insert)
3168 : : {
3169 : : /* We need to keep a pointer to the entry, not just the slot, as
3170 : : the slot can move during evaluation of the body. */
3171 : 3172236 : *slot = entry = ggc_alloc<constexpr_call> ();
3172 : 3172236 : *entry = new_call;
3173 : 3172236 : fb.preserve ();
3174 : : }
3175 : : }
3176 : : /* Calls that are in progress have their result set to NULL, so that we
3177 : : can detect circular dependencies. Now that we only cache up to
3178 : : constexpr_cache_depth this won't catch circular dependencies that
3179 : : start deeper, but they'll hit the recursion or ops limit. */
3180 : 12811392 : else if (entry->result == NULL)
3181 : : {
3182 : 12 : if (!ctx->quiet)
3183 : 0 : error ("call has circular dependency");
3184 : 12 : *non_constant_p = true;
3185 : 12 : entry->result = result = error_mark_node;
3186 : : }
3187 : : else
3188 : 12811380 : result = entry->result;
3189 : : }
3190 : :
3191 : 43870981 : if (!depth_ok)
3192 : : {
3193 : 24 : if (!ctx->quiet)
3194 : 3 : error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
3195 : : "%<-fconstexpr-depth=%> to increase the maximum)",
3196 : : max_constexpr_depth);
3197 : 24 : *non_constant_p = true;
3198 : 24 : result = error_mark_node;
3199 : : }
3200 : : else
3201 : : {
3202 : 43870957 : bool cacheable = !!entry;
3203 : 43870957 : if (result && result != error_mark_node)
3204 : : /* OK */;
3205 : 32378430 : else if (!DECL_SAVED_TREE (fun))
3206 : : {
3207 : : /* When at_eof >= 3, cgraph has started throwing away
3208 : : DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
3209 : : late code generation for VEC_INIT_EXPR, which needs to be
3210 : : completely reconsidered. */
3211 : 0 : gcc_assert (at_eof >= 3 && ctx->quiet);
3212 : 0 : *non_constant_p = true;
3213 : : }
3214 : 32378430 : else if (tree copy = get_fundef_copy (new_call.fundef))
3215 : : {
3216 : 32378430 : tree body, parms, res;
3217 : 32378430 : releasing_vec ctors;
3218 : :
3219 : : /* Reuse or create a new unshared copy of this function's body. */
3220 : 32378430 : body = TREE_PURPOSE (copy);
3221 : 32378430 : parms = TREE_VALUE (copy);
3222 : 32378430 : res = TREE_TYPE (copy);
3223 : :
3224 : : /* Associate the bindings with the remapped parms. */
3225 : 32378430 : tree bound = new_call.bindings;
3226 : 32378430 : tree remapped = parms;
3227 : 69805177 : for (int i = 0; i < TREE_VEC_LENGTH (bound); ++i)
3228 : : {
3229 : 37426747 : tree arg = TREE_VEC_ELT (bound, i);
3230 : 37426747 : if (entry)
3231 : : {
3232 : : /* Unshare args going into the hash table to separate them
3233 : : from the caller's context, for better GC and to avoid
3234 : : problems with verify_gimple. */
3235 : 1660917 : arg = unshare_expr_without_location (arg);
3236 : 1660917 : TREE_VEC_ELT (bound, i) = arg;
3237 : :
3238 : : /* And then unshare again so the callee doesn't change the
3239 : : argument values in the hash table. XXX Could we unshare
3240 : : lazily in cxx_eval_store_expression? */
3241 : 1660917 : arg = unshare_constructor (arg);
3242 : 1660917 : if (TREE_CODE (arg) == CONSTRUCTOR)
3243 : 683535 : vec_safe_push (ctors, arg);
3244 : : }
3245 : 37426747 : ctx->global->put_value (remapped, arg);
3246 : 37426747 : remapped = DECL_CHAIN (remapped);
3247 : : }
3248 : 32378430 : if (remapped)
3249 : : {
3250 : : /* We shouldn't have any parms without args, but fail gracefully
3251 : : in error recovery. */
3252 : 6 : gcc_checking_assert (seen_error ());
3253 : 6 : *non_constant_p = true;
3254 : : }
3255 : : /* Add the RESULT_DECL to the values map, too. */
3256 : 32378430 : gcc_assert (!DECL_BY_REFERENCE (res));
3257 : 32378430 : ctx->global->put_value (res, NULL_TREE);
3258 : :
3259 : : /* Remember the current call we're evaluating. */
3260 : 32378430 : constexpr_ctx call_ctx = *ctx;
3261 : 32378430 : call_ctx.call = &new_call;
3262 : 32378430 : unsigned save_heap_alloc_count = ctx->global->heap_vars.length ();
3263 : 32378430 : unsigned save_heap_dealloc_count = ctx->global->heap_dealloc_count;
3264 : :
3265 : : /* Make sure we fold std::is_constant_evaluated to true in an
3266 : : immediate function. */
3267 : 64756860 : if (DECL_IMMEDIATE_FUNCTION_P (fun))
3268 : 237541 : call_ctx.manifestly_const_eval = mce_true;
3269 : :
3270 : : /* If this is a constexpr destructor, the object's const and volatile
3271 : : semantics are no longer in effect; see [class.dtor]p5. */
3272 : 36369285 : if (new_obj && DECL_DESTRUCTOR_P (fun))
3273 : 140602 : cxx_set_object_constness (ctx, new_obj, /*readonly_p=*/false,
3274 : : non_constant_p, overflow_p);
3275 : :
3276 : : /* If this is a constructor, we are beginning the lifetime of the
3277 : : object we are initializing. */
3278 : 32378430 : if (new_obj
3279 : 7981710 : && DECL_CONSTRUCTOR_P (fun)
3280 : 3850253 : && TREE_CODE (new_obj) == COMPONENT_REF
3281 : 34207168 : && TREE_CODE (TREE_TYPE (TREE_OPERAND (new_obj, 0))) == UNION_TYPE)
3282 : : {
3283 : 7836 : tree activate = build2 (INIT_EXPR, TREE_TYPE (new_obj),
3284 : : new_obj,
3285 : 7836 : build_constructor (TREE_TYPE (new_obj),
3286 : : NULL));
3287 : 7836 : cxx_eval_constant_expression (ctx, activate,
3288 : : lval, non_constant_p, overflow_p);
3289 : 7836 : ggc_free (activate);
3290 : : }
3291 : :
3292 : 32378430 : tree jump_target = NULL_TREE;
3293 : 32378430 : cxx_eval_constant_expression (&call_ctx, body,
3294 : : vc_discard, non_constant_p, overflow_p,
3295 : : &jump_target);
3296 : :
3297 : 64756860 : if (DECL_CONSTRUCTOR_P (fun))
3298 : : /* This can be null for a subobject constructor call, in
3299 : : which case what we care about is the initialization
3300 : : side-effects rather than the value. We could get at the
3301 : : value by evaluating *this, but we don't bother; there's
3302 : : no need to put such a call in the hash table. */
3303 : 5430135 : result = lval ? ctx->object : ctx->ctor;
3304 : 26948295 : else if (VOID_TYPE_P (TREE_TYPE (res)))
3305 : 946157 : result = void_node;
3306 : : else
3307 : : {
3308 : 26002138 : result = ctx->global->get_value (res);
3309 : 10376272 : if (result == NULL_TREE && !*non_constant_p
3310 : 26002308 : && !DECL_DESTRUCTOR_P (fun))
3311 : : {
3312 : 85 : if (!ctx->quiet)
3313 : 11 : error ("%<constexpr%> call flows off the end "
3314 : : "of the function");
3315 : 85 : *non_constant_p = true;
3316 : : }
3317 : : }
3318 : :
3319 : : /* At this point, the object's constructor will have run, so
3320 : : the object is no longer under construction, and its possible
3321 : : 'const' semantics now apply. Make a note of this fact by
3322 : : marking the CONSTRUCTOR TREE_READONLY. */
3323 : 36369285 : if (new_obj && DECL_CONSTRUCTOR_P (fun))
3324 : 3850253 : cxx_set_object_constness (ctx, new_obj, /*readonly_p=*/true,
3325 : : non_constant_p, overflow_p);
3326 : :
3327 : : /* Remove the parms/result from the values map. */
3328 : 32378430 : destroy_value_checked (ctx, res, non_constant_p);
3329 : 69805183 : for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
3330 : 37426753 : destroy_value_checked (ctx, parm, non_constant_p);
3331 : :
3332 : : /* Free any parameter CONSTRUCTORs we aren't returning directly. */
3333 : 33061965 : while (!ctors->is_empty ())
3334 : : {
3335 : 683535 : tree c = ctors->pop ();
3336 : 683535 : if (c != result)
3337 : 683535 : free_constructor (c);
3338 : : }
3339 : :
3340 : : /* Make the unshared function copy we used available for re-use. */
3341 : 32378430 : save_fundef_copy (fun, copy);
3342 : :
3343 : : /* If the call allocated some heap object that hasn't been
3344 : : deallocated during the call, or if it deallocated some heap
3345 : : object it has not allocated, the call isn't really stateless
3346 : : for the constexpr evaluation and should not be cached.
3347 : : It is fine if the call allocates something and deallocates it
3348 : : too. */
3349 : 32378430 : if (cacheable
3350 : 36869531 : && (save_heap_alloc_count != ctx->global->heap_vars.length ()
3351 : 4490724 : || (save_heap_dealloc_count
3352 : 4490724 : != ctx->global->heap_dealloc_count)))
3353 : : {
3354 : 377 : tree heap_var;
3355 : 377 : unsigned int i;
3356 : 377 : if ((ctx->global->heap_vars.length ()
3357 : 377 : - ctx->global->heap_dealloc_count)
3358 : 377 : != save_heap_alloc_count - save_heap_dealloc_count)
3359 : : cacheable = false;
3360 : : else
3361 : 1087 : FOR_EACH_VEC_ELT_FROM (ctx->global->heap_vars, i, heap_var,
3362 : : save_heap_alloc_count)
3363 : 770 : if (DECL_NAME (heap_var) != heap_deleted_identifier)
3364 : : {
3365 : : cacheable = false;
3366 : : break;
3367 : : }
3368 : : }
3369 : :
3370 : : /* Rewrite all occurrences of the function's RESULT_DECL with the
3371 : : current object under construction. */
3372 : 17273781 : if (!*non_constant_p && ctx->object
3373 : 5111149 : && CLASS_TYPE_P (TREE_TYPE (res))
3374 : 33280879 : && !is_empty_class (TREE_TYPE (res)))
3375 : 304445 : if (replace_decl (&result, res, ctx->object))
3376 : : cacheable = false;
3377 : :
3378 : : /* Only cache a permitted result of a constant expression. */
3379 : 32378245 : if (cacheable && !reduced_constant_expression_p (result))
3380 : : cacheable = false;
3381 : 32378430 : }
3382 : : else
3383 : : /* Couldn't get a function copy to evaluate. */
3384 : 0 : *non_constant_p = true;
3385 : :
3386 : 43870957 : if (result == error_mark_node)
3387 : 0 : *non_constant_p = true;
3388 : 43870957 : if (*non_constant_p || *overflow_p)
3389 : 15104805 : result = error_mark_node;
3390 : 28766152 : else if (!result)
3391 : 1255848 : result = void_node;
3392 : 43870957 : if (entry)
3393 : 15983628 : entry->result = cacheable ? result : error_mark_node;
3394 : : }
3395 : :
3396 : : /* The result of a constexpr function must be completely initialized.
3397 : :
3398 : : However, in C++20, a constexpr constructor doesn't necessarily have
3399 : : to initialize all the fields, so we don't clear CONSTRUCTOR_NO_CLEARING
3400 : : in order to detect reading an unitialized object in constexpr instead
3401 : : of value-initializing it. (reduced_constant_expression_p is expected to
3402 : : take care of clearing the flag.) */
3403 : 43870981 : if (TREE_CODE (result) == CONSTRUCTOR
3404 : 43870981 : && (cxx_dialect < cxx20
3405 : 4696090 : || !DECL_CONSTRUCTOR_P (fun)))
3406 : 2866266 : clear_no_implicit_zero (result);
3407 : :
3408 : 43870981 : pop_cx_call_context ();
3409 : 43870981 : return result;
3410 : 59782026 : }
3411 : :
3412 : : /* Return true if T is a valid constant initializer. If a CONSTRUCTOR
3413 : : initializes all the members, the CONSTRUCTOR_NO_CLEARING flag will be
3414 : : cleared.
3415 : : FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
3416 : :
3417 : : bool
3418 : 522900350 : reduced_constant_expression_p (tree t)
3419 : : {
3420 : 522900350 : if (t == NULL_TREE)
3421 : : return false;
3422 : :
3423 : 521559740 : switch (TREE_CODE (t))
3424 : : {
3425 : : case PTRMEM_CST:
3426 : : /* Even if we can't lower this yet, it's constant. */
3427 : : return true;
3428 : :
3429 : 30227306 : case CONSTRUCTOR:
3430 : : /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
3431 : 30227306 : tree field;
3432 : 30227306 : if (!AGGREGATE_TYPE_P (TREE_TYPE (t)))
3433 : : /* A constant vector would be folded to VECTOR_CST.
3434 : : A CONSTRUCTOR of scalar type means uninitialized. */
3435 : : return false;
3436 : 30210227 : if (CONSTRUCTOR_NO_CLEARING (t))
3437 : : {
3438 : 672648 : if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
3439 : : {
3440 : : /* There must be a valid constant initializer at every array
3441 : : index. */
3442 : 230 : tree min = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (t)));
3443 : 230 : tree max = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (t)));
3444 : 230 : tree cursor = min;
3445 : 16243 : for (auto &e: CONSTRUCTOR_ELTS (t))
3446 : : {
3447 : 15663 : if (!reduced_constant_expression_p (e.value))
3448 : : return false;
3449 : 15613 : if (array_index_cmp (cursor, e.index) != 0)
3450 : : return false;
3451 : 15553 : if (TREE_CODE (e.index) == RANGE_EXPR)
3452 : 0 : cursor = TREE_OPERAND (e.index, 1);
3453 : 15553 : cursor = int_const_binop (PLUS_EXPR, cursor, size_one_node);
3454 : : }
3455 : 120 : if (find_array_ctor_elt (t, max) == -1)
3456 : : return false;
3457 : 34 : goto ok;
3458 : : }
3459 : 672418 : else if (cxx_dialect >= cxx20
3460 : 672418 : && TREE_CODE (TREE_TYPE (t)) == UNION_TYPE)
3461 : : {
3462 : 2234532 : if (CONSTRUCTOR_NELTS (t) == 0)
3463 : : /* An initialized union has a constructor element. */
3464 : : return false;
3465 : : /* And it only initializes one member. */
3466 : : field = NULL_TREE;
3467 : : }
3468 : : else
3469 : 672403 : field = next_subobject_field (TYPE_FIELDS (TREE_TYPE (t)));
3470 : : }
3471 : : else
3472 : : field = NULL_TREE;
3473 : 172343524 : for (auto &e: CONSTRUCTOR_ELTS (t))
3474 : : {
3475 : : /* If VAL is null, we're in the middle of initializing this
3476 : : element. */
3477 : 104247880 : if (!reduced_constant_expression_p (e.value))
3478 : : return false;
3479 : : /* We want to remove initializers for empty fields in a struct to
3480 : : avoid confusing output_constructor. */
3481 : 103888930 : if (is_empty_field (e.index)
3482 : 103888930 : && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE)
3483 : : return false;
3484 : : /* Check for non-empty fields between initialized fields when
3485 : : CONSTRUCTOR_NO_CLEARING. */
3486 : 103429418 : for (; field && e.index != field;
3487 : 56552 : field = next_subobject_field (DECL_CHAIN (field)))
3488 : 57744 : if (!is_really_empty_class (TREE_TYPE (field),
3489 : : /*ignore_vptr*/false))
3490 : : return false;
3491 : 103371674 : if (field)
3492 : 605503 : field = next_subobject_field (DECL_CHAIN (field));
3493 : : }
3494 : : /* There could be a non-empty field at the end. */
3495 : 29360503 : for (; field; field = next_subobject_field (DECL_CHAIN (field)))
3496 : 27153 : if (!is_really_empty_class (TREE_TYPE (field), /*ignore_vptr*/false))
3497 : : return false;
3498 : 29333350 : ok:
3499 : 29333384 : if (CONSTRUCTOR_NO_CLEARING (t))
3500 : : /* All the fields are initialized. */
3501 : 614793 : CONSTRUCTOR_NO_CLEARING (t) = false;
3502 : : return true;
3503 : :
3504 : 491327271 : default:
3505 : : /* FIXME are we calling this too much? */
3506 : 491327271 : return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
3507 : : }
3508 : : }
3509 : :
3510 : : /* *TP was not deemed constant by reduced_constant_expression_p. Explain
3511 : : why and suggest what could be done about it. */
3512 : :
3513 : : static tree
3514 : 862 : verify_constant_explain_r (tree *tp, int *walk_subtrees, void *)
3515 : : {
3516 : 862 : bool ref_p = false;
3517 : :
3518 : : /* No need to look into types or unevaluated operands. */
3519 : 862 : if (TYPE_P (*tp) || unevaluated_p (TREE_CODE (*tp)))
3520 : : {
3521 : 0 : *walk_subtrees = false;
3522 : 0 : return NULL_TREE;
3523 : : }
3524 : :
3525 : 862 : switch (TREE_CODE (*tp))
3526 : : {
3527 : 46 : CASE_CONVERT:
3528 : 46 : if (TREE_CODE (TREE_OPERAND (*tp, 0)) != ADDR_EXPR)
3529 : : break;
3530 : 33 : ref_p = TYPE_REF_P (TREE_TYPE (*tp));
3531 : 33 : *tp = TREE_OPERAND (*tp, 0);
3532 : 159 : gcc_fallthrough ();
3533 : 159 : case ADDR_EXPR:
3534 : 159 : {
3535 : 159 : tree op = TREE_OPERAND (*tp, 0);
3536 : 159 : if (VAR_P (op)
3537 : 90 : && DECL_DECLARED_CONSTEXPR_P (op)
3538 : 33 : && !TREE_STATIC (op)
3539 : : /* ??? We should also say something about temporaries. */
3540 : 189 : && !DECL_ARTIFICIAL (op))
3541 : : {
3542 : 27 : if (ref_p)
3543 : 6 : inform (location_of (*tp), "reference to %qD is not a constant "
3544 : : "expression", op);
3545 : : else
3546 : 21 : inform (location_of (*tp), "pointer to %qD is not a constant "
3547 : : "expression", op);
3548 : 27 : const location_t op_loc = DECL_SOURCE_LOCATION (op);
3549 : 27 : rich_location richloc (line_table, op_loc);
3550 : 27 : richloc.add_fixit_insert_before (op_loc, "static ");
3551 : 27 : inform (&richloc,
3552 : : "address of non-static constexpr variable %qD may differ on "
3553 : : "each invocation of the enclosing function; add %<static%> "
3554 : : "to give it a constant address", op);
3555 : 27 : }
3556 : : break;
3557 : : }
3558 : : default:
3559 : : break;
3560 : : }
3561 : :
3562 : : return NULL_TREE;
3563 : : }
3564 : :
3565 : : /* Some expressions may have constant operands but are not constant
3566 : : themselves, such as 1/0. Call this function to check for that
3567 : : condition.
3568 : :
3569 : : We only call this in places that require an arithmetic constant, not in
3570 : : places where we might have a non-constant expression that can be a
3571 : : component of a constant expression, such as the address of a constexpr
3572 : : variable that might be dereferenced later. */
3573 : :
3574 : : static bool
3575 : 441796448 : verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
3576 : : bool *overflow_p)
3577 : : {
3578 : 361086559 : if (!*non_constant_p && !reduced_constant_expression_p (t)
3579 : 452380859 : && t != void_node)
3580 : : {
3581 : 10584384 : if (!allow_non_constant)
3582 : : {
3583 : 218 : auto_diagnostic_group d;
3584 : 302 : error_at (cp_expr_loc_or_input_loc (t),
3585 : : "%q+E is not a constant expression", t);
3586 : 218 : cp_walk_tree_without_duplicates (&t, verify_constant_explain_r,
3587 : : nullptr);
3588 : 218 : }
3589 : 10584384 : *non_constant_p = true;
3590 : : }
3591 : 441796448 : if (TREE_OVERFLOW_P (t))
3592 : : {
3593 : 696 : if (!allow_non_constant)
3594 : : {
3595 : 155 : permerror (input_location, "overflow in constant expression");
3596 : : /* If we're being permissive (and are in an enforcing
3597 : : context), ignore the overflow. */
3598 : 155 : if (flag_permissive)
3599 : 75 : return *non_constant_p;
3600 : : }
3601 : 621 : *overflow_p = true;
3602 : : }
3603 : 441796373 : return *non_constant_p;
3604 : : }
3605 : :
3606 : : /* Check whether the shift operation with code CODE and type TYPE on LHS
3607 : : and RHS is undefined. If it is, give an error with an explanation,
3608 : : and return true; return false otherwise. */
3609 : :
3610 : : static bool
3611 : 32422224 : cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx,
3612 : : enum tree_code code, tree type, tree lhs, tree rhs)
3613 : : {
3614 : 32422224 : if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR)
3615 : 3143016 : || TREE_CODE (lhs) != INTEGER_CST
3616 : 3143016 : || TREE_CODE (rhs) != INTEGER_CST)
3617 : : return false;
3618 : :
3619 : 3143016 : tree lhstype = TREE_TYPE (lhs);
3620 : 3143016 : unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs));
3621 : :
3622 : : /* [expr.shift] The behavior is undefined if the right operand
3623 : : is negative, or greater than or equal to the length in bits
3624 : : of the promoted left operand. */
3625 : 3143016 : if (tree_int_cst_sgn (rhs) == -1)
3626 : : {
3627 : 126 : if (!ctx->quiet)
3628 : 35 : permerror (loc, "right operand of shift expression %q+E is negative",
3629 : : build2_loc (loc, code, type, lhs, rhs));
3630 : 126 : return (!flag_permissive || ctx->quiet);
3631 : : }
3632 : 3142890 : if (compare_tree_int (rhs, uprec) >= 0)
3633 : : {
3634 : 274 : if (!ctx->quiet)
3635 : 34 : permerror (loc, "right operand of shift expression %q+E is greater "
3636 : : "than or equal to the precision %wu of the left operand",
3637 : : build2_loc (loc, code, type, lhs, rhs), uprec);
3638 : 274 : return (!flag_permissive || ctx->quiet);
3639 : : }
3640 : :
3641 : : /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
3642 : : if E1 has a signed type and non-negative value, and E1x2^E2 is
3643 : : representable in the corresponding unsigned type of the result type,
3644 : : then that value, converted to the result type, is the resulting value;
3645 : : otherwise, the behavior is undefined.
3646 : : For C++20:
3647 : : The value of E1 << E2 is the unique value congruent to E1 x 2^E2 modulo
3648 : : 2^N, where N is the range exponent of the type of the result. */
3649 : 3142616 : if (code == LSHIFT_EXPR
3650 : 3015172 : && !TYPE_OVERFLOW_WRAPS (lhstype)
3651 : 2245423 : && cxx_dialect >= cxx11
3652 : 5368174 : && cxx_dialect < cxx20)
3653 : : {
3654 : 1737504 : if (tree_int_cst_sgn (lhs) == -1)
3655 : : {
3656 : 128 : if (!ctx->quiet)
3657 : 23 : permerror (loc,
3658 : : "left operand of shift expression %q+E is negative",
3659 : : build2_loc (loc, code, type, lhs, rhs));
3660 : 128 : return (!flag_permissive || ctx->quiet);
3661 : : }
3662 : : /* For signed x << y the following:
3663 : : (unsigned) x >> ((prec (lhs) - 1) - y)
3664 : : if > 1, is undefined. The right-hand side of this formula
3665 : : is the highest bit of the LHS that can be set (starting from 0),
3666 : : so that the shift doesn't overflow. We then right-shift the LHS
3667 : : to see whether any other bit is set making the original shift
3668 : : undefined -- the result is not representable in the corresponding
3669 : : unsigned type. */
3670 : 1737376 : tree t = build_int_cst (unsigned_type_node, uprec - 1);
3671 : 1737376 : t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs);
3672 : 1737376 : tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs);
3673 : 1737376 : t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t);
3674 : 1737376 : if (tree_int_cst_lt (integer_one_node, t))
3675 : : {
3676 : 86 : if (!ctx->quiet)
3677 : 8 : permerror (loc, "shift expression %q+E overflows",
3678 : : build2_loc (loc, code, type, lhs, rhs));
3679 : 86 : return (!flag_permissive || ctx->quiet);
3680 : : }
3681 : : }
3682 : : return false;
3683 : : }
3684 : :
3685 : : /* Subroutine of cxx_eval_constant_expression.
3686 : : Attempt to reduce the unary expression tree T to a compile time value.
3687 : : If successful, return the value. Otherwise issue a diagnostic
3688 : : and return error_mark_node. */
3689 : :
3690 : : static tree
3691 : 21583035 : cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
3692 : : bool /*lval*/,
3693 : : bool *non_constant_p, bool *overflow_p)
3694 : : {
3695 : 21583035 : tree r;
3696 : 21583035 : tree orig_arg = TREE_OPERAND (t, 0);
3697 : 21583035 : tree arg = cxx_eval_constant_expression (ctx, orig_arg, vc_prvalue,
3698 : : non_constant_p, overflow_p);
3699 : 21583035 : VERIFY_CONSTANT (arg);
3700 : 18225298 : location_t loc = EXPR_LOCATION (t);
3701 : 18225298 : enum tree_code code = TREE_CODE (t);
3702 : 18225298 : tree type = TREE_TYPE (t);
3703 : 18225298 : r = fold_unary_loc (loc, code, type, arg);
3704 : 18225298 : if (r == NULL_TREE)
3705 : : {
3706 : 15 : if (arg == orig_arg)
3707 : : r = t;
3708 : : else
3709 : 15 : r = build1_loc (loc, code, type, arg);
3710 : : }
3711 : 18225298 : VERIFY_CONSTANT (r);
3712 : : return r;
3713 : : }
3714 : :
3715 : : /* Helper function for cxx_eval_binary_expression. Try to optimize
3716 : : original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
3717 : : generic folding should be used. */
3718 : :
3719 : : static tree
3720 : 1958050 : cxx_fold_pointer_plus_expression (const constexpr_ctx *ctx, tree t,
3721 : : tree lhs, tree rhs, bool *non_constant_p,
3722 : : bool *overflow_p)
3723 : : {
3724 : 1958050 : STRIP_NOPS (lhs);
3725 : 1958050 : if (TREE_CODE (lhs) != ADDR_EXPR)
3726 : : return NULL_TREE;
3727 : :
3728 : 1878095 : lhs = TREE_OPERAND (lhs, 0);
3729 : :
3730 : : /* &A[i] p+ j => &A[i + j] */
3731 : 1878095 : if (TREE_CODE (lhs) == ARRAY_REF
3732 : 7565 : && TREE_CODE (TREE_OPERAND (lhs, 1)) == INTEGER_CST
3733 : 7565 : && TREE_CODE (rhs) == INTEGER_CST
3734 : 7565 : && TYPE_SIZE_UNIT (TREE_TYPE (lhs))
3735 : 1885660 : && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST)
3736 : : {
3737 : 7565 : tree orig_type = TREE_TYPE (t);
3738 : 7565 : location_t loc = EXPR_LOCATION (t);
3739 : 7565 : tree type = TREE_TYPE (lhs);
3740 : :
3741 : 7565 : t = fold_convert_loc (loc, ssizetype, TREE_OPERAND (lhs, 1));
3742 : 7565 : tree nelts = array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs, 0)));
3743 : 7565 : nelts = cxx_eval_constant_expression (ctx, nelts, vc_prvalue,
3744 : : non_constant_p, overflow_p);
3745 : 7565 : if (*non_constant_p)
3746 : : return NULL_TREE;
3747 : : /* Don't fold an out-of-bound access. */
3748 : 7553 : if (!tree_int_cst_le (t, nelts))
3749 : : return NULL_TREE;
3750 : 7553 : rhs = cp_fold_convert (ssizetype, rhs);
3751 : : /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.
3752 : : constexpr int A[1]; ... (char *)&A[0] + 1 */
3753 : 7553 : if (!integer_zerop (fold_build2_loc (loc, TRUNC_MOD_EXPR, sizetype,
3754 : 7553 : rhs, TYPE_SIZE_UNIT (type))))
3755 : : return NULL_TREE;
3756 : : /* Make sure to treat the second operand of POINTER_PLUS_EXPR
3757 : : as signed. */
3758 : 7525 : rhs = fold_build2_loc (loc, EXACT_DIV_EXPR, ssizetype, rhs,
3759 : 7525 : TYPE_SIZE_UNIT (type));
3760 : 7525 : t = size_binop_loc (loc, PLUS_EXPR, rhs, t);
3761 : 7525 : t = build4_loc (loc, ARRAY_REF, type, TREE_OPERAND (lhs, 0),
3762 : : t, NULL_TREE, NULL_TREE);
3763 : 7525 : t = cp_build_addr_expr (t, tf_warning_or_error);
3764 : 7525 : t = cp_fold_convert (orig_type, t);
3765 : 7525 : return cxx_eval_constant_expression (ctx, t, vc_prvalue,
3766 : 7525 : non_constant_p, overflow_p);
3767 : : }
3768 : :
3769 : : return NULL_TREE;
3770 : : }
3771 : :
3772 : : /* Try to fold expressions like
3773 : : (struct S *) (&a[0].D.2378 + 12)
3774 : : into
3775 : : &MEM <struct T> [(void *)&a + 12B]
3776 : : This is something normally done by gimple_fold_stmt_to_constant_1
3777 : : on GIMPLE, but is undesirable on GENERIC if we are e.g. going to
3778 : : dereference the address because some details are lost.
3779 : : For pointer comparisons we want such folding though so that
3780 : : match.pd address_compare optimization works. */
3781 : :
3782 : : static tree
3783 : 1591200 : cxx_maybe_fold_addr_pointer_plus (tree t)
3784 : : {
3785 : 3189355 : while (CONVERT_EXPR_P (t)
3786 : 1773818 : && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
3787 : 175663 : t = TREE_OPERAND (t, 0);
3788 : 1591200 : if (TREE_CODE (t) != POINTER_PLUS_EXPR)
3789 : : return NULL_TREE;
3790 : 1345570 : tree op0 = TREE_OPERAND (t, 0);
3791 : 1345570 : tree op1 = TREE_OPERAND (t, 1);
3792 : 1345570 : if (TREE_CODE (op1) != INTEGER_CST)
3793 : : return NULL_TREE;
3794 : 1345570 : while (CONVERT_EXPR_P (op0)
3795 : 2690265 : && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0))))
3796 : 1344695 : op0 = TREE_OPERAND (op0, 0);
3797 : 1345570 : if (TREE_CODE (op0) != ADDR_EXPR)
3798 : : return NULL_TREE;
3799 : 1344907 : op1 = fold_convert (ptr_type_node, op1);
3800 : 1344907 : tree r = fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (op0)), op0, op1);
3801 : 1344907 : return build1_loc (EXPR_LOCATION (t), ADDR_EXPR, TREE_TYPE (op0), r);
3802 : : }
3803 : :
3804 : : /* Subroutine of cxx_eval_constant_expression.
3805 : : Like cxx_eval_unary_expression, except for binary expressions. */
3806 : :
3807 : : static tree
3808 : 49398326 : cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
3809 : : value_cat lval,
3810 : : bool *non_constant_p, bool *overflow_p)
3811 : : {
3812 : 49398326 : tree r = NULL_TREE;
3813 : 49398326 : tree orig_lhs = TREE_OPERAND (t, 0);
3814 : 49398326 : tree orig_rhs = TREE_OPERAND (t, 1);
3815 : 49398326 : tree lhs, rhs;
3816 : 49398326 : lhs = cxx_eval_constant_expression (ctx, orig_lhs, vc_prvalue,
3817 : : non_constant_p, overflow_p);
3818 : : /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer
3819 : : subtraction. */
3820 : 49398326 : if (*non_constant_p)
3821 : : return t;
3822 : 36205215 : rhs = cxx_eval_constant_expression (ctx, orig_rhs, vc_prvalue,
3823 : : non_constant_p, overflow_p);
3824 : 36205215 : if (*non_constant_p)
3825 : : return t;
3826 : :
3827 : 34276202 : location_t loc = EXPR_LOCATION (t);
3828 : 34276202 : enum tree_code code = TREE_CODE (t);
3829 : 34276202 : tree type = TREE_TYPE (t);
3830 : :
3831 : 34276202 : if (code == EQ_EXPR || code == NE_EXPR)
3832 : : {
3833 : 3378947 : bool is_code_eq = (code == EQ_EXPR);
3834 : :
3835 : 3378947 : if (TREE_CODE (lhs) == PTRMEM_CST
3836 : 187 : && TREE_CODE (rhs) == PTRMEM_CST)
3837 : : {
3838 : 54 : tree lmem = PTRMEM_CST_MEMBER (lhs);
3839 : 54 : tree rmem = PTRMEM_CST_MEMBER (rhs);
3840 : 54 : bool eq;
3841 : 54 : if (TREE_CODE (lmem) == TREE_CODE (rmem)
3842 : 54 : && TREE_CODE (lmem) == FIELD_DECL
3843 : 54 : && TREE_CODE (DECL_CONTEXT (lmem)) == UNION_TYPE
3844 : 81 : && same_type_p (DECL_CONTEXT (lmem),
3845 : : DECL_CONTEXT (rmem)))
3846 : : /* If both refer to (possibly different) members of the same union
3847 : : (12.3), they compare equal. */
3848 : : eq = true;
3849 : : else
3850 : 27 : eq = cp_tree_equal (lhs, rhs);
3851 : 54 : r = constant_boolean_node (eq == is_code_eq, type);
3852 : 54 : }
3853 : 3378893 : else if ((TREE_CODE (lhs) == PTRMEM_CST
3854 : 3378760 : || TREE_CODE (rhs) == PTRMEM_CST)
3855 : 3378893 : && (null_member_pointer_value_p (lhs)
3856 : 133 : || null_member_pointer_value_p (rhs)))
3857 : 133 : r = constant_boolean_node (!is_code_eq, type);
3858 : 3378760 : else if (TREE_CODE (lhs) == PTRMEM_CST)
3859 : 0 : lhs = cplus_expand_constant (lhs);
3860 : 3378760 : else if (TREE_CODE (rhs) == PTRMEM_CST)
3861 : 0 : rhs = cplus_expand_constant (rhs);
3862 : : }
3863 : 34276202 : if (r == NULL_TREE
3864 : 34276015 : && TREE_CODE_CLASS (code) == tcc_comparison
3865 : 45687093 : && POINTER_TYPE_P (TREE_TYPE (lhs)))
3866 : : {
3867 : 795600 : if (tree lhso = cxx_maybe_fold_addr_pointer_plus (lhs))
3868 : 664282 : lhs = fold_convert (TREE_TYPE (lhs), lhso);
3869 : 795600 : if (tree rhso = cxx_maybe_fold_addr_pointer_plus (rhs))
3870 : 680625 : rhs = fold_convert (TREE_TYPE (rhs), rhso);
3871 : : }
3872 : 1958205 : if (code == POINTER_PLUS_EXPR && !*non_constant_p
3873 : 36234407 : && integer_zerop (lhs) && !integer_zerop (rhs))
3874 : : {
3875 : 155 : if (!ctx->quiet)
3876 : 45 : error ("arithmetic involving a null pointer in %qE", lhs);
3877 : 155 : *non_constant_p = true;
3878 : 155 : return t;
3879 : : }
3880 : 34276047 : else if (code == POINTER_PLUS_EXPR)
3881 : 1958050 : r = cxx_fold_pointer_plus_expression (ctx, t, lhs, rhs, non_constant_p,
3882 : : overflow_p);
3883 : 32317997 : else if (code == SPACESHIP_EXPR)
3884 : : {
3885 : 16072 : r = genericize_spaceship (loc, type, lhs, rhs);
3886 : 16072 : return cxx_eval_constant_expression (ctx, r, lval, non_constant_p,
3887 : 16072 : overflow_p);
3888 : : }
3889 : :
3890 : 34259975 : if (r == NULL_TREE)
3891 : : {
3892 : 34252263 : if (ctx->manifestly_const_eval == mce_true
3893 : 16643151 : && (flag_constexpr_fp_except
3894 : 16643148 : || TREE_CODE (type) != REAL_TYPE))
3895 : : {
3896 : 16632202 : auto ofcc = make_temp_override (folding_cxx_constexpr, true);
3897 : 16632202 : r = fold_binary_initializer_loc (loc, code, type, lhs, rhs);
3898 : 16632202 : }
3899 : : else
3900 : 17620061 : r = fold_binary_loc (loc, code, type, lhs, rhs);
3901 : : }
3902 : :
3903 : 34252263 : if (r == NULL_TREE
3904 : 1837883 : && (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
3905 : 141 : && TREE_CODE (lhs) == INTEGER_CST
3906 : 132 : && TREE_CODE (rhs) == INTEGER_CST
3907 : 36097858 : && wi::neg_p (wi::to_wide (rhs)))
3908 : : {
3909 : : /* For diagnostics and -fpermissive emulate previous behavior of
3910 : : handling shifts by negative amount. */
3911 : 132 : tree nrhs = const_unop (NEGATE_EXPR, TREE_TYPE (rhs), rhs);
3912 : 132 : if (nrhs)
3913 : 187 : r = fold_binary_loc (loc,
3914 : : code == LSHIFT_EXPR ? RSHIFT_EXPR : LSHIFT_EXPR,
3915 : : type, lhs, nrhs);
3916 : : }
3917 : :
3918 : 34259975 : if (r == NULL_TREE)
3919 : : {
3920 : 1837751 : if (lhs == orig_lhs && rhs == orig_rhs)
3921 : : r = t;
3922 : : else
3923 : 314501 : r = build2_loc (loc, code, type, lhs, rhs);
3924 : : }
3925 : 32422224 : else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs))
3926 : 604 : *non_constant_p = true;
3927 : : /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
3928 : : a local array in a constexpr function. */
3929 : 34259975 : bool ptr = INDIRECT_TYPE_P (TREE_TYPE (lhs));
3930 : 31472472 : if (!ptr)
3931 : 31472472 : VERIFY_CONSTANT (r);
3932 : : return r;
3933 : : }
3934 : :
3935 : : /* Subroutine of cxx_eval_constant_expression.
3936 : : Attempt to evaluate condition expressions. */
3937 : :
3938 : : static tree
3939 : 6082715 : cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
3940 : : value_cat lval,
3941 : : bool *non_constant_p, bool *overflow_p,
3942 : : tree *jump_target)
3943 : : {
3944 : 6082715 : tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3945 : : vc_prvalue,
3946 : : non_constant_p, overflow_p);
3947 : 6082715 : VERIFY_CONSTANT (val);
3948 : 4812591 : if (TREE_CODE (t) == IF_STMT && IF_STMT_CONSTEVAL_P (t))
3949 : : {
3950 : : /* Evaluate the condition as if it was
3951 : : if (__builtin_is_constant_evaluated ()), i.e. defer it if not
3952 : : ctx->manifestly_const_eval (as sometimes we try to constant evaluate
3953 : : without manifestly_const_eval even expressions or parts thereof which
3954 : : will later be manifestly const_eval evaluated), otherwise fold it to
3955 : : true. */
3956 : 502924 : if (ctx->manifestly_const_eval == mce_unknown)
3957 : : {
3958 : 498401 : *non_constant_p = true;
3959 : 498401 : return t;
3960 : : }
3961 : 4523 : val = constant_boolean_node (ctx->manifestly_const_eval == mce_true,
3962 : : boolean_type_node);
3963 : : }
3964 : : /* Don't VERIFY_CONSTANT the other operands. */
3965 : 4314190 : const bool zero_p = integer_zerop (val);
3966 : 4314190 : if (zero_p)
3967 : 2289107 : val = TREE_OPERAND (t, 2);
3968 : : else
3969 : 2025083 : val = TREE_OPERAND (t, 1);
3970 : 4314190 : if (TREE_CODE (t) == IF_STMT && !val)
3971 : 793187 : val = void_node;
3972 : :
3973 : : /* P2564: If we aren't in immediate function context (including a manifestly
3974 : : constant-evaluated expression), check any uses of immediate functions in
3975 : : the arm we're discarding. But don't do this inside a call; we already
3976 : : checked when parsing the function. */
3977 : 4314190 : if (ctx->manifestly_const_eval != mce_true
3978 : 1951846 : && !in_immediate_context ()
3979 : 1951821 : && !ctx->call
3980 : 4948179 : && cp_fold_immediate (&TREE_OPERAND (t, zero_p ? 1 : 2),
3981 : 633989 : ctx->manifestly_const_eval))
3982 : : {
3983 : 7 : *non_constant_p = true;
3984 : 7 : return t;
3985 : : }
3986 : :
3987 : : /* A TARGET_EXPR may be nested inside another TARGET_EXPR, but still
3988 : : serve as the initializer for the same object as the outer TARGET_EXPR,
3989 : : as in
3990 : : A a = true ? A{} : A{};
3991 : : so strip the inner TARGET_EXPR so we don't materialize a temporary. */
3992 : 4314183 : if (TREE_CODE (val) == TARGET_EXPR)
3993 : 665 : val = TARGET_EXPR_INITIAL (val);
3994 : 4314183 : return cxx_eval_constant_expression (ctx, val, lval, non_constant_p,
3995 : 4314183 : overflow_p, jump_target);
3996 : : }
3997 : :
3998 : : /* Subroutine of cxx_eval_constant_expression.
3999 : : Attempt to evaluate vector condition expressions. Unlike
4000 : : cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
4001 : : ternary arithmetics operation, where all 3 arguments have to be
4002 : : evaluated as constants and then folding computes the result from
4003 : : them. */
4004 : :
4005 : : static tree
4006 : 658 : cxx_eval_vector_conditional_expression (const constexpr_ctx *ctx, tree t,
4007 : : bool *non_constant_p, bool *overflow_p)
4008 : : {
4009 : 658 : tree arg1 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
4010 : : vc_prvalue,
4011 : : non_constant_p, overflow_p);
4012 : 658 : VERIFY_CONSTANT (arg1);
4013 : 656 : tree arg2 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
4014 : : vc_prvalue,
4015 : : non_constant_p, overflow_p);
4016 : 656 : VERIFY_CONSTANT (arg2);
4017 : 656 : tree arg3 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
4018 : : vc_prvalue,
4019 : : non_constant_p, overflow_p);
4020 : 656 : VERIFY_CONSTANT (arg3);
4021 : 656 : location_t loc = EXPR_LOCATION (t);
4022 : 656 : tree type = TREE_TYPE (t);
4023 : 656 : tree r = fold_ternary_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3);
4024 : 656 : if (r == NULL_TREE)
4025 : : {
4026 : 0 : if (arg1 == TREE_OPERAND (t, 0)
4027 : 0 : && arg2 == TREE_OPERAND (t, 1)
4028 : 0 : && arg3 == TREE_OPERAND (t, 2))
4029 : : r = t;
4030 : : else
4031 : 0 : r = build3_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3);
4032 : : }
4033 : 656 : VERIFY_CONSTANT (r);
4034 : : return r;
4035 : : }
4036 : :
4037 : : /* Returns less than, equal to, or greater than zero if KEY is found to be
4038 : : less than, to match, or to be greater than the constructor_elt's INDEX. */
4039 : :
4040 : : static int
4041 : 21755 : array_index_cmp (tree key, tree index)
4042 : : {
4043 : 21755 : gcc_assert (TREE_CODE (key) == INTEGER_CST);
4044 : :
4045 : 21755 : switch (TREE_CODE (index))
4046 : : {
4047 : 18578 : case INTEGER_CST:
4048 : 18578 : return tree_int_cst_compare (key, index);
4049 : 3177 : case RANGE_EXPR:
4050 : 3177 : {
4051 : 3177 : tree lo = TREE_OPERAND (index, 0);
4052 : 3177 : tree hi = TREE_OPERAND (index, 1);
4053 : 3177 : if (tree_int_cst_lt (key, lo))
4054 : : return -1;
4055 : 2878 : else if (tree_int_cst_lt (hi, key))
4056 : : return 1;
4057 : : else
4058 : 2878 : return 0;
4059 : : }
4060 : 0 : default:
4061 : 0 : gcc_unreachable ();
4062 : : }
4063 : : }
4064 : :
4065 : : /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1
4066 : : if none. If INSERT is true, insert a matching element rather than fail. */
4067 : :
4068 : : static HOST_WIDE_INT
4069 : 1257109 : find_array_ctor_elt (tree ary, tree dindex, bool insert)
4070 : : {
4071 : 1257109 : if (tree_int_cst_sgn (dindex) < 0)
4072 : : return -1;
4073 : :
4074 : 1257109 : unsigned HOST_WIDE_INT i = tree_to_uhwi (dindex);
4075 : 1257109 : vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ary);
4076 : 1257109 : unsigned HOST_WIDE_INT len = vec_safe_length (elts);
4077 : :
4078 : 1942761 : unsigned HOST_WIDE_INT end = len;
4079 : 1174293 : unsigned HOST_WIDE_INT begin = 0;
4080 : :
4081 : : /* If the last element of the CONSTRUCTOR has its own index, we can assume
4082 : : that the same is true of the other elements and index directly. */
4083 : 1174293 : if (end > 0)
4084 : : {
4085 : 1154021 : tree cindex = (*elts)[end - 1].index;
4086 : 1154021 : if (cindex == NULL_TREE)
4087 : : {
4088 : : /* Verify that if the last index is missing, all indexes
4089 : : are missing. */
4090 : 0 : if (flag_checking)
4091 : 0 : for (unsigned int j = 0; j < len - 1; ++j)
4092 : 0 : gcc_assert ((*elts)[j].index == NULL_TREE);
4093 : 0 : if (i < end)
4094 : 0 : return i;
4095 : : else
4096 : : {
4097 : 0 : begin = end;
4098 : 0 : if (i == end)
4099 : : /* If the element is to be added right at the end,
4100 : : make sure it is added with cleared index too. */
4101 : 768468 : dindex = NULL_TREE;
4102 : 0 : else if (insert)
4103 : : /* Otherwise, in order not to break the assumption
4104 : : that CONSTRUCTOR either has all indexes or none,
4105 : : we need to add indexes to all elements. */
4106 : 0 : for (unsigned int j = 0; j < len; ++j)
4107 : 0 : (*elts)[j].index = build_int_cst (TREE_TYPE (dindex), j);
4108 : : }
4109 : : }
4110 : 1154021 : else if (TREE_CODE (cindex) == INTEGER_CST
4111 : 1154021 : && compare_tree_int (cindex, end - 1) == 0)
4112 : : {
4113 : 1149951 : if (i < end)
4114 : 488641 : return i;
4115 : : else
4116 : 768468 : begin = end;
4117 : : }
4118 : : }
4119 : :
4120 : : /* Otherwise, find a matching index by means of a binary search. */
4121 : 771267 : while (begin != end)
4122 : : {
4123 : 6139 : unsigned HOST_WIDE_INT middle = (begin + end) / 2;
4124 : 6139 : constructor_elt &elt = (*elts)[middle];
4125 : 6139 : tree idx = elt.index;
4126 : :
4127 : 6139 : int cmp = array_index_cmp (dindex, idx);
4128 : 6139 : if (cmp < 0)
4129 : : end = middle;
4130 : 4745 : else if (cmp > 0)
4131 : 1405 : begin = middle + 1;
4132 : : else
4133 : : {
4134 : 3340 : if (insert && TREE_CODE (idx) == RANGE_EXPR)
4135 : : {
4136 : : /* We need to split the range. */
4137 : 386 : constructor_elt e;
4138 : 386 : tree lo = TREE_OPERAND (idx, 0);
4139 : 386 : tree hi = TREE_OPERAND (idx, 1);
4140 : 386 : tree value = elt.value;
4141 : 386 : dindex = fold_convert (sizetype, dindex);
4142 : 386 : if (tree_int_cst_lt (lo, dindex))
4143 : : {
4144 : : /* There are still some lower elts; shorten the range. */
4145 : 190 : tree new_hi = int_const_binop (MINUS_EXPR, dindex,
4146 : 95 : size_one_node);
4147 : 95 : if (tree_int_cst_equal (lo, new_hi))
4148 : : /* Only one element left, no longer a range. */
4149 : 43 : elt.index = lo;
4150 : : else
4151 : 52 : TREE_OPERAND (idx, 1) = new_hi;
4152 : : /* Append the element we want to insert. */
4153 : 95 : ++middle;
4154 : 95 : e.index = dindex;
4155 : 95 : e.value = unshare_constructor (value);
4156 : 95 : vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle, e);
4157 : : }
4158 : : else
4159 : : /* No lower elts, the range elt is now ours. */
4160 : 291 : elt.index = dindex;
4161 : :
4162 : 386 : if (tree_int_cst_lt (dindex, hi))
4163 : : {
4164 : : /* There are still some higher elts; append a range. */
4165 : 540 : tree new_lo = int_const_binop (PLUS_EXPR, dindex,
4166 : 270 : size_one_node);
4167 : 270 : if (tree_int_cst_equal (new_lo, hi))
4168 : 129 : e.index = hi;
4169 : : else
4170 : 141 : e.index = build2 (RANGE_EXPR, sizetype, new_lo, hi);
4171 : 270 : e.value = unshare_constructor (value);
4172 : 270 : vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle + 1, e);
4173 : : }
4174 : : }
4175 : 3340 : return middle;
4176 : : }
4177 : : }
4178 : :
4179 : 765128 : if (insert)
4180 : : {
4181 : 762404 : constructor_elt e = { dindex, NULL_TREE };
4182 : 762404 : vec_safe_insert (CONSTRUCTOR_ELTS (ary), end, e);
4183 : 762404 : return end;
4184 : : }
4185 : :
4186 : : return -1;
4187 : : }
4188 : :
4189 : : /* Return a pointer to the constructor_elt of CTOR which matches INDEX. If no
4190 : : matching constructor_elt exists, then add one to CTOR.
4191 : :
4192 : : As an optimization, if POS_HINT is non-negative then it is used as a guess
4193 : : for the (integer) index of the matching constructor_elt within CTOR. */
4194 : :
4195 : : static constructor_elt *
4196 : 6955292 : get_or_insert_ctor_field (tree ctor, tree index, int pos_hint = -1)
4197 : : {
4198 : : /* Check the hint first. */
4199 : 527872 : if (pos_hint >= 0 && (unsigned)pos_hint < CONSTRUCTOR_NELTS (ctor)
4200 : 7483164 : && CONSTRUCTOR_ELT (ctor, pos_hint)->index == index)
4201 : : return CONSTRUCTOR_ELT (ctor, pos_hint);
4202 : :
4203 : 6427425 : tree type = TREE_TYPE (ctor);
4204 : 6427425 : if (TREE_CODE (type) == VECTOR_TYPE && index == NULL_TREE)
4205 : : {
4206 : 128 : CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (ctor), index, NULL_TREE);
4207 : 128 : return &CONSTRUCTOR_ELTS (ctor)->last();
4208 : : }
4209 : 6427297 : else if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
4210 : : {
4211 : 1007990 : if (TREE_CODE (index) == RANGE_EXPR)
4212 : : {
4213 : : /* Support for RANGE_EXPR index lookups is currently limited to
4214 : : accessing an existing element via POS_HINT, or appending a new
4215 : : element to the end of CTOR. ??? Support for other access
4216 : : patterns may also be needed. */
4217 : 3 : vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ctor);
4218 : 3 : if (vec_safe_length (elts))
4219 : : {
4220 : 3 : tree lo = TREE_OPERAND (index, 0);
4221 : 3 : gcc_assert (array_index_cmp (elts->last().index, lo) < 0);
4222 : : }
4223 : 3 : CONSTRUCTOR_APPEND_ELT (elts, index, NULL_TREE);
4224 : 3 : return &elts->last();
4225 : : }
4226 : :
4227 : 1007987 : HOST_WIDE_INT i = find_array_ctor_elt (ctor, index, /*insert*/true);
4228 : 1007987 : gcc_assert (i >= 0);
4229 : 1007987 : constructor_elt *cep = CONSTRUCTOR_ELT (ctor, i);
4230 : 1007987 : gcc_assert (cep->index == NULL_TREE
4231 : : || TREE_CODE (cep->index) != RANGE_EXPR);
4232 : : return cep;
4233 : : }
4234 : : else
4235 : : {
4236 : 5419307 : gcc_assert (TREE_CODE (index) == FIELD_DECL
4237 : : && (same_type_ignoring_top_level_qualifiers_p
4238 : : (DECL_CONTEXT (index), TREE_TYPE (ctor))));
4239 : :
4240 : : /* We must keep the CONSTRUCTOR's ELTS in FIELD order.
4241 : : Usually we meet initializers in that order, but it is
4242 : : possible for base types to be placed not in program
4243 : : order. */
4244 : 5419307 : tree fields = TYPE_FIELDS (DECL_CONTEXT (index));
4245 : 5419307 : unsigned HOST_WIDE_INT idx = 0;
4246 : 5419307 : constructor_elt *cep = NULL;
4247 : :
4248 : : /* Check if we're changing the active member of a union. */
4249 : 133182 : if (TREE_CODE (type) == UNION_TYPE && CONSTRUCTOR_NELTS (ctor)
4250 : 5442873 : && CONSTRUCTOR_ELT (ctor, 0)->index != index)
4251 : 3585 : vec_safe_truncate (CONSTRUCTOR_ELTS (ctor), 0);
4252 : : /* If the bit offset of INDEX is larger than that of the last
4253 : : constructor_elt, then we can just immediately append a new
4254 : : constructor_elt to the end of CTOR. */
4255 : 5415722 : else if (CONSTRUCTOR_NELTS (ctor)
4256 : 6358126 : && tree_int_cst_compare (bit_position (index),
4257 : 6190696 : bit_position (CONSTRUCTOR_ELTS (ctor)
4258 : 3095348 : ->last().index)) > 0)
4259 : : {
4260 : 1368636 : idx = CONSTRUCTOR_NELTS (ctor);
4261 : 1368636 : goto insert;
4262 : : }
4263 : :
4264 : : /* Otherwise, we need to iterate over CTOR to find or insert INDEX
4265 : : appropriately. */
4266 : :
4267 : 5468460 : for (; vec_safe_iterate (CONSTRUCTOR_ELTS (ctor), idx, &cep);
4268 : 1417789 : idx++, fields = DECL_CHAIN (fields))
4269 : : {
4270 : 3144501 : if (index == cep->index)
4271 : 1724210 : goto found;
4272 : :
4273 : : /* The field we're initializing must be on the field
4274 : : list. Look to see if it is present before the
4275 : : field the current ELT initializes. */
4276 : 7667765 : for (; fields != cep->index; fields = DECL_CHAIN (fields))
4277 : 6249976 : if (index == fields)
4278 : 2502 : goto insert;
4279 : : }
4280 : : /* We fell off the end of the CONSTRUCTOR, so insert a new
4281 : : entry at the end. */
4282 : :
4283 : 3695097 : insert:
4284 : 3695097 : {
4285 : 3695097 : constructor_elt ce = { index, NULL_TREE };
4286 : :
4287 : 3695097 : vec_safe_insert (CONSTRUCTOR_ELTS (ctor), idx, ce);
4288 : 3695097 : cep = CONSTRUCTOR_ELT (ctor, idx);
4289 : : }
4290 : 5419307 : found:;
4291 : :
4292 : 5419307 : return cep;
4293 : : }
4294 : : }
4295 : :
4296 : : /* Under the control of CTX, issue a detailed diagnostic for
4297 : : an out-of-bounds subscript INDEX into the expression ARRAY. */
4298 : :
4299 : : static void
4300 : 467 : diag_array_subscript (location_t loc, const constexpr_ctx *ctx, tree array, tree index)
4301 : : {
4302 : 467 : if (!ctx->quiet)
4303 : : {
4304 : 107 : tree arraytype = TREE_TYPE (array);
4305 : :
4306 : : /* Convert the unsigned array subscript to a signed integer to avoid
4307 : : printing huge numbers for small negative values. */
4308 : 107 : tree sidx = fold_convert (ssizetype, index);
4309 : 107 : STRIP_ANY_LOCATION_WRAPPER (array);
4310 : 107 : if (DECL_P (array))
4311 : : {
4312 : 75 : auto_diagnostic_group d;
4313 : 75 : if (TYPE_DOMAIN (arraytype))
4314 : 69 : error_at (loc, "array subscript value %qE is outside the bounds "
4315 : : "of array %qD of type %qT", sidx, array, arraytype);
4316 : : else
4317 : 6 : error_at (loc, "nonzero array subscript %qE is used with array %qD of "
4318 : : "type %qT with unknown bounds", sidx, array, arraytype);
4319 : 75 : inform (DECL_SOURCE_LOCATION (array), "declared here");
4320 : 75 : }
4321 : 32 : else if (TYPE_DOMAIN (arraytype))
4322 : 29 : error_at (loc, "array subscript value %qE is outside the bounds "
4323 : : "of array type %qT", sidx, arraytype);
4324 : : else
4325 : 3 : error_at (loc, "nonzero array subscript %qE is used with array of type %qT "
4326 : : "with unknown bounds", sidx, arraytype);
4327 : : }
4328 : 467 : }
4329 : :
4330 : : /* Return the number of elements for TYPE (which is an ARRAY_TYPE or
4331 : : a VECTOR_TYPE). */
4332 : :
4333 : : static tree
4334 : 2452249 : get_array_or_vector_nelts (const constexpr_ctx *ctx, tree type,
4335 : : bool *non_constant_p, bool *overflow_p)
4336 : : {
4337 : 2452249 : tree nelts;
4338 : 2452249 : if (TREE_CODE (type) == ARRAY_TYPE)
4339 : : {
4340 : 2452249 : if (TYPE_DOMAIN (type))
4341 : 2452088 : nelts = array_type_nelts_top (type);
4342 : : else
4343 : 161 : nelts = size_zero_node;
4344 : : }
4345 : 0 : else if (VECTOR_TYPE_P (type))
4346 : 0 : nelts = size_int (TYPE_VECTOR_SUBPARTS (type));
4347 : : else
4348 : 0 : gcc_unreachable ();
4349 : :
4350 : : /* For VLAs, the number of elements won't be an integer constant. */
4351 : 2452249 : nelts = cxx_eval_constant_expression (ctx, nelts, vc_prvalue,
4352 : : non_constant_p, overflow_p);
4353 : 2452249 : return nelts;
4354 : : }
4355 : :
4356 : : /* Extract element INDEX consisting of CHARS_PER_ELT chars from
4357 : : STRING_CST STRING. */
4358 : :
4359 : : static tree
4360 : 370826 : extract_string_elt (tree string, unsigned chars_per_elt, unsigned index)
4361 : : {
4362 : 370826 : tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (string)));
4363 : 370826 : tree r;
4364 : :
4365 : 370826 : if (chars_per_elt == 1)
4366 : 347375 : r = build_int_cst (type, TREE_STRING_POINTER (string)[index]);
4367 : : else
4368 : : {
4369 : 23451 : const unsigned char *ptr
4370 : 23451 : = ((const unsigned char *)TREE_STRING_POINTER (string)
4371 : 23451 : + index * chars_per_elt);
4372 : 23451 : r = native_interpret_expr (type, ptr, chars_per_elt);
4373 : : }
4374 : 370826 : return r;
4375 : : }
4376 : :
4377 : : /* Subroutine of cxx_eval_array_reference. T is an ARRAY_REF; evaluate the
4378 : : subscript, diagnose any problems with it, and return the result. */
4379 : :
4380 : : static tree
4381 : 2455213 : eval_and_check_array_index (const constexpr_ctx *ctx,
4382 : : tree t, bool allow_one_past,
4383 : : bool *non_constant_p, bool *overflow_p)
4384 : : {
4385 : 2455213 : location_t loc = cp_expr_loc_or_input_loc (t);
4386 : 2455213 : tree ary = TREE_OPERAND (t, 0);
4387 : 2455213 : t = TREE_OPERAND (t, 1);
4388 : 2455213 : tree index = cxx_eval_constant_expression (ctx, t, vc_prvalue,
4389 : : non_constant_p, overflow_p);
4390 : 2455213 : VERIFY_CONSTANT (index);
4391 : :
4392 : 2451823 : if (!tree_fits_shwi_p (index)
4393 : 2451823 : || tree_int_cst_sgn (index) < 0)
4394 : : {
4395 : 108 : diag_array_subscript (loc, ctx, ary, index);
4396 : 108 : *non_constant_p = true;
4397 : 108 : return t;
4398 : : }
4399 : :
4400 : 2451715 : tree nelts = get_array_or_vector_nelts (ctx, TREE_TYPE (ary), non_constant_p,
4401 : : overflow_p);
4402 : 2451715 : VERIFY_CONSTANT (nelts);
4403 : 2451652 : if (allow_one_past
4404 : 4002680 : ? !tree_int_cst_le (index, nelts)
4405 : 1551028 : : !tree_int_cst_lt (index, nelts))
4406 : : {
4407 : 359 : diag_array_subscript (loc, ctx, ary, index);
4408 : 359 : *non_constant_p = true;
4409 : 359 : return t;
4410 : : }
4411 : :
4412 : : return index;
4413 : : }
4414 : :
4415 : : /* Subroutine of cxx_eval_constant_expression.
4416 : : Attempt to reduce a reference to an array slot. */
4417 : :
4418 : : static tree
4419 : 1713673 : cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
4420 : : value_cat lval,
4421 : : bool *non_constant_p, bool *overflow_p)
4422 : : {
4423 : 1713673 : tree oldary = TREE_OPERAND (t, 0);
4424 : 1713673 : tree ary = cxx_eval_constant_expression (ctx, oldary,
4425 : : lval,
4426 : : non_constant_p, overflow_p);
4427 : 1713673 : if (*non_constant_p)
4428 : : return t;
4429 : 1535460 : if (!lval
4430 : 631562 : && TREE_CODE (ary) == VIEW_CONVERT_EXPR
4431 : 13282 : && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary, 0)))
4432 : 1548742 : && (TYPE_MAIN_VARIANT (TREE_TYPE (t))
4433 : 13282 : == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary, 0))))))
4434 : 13282 : ary = TREE_OPERAND (ary, 0);
4435 : :
4436 : 1535460 : tree oldidx = TREE_OPERAND (t, 1);
4437 : 1535460 : tree index = eval_and_check_array_index (ctx, t, lval,
4438 : : non_constant_p, overflow_p);
4439 : 1535460 : if (*non_constant_p)
4440 : : return t;
4441 : :
4442 : 1531594 : if (lval && ary == oldary && index == oldidx)
4443 : : return t;
4444 : 726376 : else if (lval == vc_discard)
4445 : : return t;
4446 : 726376 : else if (lval)
4447 : 95234 : return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
4448 : :
4449 : 631142 : unsigned len = 0, elem_nchars = 1;
4450 : 631142 : tree elem_type = TREE_TYPE (TREE_TYPE (ary));
4451 : 631142 : if (TREE_CODE (ary) == CONSTRUCTOR)
4452 : 249002 : len = CONSTRUCTOR_NELTS (ary);
4453 : 382140 : else if (TREE_CODE (ary) == STRING_CST)
4454 : : {
4455 : 368866 : elem_nchars = (TYPE_PRECISION (elem_type)
4456 : 368866 : / TYPE_PRECISION (char_type_node));
4457 : 368866 : len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
4458 : : }
4459 : 13274 : else if (TREE_CODE (ary) == VECTOR_CST)
4460 : : /* We don't create variable-length VECTOR_CSTs. */
4461 : 13274 : len = VECTOR_CST_NELTS (ary).to_constant ();
4462 : : else
4463 : : {
4464 : : /* We can't do anything with other tree codes, so use
4465 : : VERIFY_CONSTANT to complain and fail. */
4466 : 0 : VERIFY_CONSTANT (ary);
4467 : 0 : gcc_unreachable ();
4468 : : }
4469 : :
4470 : 631142 : bool found;
4471 : 631142 : HOST_WIDE_INT i = 0;
4472 : 631142 : if (TREE_CODE (ary) == CONSTRUCTOR)
4473 : : {
4474 : 249002 : HOST_WIDE_INT ix = find_array_ctor_elt (ary, index);
4475 : 249002 : found = (ix >= 0);
4476 : 249002 : if (found)
4477 : 246364 : i = ix;
4478 : : }
4479 : : else
4480 : : {
4481 : 382140 : i = tree_to_shwi (index);
4482 : 382140 : found = (i < len);
4483 : : }
4484 : :
4485 : 631142 : if (found)
4486 : : {
4487 : 627809 : tree r;
4488 : 627809 : if (TREE_CODE (ary) == CONSTRUCTOR)
4489 : 246364 : r = (*CONSTRUCTOR_ELTS (ary))[i].value;
4490 : 381445 : else if (TREE_CODE (ary) == VECTOR_CST)
4491 : 13274 : r = VECTOR_CST_ELT (ary, i);
4492 : : else
4493 : 368171 : r = extract_string_elt (ary, elem_nchars, i);
4494 : :
4495 : 627809 : if (r)
4496 : : /* Don't VERIFY_CONSTANT here. */
4497 : : return r;
4498 : :
4499 : : /* Otherwise the element doesn't have a value yet. */
4500 : : }
4501 : :
4502 : : /* Not found. */
4503 : :
4504 : 3333 : if (is_really_empty_class (elem_type, /*ignore_vptr*/false))
4505 : 52 : return build_constructor (elem_type, NULL);
4506 : :
4507 : 3281 : if (TREE_CODE (ary) == CONSTRUCTOR
4508 : 3281 : && CONSTRUCTOR_NO_CLEARING (ary))
4509 : : {
4510 : : /* 'ary' is part of the aggregate initializer we're currently
4511 : : building; if there's no initializer for this element yet,
4512 : : that's an error. */
4513 : 51 : if (!ctx->quiet)
4514 : 16 : error ("accessing uninitialized array element");
4515 : 51 : *non_constant_p = true;
4516 : 51 : return t;
4517 : : }
4518 : :
4519 : : /* If it's within the array bounds but doesn't have an explicit
4520 : : initializer, it's initialized from {}. But use build_value_init
4521 : : directly for non-aggregates to avoid creating a garbage CONSTRUCTOR. */
4522 : 3230 : tree val;
4523 : 3230 : constexpr_ctx new_ctx;
4524 : 3230 : if (CP_AGGREGATE_TYPE_P (elem_type))
4525 : : {
4526 : 794 : tree empty_ctor = build_constructor (init_list_type_node, NULL);
4527 : 794 : val = digest_init (elem_type, empty_ctor, tf_warning_or_error);
4528 : : }
4529 : : else
4530 : 2436 : val = build_value_init (elem_type, tf_warning_or_error);
4531 : :
4532 : : /* Create a new constructor only if we don't already have a suitable one. */
4533 : 3230 : const bool new_ctor = (!SCALAR_TYPE_P (elem_type)
4534 : 4050 : && (!ctx->ctor
4535 : 15 : || !same_type_ignoring_top_level_qualifiers_p
4536 : 15 : (elem_type, TREE_TYPE (ctx->ctor))));
4537 : 811 : if (new_ctor)
4538 : : {
4539 : 811 : new_ctx = *ctx;
4540 : : /* We clear the object here. We used to replace it with T, but that
4541 : : caused problems (101371, 108158); and anyway, T is the initializer,
4542 : : not the target object. */
4543 : 811 : new_ctx.object = NULL_TREE;
4544 : 811 : new_ctx.ctor = build_constructor (elem_type, NULL);
4545 : 811 : ctx = &new_ctx;
4546 : : }
4547 : 3230 : t = cxx_eval_constant_expression (ctx, val, lval, non_constant_p,
4548 : : overflow_p);
4549 : 3230 : if (new_ctor && t != ctx->ctor)
4550 : 778 : free_constructor (ctx->ctor);
4551 : : return t;
4552 : : }
4553 : :
4554 : : /* Subroutine of cxx_eval_constant_expression.
4555 : : Attempt to reduce a field access of a value of class type. */
4556 : :
4557 : : static tree
4558 : 32215404 : cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
4559 : : value_cat lval,
4560 : : bool *non_constant_p, bool *overflow_p)
4561 : : {
4562 : 32215404 : unsigned HOST_WIDE_INT i;
4563 : 32215404 : tree field;
4564 : 32215404 : tree value;
4565 : 32215404 : tree part = TREE_OPERAND (t, 1);
4566 : 32215404 : tree orig_whole = TREE_OPERAND (t, 0);
4567 : 32215404 : tree whole = cxx_eval_constant_expression (ctx, orig_whole,
4568 : : lval,
4569 : : non_constant_p, overflow_p);
4570 : 32215404 : if (*non_constant_p)
4571 : : return t;
4572 : 19366244 : if (INDIRECT_REF_P (whole)
4573 : 19366244 : && integer_zerop (TREE_OPERAND (whole, 0)))
4574 : : {
4575 : 177 : if (!ctx->quiet)
4576 : 39 : error ("dereferencing a null pointer in %qE", orig_whole);
4577 : 177 : *non_constant_p = true;
4578 : 177 : return t;
4579 : : }
4580 : :
4581 : 19366067 : if (TREE_CODE (whole) == PTRMEM_CST)
4582 : 1405 : whole = cplus_expand_constant (whole);
4583 : 19366067 : if (whole == orig_whole)
4584 : : return t;
4585 : 8459546 : if (lval == vc_discard)
4586 : : return t;
4587 : 8459522 : if (lval)
4588 : 5894541 : return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
4589 : : whole, part, NULL_TREE);
4590 : : /* Don't VERIFY_CONSTANT here; we only want to check that we got a
4591 : : CONSTRUCTOR. */
4592 : 2564981 : if (TREE_CODE (whole) != CONSTRUCTOR)
4593 : : {
4594 : 0 : if (!ctx->quiet)
4595 : 0 : error ("%qE is not a constant expression", orig_whole);
4596 : 0 : *non_constant_p = true;
4597 : 0 : return t;
4598 : : }
4599 : 2563360 : if ((cxx_dialect < cxx14 || CONSTRUCTOR_MUTABLE_POISON (whole))
4600 : 2566772 : && DECL_MUTABLE_P (part))
4601 : : {
4602 : 132 : if (!ctx->quiet)
4603 : 16 : error ("mutable %qD is not usable in a constant expression", part);
4604 : 132 : *non_constant_p = true;
4605 : 132 : return t;
4606 : : }
4607 : :
4608 : 2564849 : bool pmf = TYPE_PTRMEMFUNC_P (TREE_TYPE (whole));
4609 : 3526075 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
4610 : : {
4611 : : /* Use name match for PMF fields, as a variant will have a
4612 : : different FIELD_DECL with a different type. */
4613 : 3524087 : if (pmf ? DECL_NAME (field) == DECL_NAME (part)
4614 : : : field == part)
4615 : : {
4616 : 2562861 : if (value)
4617 : : {
4618 : 2562843 : STRIP_ANY_LOCATION_WRAPPER (value);
4619 : 2562843 : return value;
4620 : : }
4621 : : else
4622 : : /* We're in the middle of initializing it. */
4623 : : break;
4624 : : }
4625 : : }
4626 : 2006 : if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE)
4627 : : {
4628 : 89 : if (CONSTRUCTOR_NELTS (whole) > 0)
4629 : : {
4630 : : /* DR 1188 says we don't have to deal with this. */
4631 : 71 : if (!ctx->quiet)
4632 : : {
4633 : 18 : constructor_elt *cep = CONSTRUCTOR_ELT (whole, 0);
4634 : 18 : if (cep->value == NULL_TREE)
4635 : 9 : error ("accessing uninitialized member %qD", part);
4636 : : else
4637 : 9 : error ("accessing %qD member instead of initialized %qD member "
4638 : : "in constant expression", part, cep->index);
4639 : : }
4640 : 71 : *non_constant_p = true;
4641 : 71 : return t;
4642 : : }
4643 : 18 : else if (!CONSTRUCTOR_NO_CLEARING (whole))
4644 : : {
4645 : : /* Value-initialized union, check if looking at the first member. */
4646 : 15 : tree first = next_aggregate_field (TYPE_FIELDS (TREE_TYPE (whole)));
4647 : 15 : if (first != part)
4648 : : {
4649 : 9 : if (!ctx->quiet)
4650 : 3 : error ("accessing %qD member instead of initialized %qD "
4651 : : "member in constant expression", part, first);
4652 : 9 : *non_constant_p = true;
4653 : 9 : return t;
4654 : : }
4655 : : }
4656 : : }
4657 : :
4658 : : /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty
4659 : : classes never get represented; throw together a value now. */
4660 : 1926 : if (is_really_empty_class (TREE_TYPE (t), /*ignore_vptr*/false))
4661 : 1259 : return build_constructor (TREE_TYPE (t), NULL);
4662 : :
4663 : 667 : gcc_assert (DECL_CONTEXT (part) == TYPE_MAIN_VARIANT (TREE_TYPE (whole)));
4664 : :
4665 : 667 : if (CONSTRUCTOR_NO_CLEARING (whole))
4666 : : {
4667 : : /* 'whole' is part of the aggregate initializer we're currently
4668 : : building; if there's no initializer for this member yet, that's an
4669 : : error. */
4670 : 367 : if (!ctx->quiet)
4671 : 21 : error ("accessing uninitialized member %qD", part);
4672 : 367 : *non_constant_p = true;
4673 : 367 : return t;
4674 : : }
4675 : :
4676 : : /* If there's no explicit init for this field, it's value-initialized. */
4677 : 300 : value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
4678 : 300 : return cxx_eval_constant_expression (ctx, value,
4679 : : lval,
4680 : 300 : non_constant_p, overflow_p);
4681 : : }
4682 : :
4683 : : /* Subroutine of cxx_eval_constant_expression.
4684 : : Attempt to reduce a field access of a value of class type that is
4685 : : expressed as a BIT_FIELD_REF. */
4686 : :
4687 : : static tree
4688 : 49 : cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
4689 : : value_cat lval,
4690 : : bool *non_constant_p, bool *overflow_p)
4691 : : {
4692 : 49 : tree orig_whole = TREE_OPERAND (t, 0);
4693 : 49 : tree retval, fldval, utype, mask;
4694 : 49 : bool fld_seen = false;
4695 : 49 : HOST_WIDE_INT istart, isize;
4696 : 49 : tree whole = cxx_eval_constant_expression (ctx, orig_whole,
4697 : : lval,
4698 : : non_constant_p, overflow_p);
4699 : 49 : tree start, field, value;
4700 : 49 : unsigned HOST_WIDE_INT i;
4701 : :
4702 : 49 : if (whole == orig_whole)
4703 : : return t;
4704 : : /* Don't VERIFY_CONSTANT here; we only want to check that we got a
4705 : : CONSTRUCTOR. */
4706 : 2 : if (!*non_constant_p
4707 : 2 : && TREE_CODE (whole) != VECTOR_CST
4708 : 0 : && TREE_CODE (whole) != CONSTRUCTOR)
4709 : : {
4710 : 0 : if (!ctx->quiet)
4711 : 0 : error ("%qE is not a constant expression", orig_whole);
4712 : 0 : *non_constant_p = true;
4713 : : }
4714 : 2 : if (*non_constant_p)
4715 : : return t;
4716 : :
4717 : 2 : if (TREE_CODE (whole) == VECTOR_CST || !INTEGRAL_TYPE_P (TREE_TYPE (t)))
4718 : : {
4719 : 2 : if (tree r = fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
4720 : : TREE_OPERAND (t, 1), TREE_OPERAND (t, 2)))
4721 : : return r;
4722 : 0 : if (!ctx->quiet)
4723 : 0 : error ("%qE is not a constant expression", orig_whole);
4724 : 0 : *non_constant_p = true;
4725 : 0 : return t;
4726 : : }
4727 : :
4728 : 0 : start = TREE_OPERAND (t, 2);
4729 : 0 : istart = tree_to_shwi (start);
4730 : 0 : isize = tree_to_shwi (TREE_OPERAND (t, 1));
4731 : 0 : utype = TREE_TYPE (t);
4732 : 0 : if (!TYPE_UNSIGNED (utype))
4733 : 0 : utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
4734 : 0 : retval = build_int_cst (utype, 0);
4735 : 0 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
4736 : : {
4737 : 0 : tree bitpos = bit_position (field);
4738 : 0 : STRIP_ANY_LOCATION_WRAPPER (value);
4739 : 0 : if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
4740 : 0 : return value;
4741 : 0 : if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
4742 : 0 : && TREE_CODE (value) == INTEGER_CST
4743 : 0 : && tree_fits_shwi_p (bitpos)
4744 : 0 : && tree_fits_shwi_p (DECL_SIZE (field)))
4745 : : {
4746 : 0 : HOST_WIDE_INT bit = tree_to_shwi (bitpos);
4747 : 0 : HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field));
4748 : 0 : HOST_WIDE_INT shift;
4749 : 0 : if (bit >= istart && bit + sz <= istart + isize)
4750 : : {
4751 : 0 : fldval = fold_convert (utype, value);
4752 : 0 : mask = build_int_cst_type (utype, -1);
4753 : 0 : mask = fold_build2 (LSHIFT_EXPR, utype, mask,
4754 : : size_int (TYPE_PRECISION (utype) - sz));
4755 : 0 : mask = fold_build2 (RSHIFT_EXPR, utype, mask,
4756 : : size_int (TYPE_PRECISION (utype) - sz));
4757 : 0 : fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
4758 : 0 : shift = bit - istart;
4759 : 0 : if (BYTES_BIG_ENDIAN)
4760 : : shift = TYPE_PRECISION (utype) - shift - sz;
4761 : 0 : fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
4762 : : size_int (shift));
4763 : 0 : retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
4764 : 0 : fld_seen = true;
4765 : : }
4766 : : }
4767 : : }
4768 : 0 : if (fld_seen)
4769 : 0 : return fold_convert (TREE_TYPE (t), retval);
4770 : 0 : gcc_unreachable ();
4771 : : return error_mark_node;
4772 : : }
4773 : :
4774 : : /* Helper for cxx_eval_bit_cast.
4775 : : Check [bit.cast]/3 rules, bit_cast is constexpr only if the To and From
4776 : : types and types of all subobjects have is_union_v<T>, is_pointer_v<T>,
4777 : : is_member_pointer_v<T>, is_volatile_v<T> false and has no non-static
4778 : : data members of reference type. */
4779 : :
4780 : : static bool
4781 : 5182 : check_bit_cast_type (const constexpr_ctx *ctx, location_t loc, tree type,
4782 : : tree orig_type)
4783 : : {
4784 : 5669 : if (TREE_CODE (type) == UNION_TYPE)
4785 : : {
4786 : 63 : if (!ctx->quiet)
4787 : : {
4788 : 21 : if (type == orig_type)
4789 : 6 : error_at (loc, "%qs is not a constant expression because %qT is "
4790 : : "a union type", "__builtin_bit_cast", type);
4791 : : else
4792 : 15 : error_at (loc, "%qs is not a constant expression because %qT "
4793 : : "contains a union type", "__builtin_bit_cast",
4794 : : orig_type);
4795 : : }
4796 : 63 : return true;
4797 : : }
4798 : : if (TREE_CODE (type) == POINTER_TYPE)
4799 : : {
4800 : 66 : if (!ctx->quiet)
4801 : : {
4802 : 18 : if (type == orig_type)
4803 : 6 : error_at (loc, "%qs is not a constant expression because %qT is "
4804 : : "a pointer type", "__builtin_bit_cast", type);
4805 : : else
4806 : 12 : error_at (loc, "%qs is not a constant expression because %qT "
4807 : : "contains a pointer type", "__builtin_bit_cast",
4808 : : orig_type);
4809 : : }
4810 : 66 : return true;
4811 : : }
4812 : : if (TREE_CODE (type) == REFERENCE_TYPE)
4813 : : {
4814 : 0 : if (!ctx->quiet)
4815 : : {
4816 : 0 : if (type == orig_type)
4817 : 0 : error_at (loc, "%qs is not a constant expression because %qT is "
4818 : : "a reference type", "__builtin_bit_cast", type);
4819 : : else
4820 : 0 : error_at (loc, "%qs is not a constant expression because %qT "
4821 : : "contains a reference type", "__builtin_bit_cast",
4822 : : orig_type);
4823 : : }
4824 : 0 : return true;
4825 : : }
4826 : 1341 : if (TYPE_PTRMEM_P (type))
4827 : : {
4828 : 36 : if (!ctx->quiet)
4829 : : {
4830 : 12 : if (type == orig_type)
4831 : 12 : error_at (loc, "%qs is not a constant expression because %qT is "
4832 : : "a pointer to member type", "__builtin_bit_cast",
4833 : : type);
4834 : : else
4835 : 0 : error_at (loc, "%qs is not a constant expression because %qT "
4836 : : "contains a pointer to member type",
4837 : : "__builtin_bit_cast", orig_type);
4838 : : }
4839 : 36 : return true;
4840 : : }
4841 : 5504 : if (TYPE_VOLATILE (type))
4842 : : {
4843 : 0 : if (!ctx->quiet)
4844 : : {
4845 : 0 : if (type == orig_type)
4846 : 0 : error_at (loc, "%qs is not a constant expression because %qT is "
4847 : : "volatile", "__builtin_bit_cast", type);
4848 : : else
4849 : 0 : error_at (loc, "%qs is not a constant expression because %qT "
4850 : : "contains a volatile subobject",
4851 : : "__builtin_bit_cast", orig_type);
4852 : : }
4853 : 0 : return true;
4854 : : }
4855 : 5504 : if (TREE_CODE (type) == RECORD_TYPE)
4856 : 25880 : for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
4857 : 24647 : if (TREE_CODE (field) == FIELD_DECL
4858 : 24647 : && check_bit_cast_type (ctx, loc, TREE_TYPE (field), orig_type))
4859 : : return true;
4860 : 5414 : if (TREE_CODE (type) == ARRAY_TYPE)
4861 : 487 : return check_bit_cast_type (ctx, loc, TREE_TYPE (type), orig_type);
4862 : : return false;
4863 : : }
4864 : :
4865 : : /* Helper function for cxx_eval_bit_cast. For unsigned char or
4866 : : std::byte members of CONSTRUCTOR (recursively) if they contain
4867 : : some indeterminate bits (as set in MASK), remove the ctor elts,
4868 : : mark the CONSTRUCTOR as CONSTRUCTOR_NO_CLEARING and clear the
4869 : : bits in MASK. */
4870 : :
4871 : : static void
4872 : 659 : clear_uchar_or_std_byte_in_mask (location_t loc, tree t, unsigned char *mask)
4873 : : {
4874 : 659 : if (TREE_CODE (t) != CONSTRUCTOR)
4875 : : return;
4876 : :
4877 : : unsigned i, j = 0;
4878 : : tree index, value;
4879 : 2258 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, index, value)
4880 : : {
4881 : 1599 : tree type = TREE_TYPE (value);
4882 : 1599 : if (TREE_CODE (TREE_TYPE (t)) != ARRAY_TYPE
4883 : 2759 : && DECL_BIT_FIELD_TYPE (index) != NULL_TREE)
4884 : : {
4885 : 270 : if (is_byte_access_type_not_plain_char (DECL_BIT_FIELD_TYPE (index)))
4886 : : {
4887 : 135 : HOST_WIDE_INT fldsz = TYPE_PRECISION (TREE_TYPE (index));
4888 : 135 : gcc_assert (fldsz != 0);
4889 : 135 : HOST_WIDE_INT pos = int_byte_position (index);
4890 : 135 : HOST_WIDE_INT bpos
4891 : 135 : = tree_to_uhwi (DECL_FIELD_BIT_OFFSET (index));
4892 : 135 : bpos %= BITS_PER_UNIT;
4893 : 135 : HOST_WIDE_INT end
4894 : 135 : = ROUND_UP (bpos + fldsz, BITS_PER_UNIT) / BITS_PER_UNIT;
4895 : 135 : gcc_assert (end == 1 || end == 2);
4896 : 135 : unsigned char *p = mask + pos;
4897 : 135 : unsigned char mask_save[2];
4898 : 135 : mask_save[0] = mask[pos];
4899 : 135 : mask_save[1] = end == 2 ? mask[pos + 1] : 0;
4900 : 135 : if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
4901 : : sorry_at (loc, "PDP11 bit-field handling unsupported"
4902 : : " in %qs", "__builtin_bit_cast");
4903 : 135 : else if (BYTES_BIG_ENDIAN)
4904 : : {
4905 : : /* Big endian. */
4906 : : if (bpos + fldsz <= BITS_PER_UNIT)
4907 : : *p &= ~(((1 << fldsz) - 1)
4908 : : << (BITS_PER_UNIT - bpos - fldsz));
4909 : : else
4910 : : {
4911 : : gcc_assert (bpos);
4912 : : *p &= ~(((1U << BITS_PER_UNIT) - 1) >> bpos);
4913 : : p++;
4914 : : fldsz -= BITS_PER_UNIT - bpos;
4915 : : gcc_assert (fldsz && fldsz < BITS_PER_UNIT);
4916 : : *p &= ((1U << BITS_PER_UNIT) - 1) >> fldsz;
4917 : : }
4918 : : }
4919 : : else
4920 : : {
4921 : : /* Little endian. */
4922 : 135 : if (bpos + fldsz <= BITS_PER_UNIT)
4923 : 135 : *p &= ~(((1 << fldsz) - 1) << bpos);
4924 : : else
4925 : : {
4926 : 0 : gcc_assert (bpos);
4927 : 0 : *p &= ~(((1 << BITS_PER_UNIT) - 1) << bpos);
4928 : 0 : p++;
4929 : 0 : fldsz -= BITS_PER_UNIT - bpos;
4930 : 0 : gcc_assert (fldsz && fldsz < BITS_PER_UNIT);
4931 : 0 : *p &= ~((1 << fldsz) - 1);
4932 : : }
4933 : : }
4934 : 135 : if (mask_save[0] != mask[pos]
4935 : 99 : || (end == 2 && mask_save[1] != mask[pos + 1]))
4936 : : {
4937 : 36 : CONSTRUCTOR_NO_CLEARING (t) = 1;
4938 : 36 : continue;
4939 : : }
4940 : : }
4941 : : }
4942 : 1329 : else if (is_byte_access_type_not_plain_char (type))
4943 : : {
4944 : 228 : HOST_WIDE_INT pos;
4945 : 228 : if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
4946 : 132 : pos = tree_to_shwi (index);
4947 : : else
4948 : 96 : pos = int_byte_position (index);
4949 : 228 : if (mask[pos])
4950 : : {
4951 : 48 : CONSTRUCTOR_NO_CLEARING (t) = 1;
4952 : 48 : mask[pos] = 0;
4953 : 48 : continue;
4954 : : }
4955 : : }
4956 : 1515 : if (TREE_CODE (value) == CONSTRUCTOR)
4957 : : {
4958 : 264 : HOST_WIDE_INT pos;
4959 : 264 : if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
4960 : 144 : pos = tree_to_shwi (index)
4961 : 72 : * tree_to_shwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t))));
4962 : : else
4963 : 192 : pos = int_byte_position (index);
4964 : 264 : clear_uchar_or_std_byte_in_mask (loc, value, mask + pos);
4965 : : }
4966 : 1515 : if (i != j)
4967 : : {
4968 : 180 : CONSTRUCTOR_ELT (t, j)->index = index;
4969 : 180 : CONSTRUCTOR_ELT (t, j)->value = value;
4970 : : }
4971 : 1515 : ++j;
4972 : : }
4973 : 1318 : if (CONSTRUCTOR_NELTS (t) != j)
4974 : 84 : vec_safe_truncate (CONSTRUCTOR_ELTS (t), j);
4975 : : }
4976 : :
4977 : : /* Subroutine of cxx_eval_constant_expression.
4978 : : Attempt to evaluate a BIT_CAST_EXPR. */
4979 : :
4980 : : static tree
4981 : 1226 : cxx_eval_bit_cast (const constexpr_ctx *ctx, tree t, bool *non_constant_p,
4982 : : bool *overflow_p)
4983 : : {
4984 : 1226 : if (check_bit_cast_type (ctx, EXPR_LOCATION (t), TREE_TYPE (t),
4985 : 1226 : TREE_TYPE (t))
4986 : 3943 : || check_bit_cast_type (ctx, cp_expr_loc_or_loc (TREE_OPERAND (t, 0),
4987 : 1145 : EXPR_LOCATION (t)),
4988 : 1145 : TREE_TYPE (TREE_OPERAND (t, 0)),
4989 : 1145 : TREE_TYPE (TREE_OPERAND (t, 0))))
4990 : : {
4991 : 165 : *non_constant_p = true;
4992 : 165 : return t;
4993 : : }
4994 : :
4995 : 1061 : tree op = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), vc_prvalue,
4996 : : non_constant_p, overflow_p);
4997 : 1061 : if (*non_constant_p)
4998 : : return t;
4999 : :
5000 : 906 : location_t loc = EXPR_LOCATION (t);
5001 : 906 : if (BITS_PER_UNIT != 8 || CHAR_BIT != 8)
5002 : : {
5003 : : if (!ctx->quiet)
5004 : : sorry_at (loc, "%qs cannot be constant evaluated on the target",
5005 : : "__builtin_bit_cast");
5006 : : *non_constant_p = true;
5007 : : return t;
5008 : : }
5009 : :
5010 : 906 : if (!tree_fits_shwi_p (TYPE_SIZE_UNIT (TREE_TYPE (t))))
5011 : : {
5012 : 0 : if (!ctx->quiet)
5013 : 0 : sorry_at (loc, "%qs cannot be constant evaluated because the "
5014 : : "type is too large", "__builtin_bit_cast");
5015 : 0 : *non_constant_p = true;
5016 : 0 : return t;
5017 : : }
5018 : :
5019 : 906 : HOST_WIDE_INT len = tree_to_shwi (TYPE_SIZE_UNIT (TREE_TYPE (t)));
5020 : 906 : if (len < 0 || (int) len != len)
5021 : : {
5022 : 0 : if (!ctx->quiet)
5023 : 0 : sorry_at (loc, "%qs cannot be constant evaluated because the "
5024 : : "type is too large", "__builtin_bit_cast");
5025 : 0 : *non_constant_p = true;
5026 : 0 : return t;
5027 : : }
5028 : :
5029 : 906 : unsigned char buf[64];
5030 : 906 : unsigned char *ptr, *mask;
5031 : 906 : size_t alen = (size_t) len * 2;
5032 : 906 : if (alen <= sizeof (buf))
5033 : : ptr = buf;
5034 : : else
5035 : 3 : ptr = XNEWVEC (unsigned char, alen);
5036 : 906 : mask = ptr + (size_t) len;
5037 : : /* At the beginning consider everything indeterminate. */
5038 : 906 : memset (mask, ~0, (size_t) len);
5039 : :
5040 : 906 : if (native_encode_initializer (op, ptr, len, 0, mask) != len)
5041 : : {
5042 : 0 : if (!ctx->quiet)
5043 : 0 : sorry_at (loc, "%qs cannot be constant evaluated because the "
5044 : : "argument cannot be encoded", "__builtin_bit_cast");
5045 : 0 : *non_constant_p = true;
5046 : 0 : if (ptr != buf)
5047 : 0 : XDELETE (ptr);
5048 : 0 : return t;
5049 : : }
5050 : :
5051 : 906 : tree r = NULL_TREE;
5052 : 906 : if (can_native_interpret_type_p (TREE_TYPE (t)))
5053 : : {
5054 : 511 : r = native_interpret_expr (TREE_TYPE (t), ptr, len);
5055 : 511 : if (is_byte_access_type_not_plain_char (TREE_TYPE (t)))
5056 : : {
5057 : 46 : gcc_assert (len == 1);
5058 : 46 : if (mask[0])
5059 : : {
5060 : 24 : memset (mask, 0, len);
5061 : 24 : r = build_constructor (TREE_TYPE (r), NULL);
5062 : 24 : CONSTRUCTOR_NO_CLEARING (r) = 1;
5063 : : }
5064 : : }
5065 : : }
5066 : 395 : else if (TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE)
5067 : : {
5068 : 395 : r = native_interpret_aggregate (TREE_TYPE (t), ptr, 0, len);
5069 : 395 : if (r != NULL_TREE)
5070 : : {
5071 : 395 : clear_type_padding_in_mask (TREE_TYPE (t), mask);
5072 : 395 : clear_uchar_or_std_byte_in_mask (loc, r, mask);
5073 : 395 : if (CHECKING_P)
5074 : : {
5075 : 395 : tree e = cxx_eval_bare_aggregate (ctx, r, vc_prvalue,
5076 : : non_constant_p, overflow_p);
5077 : 395 : gcc_checking_assert (e == r);
5078 : : r = e;
5079 : : }
5080 : : }
5081 : : }
5082 : :
5083 : 906 : if (r != NULL_TREE)
5084 : : {
5085 : 7757 : for (int i = 0; i < len; i++)
5086 : 6941 : if (mask[i])
5087 : : {
5088 : 90 : if (!ctx->quiet)
5089 : 30 : error_at (loc, "%qs accessing uninitialized byte at offset %d",
5090 : : "__builtin_bit_cast", i);
5091 : 90 : *non_constant_p = true;
5092 : 90 : r = t;
5093 : 90 : break;
5094 : : }
5095 : 906 : if (ptr != buf)
5096 : 3 : XDELETE (ptr);
5097 : 906 : return r;
5098 : : }
5099 : :
5100 : 0 : if (!ctx->quiet)
5101 : 0 : sorry_at (loc, "%qs cannot be constant evaluated because the "
5102 : : "argument cannot be interpreted", "__builtin_bit_cast");
5103 : 0 : *non_constant_p = true;
5104 : 0 : if (ptr != buf)
5105 : 0 : XDELETE (ptr);
5106 : : return t;
5107 : : }
5108 : :
5109 : : /* Subroutine of cxx_eval_constant_expression.
5110 : : Evaluate a short-circuited logical expression T in the context
5111 : : of a given constexpr CALL. BAILOUT_VALUE is the value for
5112 : : early return. CONTINUE_VALUE is used here purely for
5113 : : sanity check purposes. */
5114 : :
5115 : : static tree
5116 : 9893710 : cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
5117 : : tree bailout_value, tree continue_value,
5118 : : bool *non_constant_p, bool *overflow_p)
5119 : : {
5120 : 9893710 : tree r;
5121 : 9893710 : tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
5122 : : vc_prvalue, non_constant_p,
5123 : : overflow_p);
5124 : 9893710 : VERIFY_CONSTANT (lhs);
5125 : 7336999 : if (tree_int_cst_equal (lhs, bailout_value))
5126 : : return lhs;
5127 : 6937846 : gcc_assert (tree_int_cst_equal (lhs, continue_value));
5128 : 6937846 : r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
5129 : : vc_prvalue, non_constant_p,
5130 : : overflow_p);
5131 : 6937846 : VERIFY_CONSTANT (r);
5132 : : return r;
5133 : : }
5134 : :
5135 : : /* REF is a COMPONENT_REF designating a particular field. V is a vector of
5136 : : CONSTRUCTOR elements to initialize (part of) an object containing that
5137 : : field. Return a pointer to the constructor_elt corresponding to the
5138 : : initialization of the field. */
5139 : :
5140 : : static constructor_elt *
5141 : 0 : base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
5142 : : {
5143 : 0 : tree aggr = TREE_OPERAND (ref, 0);
5144 : 0 : tree field = TREE_OPERAND (ref, 1);
5145 : 0 : HOST_WIDE_INT i;
5146 : 0 : constructor_elt *ce;
5147 : :
5148 : 0 : gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
5149 : :
5150 : 0 : if (TREE_CODE (aggr) == COMPONENT_REF)
5151 : : {
5152 : 0 : constructor_elt *base_ce
5153 : 0 : = base_field_constructor_elt (v, aggr);
5154 : 0 : v = CONSTRUCTOR_ELTS (base_ce->value);
5155 : : }
5156 : :
5157 : 0 : for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
5158 : 0 : if (ce->index == field)
5159 : 0 : return ce;
5160 : :
5161 : 0 : gcc_unreachable ();
5162 : : return NULL;
5163 : : }
5164 : :
5165 : : /* Some of the expressions fed to the constexpr mechanism are calls to
5166 : : constructors, which have type void. In that case, return the type being
5167 : : initialized by the constructor. */
5168 : :
5169 : : static tree
5170 : 354448352 : initialized_type (tree t)
5171 : : {
5172 : 355309779 : if (TYPE_P (t))
5173 : : return t;
5174 : 355309485 : tree type = TREE_TYPE (t);
5175 : 355309485 : if (TREE_CODE (t) == CALL_EXPR)
5176 : : {
5177 : : /* A constructor call has void type, so we need to look deeper. */
5178 : 38222704 : tree fn = get_function_named_in_call (t);
5179 : 38222679 : if (fn && TREE_CODE (fn) == FUNCTION_DECL
5180 : 76408229 : && DECL_CXX_CONSTRUCTOR_P (fn))
5181 : 2239760 : type = DECL_CONTEXT (fn);
5182 : : }
5183 : 317086781 : else if (TREE_CODE (t) == COMPOUND_EXPR)
5184 : 861427 : return initialized_type (TREE_OPERAND (t, 1));
5185 : 316225354 : else if (TREE_CODE (t) == AGGR_INIT_EXPR)
5186 : 403331 : type = TREE_TYPE (AGGR_INIT_EXPR_SLOT (t));
5187 : 354448058 : return cv_unqualified (type);
5188 : : }
5189 : :
5190 : : /* We're about to initialize element INDEX of an array or class from VALUE.
5191 : : Set up NEW_CTX appropriately by adjusting .object to refer to the
5192 : : subobject and creating a new CONSTRUCTOR if the element is itself
5193 : : a class or array. */
5194 : :
5195 : : static void
5196 : 1093629 : init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
5197 : : tree index, tree &value)
5198 : : {
5199 : 1093629 : new_ctx = *ctx;
5200 : :
5201 : 1093629 : if (index && TREE_CODE (index) != INTEGER_CST
5202 : 981468 : && TREE_CODE (index) != FIELD_DECL
5203 : 3 : && TREE_CODE (index) != RANGE_EXPR)
5204 : : /* This won't have an element in the new CONSTRUCTOR. */
5205 : : return;
5206 : :
5207 : 1093629 : tree type = initialized_type (value);
5208 : 1093629 : if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type))
5209 : : /* A non-aggregate member doesn't get its own CONSTRUCTOR. */
5210 : : return;
5211 : 559531 : if (VECTOR_TYPE_P (type)
5212 : 9073 : && VECTOR_TYPE_P (TREE_TYPE (ctx->ctor))
5213 : 559567 : && index == NULL_TREE)
5214 : : /* A vector inside of a vector CONSTRUCTOR, e.g. when a larger
5215 : : vector is constructed from smaller vectors, doesn't get its own
5216 : : CONSTRUCTOR either. */
5217 : : return;
5218 : :
5219 : : /* The sub-aggregate initializer might contain a placeholder;
5220 : : update object to refer to the subobject and ctor to refer to
5221 : : the (newly created) sub-initializer. */
5222 : 559495 : if (ctx->object)
5223 : : {
5224 : 396337 : if (index == NULL_TREE || TREE_CODE (index) == RANGE_EXPR)
5225 : : /* There's no well-defined subobject for this index. */
5226 : 3 : new_ctx.object = NULL_TREE;
5227 : : else
5228 : 396334 : new_ctx.object = build_ctor_subob_ref (index, type, ctx->object);
5229 : : }
5230 : :
5231 : 559495 : if (is_empty_class (type))
5232 : : /* Leave ctor null for an empty subobject, they aren't represented in the
5233 : : result of evaluation. */
5234 : 517168 : new_ctx.ctor = NULL_TREE;
5235 : : else
5236 : : {
5237 : 42327 : tree elt = build_constructor (type, NULL);
5238 : 42327 : CONSTRUCTOR_NO_CLEARING (elt) = true;
5239 : 42327 : new_ctx.ctor = elt;
5240 : : }
5241 : :
5242 : 559495 : if (TREE_CODE (value) == TARGET_EXPR)
5243 : : /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */
5244 : 23057 : value = TARGET_EXPR_INITIAL (value);
5245 : : }
5246 : :
5247 : : /* We're about to process an initializer for a class or array TYPE. Make
5248 : : sure that CTX is set up appropriately. */
5249 : :
5250 : : static void
5251 : 738676 : verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
5252 : : {
5253 : : /* We don't bother building a ctor for an empty base subobject. */
5254 : 738676 : if (is_empty_class (type))
5255 : : return;
5256 : :
5257 : : /* We're in the middle of an initializer that might involve placeholders;
5258 : : our caller should have created a CONSTRUCTOR for us to put the
5259 : : initializer into. We will either return that constructor or T. */
5260 : 223305 : gcc_assert (ctx->ctor);
5261 : 223305 : gcc_assert (same_type_ignoring_top_level_qualifiers_p
5262 : : (type, TREE_TYPE (ctx->ctor)));
5263 : : /* We used to check that ctx->ctor was empty, but that isn't the case when
5264 : : the object is zero-initialized before calling the constructor. */
5265 : 223305 : if (ctx->object)
5266 : : {
5267 : 112272 : tree otype = TREE_TYPE (ctx->object);
5268 : 112272 : gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, otype)
5269 : : /* Handle flexible array members. */
5270 : : || (TREE_CODE (otype) == ARRAY_TYPE
5271 : : && TYPE_DOMAIN (otype) == NULL_TREE
5272 : : && TREE_CODE (type) == ARRAY_TYPE
5273 : : && (same_type_ignoring_top_level_qualifiers_p
5274 : : (TREE_TYPE (type), TREE_TYPE (otype)))));
5275 : : }
5276 : 223305 : gcc_assert (!ctx->object || !DECL_P (ctx->object)
5277 : : || ctx->global->get_value (ctx->object) == ctx->ctor);
5278 : : }
5279 : :
5280 : : /* Subroutine of cxx_eval_constant_expression.
5281 : : The expression tree T denotes a C-style array or a C-style
5282 : : aggregate. Reduce it to a constant expression. */
5283 : :
5284 : : static tree
5285 : 738142 : cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
5286 : : value_cat lval,
5287 : : bool *non_constant_p, bool *overflow_p)
5288 : : {
5289 : 738142 : vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
5290 : 738142 : bool changed = false;
5291 : 738142 : gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
5292 : 738142 : tree type = TREE_TYPE (t);
5293 : :
5294 : 738142 : constexpr_ctx new_ctx;
5295 : 738142 : if (TYPE_PTRMEMFUNC_P (type) || VECTOR_TYPE_P (type))
5296 : : {
5297 : : /* We don't really need the ctx->ctor business for a PMF or
5298 : : vector, but it's simpler to use the same code. */
5299 : 24886 : new_ctx = *ctx;
5300 : 24886 : new_ctx.ctor = build_constructor (type, NULL);
5301 : 24886 : new_ctx.object = NULL_TREE;
5302 : 24886 : ctx = &new_ctx;
5303 : 738142 : };
5304 : 738142 : verify_ctor_sanity (ctx, type);
5305 : 738142 : vec<constructor_elt, va_gc> **p = nullptr;
5306 : 738142 : if (ctx->ctor)
5307 : : {
5308 : 738131 : p = &CONSTRUCTOR_ELTS (ctx->ctor);
5309 : 1476164 : vec_alloc (*p, vec_safe_length (v));
5310 : 738131 : if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (t))
5311 : 15900 : CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ctx->ctor) = 1;
5312 : : }
5313 : :
5314 : 738142 : unsigned i;
5315 : 738142 : tree index, value;
5316 : 738142 : bool constant_p = true;
5317 : 738142 : bool side_effects_p = false;
5318 : 1782583 : FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value)
5319 : : {
5320 : 1087654 : tree orig_value = value;
5321 : 1087654 : init_subob_ctx (ctx, new_ctx, index, value);
5322 : : /* Like in cxx_eval_store_expression, omit entries for empty fields. */
5323 : 1087654 : bool no_slot = new_ctx.ctor == NULL_TREE;
5324 : 1087654 : int pos_hint = -1;
5325 : 1087654 : if (new_ctx.ctor != ctx->ctor && !no_slot)
5326 : : {
5327 : : /* If we built a new CONSTRUCTOR, attach it now so that other
5328 : : initializers can refer to it. */
5329 : 36498 : constructor_elt *cep = get_or_insert_ctor_field (ctx->ctor, index);
5330 : 36498 : cep->value = new_ctx.ctor;
5331 : 36498 : pos_hint = cep - (*p)->begin();
5332 : 36498 : }
5333 : 1051156 : else if (TREE_CODE (type) == UNION_TYPE)
5334 : : /* Otherwise if we're constructing a non-aggregate union member, set
5335 : : the active union member now so that we can later detect and diagnose
5336 : : if its initializer attempts to activate another member. */
5337 : 933 : get_or_insert_ctor_field (ctx->ctor, index);
5338 : 1087654 : tree elt = cxx_eval_constant_expression (&new_ctx, value,
5339 : : lval,
5340 : : non_constant_p, overflow_p);
5341 : : /* Don't VERIFY_CONSTANT here. */
5342 : 1087654 : if (ctx->quiet && *non_constant_p)
5343 : : break;
5344 : 1044441 : if (elt != orig_value)
5345 : 107837 : changed = true;
5346 : :
5347 : 1044441 : if (!TREE_CONSTANT (elt))
5348 : 359306 : constant_p = false;
5349 : 1044441 : if (TREE_SIDE_EFFECTS (elt))
5350 : 24 : side_effects_p = true;
5351 : 1044441 : if (index && TREE_CODE (index) == COMPONENT_REF)
5352 : : {
5353 : : /* This is an initialization of a vfield inside a base
5354 : : subaggregate that we already initialized; push this
5355 : : initialization into the previous initialization. */
5356 : 0 : constructor_elt *inner = base_field_constructor_elt (*p, index);
5357 : 0 : inner->value = elt;
5358 : 0 : changed = true;
5359 : 0 : }
5360 : 1044441 : else if (no_slot)
5361 : : /* This is an initializer for an empty field; now that we've
5362 : : checked that it's constant, we can ignore it. */
5363 : : changed = true;
5364 : 527331 : else if (index
5365 : 527203 : && (TREE_CODE (index) == NOP_EXPR
5366 : 527203 : || TREE_CODE (index) == POINTER_PLUS_EXPR))
5367 : : {
5368 : : /* Old representation of empty bases. FIXME remove. */
5369 : 0 : gcc_checking_assert (false);
5370 : : gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index))));
5371 : : changed = true;
5372 : : }
5373 : : else
5374 : : {
5375 : 527331 : if (TREE_CODE (type) == UNION_TYPE
5376 : 527331 : && (*p)->last().index != index)
5377 : : /* The initializer erroneously changed the active union member that
5378 : : we're initializing. */
5379 : 8 : gcc_assert (*non_constant_p);
5380 : : else
5381 : : {
5382 : : /* The initializer might have mutated the underlying CONSTRUCTOR,
5383 : : so recompute the location of the target constructer_elt. */
5384 : 527323 : constructor_elt *cep
5385 : 527323 : = get_or_insert_ctor_field (ctx->ctor, index, pos_hint);
5386 : 527323 : cep->value = elt;
5387 : : }
5388 : :
5389 : : /* Adding or replacing an element might change the ctor's flags. */
5390 : 527331 : TREE_CONSTANT (ctx->ctor) = constant_p;
5391 : 527331 : TREE_SIDE_EFFECTS (ctx->ctor) = side_effects_p;
5392 : : }
5393 : : }
5394 : 738142 : if (*non_constant_p)
5395 : : return t;
5396 : 694896 : if (!changed)
5397 : : {
5398 : 120782 : if (VECTOR_TYPE_P (type))
5399 : 13908 : t = fold (t);
5400 : 120782 : return t;
5401 : : }
5402 : 574114 : t = ctx->ctor;
5403 : 574114 : if (!t)
5404 : 11 : t = build_constructor (type, NULL);
5405 : : /* We're done building this CONSTRUCTOR, so now we can interpret an
5406 : : element without an explicit initializer as value-initialized. */
5407 : 574114 : CONSTRUCTOR_NO_CLEARING (t) = false;
5408 : 574114 : TREE_CONSTANT (t) = constant_p;
5409 : 574114 : TREE_SIDE_EFFECTS (t) = side_effects_p;
5410 : 574114 : if (VECTOR_TYPE_P (type))
5411 : 1081 : t = fold (t);
5412 : : return t;
5413 : : }
5414 : :
5415 : : /* Subroutine of cxx_eval_constant_expression.
5416 : : The expression tree T is a VEC_INIT_EXPR which denotes the desired
5417 : : initialization of a non-static data member of array type. Reduce it to a
5418 : : CONSTRUCTOR.
5419 : :
5420 : : Note that apart from value-initialization (when VALUE_INIT is true),
5421 : : this is only intended to support value-initialization and the
5422 : : initializations done by defaulted constructors for classes with
5423 : : non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
5424 : : will either be NULL_TREE for the default constructor, or a COMPONENT_REF
5425 : : for the copy/move constructor. */
5426 : :
5427 : : static tree
5428 : 534 : cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
5429 : : bool value_init, value_cat lval,
5430 : : bool *non_constant_p, bool *overflow_p)
5431 : : {
5432 : 534 : tree elttype = TREE_TYPE (atype);
5433 : 534 : verify_ctor_sanity (ctx, atype);
5434 : 534 : vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
5435 : 534 : bool pre_init = false;
5436 : 534 : unsigned HOST_WIDE_INT i;
5437 : 534 : tsubst_flags_t complain = ctx->quiet ? tf_none : tf_warning_or_error;
5438 : :
5439 : 534 : if (init && TREE_CODE (init) == CONSTRUCTOR)
5440 : 0 : return cxx_eval_bare_aggregate (ctx, init, lval,
5441 : 0 : non_constant_p, overflow_p);
5442 : :
5443 : : /* For the default constructor, build up a call to the default
5444 : : constructor of the element type. We only need to handle class types
5445 : : here, as for a constructor to be constexpr, all members must be
5446 : : initialized, which for a defaulted default constructor means they must
5447 : : be of a class type with a constexpr default constructor. */
5448 : 534 : if (TREE_CODE (elttype) == ARRAY_TYPE)
5449 : : /* We only do this at the lowest level. */;
5450 : 491 : else if (value_init)
5451 : : {
5452 : 136 : init = build_value_init (elttype, complain);
5453 : 136 : pre_init = true;
5454 : : }
5455 : 355 : else if (!init)
5456 : : {
5457 : 307 : releasing_vec argvec;
5458 : 307 : init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
5459 : : &argvec, elttype, LOOKUP_NORMAL,
5460 : : complain);
5461 : 307 : init = build_aggr_init_expr (elttype, init);
5462 : 307 : pre_init = true;
5463 : 307 : }
5464 : :
5465 : 534 : bool zeroed_out = false;
5466 : 534 : if (!CONSTRUCTOR_NO_CLEARING (ctx->ctor))
5467 : : {
5468 : : /* We're initializing an array object that had been zero-initialized
5469 : : earlier. Truncate ctx->ctor, and propagate its zeroed state by
5470 : : clearing CONSTRUCTOR_NO_CLEARING on each of the aggregate element
5471 : : initializers we append to it. */
5472 : 156 : gcc_checking_assert (initializer_zerop (ctx->ctor));
5473 : 156 : zeroed_out = true;
5474 : 156 : vec_safe_truncate (*p, 0);
5475 : : }
5476 : :
5477 : 534 : tree nelts = get_array_or_vector_nelts (ctx, atype, non_constant_p,
5478 : : overflow_p);
5479 : 534 : unsigned HOST_WIDE_INT max = tree_to_uhwi (nelts);
5480 : 6178 : for (i = 0; i < max; ++i)
5481 : : {
5482 : 5975 : tree idx = build_int_cst (size_type_node, i);
5483 : 5975 : tree eltinit;
5484 : 5975 : bool reuse = false;
5485 : 5975 : constexpr_ctx new_ctx;
5486 : 6269 : init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype);
5487 : 5975 : bool no_slot = new_ctx.ctor == NULL_TREE;
5488 : 5975 : if (new_ctx.ctor != ctx->ctor && !no_slot)
5489 : : {
5490 : 5829 : if (zeroed_out)
5491 : 5445 : CONSTRUCTOR_NO_CLEARING (new_ctx.ctor) = false;
5492 : 5829 : CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor);
5493 : : }
5494 : 5975 : if (TREE_CODE (elttype) == ARRAY_TYPE)
5495 : : {
5496 : : /* A multidimensional array; recurse. */
5497 : 175 : if (value_init || init == NULL_TREE)
5498 : : {
5499 : 167 : eltinit = NULL_TREE;
5500 : 167 : reuse = i == 0;
5501 : : }
5502 : : else
5503 : 8 : eltinit = cp_build_array_ref (input_location, init, idx, complain);
5504 : 175 : eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
5505 : : lval,
5506 : : non_constant_p, overflow_p);
5507 : : }
5508 : 5800 : else if (pre_init)
5509 : : {
5510 : : /* Initializing an element using value or default initialization
5511 : : we just pre-built above. */
5512 : 5681 : if (init == void_node)
5513 : : /* Trivial default-init, don't do anything to the CONSTRUCTOR. */
5514 : 3 : return ctx->ctor;
5515 : 5678 : eltinit = cxx_eval_constant_expression (&new_ctx, init, lval,
5516 : : non_constant_p, overflow_p);
5517 : 5678 : reuse = i == 0;
5518 : : }
5519 : : else
5520 : : {
5521 : : /* Copying an element. */
5522 : 119 : eltinit = cp_build_array_ref (input_location, init, idx, complain);
5523 : 119 : if (!lvalue_p (init))
5524 : 95 : eltinit = move (eltinit);
5525 : 119 : eltinit = (perform_implicit_conversion_flags
5526 : 119 : (elttype, eltinit, complain,
5527 : : LOOKUP_IMPLICIT|LOOKUP_NO_NARROWING));
5528 : 119 : eltinit = cxx_eval_constant_expression (&new_ctx, eltinit, lval,
5529 : : non_constant_p, overflow_p);
5530 : : }
5531 : 5972 : if (*non_constant_p)
5532 : : break;
5533 : 5902 : if (no_slot)
5534 : : {
5535 : : /* This is an initializer for an empty subobject; now that we've
5536 : : checked that it's constant, we can ignore it. */
5537 : 15 : gcc_checking_assert (i == 0);
5538 : : break;
5539 : : }
5540 : 5887 : else if (new_ctx.ctor != ctx->ctor)
5541 : : {
5542 : : /* We appended this element above; update the value. */
5543 : 5775 : gcc_assert ((*p)->last().index == idx);
5544 : 5775 : (*p)->last().value = eltinit;
5545 : : }
5546 : : else
5547 : 112 : CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit);
5548 : : /* Reuse the result of cxx_eval_constant_expression call
5549 : : from the first iteration to all others if it is a constant
5550 : : initializer that doesn't require relocations. */
5551 : 5887 : if (reuse
5552 : 5887 : && max > 1
5553 : 5887 : && (eltinit == NULL_TREE
5554 : 399 : || (initializer_constant_valid_p (eltinit, TREE_TYPE (eltinit))
5555 : 399 : == null_pointer_node)))
5556 : : {
5557 : 243 : if (new_ctx.ctor != ctx->ctor)
5558 : 137 : eltinit = new_ctx.ctor;
5559 : 243 : tree range = build2 (RANGE_EXPR, size_type_node,
5560 : 243 : build_int_cst (size_type_node, 1),
5561 : 243 : build_int_cst (size_type_node, max - 1));
5562 : 243 : CONSTRUCTOR_APPEND_ELT (*p, range, unshare_constructor (eltinit));
5563 : 243 : break;
5564 : : }
5565 : 5644 : else if (i == 0)
5566 : 200 : vec_safe_reserve (*p, max);
5567 : : }
5568 : :
5569 : 531 : if (!*non_constant_p)
5570 : : {
5571 : 461 : init = ctx->ctor;
5572 : 461 : CONSTRUCTOR_NO_CLEARING (init) = false;
5573 : : }
5574 : 531 : return init;
5575 : : }
5576 : :
5577 : : static tree
5578 : 445 : cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
5579 : : value_cat lval,
5580 : : bool *non_constant_p, bool *overflow_p)
5581 : : {
5582 : 445 : tree atype = TREE_TYPE (t);
5583 : 445 : tree init = VEC_INIT_EXPR_INIT (t);
5584 : 445 : bool value_init = VEC_INIT_EXPR_VALUE_INIT (t);
5585 : 445 : if (!init || !BRACE_ENCLOSED_INITIALIZER_P (init))
5586 : : ;
5587 : 95 : else if (CONSTRUCTOR_NELTS (init) == 0
5588 : 95 : && !CP_AGGREGATE_TYPE_P (strip_array_types (atype)))
5589 : : {
5590 : : /* Handle {} as value-init. */
5591 : : init = NULL_TREE;
5592 : : value_init = true;
5593 : : }
5594 : : else
5595 : : {
5596 : : /* This is a more complicated case, like needing to loop over trailing
5597 : : elements; call build_vec_init and evaluate the result. */
5598 : 86 : tsubst_flags_t complain = ctx->quiet ? tf_none : tf_warning_or_error;
5599 : 86 : constexpr_ctx new_ctx = *ctx;
5600 : 86 : if (!ctx->object)
5601 : : {
5602 : : /* We want to have an initialization target for an VEC_INIT_EXPR.
5603 : : If we don't already have one in CTX, use the VEC_INIT_EXPR_SLOT. */
5604 : 59 : new_ctx.object = VEC_INIT_EXPR_SLOT (t);
5605 : 59 : tree ctor = new_ctx.ctor = build_constructor (atype, NULL);
5606 : 59 : CONSTRUCTOR_NO_CLEARING (ctor) = true;
5607 : 59 : ctx->global->put_value (new_ctx.object, ctor);
5608 : 59 : ctx = &new_ctx;
5609 : : }
5610 : 86 : init = expand_vec_init_expr (ctx->object, t, complain);
5611 : 86 : return cxx_eval_constant_expression (ctx, init, lval, non_constant_p,
5612 : : overflow_p);
5613 : : }
5614 : 359 : tree r = cxx_eval_vec_init_1 (ctx, atype, init, value_init,
5615 : : lval, non_constant_p, overflow_p);
5616 : 359 : if (*non_constant_p)
5617 : : return t;
5618 : : else
5619 : 308 : return r;
5620 : : }
5621 : :
5622 : : /* Like same_type_ignoring_top_level_qualifiers_p, but also handle the case
5623 : : where the desired type is an array of unknown bounds because the variable
5624 : : has had its bounds deduced since the wrapping expression was created. */
5625 : :
5626 : : static bool
5627 : 141204701 : same_type_ignoring_tlq_and_bounds_p (tree type1, tree type2)
5628 : : {
5629 : 141204701 : while (TREE_CODE (type1) == ARRAY_TYPE
5630 : 13322 : && TREE_CODE (type2) == ARRAY_TYPE
5631 : 141204705 : && (!TYPE_DOMAIN (type1) || !TYPE_DOMAIN (type2)))
5632 : : {
5633 : 2 : type1 = TREE_TYPE (type1);
5634 : 2 : type2 = TREE_TYPE (type2);
5635 : : }
5636 : 141204701 : return same_type_ignoring_top_level_qualifiers_p (type1, type2);
5637 : : }
5638 : :
5639 : : /* Try to determine the currently active union member for an expression
5640 : : with UNION_TYPE. If it can be determined, return the FIELD_DECL,
5641 : : otherwise return NULL_TREE. */
5642 : :
5643 : : static tree
5644 : 30 : cxx_union_active_member (const constexpr_ctx *ctx, tree t)
5645 : : {
5646 : 30 : constexpr_ctx new_ctx = *ctx;
5647 : 30 : new_ctx.quiet = true;
5648 : 30 : bool non_constant_p = false, overflow_p = false;
5649 : 30 : tree ctor = cxx_eval_constant_expression (&new_ctx, t, vc_prvalue,
5650 : : &non_constant_p,
5651 : : &overflow_p);
5652 : 30 : if (TREE_CODE (ctor) == CONSTRUCTOR
5653 : 12 : && CONSTRUCTOR_NELTS (ctor) == 1
5654 : 12 : && CONSTRUCTOR_ELT (ctor, 0)->index
5655 : 42 : && TREE_CODE (CONSTRUCTOR_ELT (ctor, 0)->index) == FIELD_DECL)
5656 : : return CONSTRUCTOR_ELT (ctor, 0)->index;
5657 : : return NULL_TREE;
5658 : : }
5659 : :
5660 : : /* Helper function for cxx_fold_indirect_ref_1, called recursively. */
5661 : :
5662 : : static tree
5663 : 3778730 : cxx_fold_indirect_ref_1 (const constexpr_ctx *ctx, location_t loc, tree type,
5664 : : tree op, unsigned HOST_WIDE_INT off, bool *empty_base)
5665 : : {
5666 : 4986724 : tree optype = TREE_TYPE (op);
5667 : 4986724 : unsigned HOST_WIDE_INT const_nunits;
5668 : 4986724 : if (off == 0 && similar_type_p (optype, type))
5669 : : return op;
5670 : 3777222 : else if (TREE_CODE (optype) == COMPLEX_TYPE
5671 : 3777222 : && similar_type_p (type, TREE_TYPE (optype)))
5672 : : {
5673 : : /* *(foo *)&complexfoo => __real__ complexfoo */
5674 : 0 : if (off == 0)
5675 : 0 : return build1_loc (loc, REALPART_EXPR, type, op);
5676 : : /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
5677 : 0 : else if (tree_to_uhwi (TYPE_SIZE_UNIT (type)) == off)
5678 : 0 : return build1_loc (loc, IMAGPART_EXPR, type, op);
5679 : : }
5680 : : /* ((foo*)&vectorfoo)[x] => BIT_FIELD_REF<vectorfoo,...> */
5681 : 3777222 : else if (VECTOR_TYPE_P (optype)
5682 : 0 : && similar_type_p (type, TREE_TYPE (optype))
5683 : 3777222 : && TYPE_VECTOR_SUBPARTS (optype).is_constant (&const_nunits))
5684 : : {
5685 : 0 : unsigned HOST_WIDE_INT part_width = tree_to_uhwi (TYPE_SIZE_UNIT (type));
5686 : 0 : unsigned HOST_WIDE_INT max_offset = part_width * const_nunits;
5687 : 0 : if (off < max_offset && off % part_width == 0)
5688 : : {
5689 : 0 : tree index = bitsize_int (off * BITS_PER_UNIT);
5690 : 0 : return build3_loc (loc, BIT_FIELD_REF, type, op,
5691 : 0 : TYPE_SIZE (type), index);
5692 : : }
5693 : : }
5694 : : /* ((foo *)&fooarray)[x] => fooarray[x] */
5695 : 3777222 : else if (TREE_CODE (optype) == ARRAY_TYPE
5696 : 1207994 : && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (optype)))
5697 : 4985216 : && !integer_zerop (TYPE_SIZE_UNIT (TREE_TYPE (optype))))
5698 : : {
5699 : 1207994 : tree type_domain = TYPE_DOMAIN (optype);
5700 : 1207994 : tree min_val = size_zero_node;
5701 : 1207994 : if (type_domain && TYPE_MIN_VALUE (type_domain))
5702 : 1207987 : min_val = TYPE_MIN_VALUE (type_domain);
5703 : 1207994 : unsigned HOST_WIDE_INT el_sz
5704 : 1207994 : = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (optype)));
5705 : 1207994 : unsigned HOST_WIDE_INT idx = off / el_sz;
5706 : 1207994 : unsigned HOST_WIDE_INT rem = off % el_sz;
5707 : 1207994 : if (tree_fits_uhwi_p (min_val))
5708 : : {
5709 : 1207994 : tree index = size_int (idx + tree_to_uhwi (min_val));
5710 : 1207994 : op = build4_loc (loc, ARRAY_REF, TREE_TYPE (optype), op, index,
5711 : : NULL_TREE, NULL_TREE);
5712 : 1207994 : return cxx_fold_indirect_ref_1 (ctx, loc, type, op, rem,
5713 : 1207994 : empty_base);
5714 : : }
5715 : : }
5716 : : /* ((foo *)&struct_with_foo_field)[x] => COMPONENT_REF */
5717 : 2569228 : else if (TREE_CODE (optype) == RECORD_TYPE
5718 : 2569228 : || TREE_CODE (optype) == UNION_TYPE)
5719 : : {
5720 : 2566308 : if (TREE_CODE (optype) == UNION_TYPE)
5721 : : /* For unions prefer the currently active member. */
5722 : 30 : if (tree field = cxx_union_active_member (ctx, op))
5723 : : {
5724 : 12 : unsigned HOST_WIDE_INT el_sz
5725 : 12 : = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (field)));
5726 : 12 : if (off < el_sz)
5727 : : {
5728 : 12 : tree cop = build3 (COMPONENT_REF, TREE_TYPE (field),
5729 : : op, field, NULL_TREE);
5730 : 12 : if (tree ret = cxx_fold_indirect_ref_1 (ctx, loc, type, cop,
5731 : : off, empty_base))
5732 : : return ret;
5733 : : }
5734 : : }
5735 : :
5736 : : /* Handle conversion to "as base" type. */
5737 : 2566302 : if (CLASS_TYPE_P (optype)
5738 : 5132528 : && CLASSTYPE_AS_BASE (optype) == type)
5739 : : return op;
5740 : :
5741 : : /* Handle conversion to an empty base class, which is represented with a
5742 : : NOP_EXPR. Do this before spelunking into the non-empty subobjects,
5743 : : which is likely to be a waste of time (109678). */
5744 : 2565773 : if (is_empty_class (type)
5745 : 2554470 : && CLASS_TYPE_P (optype)
5746 : 5120243 : && lookup_base (optype, type, ba_any, NULL, tf_none, off))
5747 : : {
5748 : 1441374 : if (empty_base)
5749 : 1441374 : *empty_base = true;
5750 : 1441374 : return op;
5751 : : }
5752 : :
5753 : 1124399 : for (tree field = TYPE_FIELDS (optype);
5754 : 15273416 : field; field = DECL_CHAIN (field))
5755 : 15270148 : if (TREE_CODE (field) == FIELD_DECL
5756 : 1124788 : && TREE_TYPE (field) != error_mark_node
5757 : 16394936 : && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (field))))
5758 : : {
5759 : 1124788 : tree pos = byte_position (field);
5760 : 1124788 : if (!tree_fits_uhwi_p (pos))
5761 : 0 : continue;
5762 : 1124788 : unsigned HOST_WIDE_INT upos = tree_to_uhwi (pos);
5763 : 1124788 : unsigned HOST_WIDE_INT el_sz
5764 : 1124788 : = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (field)));
5765 : 1124788 : if (upos <= off && off < upos + el_sz)
5766 : : {
5767 : 1124326 : tree cop = build3 (COMPONENT_REF, TREE_TYPE (field),
5768 : : op, field, NULL_TREE);
5769 : 1124326 : if (tree ret = cxx_fold_indirect_ref_1 (ctx, loc, type, cop,
5770 : : off - upos,
5771 : : empty_base))
5772 : 1121131 : return ret;
5773 : : }
5774 : : }
5775 : : }
5776 : :
5777 : : return NULL_TREE;
5778 : : }
5779 : :
5780 : : /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
5781 : : match. We want to be less strict for simple *& folding; if we have a
5782 : : non-const temporary that we access through a const pointer, that should
5783 : : work. We handle this here rather than change fold_indirect_ref_1
5784 : : because we're dealing with things like ADDR_EXPR of INTEGER_CST which
5785 : : don't really make sense outside of constant expression evaluation. Also
5786 : : we want to allow folding to COMPONENT_REF, which could cause trouble
5787 : : with TBAA in fold_indirect_ref_1. */
5788 : :
5789 : : static tree
5790 : 66637002 : cxx_fold_indirect_ref (const constexpr_ctx *ctx, location_t loc, tree type,
5791 : : tree op0, bool *empty_base /* = NULL*/)
5792 : : {
5793 : 66637002 : tree sub = op0;
5794 : 66637002 : tree subtype;
5795 : :
5796 : : /* STRIP_NOPS, but stop if REINTERPRET_CAST_P. */
5797 : 137287582 : while (CONVERT_EXPR_P (sub) || TREE_CODE (sub) == NON_LVALUE_EXPR
5798 : 184247740 : || TREE_CODE (sub) == VIEW_CONVERT_EXPR)
5799 : : {
5800 : 49602743 : if (TREE_CODE (sub) == NOP_EXPR
5801 : 49602743 : && REINTERPRET_CAST_P (sub))
5802 : : return NULL_TREE;
5803 : 49568527 : sub = TREE_OPERAND (sub, 0);
5804 : : }
5805 : :
5806 : 66602786 : subtype = TREE_TYPE (sub);
5807 : 66602786 : if (!INDIRECT_TYPE_P (subtype))
5808 : : return NULL_TREE;
5809 : :
5810 : : /* Canonicalizes the given OBJ/OFF pair by iteratively absorbing
5811 : : the innermost component into the offset until it would make the
5812 : : offset positive, so that cxx_fold_indirect_ref_1 can identify
5813 : : more folding opportunities. */
5814 : 69257059 : auto canonicalize_obj_off = [] (tree& obj, tree& off) {
5815 : 2654392 : while (TREE_CODE (obj) == COMPONENT_REF
5816 : : /* We need to preserve union member accesses so that we can
5817 : : later properly diagnose accessing the wrong member. */
5818 : 2271582 : && TREE_CODE (TREE_TYPE (TREE_OPERAND (obj, 0))) == RECORD_TYPE
5819 : 6463858 : && (tree_int_cst_sign_bit (off) || integer_zerop (off)))
5820 : : {
5821 : 1619602 : tree field = TREE_OPERAND (obj, 1);
5822 : 1619602 : tree pos = byte_position (field);
5823 : 1619602 : if (integer_zerop (off) && integer_nonzerop (pos))
5824 : : /* If the offset is already 0, keep going as long as the
5825 : : component is at position 0. */
5826 : : break;
5827 : 1617367 : off = int_const_binop (PLUS_EXPR, off, pos);
5828 : 1617367 : obj = TREE_OPERAND (obj, 0);
5829 : : }
5830 : 2654392 : };
5831 : :
5832 : 66602667 : if (TREE_CODE (sub) == ADDR_EXPR)
5833 : : {
5834 : 19110126 : tree op = TREE_OPERAND (sub, 0);
5835 : 19110126 : tree optype = TREE_TYPE (op);
5836 : :
5837 : : /* *&CONST_DECL -> to the value of the const decl. */
5838 : 19110126 : if (TREE_CODE (op) == CONST_DECL)
5839 : 0 : return DECL_INITIAL (op);
5840 : : /* *&p => p; make sure to handle *&"str"[cst] here. */
5841 : 19110126 : if (similar_type_p (optype, type))
5842 : : {
5843 : 17465946 : tree fop = fold_read_from_constant_string (op);
5844 : 17465946 : if (fop)
5845 : : return fop;
5846 : : else
5847 : 17453984 : return op;
5848 : : }
5849 : : else
5850 : : {
5851 : 1644180 : tree off = integer_zero_node;
5852 : 1644180 : canonicalize_obj_off (op, off);
5853 : 1644180 : gcc_assert (integer_zerop (off));
5854 : 1644180 : return cxx_fold_indirect_ref_1 (ctx, loc, type, op, 0, empty_base);
5855 : : }
5856 : : }
5857 : 47492541 : else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
5858 : 47492541 : && tree_fits_uhwi_p (TREE_OPERAND (sub, 1)))
5859 : : {
5860 : 1105881 : tree op00 = TREE_OPERAND (sub, 0);
5861 : 1105881 : tree off = TREE_OPERAND (sub, 1);
5862 : :
5863 : 1105881 : STRIP_NOPS (op00);
5864 : 1105881 : if (TREE_CODE (op00) == ADDR_EXPR)
5865 : : {
5866 : 1010212 : tree obj = TREE_OPERAND (op00, 0);
5867 : 1010212 : canonicalize_obj_off (obj, off);
5868 : 1010212 : return cxx_fold_indirect_ref_1 (ctx, loc, type, obj,
5869 : : tree_to_uhwi (off), empty_base);
5870 : : }
5871 : : }
5872 : : /* *(foo *)fooarrptr => (*fooarrptr)[0] */
5873 : 46386660 : else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
5874 : 46386660 : && similar_type_p (type, TREE_TYPE (TREE_TYPE (subtype))))
5875 : : {
5876 : 349 : tree type_domain;
5877 : 349 : tree min_val = size_zero_node;
5878 : 349 : tree newsub
5879 : 349 : = cxx_fold_indirect_ref (ctx, loc, TREE_TYPE (subtype), sub, NULL);
5880 : 349 : if (newsub)
5881 : : sub = newsub;
5882 : : else
5883 : 349 : sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
5884 : 349 : type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
5885 : 349 : if (type_domain && TYPE_MIN_VALUE (type_domain))
5886 : 349 : min_val = TYPE_MIN_VALUE (type_domain);
5887 : 349 : return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
5888 : 349 : NULL_TREE);
5889 : : }
5890 : :
5891 : : return NULL_TREE;
5892 : : }
5893 : :
5894 : : static tree
5895 : 31584367 : cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
5896 : : value_cat lval,
5897 : : bool *non_constant_p, bool *overflow_p)
5898 : : {
5899 : 31584367 : tree orig_op0 = TREE_OPERAND (t, 0);
5900 : 31584367 : bool empty_base = false;
5901 : :
5902 : : /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second
5903 : : operand is an integer-zero. Otherwise reject the MEM_REF for now. */
5904 : :
5905 : 31584367 : if (TREE_CODE (t) == MEM_REF
5906 : 31584367 : && (!TREE_OPERAND (t, 1) || !integer_zerop (TREE_OPERAND (t, 1))))
5907 : : {
5908 : 9 : gcc_assert (ctx->quiet);
5909 : 9 : *non_constant_p = true;
5910 : 9 : return t;
5911 : : }
5912 : :
5913 : : /* First try to simplify it directly. */
5914 : 31584358 : tree r = cxx_fold_indirect_ref (ctx, EXPR_LOCATION (t), TREE_TYPE (t),
5915 : : orig_op0, &empty_base);
5916 : 31584358 : if (!r)
5917 : : {
5918 : : /* If that didn't work, evaluate the operand first. */
5919 : 30994059 : tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
5920 : : vc_prvalue, non_constant_p,
5921 : : overflow_p);
5922 : : /* Don't VERIFY_CONSTANT here. */
5923 : 30994059 : if (*non_constant_p)
5924 : : return t;
5925 : :
5926 : 29480435 : if (!lval && integer_zerop (op0))
5927 : : {
5928 : 68 : if (!ctx->quiet)
5929 : 12 : error ("dereferencing a null pointer");
5930 : 68 : *non_constant_p = true;
5931 : 68 : return t;
5932 : : }
5933 : :
5934 : 29480367 : r = cxx_fold_indirect_ref (ctx, EXPR_LOCATION (t), TREE_TYPE (t), op0,
5935 : : &empty_base);
5936 : 29480367 : if (r == NULL_TREE)
5937 : : {
5938 : : /* We couldn't fold to a constant value. Make sure it's not
5939 : : something we should have been able to fold. */
5940 : 15176501 : tree sub = op0;
5941 : 15176501 : STRIP_NOPS (sub);
5942 : 15176501 : if (TREE_CODE (sub) == ADDR_EXPR)
5943 : : {
5944 : 1422 : gcc_assert (!similar_type_p
5945 : : (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
5946 : : /* DR 1188 says we don't have to deal with this. */
5947 : 1422 : if (!ctx->quiet)
5948 : 5 : error_at (cp_expr_loc_or_input_loc (t),
5949 : : "accessing value of %qE through a %qT glvalue in a "
5950 : : "constant expression", build_fold_indirect_ref (sub),
5951 : 4 : TREE_TYPE (t));
5952 : 1422 : *non_constant_p = true;
5953 : 1422 : return t;
5954 : : }
5955 : :
5956 : 15175079 : if (lval == vc_glvalue && op0 != orig_op0)
5957 : 1782916 : return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
5958 : 13392163 : if (!lval)
5959 : 7917048 : VERIFY_CONSTANT (t);
5960 : 13392163 : return t;
5961 : : }
5962 : : }
5963 : :
5964 : 14894165 : r = cxx_eval_constant_expression (ctx, r,
5965 : : lval, non_constant_p, overflow_p);
5966 : 14894165 : if (*non_constant_p)
5967 : : return t;
5968 : :
5969 : : /* If we're pulling out the value of an empty base, just return an empty
5970 : : CONSTRUCTOR. */
5971 : 10535370 : if (empty_base && !lval)
5972 : : {
5973 : 13909 : r = build_constructor (TREE_TYPE (t), NULL);
5974 : 13909 : TREE_CONSTANT (r) = true;
5975 : : }
5976 : :
5977 : : return r;
5978 : : }
5979 : :
5980 : : /* Complain about R, a DECL that is accessed outside its lifetime. */
5981 : :
5982 : : static void
5983 : 34 : outside_lifetime_error (location_t loc, tree r)
5984 : : {
5985 : 34 : auto_diagnostic_group d;
5986 : 34 : if (DECL_NAME (r) == heap_deleted_identifier)
5987 : : {
5988 : : /* Provide a more accurate message for deleted variables. */
5989 : 6 : error_at (loc, "use of allocated storage after deallocation "
5990 : : "in a constant expression");
5991 : 6 : inform (DECL_SOURCE_LOCATION (r), "allocated here");
5992 : : }
5993 : : else
5994 : : {
5995 : 28 : error_at (loc, "accessing %qE outside its lifetime", r);
5996 : 28 : inform (DECL_SOURCE_LOCATION (r), "declared here");
5997 : : }
5998 : 34 : }
5999 : :
6000 : : /* Complain about R, a VAR_DECL, not being usable in a constant expression.
6001 : : FUNDEF_P is true if we're checking a constexpr function body.
6002 : : Shared between potential_constant_expression and
6003 : : cxx_eval_constant_expression. */
6004 : :
6005 : : static void
6006 : 290 : non_const_var_error (location_t loc, tree r, bool fundef_p)
6007 : : {
6008 : 290 : auto_diagnostic_group d;
6009 : 290 : tree type = TREE_TYPE (r);
6010 : 290 : if (DECL_NAME (r) == heap_uninit_identifier
6011 : 290 : || DECL_NAME (r) == heap_identifier
6012 : 287 : || DECL_NAME (r) == heap_vec_uninit_identifier
6013 : 577 : || DECL_NAME (r) == heap_vec_identifier)
6014 : : {
6015 : 3 : if (constexpr_error (loc, fundef_p, "the content of uninitialized "
6016 : : "storage is not usable in a constant expression"))
6017 : 3 : inform (DECL_SOURCE_LOCATION (r), "allocated here");
6018 : 3 : return;
6019 : : }
6020 : 287 : if (DECL_NAME (r) == heap_deleted_identifier)
6021 : : {
6022 : 0 : if (constexpr_error (loc, fundef_p, "use of allocated storage after "
6023 : : "deallocation in a constant expression"))
6024 : 0 : inform (DECL_SOURCE_LOCATION (r), "allocated here");
6025 : 0 : return;
6026 : : }
6027 : 287 : if (!constexpr_error (loc, fundef_p, "the value of %qD is not usable in "
6028 : : "a constant expression", r))
6029 : : return;
6030 : : /* Avoid error cascade. */
6031 : 286 : if (DECL_INITIAL (r) == error_mark_node)
6032 : : return;
6033 : 272 : if (DECL_DECLARED_CONSTEXPR_P (r))
6034 : 3 : inform (DECL_SOURCE_LOCATION (r),
6035 : : "%qD used in its own initializer", r);
6036 : 269 : else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
6037 : : {
6038 : 212 : if (!CP_TYPE_CONST_P (type))
6039 : 183 : inform (DECL_SOURCE_LOCATION (r),
6040 : : "%q#D is not const", r);
6041 : 29 : else if (CP_TYPE_VOLATILE_P (type))
6042 : 0 : inform (DECL_SOURCE_LOCATION (r),
6043 : : "%q#D is volatile", r);
6044 : 29 : else if (!DECL_INITIAL (r)
6045 : 9 : || !TREE_CONSTANT (DECL_INITIAL (r))
6046 : 37 : || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r))
6047 : 29 : inform (DECL_SOURCE_LOCATION (r),
6048 : : "%qD was not initialized with a constant "
6049 : : "expression", r);
6050 : : else
6051 : 0 : gcc_unreachable ();
6052 : : }
6053 : 57 : else if (TYPE_REF_P (type))
6054 : 9 : inform (DECL_SOURCE_LOCATION (r),
6055 : : "%qD was not initialized with a constant "
6056 : : "expression", r);
6057 : : else
6058 : : {
6059 : 48 : if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
6060 : 48 : inform (DECL_SOURCE_LOCATION (r),
6061 : : "%qD was not declared %<constexpr%>", r);
6062 : : else
6063 : 0 : inform (DECL_SOURCE_LOCATION (r),
6064 : : "%qD does not have integral or enumeration type",
6065 : : r);
6066 : : }
6067 : 290 : }
6068 : :
6069 : : /* Subroutine of cxx_eval_constant_expression.
6070 : : Like cxx_eval_unary_expression, except for trinary expressions. */
6071 : :
6072 : : static tree
6073 : 16 : cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
6074 : : value_cat lval,
6075 : : bool *non_constant_p, bool *overflow_p)
6076 : : {
6077 : 16 : int i;
6078 : 16 : tree args[3];
6079 : 16 : tree val;
6080 : :
6081 : 37 : for (i = 0; i < 3; i++)
6082 : : {
6083 : 30 : args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
6084 : : lval,
6085 : : non_constant_p, overflow_p);
6086 : 30 : VERIFY_CONSTANT (args[i]);
6087 : : }
6088 : :
6089 : 7 : val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
6090 : : args[0], args[1], args[2]);
6091 : 7 : if (val == NULL_TREE)
6092 : : return t;
6093 : 7 : VERIFY_CONSTANT (val);
6094 : : return val;
6095 : : }
6096 : :
6097 : : /* True if T was declared in a function declared to be constexpr, and
6098 : : therefore potentially constant in C++14. */
6099 : :
6100 : : bool
6101 : 74560681 : var_in_constexpr_fn (tree t)
6102 : : {
6103 : 74560681 : tree ctx = DECL_CONTEXT (t);
6104 : 74560681 : return (ctx && TREE_CODE (ctx) == FUNCTION_DECL
6105 : 141708735 : && DECL_DECLARED_CONSTEXPR_P (ctx));
6106 : : }
6107 : :
6108 : : /* True if a function might be constexpr: either a function that was
6109 : : declared constexpr, or a C++17 lambda op(). */
6110 : :
6111 : : bool
6112 : 343869296 : maybe_constexpr_fn (tree t)
6113 : : {
6114 : 343869296 : return (DECL_DECLARED_CONSTEXPR_P (t)
6115 : 144025295 : || (cxx_dialect >= cxx17 && LAMBDA_FUNCTION_P (t))
6116 : 486591611 : || (flag_implicit_constexpr
6117 : 23 : && DECL_DECLARED_INLINE_P (STRIP_TEMPLATE (t))));
6118 : : }
6119 : :
6120 : : /* True if T was declared in a function that might be constexpr: either a
6121 : : function that was declared constexpr, or a C++17 lambda op(). */
6122 : :
6123 : : bool
6124 : 58270148 : var_in_maybe_constexpr_fn (tree t)
6125 : : {
6126 : 116539720 : return (DECL_FUNCTION_SCOPE_P (t)
6127 : 110544692 : && maybe_constexpr_fn (DECL_CONTEXT (t)));
6128 : : }
6129 : :
6130 : : /* We're assigning INIT to TARGET. In do_build_copy_constructor and
6131 : : build_over_call we implement trivial copy of a class with tail padding using
6132 : : assignment of character arrays, which is valid in normal code, but not in
6133 : : constexpr evaluation. We don't need to worry about clobbering tail padding
6134 : : in constexpr evaluation, so strip the type punning. */
6135 : :
6136 : : static void
6137 : 34399404 : maybe_simplify_trivial_copy (tree &target, tree &init)
6138 : : {
6139 : 34399404 : if (TREE_CODE (target) == MEM_REF
6140 : 696 : && TREE_CODE (init) == MEM_REF
6141 : 696 : && TREE_TYPE (target) == TREE_TYPE (init)
6142 : 696 : && TREE_CODE (TREE_TYPE (target)) == ARRAY_TYPE
6143 : 34400100 : && TREE_TYPE (TREE_TYPE (target)) == unsigned_char_type_node)
6144 : : {
6145 : 696 : target = build_fold_indirect_ref (TREE_OPERAND (target, 0));
6146 : 696 : init = build_fold_indirect_ref (TREE_OPERAND (init, 0));
6147 : : }
6148 : 34399404 : }
6149 : :
6150 : : /* Returns true if REF, which is a COMPONENT_REF, has any fields
6151 : : of constant type. This does not check for 'mutable', so the
6152 : : caller is expected to be mindful of that. */
6153 : :
6154 : : static bool
6155 : 277 : cref_has_const_field (tree ref)
6156 : : {
6157 : 346 : while (TREE_CODE (ref) == COMPONENT_REF)
6158 : : {
6159 : 337 : if (CP_TYPE_CONST_P (TREE_TYPE (TREE_OPERAND (ref, 1))))
6160 : : return true;
6161 : 69 : ref = TREE_OPERAND (ref, 0);
6162 : : }
6163 : : return false;
6164 : : }
6165 : :
6166 : : /* Return true if we are modifying something that is const during constant
6167 : : expression evaluation. CODE is the code of the statement, OBJ is the
6168 : : object in question, MUTABLE_P is true if one of the subobjects were
6169 : : declared mutable. */
6170 : :
6171 : : static bool
6172 : 28043673 : modifying_const_object_p (tree_code code, tree obj, bool mutable_p)
6173 : : {
6174 : : /* If this is initialization, there's no problem. */
6175 : 28043673 : if (code != MODIFY_EXPR)
6176 : : return false;
6177 : :
6178 : : /* [basic.type.qualifier] "A const object is an object of type
6179 : : const T or a non-mutable subobject of a const object." */
6180 : 6691155 : if (mutable_p)
6181 : : return false;
6182 : :
6183 : 6690065 : if (TREE_READONLY (obj))
6184 : : return true;
6185 : :
6186 : 6688385 : if (CP_TYPE_CONST_P (TREE_TYPE (obj)))
6187 : : {
6188 : : /* Although a COMPONENT_REF may have a const type, we should
6189 : : only consider it modifying a const object when any of the
6190 : : field components is const. This can happen when using
6191 : : constructs such as const_cast<const T &>(m), making something
6192 : : const even though it wasn't declared const. */
6193 : 2872 : if (TREE_CODE (obj) == COMPONENT_REF)
6194 : 277 : return cref_has_const_field (obj);
6195 : : else
6196 : : return true;
6197 : : }
6198 : :
6199 : : return false;
6200 : : }
6201 : :
6202 : : /* Evaluate an INIT_EXPR or MODIFY_EXPR. */
6203 : :
6204 : : static tree
6205 : 37447144 : cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
6206 : : value_cat lval,
6207 : : bool *non_constant_p, bool *overflow_p)
6208 : : {
6209 : 37447144 : constexpr_ctx new_ctx = *ctx;
6210 : :
6211 : 37447144 : tree init = TREE_OPERAND (t, 1);
6212 : :
6213 : 37447144 : if (TREE_CLOBBER_P (init)
6214 : 37447144 : && CLOBBER_KIND (init) < CLOBBER_OBJECT_END)
6215 : : /* Only handle clobbers ending the lifetime of objects. */
6216 : 3047740 : return void_node;
6217 : :
6218 : : /* First we figure out where we're storing to. */
6219 : 34399404 : tree target = TREE_OPERAND (t, 0);
6220 : :
6221 : 34399404 : maybe_simplify_trivial_copy (target, init);
6222 : :
6223 : 34399404 : tree type = TREE_TYPE (target);
6224 : 34399404 : bool preeval = SCALAR_TYPE_P (type) || TREE_CODE (t) == MODIFY_EXPR;
6225 : 26023680 : if (preeval && !TREE_CLOBBER_P (init))
6226 : : {
6227 : : /* Evaluate the value to be stored without knowing what object it will be
6228 : : stored in, so that any side-effects happen first. */
6229 : 26012192 : if (!SCALAR_TYPE_P (type))
6230 : 11976 : new_ctx.ctor = new_ctx.object = NULL_TREE;
6231 : 26012192 : init = cxx_eval_constant_expression (&new_ctx, init, vc_prvalue,
6232 : : non_constant_p, overflow_p);
6233 : 26012192 : if (*non_constant_p)
6234 : : return t;
6235 : : }
6236 : :
6237 : 25170392 : bool evaluated = false;
6238 : 25170392 : if (lval == vc_glvalue)
6239 : : {
6240 : : /* If we want to return a reference to the target, we need to evaluate it
6241 : : as a whole; otherwise, only evaluate the innermost piece to avoid
6242 : : building up unnecessary *_REFs. */
6243 : 0 : target = cxx_eval_constant_expression (ctx, target, lval,
6244 : : non_constant_p, overflow_p);
6245 : 0 : evaluated = true;
6246 : 0 : if (*non_constant_p)
6247 : : return t;
6248 : : }
6249 : :
6250 : : /* Find the underlying variable. */
6251 : 25170392 : releasing_vec refs;
6252 : 25170392 : tree object = NULL_TREE;
6253 : : /* If we're modifying a const object, save it. */
6254 : 25170392 : tree const_object_being_modified = NULL_TREE;
6255 : 25170392 : bool mutable_p = false;
6256 : 83496973 : for (tree probe = target; object == NULL_TREE; )
6257 : : {
6258 : 58326715 : switch (TREE_CODE (probe))
6259 : : {
6260 : 7986088 : case BIT_FIELD_REF:
6261 : 7986088 : case COMPONENT_REF:
6262 : 7986088 : case ARRAY_REF:
6263 : 7986088 : {
6264 : 7986088 : tree ob = TREE_OPERAND (probe, 0);
6265 : 7986088 : tree elt = TREE_OPERAND (probe, 1);
6266 : 7986088 : if (TREE_CODE (elt) == FIELD_DECL && DECL_MUTABLE_P (elt))
6267 : : mutable_p = true;
6268 : 7986088 : if (TREE_CODE (probe) == ARRAY_REF)
6269 : : {
6270 : 919753 : elt = eval_and_check_array_index (ctx, probe, false,
6271 : : non_constant_p, overflow_p);
6272 : 919753 : if (*non_constant_p)
6273 : 54 : return t;
6274 : : }
6275 : : /* We don't check modifying_const_object_p for ARRAY_REFs. Given
6276 : : "int a[10]", an ARRAY_REF "a[2]" can be "const int", even though
6277 : : the array isn't const. Instead, check "a" in the next iteration;
6278 : : that will detect modifying "const int a[10]". */
6279 : 7066335 : else if (evaluated
6280 : 2873415 : && modifying_const_object_p (TREE_CODE (t), probe,
6281 : : mutable_p)
6282 : 7066603 : && const_object_being_modified == NULL_TREE)
6283 : : const_object_being_modified = probe;
6284 : :
6285 : : /* Track named member accesses for unions to validate modifications
6286 : : that change active member. */
6287 : 7986034 : if (!evaluated && TREE_CODE (probe) == COMPONENT_REF)
6288 : 4192920 : vec_safe_push (refs, probe);
6289 : : else
6290 : 3793114 : vec_safe_push (refs, NULL_TREE);
6291 : :
6292 : 7986034 : vec_safe_push (refs, elt);
6293 : 7986034 : vec_safe_push (refs, TREE_TYPE (probe));
6294 : 7986034 : probe = ob;
6295 : : }
6296 : 7986034 : break;
6297 : :
6298 : 4 : case REALPART_EXPR:
6299 : 4 : gcc_assert (probe == target);
6300 : 4 : vec_safe_push (refs, NULL_TREE);
6301 : 4 : vec_safe_push (refs, probe);
6302 : 4 : vec_safe_push (refs, TREE_TYPE (probe));
6303 : 4 : probe = TREE_OPERAND (probe, 0);
6304 : 4 : break;
6305 : :
6306 : 6 : case IMAGPART_EXPR:
6307 : 6 : gcc_assert (probe == target);
6308 : 6 : vec_safe_push (refs, NULL_TREE);
6309 : 6 : vec_safe_push (refs, probe);
6310 : 6 : vec_safe_push (refs, TREE_TYPE (probe));
6311 : 6 : probe = TREE_OPERAND (probe, 0);
6312 : 6 : break;
6313 : :
6314 : 50340617 : default:
6315 : 50340617 : if (evaluated)
6316 : : object = probe;
6317 : : else
6318 : : {
6319 : 25170359 : probe = cxx_eval_constant_expression (ctx, probe, vc_glvalue,
6320 : : non_constant_p, overflow_p);
6321 : 25170359 : evaluated = true;
6322 : 25170359 : if (*non_constant_p)
6323 : : return t;
6324 : : }
6325 : : break;
6326 : : }
6327 : : }
6328 : :
6329 : 25170258 : if (modifying_const_object_p (TREE_CODE (t), object, mutable_p)
6330 : 25170258 : && const_object_being_modified == NULL_TREE)
6331 : 25170258 : const_object_being_modified = object;
6332 : :
6333 : 25170258 : if (DECL_P (object)
6334 : 24008577 : && TREE_CLOBBER_P (init)
6335 : 25181746 : && DECL_NAME (object) == heap_deleted_identifier)
6336 : : /* Ignore clobbers of deleted allocations for now; we'll get a better error
6337 : : message later when operator delete is called. */
6338 : 15 : return void_node;
6339 : :
6340 : : /* And then find/build up our initializer for the path to the subobject
6341 : : we're initializing. */
6342 : 25170243 : tree *valp;
6343 : 25170243 : if (DECL_P (object))
6344 : 24008562 : valp = ctx->global->get_value_ptr (object, TREE_CODE (t) == INIT_EXPR);
6345 : : else
6346 : 1161681 : valp = NULL;
6347 : 25170243 : if (!valp)
6348 : : {
6349 : : /* A constant-expression cannot modify objects from outside the
6350 : : constant-expression. */
6351 : 1164344 : if (!ctx->quiet)
6352 : : {
6353 : 22 : auto_diagnostic_group d;
6354 : 22 : if (DECL_P (object) && DECL_NAME (object) == heap_deleted_identifier)
6355 : : {
6356 : 0 : error ("modification of allocated storage after deallocation "
6357 : : "is not a constant expression");
6358 : 0 : inform (DECL_SOURCE_LOCATION (object), "allocated here");
6359 : : }
6360 : 22 : else if (DECL_P (object) && ctx->global->is_outside_lifetime (object))
6361 : : {
6362 : 10 : if (TREE_CLOBBER_P (init))
6363 : 3 : error ("destroying %qE outside its lifetime", object);
6364 : : else
6365 : 7 : error ("modification of %qE outside its lifetime "
6366 : : "is not a constant expression", object);
6367 : 10 : inform (DECL_SOURCE_LOCATION (object), "declared here");
6368 : : }
6369 : : else
6370 : : {
6371 : 12 : if (TREE_CLOBBER_P (init))
6372 : 6 : error ("destroying %qE from outside current evaluation "
6373 : : "is not a constant expression", object);
6374 : : else
6375 : 6 : error ("modification of %qE from outside current evaluation "
6376 : : "is not a constant expression", object);
6377 : : }
6378 : 22 : }
6379 : 1164344 : *non_constant_p = true;
6380 : 1164344 : return t;
6381 : : }
6382 : :
6383 : : /* Handle explicit end-of-lifetime. */
6384 : 24005899 : if (TREE_CLOBBER_P (init))
6385 : : {
6386 : 11443 : if (refs->is_empty ())
6387 : 6669 : ctx->global->destroy_value (object);
6388 : 11443 : return void_node;
6389 : : }
6390 : :
6391 : 23994456 : type = TREE_TYPE (object);
6392 : 23994456 : bool no_zero_init = true;
6393 : :
6394 : 47988912 : auto_vec<tree *> ctors;
6395 : 47988912 : releasing_vec indexes;
6396 : 47988912 : auto_vec<int> index_pos_hints;
6397 : 23994456 : bool activated_union_member_p = false;
6398 : 23994456 : bool empty_base = false;
6399 : 29887460 : while (!refs->is_empty ())
6400 : : {
6401 : 5897421 : if (*valp == NULL_TREE)
6402 : : {
6403 : 729858 : *valp = build_constructor (type, NULL);
6404 : 729858 : CONSTRUCTOR_NO_CLEARING (*valp) = no_zero_init;
6405 : : }
6406 : 5167563 : else if (STRIP_ANY_LOCATION_WRAPPER (*valp),
6407 : 5167563 : TREE_CODE (*valp) == STRING_CST)
6408 : : {
6409 : : /* An array was initialized with a string constant, and now
6410 : : we're writing into one of its elements. Explode the
6411 : : single initialization into a set of element
6412 : : initializations. */
6413 : 2500 : gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
6414 : :
6415 : 2500 : tree string = *valp;
6416 : 2500 : tree elt_type = TREE_TYPE (type);
6417 : 2500 : unsigned chars_per_elt = (TYPE_PRECISION (elt_type)
6418 : 2500 : / TYPE_PRECISION (char_type_node));
6419 : 2500 : unsigned num_elts = TREE_STRING_LENGTH (string) / chars_per_elt;
6420 : 2500 : tree ary_ctor = build_constructor (type, NULL);
6421 : :
6422 : 2500 : vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor), num_elts);
6423 : 5155 : for (unsigned ix = 0; ix != num_elts; ix++)
6424 : : {
6425 : 2655 : constructor_elt elt =
6426 : : {
6427 : 2655 : build_int_cst (size_type_node, ix),
6428 : 2655 : extract_string_elt (string, chars_per_elt, ix)
6429 : 2655 : };
6430 : 2655 : CONSTRUCTOR_ELTS (ary_ctor)->quick_push (elt);
6431 : : }
6432 : :
6433 : 2500 : *valp = ary_ctor;
6434 : : }
6435 : :
6436 : 5897421 : enum tree_code code = TREE_CODE (type);
6437 : 5897421 : tree reftype = refs->pop();
6438 : 5897421 : tree index = refs->pop();
6439 : 5897421 : bool is_access_expr = refs->pop() != NULL_TREE;
6440 : :
6441 : 5897421 : if (code == COMPLEX_TYPE)
6442 : : {
6443 : 10 : if (TREE_CODE (*valp) == COMPLEX_CST)
6444 : 8 : *valp = build2 (COMPLEX_EXPR, type, TREE_REALPART (*valp),
6445 : 8 : TREE_IMAGPART (*valp));
6446 : 2 : else if (TREE_CODE (*valp) == CONSTRUCTOR
6447 : 1 : && CONSTRUCTOR_NELTS (*valp) == 0
6448 : 3 : && CONSTRUCTOR_NO_CLEARING (*valp))
6449 : : {
6450 : 1 : tree r = build_constructor (reftype, NULL);
6451 : 1 : CONSTRUCTOR_NO_CLEARING (r) = 1;
6452 : 1 : *valp = build2 (COMPLEX_EXPR, type, r, r);
6453 : : }
6454 : 10 : gcc_assert (TREE_CODE (*valp) == COMPLEX_EXPR);
6455 : 10 : ctors.safe_push (valp);
6456 : 10 : vec_safe_push (indexes, index);
6457 : 10 : valp = &TREE_OPERAND (*valp, TREE_CODE (index) == IMAGPART_EXPR);
6458 : 10 : gcc_checking_assert (refs->is_empty ());
6459 : : type = reftype;
6460 : 4417 : break;
6461 : : }
6462 : :
6463 : : /* If the value of object is already zero-initialized, any new ctors for
6464 : : subobjects will also be zero-initialized. */
6465 : 5897411 : no_zero_init = CONSTRUCTOR_NO_CLEARING (*valp);
6466 : :
6467 : 5897411 : if (code == RECORD_TYPE && is_empty_field (index))
6468 : : /* Don't build a sub-CONSTRUCTOR for an empty base or field, as they
6469 : : have no data and might have an offset lower than previously declared
6470 : : fields, which confuses the middle-end. The code below will notice
6471 : : that we don't have a CONSTRUCTOR for our inner target and just
6472 : : return init. */
6473 : : {
6474 : : empty_base = true;
6475 : : break;
6476 : : }
6477 : :
6478 : : /* If a union is zero-initialized, its first non-static named data member
6479 : : is zero-initialized (and therefore active). */
6480 : 5893004 : if (code == UNION_TYPE
6481 : 5893004 : && !no_zero_init
6482 : 5893004 : && CONSTRUCTOR_NELTS (*valp) == 0)
6483 : 2217 : if (tree first = next_aggregate_field (TYPE_FIELDS (type)))
6484 : 2217 : CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (*valp), first, NULL_TREE);
6485 : :
6486 : : /* Check for implicit change of active member for a union. */
6487 : 5893004 : if (code == UNION_TYPE
6488 : 131359 : && (CONSTRUCTOR_NELTS (*valp) == 0
6489 : 23541 : || CONSTRUCTOR_ELT (*valp, 0)->index != index)
6490 : : /* An INIT_EXPR of the last member in an access chain is always OK,
6491 : : but still check implicit change of members earlier on; see
6492 : : cpp2a/constexpr-union6.C. */
6493 : 6004404 : && !(TREE_CODE (t) == INIT_EXPR && refs->is_empty ()))
6494 : : {
6495 : 78055 : bool has_active_member = CONSTRUCTOR_NELTS (*valp) != 0;
6496 : 78055 : tree inner = strip_array_types (reftype);
6497 : :
6498 : 78055 : if (has_active_member && cxx_dialect < cxx20)
6499 : : {
6500 : 68 : if (!ctx->quiet)
6501 : 22 : error_at (cp_expr_loc_or_input_loc (t),
6502 : : "change of the active member of a union "
6503 : : "from %qD to %qD is not a constant expression "
6504 : : "before C++20",
6505 : 22 : CONSTRUCTOR_ELT (*valp, 0)->index,
6506 : : index);
6507 : 68 : *non_constant_p = true;
6508 : : }
6509 : 77987 : else if (!is_access_expr
6510 : 77987 : || (TREE_CODE (t) == MODIFY_EXPR
6511 : 546 : && CLASS_TYPE_P (inner)
6512 : 18 : && !type_has_non_deleted_trivial_default_ctor (inner)))
6513 : : {
6514 : : /* Diagnose changing active union member after initialization
6515 : : without a valid member access expression, as described in
6516 : : [class.union.general] p5. */
6517 : 77441 : if (!ctx->quiet)
6518 : : {
6519 : 36 : auto_diagnostic_group d;
6520 : 36 : if (has_active_member)
6521 : 24 : error_at (cp_expr_loc_or_input_loc (t),
6522 : : "accessing %qD member instead of initialized "
6523 : : "%qD member in constant expression",
6524 : 24 : index, CONSTRUCTOR_ELT (*valp, 0)->index);
6525 : : else
6526 : 12 : error_at (cp_expr_loc_or_input_loc (t),
6527 : : "accessing uninitialized member %qD",
6528 : : index);
6529 : 36 : if (is_access_expr)
6530 : 3 : inform (DECL_SOURCE_LOCATION (index),
6531 : : "%qD does not implicitly begin its lifetime "
6532 : : "because %qT does not have a non-deleted "
6533 : : "trivial default constructor, use "
6534 : : "%<std::construct_at%> instead",
6535 : : index, inner);
6536 : : else
6537 : 33 : inform (DECL_SOURCE_LOCATION (index),
6538 : : "initializing %qD requires a member access "
6539 : : "expression as the left operand of the assignment",
6540 : : index);
6541 : 36 : }
6542 : 77441 : *non_constant_p = true;
6543 : : }
6544 : 546 : else if (has_active_member && CONSTRUCTOR_NO_CLEARING (*valp))
6545 : : {
6546 : : /* Diagnose changing the active union member while the union
6547 : : is in the process of being initialized. */
6548 : 9 : if (!ctx->quiet)
6549 : 3 : error_at (cp_expr_loc_or_input_loc (t),
6550 : : "change of the active member of a union "
6551 : : "from %qD to %qD during initialization",
6552 : 3 : CONSTRUCTOR_ELT (*valp, 0)->index,
6553 : : index);
6554 : 9 : *non_constant_p = true;
6555 : : }
6556 : : no_zero_init = true;
6557 : : }
6558 : :
6559 : 5893004 : ctors.safe_push (valp);
6560 : 5893004 : vec_safe_push (indexes, index);
6561 : :
6562 : 5893004 : constructor_elt *cep
6563 : 5893004 : = get_or_insert_ctor_field (*valp, index);
6564 : 5893004 : index_pos_hints.safe_push (cep - CONSTRUCTOR_ELTS (*valp)->begin());
6565 : :
6566 : 5893004 : if (code == UNION_TYPE)
6567 : 131359 : activated_union_member_p = true;
6568 : :
6569 : 5893004 : valp = &cep->value;
6570 : 5893004 : type = reftype;
6571 : : }
6572 : :
6573 : : /* For initialization of an empty base, the original target will be
6574 : : *(base*)this, evaluation of which resolves to the object
6575 : : argument, which has the derived type rather than the base type. */
6576 : 47984505 : if (!empty_base && !(same_type_ignoring_top_level_qualifiers_p
6577 : 23990049 : (initialized_type (init), type)))
6578 : : {
6579 : 1202 : gcc_assert (is_empty_class (TREE_TYPE (target)));
6580 : : empty_base = true;
6581 : : }
6582 : :
6583 : : /* Detect modifying a constant object in constexpr evaluation.
6584 : : We have found a const object that is being modified. Figure out
6585 : : if we need to issue an error. Consider
6586 : :
6587 : : struct A {
6588 : : int n;
6589 : : constexpr A() : n(1) { n = 2; } // #1
6590 : : };
6591 : : struct B {
6592 : : const A a;
6593 : : constexpr B() { a.n = 3; } // #2
6594 : : };
6595 : : constexpr B b{};
6596 : :
6597 : : #1 is OK, since we're modifying an object under construction, but
6598 : : #2 is wrong, since "a" is const and has been fully constructed.
6599 : : To track it, we use the TREE_READONLY bit in the object's CONSTRUCTOR
6600 : : which means that the object is read-only. For the example above, the
6601 : : *ctors stack at the point of #2 will look like:
6602 : :
6603 : : ctors[0] = {.a={.n=2}} TREE_READONLY = 0
6604 : : ctors[1] = {.n=2} TREE_READONLY = 1
6605 : :
6606 : : and we're modifying "b.a", so we search the stack and see if the
6607 : : constructor for "b.a" has already run. */
6608 : 23994456 : if (const_object_being_modified)
6609 : : {
6610 : 3866 : bool fail = false;
6611 : 3866 : tree const_objtype
6612 : 3866 : = strip_array_types (TREE_TYPE (const_object_being_modified));
6613 : 3866 : if (!CLASS_TYPE_P (const_objtype))
6614 : : fail = true;
6615 : : else
6616 : : {
6617 : : /* [class.ctor]p5 "A constructor can be invoked for a const,
6618 : : volatile, or const volatile object. const and volatile
6619 : : semantics are not applied on an object under construction.
6620 : : They come into effect when the constructor for the most
6621 : : derived object ends." */
6622 : 11448 : for (tree *elt : ctors)
6623 : 3928 : if (same_type_ignoring_top_level_qualifiers_p
6624 : 3928 : (TREE_TYPE (const_object_being_modified), TREE_TYPE (*elt)))
6625 : : {
6626 : 3759 : fail = TREE_READONLY (*elt);
6627 : 3759 : break;
6628 : : }
6629 : : }
6630 : 3761 : if (fail)
6631 : : {
6632 : 198 : if (!ctx->quiet)
6633 : 63 : modifying_const_object_error (t, const_object_being_modified);
6634 : 198 : *non_constant_p = true;
6635 : 198 : return t;
6636 : : }
6637 : : }
6638 : :
6639 : 23994258 : if (!preeval)
6640 : : {
6641 : : /* We're handling an INIT_EXPR of class type, so the value of the
6642 : : initializer can depend on the object it's initializing. */
6643 : :
6644 : : /* Create a new CONSTRUCTOR in case evaluation of the initializer
6645 : : wants to modify it. */
6646 : 7714475 : if (*valp == NULL_TREE)
6647 : : {
6648 : 7648985 : *valp = build_constructor (type, NULL);
6649 : 7648985 : CONSTRUCTOR_NO_CLEARING (*valp) = no_zero_init;
6650 : : }
6651 : 7714475 : new_ctx.ctor = empty_base ? NULL_TREE : *valp;
6652 : 7714475 : new_ctx.object = target;
6653 : : /* Avoid temporary materialization when initializing from a TARGET_EXPR.
6654 : : We don't need to mess with AGGR_EXPR_SLOT/VEC_INIT_EXPR_SLOT because
6655 : : expansion of those trees uses ctx instead. */
6656 : 7714475 : if (TREE_CODE (init) == TARGET_EXPR)
6657 : 2293556 : if (tree tinit = TARGET_EXPR_INITIAL (init))
6658 : 2293556 : init = tinit;
6659 : 7714475 : init = cxx_eval_constant_expression (&new_ctx, init, vc_prvalue,
6660 : : non_constant_p, overflow_p);
6661 : : /* The hash table might have moved since the get earlier, and the
6662 : : initializer might have mutated the underlying CONSTRUCTORs, so we must
6663 : : recompute VALP. */
6664 : 7714475 : valp = ctx->global->get_value_ptr (object, TREE_CODE (t) == INIT_EXPR);
6665 : 8212009 : for (unsigned i = 0; i < vec_safe_length (indexes); i++)
6666 : : {
6667 : 497534 : ctors[i] = valp;
6668 : 497534 : constructor_elt *cep
6669 : 497534 : = get_or_insert_ctor_field (*valp, indexes[i], index_pos_hints[i]);
6670 : 497534 : valp = &cep->value;
6671 : : }
6672 : : }
6673 : :
6674 : 23994258 : if (*non_constant_p)
6675 : : return t;
6676 : :
6677 : : /* Don't share a CONSTRUCTOR that might be changed later. */
6678 : 21670039 : init = unshare_constructor (init);
6679 : :
6680 : 21670039 : gcc_checking_assert (!*valp || (same_type_ignoring_top_level_qualifiers_p
6681 : : (TREE_TYPE (*valp), type)));
6682 : 21670039 : if (empty_base)
6683 : : {
6684 : : /* Just evaluate the initializer and return, since there's no actual data
6685 : : to store, and we didn't build a CONSTRUCTOR. */
6686 : 5335 : if (!*valp)
6687 : : {
6688 : : /* But do make sure we have something in *valp. */
6689 : 0 : *valp = build_constructor (type, nullptr);
6690 : 0 : CONSTRUCTOR_NO_CLEARING (*valp) = no_zero_init;
6691 : : }
6692 : : }
6693 : 21664704 : else if (*valp && TREE_CODE (*valp) == CONSTRUCTOR
6694 : 5473043 : && TREE_CODE (init) == CONSTRUCTOR)
6695 : : {
6696 : : /* An outer ctx->ctor might be pointing to *valp, so replace
6697 : : its contents. */
6698 : 1311964 : CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init);
6699 : 1311964 : TREE_CONSTANT (*valp) = TREE_CONSTANT (init);
6700 : 1311964 : TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init);
6701 : 3935892 : CONSTRUCTOR_NO_CLEARING (*valp)
6702 : 1311964 : = CONSTRUCTOR_NO_CLEARING (init);
6703 : : }
6704 : : else
6705 : 20352740 : *valp = init;
6706 : :
6707 : : /* After initialization, 'const' semantics apply to the value of the
6708 : : object. Make a note of this fact by marking the CONSTRUCTOR
6709 : : TREE_READONLY. */
6710 : 21670039 : if (TREE_CODE (t) == INIT_EXPR
6711 : 16091631 : && !empty_base
6712 : 16086296 : && TREE_CODE (*valp) == CONSTRUCTOR
6713 : 22971404 : && TYPE_READONLY (type))
6714 : : {
6715 : 17390 : if (INDIRECT_REF_P (target)
6716 : 32468 : && (is_this_parameter
6717 : 15078 : (tree_strip_nop_conversions (TREE_OPERAND (target, 0)))))
6718 : : /* We've just initialized '*this' (perhaps via the target
6719 : : constructor of a delegating constructor). Leave it up to the
6720 : : caller that set 'this' to set TREE_READONLY appropriately. */
6721 : 26 : gcc_checking_assert (same_type_ignoring_top_level_qualifiers_p
6722 : : (TREE_TYPE (target), type) || empty_base);
6723 : : else
6724 : 17364 : TREE_READONLY (*valp) = true;
6725 : : }
6726 : :
6727 : : /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
6728 : : CONSTRUCTORs, if any. */
6729 : 21670039 : bool c = TREE_CONSTANT (init);
6730 : 21670039 : bool s = TREE_SIDE_EFFECTS (init);
6731 : 21670039 : if (!indexes->is_empty ())
6732 : : {
6733 : 3572372 : tree last = indexes->last ();
6734 : 3572372 : if (TREE_CODE (last) == REALPART_EXPR
6735 : 3572372 : || TREE_CODE (last) == IMAGPART_EXPR)
6736 : : {
6737 : : /* And canonicalize COMPLEX_EXPR into COMPLEX_CST if
6738 : : possible. */
6739 : 10 : tree *cexpr = ctors.last ();
6740 : 10 : if (tree c = const_binop (COMPLEX_EXPR, TREE_TYPE (*cexpr),
6741 : 10 : TREE_OPERAND (*cexpr, 0),
6742 : 10 : TREE_OPERAND (*cexpr, 1)))
6743 : 9 : *cexpr = c;
6744 : : else
6745 : : {
6746 : 2 : TREE_CONSTANT (*cexpr)
6747 : 1 : = (TREE_CONSTANT (TREE_OPERAND (*cexpr, 0))
6748 : 1 : & TREE_CONSTANT (TREE_OPERAND (*cexpr, 1)));
6749 : 2 : TREE_SIDE_EFFECTS (*cexpr)
6750 : 2 : = (TREE_SIDE_EFFECTS (TREE_OPERAND (*cexpr, 0))
6751 : 1 : | TREE_SIDE_EFFECTS (TREE_OPERAND (*cexpr, 1)));
6752 : : }
6753 : 10 : c = TREE_CONSTANT (*cexpr);
6754 : 10 : s = TREE_SIDE_EFFECTS (*cexpr);
6755 : : }
6756 : : }
6757 : 21670039 : if (!c || s || activated_union_member_p)
6758 : 9303577 : for (tree *elt : ctors)
6759 : : {
6760 : 758531 : if (TREE_CODE (*elt) != CONSTRUCTOR)
6761 : 0 : continue;
6762 : 758531 : if (!c)
6763 : 539107 : TREE_CONSTANT (*elt) = false;
6764 : 758531 : if (s)
6765 : 0 : TREE_SIDE_EFFECTS (*elt) = true;
6766 : : /* Clear CONSTRUCTOR_NO_CLEARING since we've activated a member of
6767 : : this union. */
6768 : 758531 : if (TREE_CODE (TREE_TYPE (*elt)) == UNION_TYPE)
6769 : 53801 : CONSTRUCTOR_NO_CLEARING (*elt) = false;
6770 : : }
6771 : :
6772 : 21670039 : if (lval)
6773 : : return target;
6774 : : else
6775 : 2381191 : return init;
6776 : 25170392 : }
6777 : :
6778 : : /* Evaluate a ++ or -- expression. */
6779 : :
6780 : : static tree
6781 : 1790589 : cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
6782 : : value_cat lval,
6783 : : bool *non_constant_p, bool *overflow_p)
6784 : : {
6785 : 1790589 : enum tree_code code = TREE_CODE (t);
6786 : 1790589 : tree type = TREE_TYPE (t);
6787 : 1790589 : tree op = TREE_OPERAND (t, 0);
6788 : 1790589 : tree offset = TREE_OPERAND (t, 1);
6789 : 1790589 : gcc_assert (TREE_CONSTANT (offset));
6790 : :
6791 : : /* OFFSET is constant, but perhaps not constant enough. We need to
6792 : : e.g. bash FLOAT_EXPRs to REAL_CSTs. */
6793 : 1790589 : offset = fold_simple (offset);
6794 : :
6795 : : /* The operand as an lvalue. */
6796 : 1790589 : op = cxx_eval_constant_expression (ctx, op, vc_glvalue,
6797 : : non_constant_p, overflow_p);
6798 : :
6799 : : /* The operand as an rvalue. */
6800 : 1790589 : tree val
6801 : 1790589 : = cxx_eval_constant_expression (ctx, op, vc_prvalue,
6802 : : non_constant_p, overflow_p);
6803 : : /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
6804 : : a local array in a constexpr function. */
6805 : 1790589 : bool ptr = INDIRECT_TYPE_P (TREE_TYPE (val));
6806 : 766781 : if (!ptr)
6807 : 766781 : VERIFY_CONSTANT (val);
6808 : :
6809 : : /* The modified value. */
6810 : 1753706 : bool inc = (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR);
6811 : 1753706 : tree mod;
6812 : 1753706 : if (INDIRECT_TYPE_P (type))
6813 : : {
6814 : : /* The middle end requires pointers to use POINTER_PLUS_EXPR. */
6815 : 1023808 : offset = convert_to_ptrofftype (offset);
6816 : 1023808 : if (!inc)
6817 : 76554 : offset = fold_build1 (NEGATE_EXPR, TREE_TYPE (offset), offset);
6818 : 1023808 : mod = fold_build2 (POINTER_PLUS_EXPR, type, val, offset);
6819 : : }
6820 : 729898 : else if (c_promoting_integer_type_p (type)
6821 : 1719 : && !TYPE_UNSIGNED (type)
6822 : 729967 : && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
6823 : : {
6824 : 69 : offset = fold_convert (integer_type_node, offset);
6825 : 69 : mod = fold_convert (integer_type_node, val);
6826 : 125 : tree t = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR, integer_type_node,
6827 : : mod, offset);
6828 : 69 : mod = fold_convert (type, t);
6829 : 69 : if (TREE_OVERFLOW_P (mod) && !TREE_OVERFLOW_P (t))
6830 : 9 : TREE_OVERFLOW (mod) = false;
6831 : : }
6832 : : else
6833 : 1147627 : mod = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR, type, val, offset);
6834 : 1753706 : if (!ptr)
6835 : 729898 : VERIFY_CONSTANT (mod);
6836 : :
6837 : : /* Storing the modified value. */
6838 : 2717744 : tree store = build2_loc (cp_expr_loc_or_loc (t, input_location),
6839 : : MODIFY_EXPR, type, op, mod);
6840 : 1753706 : mod = cxx_eval_constant_expression (ctx, store, lval,
6841 : : non_constant_p, overflow_p);
6842 : 1753706 : ggc_free (store);
6843 : 1753706 : if (*non_constant_p)
6844 : : return t;
6845 : :
6846 : : /* And the value of the expression. */
6847 : 1724658 : if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
6848 : : /* Prefix ops are lvalues, but the caller might want an rvalue;
6849 : : lval has already been taken into account in the store above. */
6850 : : return mod;
6851 : : else
6852 : : /* Postfix ops are rvalues. */
6853 : 456250 : return val;
6854 : : }
6855 : :
6856 : : /* Predicates for the meaning of *jump_target. */
6857 : :
6858 : : static bool
6859 : 27820989 : returns (tree *jump_target)
6860 : : {
6861 : 27820989 : return *jump_target
6862 : 3296264 : && TREE_CODE (*jump_target) == RETURN_EXPR;
6863 : : }
6864 : :
6865 : : static bool
6866 : 28901999 : breaks (tree *jump_target)
6867 : : {
6868 : 28901999 : return *jump_target
6869 : 28901999 : && ((TREE_CODE (*jump_target) == LABEL_DECL
6870 : 11 : && LABEL_DECL_BREAK (*jump_target))
6871 : 236874 : || TREE_CODE (*jump_target) == BREAK_STMT
6872 : 230672 : || TREE_CODE (*jump_target) == EXIT_EXPR);
6873 : : }
6874 : :
6875 : : static bool
6876 : 44998721 : continues (tree *jump_target)
6877 : : {
6878 : 44998721 : return *jump_target
6879 : 44998721 : && ((TREE_CODE (*jump_target) == LABEL_DECL
6880 : 11 : && LABEL_DECL_CONTINUE (*jump_target))
6881 : 234405 : || TREE_CODE (*jump_target) == CONTINUE_STMT);
6882 : :
6883 : : }
6884 : :
6885 : : static bool
6886 : 6041367 : switches (tree *jump_target)
6887 : : {
6888 : 6041367 : return *jump_target
6889 : 6041338 : && TREE_CODE (*jump_target) == INTEGER_CST;
6890 : : }
6891 : :
6892 : : /* Subroutine of cxx_eval_statement_list. Determine whether the statement
6893 : : STMT matches *jump_target. If we're looking for a case label and we see
6894 : : the default label, note it in ctx->css_state. */
6895 : :
6896 : : static bool
6897 : 77340 : label_matches (const constexpr_ctx *ctx, tree *jump_target, tree stmt)
6898 : : {
6899 : 77340 : switch (TREE_CODE (*jump_target))
6900 : : {
6901 : 0 : case LABEL_DECL:
6902 : 0 : if (TREE_CODE (stmt) == LABEL_EXPR
6903 : 0 : && LABEL_EXPR_LABEL (stmt) == *jump_target)
6904 : : return true;
6905 : : break;
6906 : :
6907 : 74802 : case INTEGER_CST:
6908 : 74802 : if (TREE_CODE (stmt) == CASE_LABEL_EXPR)
6909 : : {
6910 : 74802 : gcc_assert (ctx->css_state != NULL);
6911 : 74802 : if (!CASE_LOW (stmt))
6912 : : {
6913 : : /* default: should appear just once in a SWITCH_EXPR
6914 : : body (excluding nested SWITCH_EXPR). */
6915 : 9560 : gcc_assert (*ctx->css_state != css_default_seen);
6916 : : /* When evaluating SWITCH_EXPR body for the second time,
6917 : : return true for the default: label. */
6918 : 9560 : if (*ctx->css_state == css_default_processing)
6919 : : return true;
6920 : 4804 : *ctx->css_state = css_default_seen;
6921 : : }
6922 : 65242 : else if (CASE_HIGH (stmt))
6923 : : {
6924 : 40 : if (tree_int_cst_le (CASE_LOW (stmt), *jump_target)
6925 : 62 : && tree_int_cst_le (*jump_target, CASE_HIGH (stmt)))
6926 : : return true;
6927 : : }
6928 : 65202 : else if (tree_int_cst_equal (*jump_target, CASE_LOW (stmt)))
6929 : : return true;
6930 : : }
6931 : : break;
6932 : :
6933 : : case BREAK_STMT:
6934 : : case CONTINUE_STMT:
6935 : : /* These two are handled directly in cxx_eval_loop_expr by testing
6936 : : breaks (jump_target) or continues (jump_target). */
6937 : : break;
6938 : :
6939 : 0 : default:
6940 : 0 : gcc_unreachable ();
6941 : : }
6942 : : return false;
6943 : : }
6944 : :
6945 : : /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump
6946 : : semantics, for switch, break, continue, and return. */
6947 : :
6948 : : static tree
6949 : 17485806 : cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
6950 : : bool *non_constant_p, bool *overflow_p,
6951 : : tree *jump_target)
6952 : : {
6953 : 17485806 : tree local_target;
6954 : : /* In a statement-expression we want to return the last value.
6955 : : For empty statement expression return void_node. */
6956 : 17485806 : tree r = void_node;
6957 : 17485806 : if (!jump_target)
6958 : : {
6959 : 402 : local_target = NULL_TREE;
6960 : 402 : jump_target = &local_target;
6961 : : }
6962 : 37189201 : for (tree_stmt_iterator i = tsi_start (t); !tsi_end_p (i); ++i)
6963 : : {
6964 : 29797898 : tree stmt = *i;
6965 : :
6966 : : /* We've found a continue, so skip everything until we reach
6967 : : the label its jumping to. */
6968 : 29797898 : if (continues (jump_target))
6969 : : {
6970 : 2538 : if (label_matches (ctx, jump_target, stmt))
6971 : : /* Found it. */
6972 : 0 : *jump_target = NULL_TREE;
6973 : : else
6974 : 2538 : continue;
6975 : : }
6976 : 29795360 : if (TREE_CODE (stmt) == DEBUG_BEGIN_STMT)
6977 : 6011633 : continue;
6978 : :
6979 : 23783727 : value_cat lval = vc_discard;
6980 : : /* The result of a statement-expression is not wrapped in EXPR_STMT. */
6981 : 23783727 : if (tsi_one_before_end_p (i) && TREE_CODE (stmt) != EXPR_STMT)
6982 : : lval = vc_prvalue;
6983 : :
6984 : 23783727 : r = cxx_eval_constant_expression (ctx, stmt, lval,
6985 : : non_constant_p, overflow_p,
6986 : : jump_target);
6987 : 23783727 : if (*non_constant_p)
6988 : : break;
6989 : 16111358 : if (returns (jump_target) || breaks (jump_target))
6990 : : break;
6991 : : }
6992 : 17485806 : if (*jump_target && jump_target == &local_target)
6993 : : {
6994 : : /* We aren't communicating the jump to our caller, so give up. We don't
6995 : : need to support evaluation of jumps out of statement-exprs. */
6996 : 24 : if (!ctx->quiet)
6997 : 3 : error_at (cp_expr_loc_or_input_loc (r),
6998 : : "statement is not a constant expression");
6999 : 24 : *non_constant_p = true;
7000 : : }
7001 : 17485806 : return r;
7002 : : }
7003 : :
7004 : : /* Evaluate a LOOP_EXPR for side-effects. Handles break and return
7005 : : semantics; continue semantics are covered by cxx_eval_statement_list. */
7006 : :
7007 : : static tree
7008 : 452018 : cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t,
7009 : : bool *non_constant_p, bool *overflow_p,
7010 : : tree *jump_target)
7011 : : {
7012 : 452018 : tree local_target;
7013 : 452018 : if (!jump_target)
7014 : : {
7015 : 39 : local_target = NULL_TREE;
7016 : 39 : jump_target = &local_target;
7017 : : }
7018 : :
7019 : 452018 : tree body, cond = NULL_TREE, expr = NULL_TREE;
7020 : 452018 : int count = 0;
7021 : 452018 : switch (TREE_CODE (t))
7022 : : {
7023 : 39 : case LOOP_EXPR:
7024 : 39 : body = LOOP_EXPR_BODY (t);
7025 : 39 : break;
7026 : 377139 : case DO_STMT:
7027 : 377139 : body = DO_BODY (t);
7028 : 377139 : cond = DO_COND (t);
7029 : 377139 : break;
7030 : 34549 : case WHILE_STMT:
7031 : 34549 : body = WHILE_BODY (t);
7032 : 34549 : cond = WHILE_COND (t);
7033 : 34549 : count = -1;
7034 : 34549 : break;
7035 : 40291 : case FOR_STMT:
7036 : 40291 : if (FOR_INIT_STMT (t))
7037 : 0 : cxx_eval_constant_expression (ctx, FOR_INIT_STMT (t), vc_discard,
7038 : : non_constant_p, overflow_p, jump_target);
7039 : 40291 : if (*non_constant_p)
7040 : : return NULL_TREE;
7041 : 40291 : body = FOR_BODY (t);
7042 : 40291 : cond = FOR_COND (t);
7043 : 40291 : expr = FOR_EXPR (t);
7044 : 40291 : count = -1;
7045 : 40291 : break;
7046 : 0 : default:
7047 : 0 : gcc_unreachable ();
7048 : : }
7049 : 6479553 : do
7050 : : {
7051 : 6479553 : if (count != -1)
7052 : : {
7053 : 6404713 : if (body)
7054 : 6404713 : cxx_eval_constant_expression (ctx, body, vc_discard,
7055 : : non_constant_p, overflow_p,
7056 : : jump_target);
7057 : 6404713 : if (breaks (jump_target))
7058 : : {
7059 : 560 : *jump_target = NULL_TREE;
7060 : 560 : break;
7061 : : }
7062 : :
7063 : 6404153 : if (TREE_CODE (t) != LOOP_EXPR && continues (jump_target))
7064 : 1072 : *jump_target = NULL_TREE;
7065 : :
7066 : 6404153 : if (expr)
7067 : 930565 : cxx_eval_constant_expression (ctx, expr, vc_prvalue,
7068 : : non_constant_p, overflow_p,
7069 : : jump_target);
7070 : : }
7071 : :
7072 : 6478993 : if (cond)
7073 : : {
7074 : 6477941 : tree res
7075 : 6477941 : = cxx_eval_constant_expression (ctx, cond, vc_prvalue,
7076 : : non_constant_p, overflow_p,
7077 : : jump_target);
7078 : 6477941 : if (res)
7079 : : {
7080 : 6462544 : if (verify_constant (res, ctx->quiet, non_constant_p,
7081 : : overflow_p))
7082 : : break;
7083 : 6390106 : if (integer_zerop (res))
7084 : : break;
7085 : : }
7086 : : else
7087 : 15397 : gcc_assert (*jump_target);
7088 : : }
7089 : :
7090 : 6043156 : if (++count >= constexpr_loop_limit)
7091 : : {
7092 : 28 : if (!ctx->quiet)
7093 : 9 : error_at (cp_expr_loc_or_input_loc (t),
7094 : : "%<constexpr%> loop iteration count exceeds limit of %d "
7095 : : "(use %<-fconstexpr-loop-limit=%> to increase the limit)",
7096 : : constexpr_loop_limit);
7097 : 28 : *non_constant_p = true;
7098 : 28 : break;
7099 : : }
7100 : : }
7101 : 12070839 : while (!returns (jump_target)
7102 : 6027711 : && !breaks (jump_target)
7103 : 6027711 : && !continues (jump_target)
7104 : 186 : && (!switches (jump_target) || count == 0)
7105 : 12086372 : && !*non_constant_p);
7106 : :
7107 : : return NULL_TREE;
7108 : : }
7109 : :
7110 : : /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump
7111 : : semantics. */
7112 : :
7113 : : static tree
7114 : 8467 : cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t,
7115 : : bool *non_constant_p, bool *overflow_p,
7116 : : tree *jump_target)
7117 : : {
7118 : 8467 : tree cond
7119 : 8467 : = TREE_CODE (t) == SWITCH_STMT ? SWITCH_STMT_COND (t) : SWITCH_COND (t);
7120 : 8467 : cond = cxx_eval_constant_expression (ctx, cond, vc_prvalue,
7121 : : non_constant_p, overflow_p);
7122 : 8467 : VERIFY_CONSTANT (cond);
7123 : 8036 : if (TREE_CODE (cond) != INTEGER_CST)
7124 : : {
7125 : : /* If the condition doesn't reduce to an INTEGER_CST it isn't a usable
7126 : : switch condition even if it's constant enough for other things
7127 : : (c++/113545). */
7128 : 6 : gcc_checking_assert (ctx->quiet);
7129 : 6 : *non_constant_p = true;
7130 : 6 : return t;
7131 : : }
7132 : :
7133 : 8030 : *jump_target = cond;
7134 : :
7135 : 8030 : tree body
7136 : 8030 : = TREE_CODE (t) == SWITCH_STMT ? SWITCH_STMT_BODY (t) : SWITCH_BODY (t);
7137 : 8030 : constexpr_ctx new_ctx = *ctx;
7138 : 8030 : constexpr_switch_state css = css_default_not_seen;
7139 : 8030 : new_ctx.css_state = &css;
7140 : 8030 : cxx_eval_constant_expression (&new_ctx, body, vc_discard,
7141 : : non_constant_p, overflow_p, jump_target);
7142 : 12816 : if (switches (jump_target) && css == css_default_seen)
7143 : : {
7144 : : /* If the SWITCH_EXPR body has default: label, process it once again,
7145 : : this time instructing label_matches to return true for default:
7146 : : label on switches (jump_target). */
7147 : 4756 : css = css_default_processing;
7148 : 4756 : cxx_eval_constant_expression (&new_ctx, body, vc_discard,
7149 : : non_constant_p, overflow_p, jump_target);
7150 : : }
7151 : 8030 : if (breaks (jump_target) || switches (jump_target))
7152 : 2434 : *jump_target = NULL_TREE;
7153 : : return NULL_TREE;
7154 : : }
7155 : :
7156 : : /* Find the object of TYPE under initialization in CTX. */
7157 : :
7158 : : static tree
7159 : 16588 : lookup_placeholder (const constexpr_ctx *ctx, value_cat lval, tree type)
7160 : : {
7161 : 16588 : if (!ctx)
7162 : : return NULL_TREE;
7163 : :
7164 : : /* Prefer the outermost matching object, but don't cross
7165 : : CONSTRUCTOR_PLACEHOLDER_BOUNDARY constructors. */
7166 : 16268 : if (ctx->ctor && !CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ctx->ctor))
7167 : 498 : if (tree outer_ob = lookup_placeholder (ctx->parent, lval, type))
7168 : : return outer_ob;
7169 : :
7170 : : /* We could use ctx->object unconditionally, but using ctx->ctor when we
7171 : : can is a minor optimization. */
7172 : 16090 : if (!lval && ctx->ctor && same_type_p (TREE_TYPE (ctx->ctor), type))
7173 : 309 : return ctx->ctor;
7174 : :
7175 : 15781 : if (!ctx->object)
7176 : : return NULL_TREE;
7177 : :
7178 : : /* Since an object cannot have a field of its own type, we can search outward
7179 : : from ctx->object to find the unique containing object of TYPE. */
7180 : : tree ob = ctx->object;
7181 : 15807 : while (ob)
7182 : : {
7183 : 15807 : if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob), type))
7184 : : break;
7185 : 223 : if (handled_component_p (ob))
7186 : 221 : ob = TREE_OPERAND (ob, 0);
7187 : : else
7188 : : ob = NULL_TREE;
7189 : : }
7190 : :
7191 : : return ob;
7192 : : }
7193 : :
7194 : : /* Complain about an attempt to evaluate inline assembly. If FUNDEF_P is
7195 : : true, we're checking a constexpr function body. */
7196 : :
7197 : : static void
7198 : 31 : inline_asm_in_constexpr_error (location_t loc, bool fundef_p)
7199 : : {
7200 : 31 : auto_diagnostic_group d;
7201 : 31 : if (constexpr_error (loc, fundef_p, "inline assembly is not a "
7202 : : "constant expression"))
7203 : 31 : inform (loc, "only unevaluated inline assembly is allowed in a "
7204 : : "%<constexpr%> function in C++20");
7205 : 31 : }
7206 : :
7207 : : /* We're getting the constant value of DECL in a manifestly constant-evaluated
7208 : : context; maybe complain about that. */
7209 : :
7210 : : static void
7211 : 51850879 : maybe_warn_about_constant_value (location_t loc, tree decl)
7212 : : {
7213 : 51850879 : static bool explained = false;
7214 : 51850879 : if (cxx_dialect >= cxx17
7215 : 51661329 : && warn_interference_size
7216 : 51661329 : && !OPTION_SET_P (param_destruct_interfere_size)
7217 : 51661329 : && DECL_CONTEXT (decl) == std_node
7218 : 4680594 : && id_equal (DECL_NAME (decl), "hardware_destructive_interference_size")
7219 : 51850885 : && (LOCATION_FILE (input_location) != main_input_filename
7220 : 6 : || module_exporting_p ())
7221 : 9 : && warning_at (loc, OPT_Winterference_size, "use of %qD", decl)
7222 : 51850888 : && !explained)
7223 : : {
7224 : 6 : explained = true;
7225 : 6 : inform (loc, "its value can vary between compiler versions or "
7226 : : "with different %<-mtune%> or %<-mcpu%> flags");
7227 : 6 : inform (loc, "if this use is part of a public ABI, change it to "
7228 : : "instead use a constant variable you define");
7229 : 6 : inform (loc, "the default value for the current CPU tuning "
7230 : : "is %d bytes", param_destruct_interfere_size);
7231 : 6 : inform (loc, "you can stabilize this value with %<--param "
7232 : : "hardware_destructive_interference_size=%d%>, or disable "
7233 : : "this warning with %<-Wno-interference-size%>",
7234 : : param_destruct_interfere_size);
7235 : : }
7236 : 51850879 : }
7237 : :
7238 : : /* For element type ELT_TYPE, return the appropriate type of the heap object
7239 : : containing such element(s). COOKIE_SIZE is NULL or the size of cookie
7240 : : in bytes. If COOKIE_SIZE is NULL, return array type
7241 : : ELT_TYPE[FULL_SIZE / sizeof(ELT_TYPE)], otherwise return
7242 : : struct { size_t[COOKIE_SIZE/sizeof(size_t)]; ELT_TYPE[N]; }
7243 : : where N is computed such that the size of the struct fits into FULL_SIZE.
7244 : : If ARG_SIZE is non-NULL, it is the first argument to the new operator.
7245 : : It should be passed if ELT_TYPE is zero sized type in which case FULL_SIZE
7246 : : will be also 0 and so it is not possible to determine the actual array
7247 : : size. CTX, NON_CONSTANT_P and OVERFLOW_P are used during constant
7248 : : expression evaluation of subexpressions of ARG_SIZE. */
7249 : :
7250 : : static tree
7251 : 1273 : build_new_constexpr_heap_type (const constexpr_ctx *ctx, tree elt_type,
7252 : : tree cookie_size, tree full_size, tree arg_size,
7253 : : bool *non_constant_p, bool *overflow_p)
7254 : : {
7255 : 1273 : gcc_assert (cookie_size == NULL_TREE || tree_fits_uhwi_p (cookie_size));
7256 : 1273 : gcc_assert (tree_fits_uhwi_p (full_size));
7257 : 1273 : unsigned HOST_WIDE_INT csz = cookie_size ? tree_to_uhwi (cookie_size) : 0;
7258 : 1273 : if (arg_size)
7259 : : {
7260 : 9 : STRIP_NOPS (arg_size);
7261 : 9 : if (cookie_size)
7262 : : {
7263 : 0 : if (TREE_CODE (arg_size) != PLUS_EXPR)
7264 : : arg_size = NULL_TREE;
7265 : 0 : else if (TREE_CODE (TREE_OPERAND (arg_size, 0)) == INTEGER_CST
7266 : 0 : && tree_int_cst_equal (cookie_size,
7267 : 0 : TREE_OPERAND (arg_size, 0)))
7268 : : {
7269 : 0 : arg_size = TREE_OPERAND (arg_size, 1);
7270 : 0 : STRIP_NOPS (arg_size);
7271 : : }
7272 : 0 : else if (TREE_CODE (TREE_OPERAND (arg_size, 1)) == INTEGER_CST
7273 : 0 : && tree_int_cst_equal (cookie_size,
7274 : 0 : TREE_OPERAND (arg_size, 1)))
7275 : : {
7276 : 0 : arg_size = TREE_OPERAND (arg_size, 0);
7277 : 0 : STRIP_NOPS (arg_size);
7278 : : }
7279 : : else
7280 : : arg_size = NULL_TREE;
7281 : : }
7282 : 9 : if (arg_size && TREE_CODE (arg_size) == MULT_EXPR)
7283 : : {
7284 : 9 : tree op0 = TREE_OPERAND (arg_size, 0);
7285 : 9 : tree op1 = TREE_OPERAND (arg_size, 1);
7286 : 9 : if (integer_zerop (op0))
7287 : 9 : arg_size
7288 : 9 : = cxx_eval_constant_expression (ctx, op1, vc_prvalue,
7289 : : non_constant_p, overflow_p);
|
