Branch data Line data Source code
1 : : /* Perform the semantic phase of lambda parsing, i.e., the process of
2 : : building tree structure, checking semantic consistency, and
3 : : building RTL. These routines are used both during actual parsing
4 : : and during the instantiation of template functions.
5 : :
6 : : Copyright (C) 1998-2024 Free Software Foundation, Inc.
7 : :
8 : : This file is part of GCC.
9 : :
10 : : GCC is free software; you can redistribute it and/or modify it
11 : : under the terms of the GNU General Public License as published by
12 : : the Free Software Foundation; either version 3, or (at your option)
13 : : any later version.
14 : :
15 : : GCC is distributed in the hope that it will be useful, but
16 : : WITHOUT ANY WARRANTY; without even the implied warranty of
17 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 : : General Public License for more details.
19 : :
20 : : You should have received a copy of the GNU General Public License
21 : : along with GCC; see the file COPYING3. If not see
22 : : <http://www.gnu.org/licenses/>. */
23 : :
24 : : #include "config.h"
25 : : #include "system.h"
26 : : #include "coretypes.h"
27 : : #include "cp-tree.h"
28 : : #include "stringpool.h"
29 : : #include "cgraph.h"
30 : : #include "tree-iterator.h"
31 : : #include "toplev.h"
32 : : #include "gimplify.h"
33 : : #include "target.h"
34 : : #include "decl.h"
35 : :
36 : : /* Constructor for a lambda expression. */
37 : :
38 : : tree
39 : 739066 : build_lambda_expr (void)
40 : : {
41 : 739066 : tree lambda = make_node (LAMBDA_EXPR);
42 : 739066 : LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) = CPLD_NONE;
43 : 739066 : LAMBDA_EXPR_CAPTURE_LIST (lambda) = NULL_TREE;
44 : 739066 : LAMBDA_EXPR_THIS_CAPTURE (lambda) = NULL_TREE;
45 : 739066 : LAMBDA_EXPR_REGEN_INFO (lambda) = NULL_TREE;
46 : 739066 : LAMBDA_EXPR_PENDING_PROXIES (lambda) = NULL;
47 : 739066 : return lambda;
48 : : }
49 : :
50 : : /* Create the closure object for a LAMBDA_EXPR. */
51 : :
52 : : tree
53 : 739065 : build_lambda_object (tree lambda_expr)
54 : : {
55 : : /* Build aggregate constructor call.
56 : : - cp_parser_braced_list
57 : : - cp_parser_functional_cast */
58 : 739065 : vec<constructor_elt, va_gc> *elts = NULL;
59 : 739065 : tree node, expr, type;
60 : :
61 : 739065 : if (processing_template_decl || lambda_expr == error_mark_node)
62 : : return lambda_expr;
63 : :
64 : : /* Make sure any error messages refer to the lambda-introducer. */
65 : 252270 : location_t loc = LAMBDA_EXPR_LOCATION (lambda_expr);
66 : 252270 : iloc_sentinel il (loc);
67 : :
68 : 252270 : for (node = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr);
69 : 742394 : node;
70 : 490124 : node = TREE_CHAIN (node))
71 : : {
72 : 490124 : tree field = TREE_PURPOSE (node);
73 : 490124 : tree val = TREE_VALUE (node);
74 : :
75 : 490124 : if (field == error_mark_node)
76 : : {
77 : 0 : expr = error_mark_node;
78 : 0 : goto out;
79 : : }
80 : :
81 : 490124 : if (TREE_CODE (val) == TREE_LIST)
82 : 0 : val = build_x_compound_expr_from_list (val, ELK_INIT,
83 : : tf_warning_or_error);
84 : :
85 : 490124 : if (DECL_P (val))
86 : 267646 : mark_used (val);
87 : :
88 : : /* Mere mortals can't copy arrays with aggregate initialization, so
89 : : do some magic to make it work here. */
90 : 490124 : if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE)
91 : 19 : val = build_array_copy (val);
92 : 490105 : else if (DECL_NORMAL_CAPTURE_P (field)
93 : 489729 : && !DECL_VLA_CAPTURE_P (field)
94 : 979792 : && !TYPE_REF_P (TREE_TYPE (field)))
95 : : {
96 : : /* "the entities that are captured by copy are used to
97 : : direct-initialize each corresponding non-static data
98 : : member of the resulting closure object."
99 : :
100 : : There's normally no way to express direct-initialization
101 : : from an element of a CONSTRUCTOR, so we build up a special
102 : : TARGET_EXPR to bypass the usual copy-initialization. */
103 : 203795 : val = force_rvalue (val, tf_warning_or_error);
104 : 203795 : if (TREE_CODE (val) == TARGET_EXPR)
105 : 4618 : TARGET_EXPR_DIRECT_INIT_P (val) = true;
106 : : }
107 : :
108 : 490124 : CONSTRUCTOR_APPEND_ELT (elts, DECL_NAME (field), val);
109 : : }
110 : :
111 : 252270 : expr = build_constructor (init_list_type_node, elts);
112 : 252270 : CONSTRUCTOR_IS_DIRECT_INIT (expr) = 1;
113 : :
114 : : /* N2927: "[The closure] class type is not an aggregate."
115 : : But we briefly treat it as an aggregate to make this simpler. */
116 : 252270 : type = LAMBDA_EXPR_CLOSURE (lambda_expr);
117 : 252270 : CLASSTYPE_NON_AGGREGATE (type) = 0;
118 : 252270 : expr = finish_compound_literal (type, expr, tf_warning_or_error);
119 : 252270 : protected_set_expr_location (expr, loc);
120 : 252270 : CLASSTYPE_NON_AGGREGATE (type) = 1;
121 : :
122 : 252270 : out:
123 : 252270 : return expr;
124 : 252270 : }
125 : :
126 : : /* Return an initialized RECORD_TYPE for LAMBDA.
127 : : LAMBDA must have its explicit captures already. */
128 : :
129 : : tree
130 : 739057 : begin_lambda_type (tree lambda)
131 : : {
132 : : /* Lambda names are nearly but not quite anonymous. */
133 : 739057 : tree name = make_anon_name ();
134 : 739057 : IDENTIFIER_LAMBDA_P (name) = true;
135 : :
136 : : /* Create the new RECORD_TYPE for this lambda. */
137 : 739057 : tree type = xref_tag (/*tag_code=*/record_type, name);
138 : 739057 : if (type == error_mark_node)
139 : : return error_mark_node;
140 : :
141 : : /* Designate it as a struct so that we can use aggregate initialization. */
142 : 739057 : CLASSTYPE_DECLARED_CLASS (type) = false;
143 : :
144 : : /* Cross-reference the expression and the type. */
145 : 739057 : LAMBDA_EXPR_CLOSURE (lambda) = type;
146 : 739057 : CLASSTYPE_LAMBDA_EXPR (type) = lambda;
147 : :
148 : : /* In C++17, assume the closure is literal; we'll clear the flag later if
149 : : necessary. */
150 : 739057 : if (cxx_dialect >= cxx17)
151 : 735354 : CLASSTYPE_LITERAL_P (type) = true;
152 : :
153 : : /* Clear base types. */
154 : 739057 : xref_basetypes (type, /*bases=*/NULL_TREE);
155 : :
156 : : /* Start the class. */
157 : 739057 : type = begin_class_definition (type);
158 : :
159 : 739057 : return type;
160 : : }
161 : :
162 : : /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
163 : : closure type. */
164 : :
165 : : tree
166 : 6410259 : lambda_function (tree lambda)
167 : : {
168 : 6410259 : tree type;
169 : 6410259 : if (TREE_CODE (lambda) == LAMBDA_EXPR)
170 : 2522738 : type = LAMBDA_EXPR_CLOSURE (lambda);
171 : : else
172 : : type = lambda;
173 : 12820518 : gcc_assert (LAMBDA_TYPE_P (type));
174 : : /* Don't let debug_tree cause instantiation. */
175 : 6410259 : if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
176 : 6410259 : && !COMPLETE_OR_OPEN_TYPE_P (type))
177 : : return NULL_TREE;
178 : 6410259 : lambda = get_class_binding_direct (type, call_op_identifier);
179 : 6410259 : if (lambda)
180 : 6410250 : lambda = STRIP_TEMPLATE (get_first_fn (lambda));
181 : : return lambda;
182 : : }
183 : :
184 : : /* True if EXPR is an expression whose type can be used directly in lambda
185 : : capture. Not to be used for 'auto'. */
186 : :
187 : : static bool
188 : 732948 : type_deducible_expression_p (tree expr)
189 : : {
190 : 732948 : if (!type_dependent_expression_p (expr))
191 : : return true;
192 : 0 : if (BRACE_ENCLOSED_INITIALIZER_P (expr)
193 : 343097 : || TREE_CODE (expr) == EXPR_PACK_EXPANSION)
194 : : return false;
195 : 343097 : tree t = non_reference (TREE_TYPE (expr));
196 : 343097 : return (t && TREE_CODE (t) != TYPE_PACK_EXPANSION
197 : 245982 : && !WILDCARD_TYPE_P (t) && !LAMBDA_TYPE_P (t)
198 : 134625 : && !array_of_unknown_bound_p (t)
199 : 477683 : && !type_uses_auto (t));
200 : : }
201 : :
202 : : /* Returns the type to use for the FIELD_DECL corresponding to the
203 : : capture of EXPR. EXPLICIT_INIT_P indicates whether this is a
204 : : C++14 init capture, and BY_REFERENCE_P indicates whether we're
205 : : capturing by reference. */
206 : :
207 : : tree
208 : 912151 : lambda_capture_field_type (tree expr, bool explicit_init_p,
209 : : bool by_reference_p)
210 : : {
211 : 912151 : tree type;
212 : 912151 : bool is_this = is_this_parameter (tree_strip_nop_conversions (expr));
213 : :
214 : 912151 : if (is_this)
215 : 178683 : type = TREE_TYPE (expr);
216 : 733468 : else if (explicit_init_p)
217 : : {
218 : 520 : tree auto_node = make_auto ();
219 : :
220 : 520 : type = auto_node;
221 : 520 : if (by_reference_p)
222 : : /* Add the reference now, so deduction doesn't lose
223 : : outermost CV qualifiers of EXPR. */
224 : 63 : type = build_reference_type (type);
225 : 520 : if (uses_parameter_packs (expr))
226 : : /* Stick with 'auto' even if the type could be deduced. */
227 : 38 : TEMPLATE_TYPE_PARAMETER_PACK (auto_node) = true;
228 : : else
229 : 482 : type = do_auto_deduction (type, expr, auto_node);
230 : : }
231 : 732948 : else if (!type_deducible_expression_p (expr))
232 : : {
233 : 208514 : type = cxx_make_type (DECLTYPE_TYPE);
234 : 208514 : DECLTYPE_TYPE_EXPR (type) = expr;
235 : 208514 : DECLTYPE_FOR_LAMBDA_CAPTURE (type) = true;
236 : 208514 : DECLTYPE_FOR_REF_CAPTURE (type) = by_reference_p;
237 : 208514 : SET_TYPE_STRUCTURAL_EQUALITY (type);
238 : : }
239 : : else
240 : : {
241 : 524434 : STRIP_ANY_LOCATION_WRAPPER (expr);
242 : :
243 : 524434 : if (!by_reference_p && is_capture_proxy (expr))
244 : : {
245 : : /* When capturing by-value another capture proxy from an enclosing
246 : : lambda, consider the type of the corresponding field instead,
247 : : as the proxy may be additionally const-qualifed if the enclosing
248 : : lambda is non-mutable (PR94376). */
249 : 114 : gcc_assert (TREE_CODE (DECL_VALUE_EXPR (expr)) == COMPONENT_REF);
250 : 114 : expr = TREE_OPERAND (DECL_VALUE_EXPR (expr), 1);
251 : : }
252 : :
253 : 524434 : type = non_reference (unlowered_expr_type (expr));
254 : :
255 : 524434 : if (by_reference_p || TREE_CODE (type) == FUNCTION_TYPE)
256 : 342164 : type = build_reference_type (type);
257 : : }
258 : :
259 : 912151 : return type;
260 : : }
261 : :
262 : : /* Returns true iff DECL is a lambda capture proxy variable created by
263 : : build_capture_proxy. */
264 : :
265 : : bool
266 : 4212137702 : is_capture_proxy (tree decl)
267 : : {
268 : : /* Location wrappers should be stripped or otherwise handled by the
269 : : caller before using this predicate. */
270 : 4212137702 : gcc_checking_assert (!location_wrapper_p (decl));
271 : :
272 : 4212137702 : return (VAR_P (decl)
273 : 1160656212 : && DECL_HAS_VALUE_EXPR_P (decl)
274 : 16456903 : && !DECL_ANON_UNION_VAR_P (decl)
275 : 16454946 : && !DECL_DECOMPOSITION_P (decl)
276 : 15576904 : && !DECL_FNAME_P (decl)
277 : 15397662 : && !(DECL_ARTIFICIAL (decl)
278 : 15395776 : && DECL_LANG_SPECIFIC (decl)
279 : 15388932 : && DECL_OMP_PRIVATIZED_MEMBER (decl))
280 : 4242917140 : && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl)));
281 : : }
282 : :
283 : : /* Returns true iff DECL is a capture proxy for a normal capture
284 : : (i.e. without explicit initializer). */
285 : :
286 : : bool
287 : 4075774405 : is_normal_capture_proxy (tree decl)
288 : : {
289 : 4075774405 : if (!is_capture_proxy (decl))
290 : : /* It's not a capture proxy. */
291 : : return false;
292 : :
293 : 11062746 : return (DECL_LANG_SPECIFIC (decl)
294 : 11062746 : && DECL_CAPTURED_VARIABLE (decl));
295 : : }
296 : :
297 : : /* Returns true iff DECL is a capture proxy for a normal capture
298 : : of a constant variable. */
299 : :
300 : : bool
301 : 3550 : is_constant_capture_proxy (tree decl)
302 : : {
303 : 3550 : if (is_normal_capture_proxy (decl))
304 : 284 : return decl_constant_var_p (DECL_CAPTURED_VARIABLE (decl));
305 : : return false;
306 : : }
307 : :
308 : : /* VAR is a capture proxy created by build_capture_proxy; add it to the
309 : : current function, which is the operator() for the appropriate lambda. */
310 : :
311 : : void
312 : 1225818 : insert_capture_proxy (tree var)
313 : : {
314 : 1225818 : if (is_normal_capture_proxy (var))
315 : : {
316 : 1225116 : tree cap = DECL_CAPTURED_VARIABLE (var);
317 : 1225116 : if (CHECKING_P)
318 : : {
319 : 1225116 : gcc_assert (!is_normal_capture_proxy (cap));
320 : 1225116 : tree old = retrieve_local_specialization (cap);
321 : 1225116 : if (old)
322 : 14565 : gcc_assert (DECL_CONTEXT (old) != DECL_CONTEXT (var));
323 : : }
324 : 1225116 : register_local_specialization (var, cap);
325 : : }
326 : :
327 : : /* Put the capture proxy in the extra body block so that it won't clash
328 : : with a later local variable. */
329 : 1225818 : pushdecl_outermost_localscope (var);
330 : :
331 : : /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
332 : 1225818 : var = build_stmt (DECL_SOURCE_LOCATION (var), DECL_EXPR, var);
333 : 1225818 : tree stmt_list = (*stmt_list_stack)[1];
334 : 1225818 : gcc_assert (stmt_list);
335 : 1225818 : append_to_statement_list_force (var, &stmt_list);
336 : 1225818 : }
337 : :
338 : : /* We've just finished processing a lambda; if the containing scope is also
339 : : a lambda, insert any capture proxies that were created while processing
340 : : the nested lambda. */
341 : :
342 : : void
343 : 739057 : insert_pending_capture_proxies (void)
344 : : {
345 : 739057 : tree lam;
346 : 739057 : vec<tree, va_gc> *proxies;
347 : 739057 : unsigned i;
348 : :
349 : 786211 : if (!current_function_decl || !LAMBDA_FUNCTION_P (current_function_decl))
350 : : return;
351 : :
352 : 18156 : lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl));
353 : 18156 : proxies = LAMBDA_EXPR_PENDING_PROXIES (lam);
354 : 24019 : for (i = 0; i < vec_safe_length (proxies); ++i)
355 : : {
356 : 2295 : tree var = (*proxies)[i];
357 : 2295 : insert_capture_proxy (var);
358 : : }
359 : 18156 : release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam));
360 : 18156 : LAMBDA_EXPR_PENDING_PROXIES (lam) = NULL;
361 : : }
362 : :
363 : : /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
364 : : return the type we want the proxy to have: the type of the field itself,
365 : : with added const-qualification if the lambda isn't mutable and the
366 : : capture is by value. */
367 : :
368 : : tree
369 : 1065472 : lambda_proxy_type (tree ref)
370 : : {
371 : 1065472 : tree type;
372 : 1065472 : if (ref == error_mark_node)
373 : : return error_mark_node;
374 : 1065463 : if (REFERENCE_REF_P (ref))
375 : 0 : ref = TREE_OPERAND (ref, 0);
376 : 1065463 : gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
377 : 1065463 : type = TREE_TYPE (ref);
378 : 1065463 : if (!type || WILDCARD_TYPE_P (non_reference (type)))
379 : : {
380 : 209847 : type = cxx_make_type (DECLTYPE_TYPE);
381 : 209847 : DECLTYPE_TYPE_EXPR (type) = ref;
382 : 209847 : DECLTYPE_FOR_LAMBDA_PROXY (type) = true;
383 : 209847 : SET_TYPE_STRUCTURAL_EQUALITY (type);
384 : : }
385 : 1065463 : if (DECL_PACK_P (TREE_OPERAND (ref, 1)))
386 : 80 : type = make_pack_expansion (type);
387 : : return type;
388 : : }
389 : :
390 : : /* MEMBER is a capture field in a lambda closure class. Now that we're
391 : : inside the operator(), build a placeholder var for future lookups and
392 : : debugging. */
393 : :
394 : : static tree
395 : 1065317 : build_capture_proxy (tree member, tree init)
396 : : {
397 : 1065317 : tree var, object, fn, closure, name, lam, type;
398 : :
399 : 1065317 : if (PACK_EXPANSION_P (member))
400 : 71 : member = PACK_EXPANSION_PATTERN (member);
401 : :
402 : 1065317 : closure = DECL_CONTEXT (member);
403 : 1065317 : fn = lambda_function (closure);
404 : 1065317 : lam = CLASSTYPE_LAMBDA_EXPR (closure);
405 : :
406 : 1065317 : object = DECL_ARGUMENTS (fn);
407 : : /* The proxy variable forwards to the capture field. */
408 : 1065317 : if (INDIRECT_TYPE_P (TREE_TYPE (object)))
409 : 1065217 : object = build_fold_indirect_ref (object);
410 : 1065317 : object = finish_non_static_data_member (member, object, NULL_TREE);
411 : 1065317 : if (REFERENCE_REF_P (object))
412 : 465476 : object = TREE_OPERAND (object, 0);
413 : :
414 : : /* Remove the __ inserted by add_capture. */
415 : 1065317 : if (IDENTIFIER_POINTER (DECL_NAME (member))[2] == '_'
416 : 1065317 : && IDENTIFIER_POINTER (DECL_NAME (member))[3] == '.')
417 : 18 : name = get_identifier ("_");
418 : : else
419 : 1065299 : name = get_identifier (IDENTIFIER_POINTER (DECL_NAME (member)) + 2);
420 : :
421 : 1065317 : type = lambda_proxy_type (object);
422 : :
423 : 1065317 : if (name == this_identifier && !INDIRECT_TYPE_P (type))
424 : : {
425 : 118 : type = build_pointer_type (type);
426 : 118 : type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
427 : 118 : object = build_fold_addr_expr_with_type (object, type);
428 : : }
429 : :
430 : 1065317 : if (DECL_VLA_CAPTURE_P (member))
431 : : {
432 : : /* Rebuild the VLA type from the pointer and maxindex. */
433 : 45 : tree field = next_aggregate_field (TYPE_FIELDS (type));
434 : 45 : tree ptr = build_simple_component_ref (object, field);
435 : 45 : field = next_aggregate_field (DECL_CHAIN (field));
436 : 45 : tree max = build_simple_component_ref (object, field);
437 : 45 : type = build_cplus_array_type (TREE_TYPE (TREE_TYPE (ptr)),
438 : : build_index_type (max));
439 : 45 : type = build_reference_type (type);
440 : 45 : object = convert (type, ptr);
441 : : }
442 : :
443 : 1065317 : complete_type (type);
444 : :
445 : 1065317 : var = build_decl (input_location, VAR_DECL, name, type);
446 : 1065317 : SET_DECL_VALUE_EXPR (var, object);
447 : 1065317 : DECL_HAS_VALUE_EXPR_P (var) = 1;
448 : 1065317 : DECL_ARTIFICIAL (var) = 1;
449 : 1065317 : TREE_USED (var) = 1;
450 : 1065317 : DECL_CONTEXT (var) = fn;
451 : :
452 : 1065317 : if (DECL_NORMAL_CAPTURE_P (member))
453 : : {
454 : 1064685 : if (DECL_VLA_CAPTURE_P (member))
455 : : {
456 : 42 : init = CONSTRUCTOR_ELT (init, 0)->value;
457 : 42 : init = TREE_OPERAND (init, 0); // Strip ADDR_EXPR.
458 : 42 : init = TREE_OPERAND (init, 0); // Strip ARRAY_REF.
459 : : }
460 : : else
461 : : {
462 : 1064643 : if (PACK_EXPANSION_P (init))
463 : 45 : init = PACK_EXPANSION_PATTERN (init);
464 : : }
465 : :
466 : 1064685 : if (INDIRECT_REF_P (init))
467 : 265419 : init = TREE_OPERAND (init, 0);
468 : 1064685 : STRIP_NOPS (init);
469 : :
470 : 1064685 : gcc_assert (VAR_P (init) || TREE_CODE (init) == PARM_DECL);
471 : 1081545 : while (is_normal_capture_proxy (init))
472 : 16860 : init = DECL_CAPTURED_VARIABLE (init);
473 : 1064685 : retrofit_lang_decl (var);
474 : 1064685 : DECL_CAPTURED_VARIABLE (var) = init;
475 : : }
476 : :
477 : 1065317 : if (name == this_identifier)
478 : : {
479 : 206005 : gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam) == member);
480 : 206005 : LAMBDA_EXPR_THIS_CAPTURE (lam) = var;
481 : : }
482 : :
483 : 1065317 : if (fn == current_function_decl)
484 : 1063022 : insert_capture_proxy (var);
485 : : else
486 : 2295 : vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam), var);
487 : :
488 : 1065317 : return var;
489 : : }
490 : :
491 : : static GTY(()) tree ptr_id;
492 : : static GTY(()) tree max_id;
493 : :
494 : : /* Return a struct containing a pointer and a length for lambda capture of
495 : : an array of runtime length. */
496 : :
497 : : static tree
498 : 45 : vla_capture_type (tree array_type)
499 : : {
500 : 45 : tree type = xref_tag (record_type, make_anon_name ());
501 : 45 : xref_basetypes (type, NULL_TREE);
502 : 45 : type = begin_class_definition (type);
503 : 45 : if (!ptr_id)
504 : : {
505 : 36 : ptr_id = get_identifier ("ptr");
506 : 36 : max_id = get_identifier ("max");
507 : : }
508 : 45 : tree ptrtype = build_pointer_type (TREE_TYPE (array_type));
509 : 45 : tree field = build_decl (input_location, FIELD_DECL, ptr_id, ptrtype);
510 : 45 : finish_member_declaration (field);
511 : 45 : field = build_decl (input_location, FIELD_DECL, max_id, sizetype);
512 : 45 : finish_member_declaration (field);
513 : 45 : return finish_struct (type, NULL_TREE);
514 : : }
515 : :
516 : : /* From an ID and INITIALIZER, create a capture (by reference if
517 : : BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
518 : : and return it. If ID is `this', BY_REFERENCE_P says whether
519 : : `*this' is captured by reference. */
520 : :
521 : : tree
522 : 786662 : add_capture (tree lambda, tree id, tree orig_init, bool by_reference_p,
523 : : bool explicit_init_p, unsigned *name_independent_cnt)
524 : : {
525 : 786662 : char *buf;
526 : 786662 : tree type, member, name;
527 : 786662 : bool vla = false;
528 : 786662 : bool variadic = false;
529 : 786662 : tree initializer = orig_init;
530 : :
531 : 786662 : if (PACK_EXPANSION_P (initializer))
532 : : {
533 : 71 : initializer = PACK_EXPANSION_PATTERN (initializer);
534 : : variadic = true;
535 : : }
536 : :
537 : 786662 : if (TREE_CODE (initializer) == TREE_LIST
538 : : /* A pack expansion might end up with multiple elements. */
539 : 786662 : && !PACK_EXPANSION_P (TREE_VALUE (initializer)))
540 : 9 : initializer = build_x_compound_expr_from_list (initializer, ELK_INIT,
541 : : tf_warning_or_error);
542 : 786662 : type = TREE_TYPE (initializer);
543 : 786662 : if (type == error_mark_node)
544 : : return error_mark_node;
545 : :
546 : 786641 : if (!dependent_type_p (type) && array_of_runtime_bound_p (type))
547 : : {
548 : 45 : vla = true;
549 : 45 : if (!by_reference_p)
550 : 3 : error ("array of runtime bound cannot be captured by copy, "
551 : : "only by reference");
552 : :
553 : : /* For a VLA, we capture the address of the first element and the
554 : : maximum index, and then reconstruct the VLA for the proxy. */
555 : 45 : tree elt = cp_build_array_ref (input_location, initializer,
556 : : integer_zero_node, tf_warning_or_error);
557 : 45 : initializer = build_constructor_va (init_list_type_node, 2,
558 : : NULL_TREE, build_address (elt),
559 : : NULL_TREE, array_type_nelts (type));
560 : 45 : type = vla_capture_type (type);
561 : : }
562 : 786596 : else if (!dependent_type_p (type)
563 : 786596 : && variably_modified_type_p (type, NULL_TREE))
564 : : {
565 : 18 : auto_diagnostic_group d;
566 : 18 : sorry ("capture of variably-modified type %qT that is not an N3639 array "
567 : : "of runtime bound", type);
568 : 18 : if (TREE_CODE (type) == ARRAY_TYPE
569 : 18 : && variably_modified_type_p (TREE_TYPE (type), NULL_TREE))
570 : 12 : inform (input_location, "because the array element type %qT has "
571 : 12 : "variable size", TREE_TYPE (type));
572 : 18 : return error_mark_node;
573 : 18 : }
574 : : else
575 : : {
576 : 786578 : type = lambda_capture_field_type (initializer, explicit_init_p,
577 : : by_reference_p);
578 : 786578 : if (type == error_mark_node)
579 : : return error_mark_node;
580 : :
581 : 786575 : if (id == this_identifier && !by_reference_p)
582 : : {
583 : 112 : gcc_assert (INDIRECT_TYPE_P (type));
584 : 112 : type = TREE_TYPE (type);
585 : 112 : initializer = cp_build_fold_indirect_ref (initializer);
586 : : }
587 : :
588 : 786575 : if (dependent_type_p (type))
589 : : ;
590 : 282161 : else if (id != this_identifier && by_reference_p)
591 : : {
592 : 95485 : if (!lvalue_p (initializer))
593 : : {
594 : 3 : error ("cannot capture %qE by reference", initializer);
595 : 3 : return error_mark_node;
596 : : }
597 : : }
598 : : else
599 : : {
600 : : /* Capture by copy requires a complete type. */
601 : 186676 : type = complete_type (type);
602 : 186676 : if (!COMPLETE_TYPE_P (type))
603 : : {
604 : 6 : auto_diagnostic_group d;
605 : 6 : error ("capture by copy of incomplete type %qT", type);
606 : 6 : cxx_incomplete_type_inform (type);
607 : 6 : return error_mark_node;
608 : 6 : }
609 : 186670 : else if (!verify_type_context (input_location,
610 : : TCTX_CAPTURE_BY_COPY, type))
611 : 0 : return error_mark_node;
612 : : }
613 : :
614 : 786566 : if (cxx_dialect < cxx20)
615 : : {
616 : 363005 : auto_diagnostic_group d;
617 : 363005 : tree stripped_init = tree_strip_any_location_wrapper (initializer);
618 : 116501 : if (DECL_DECOMPOSITION_P (stripped_init)
619 : 363043 : && pedwarn (input_location, OPT_Wc__20_extensions,
620 : : "captured structured bindings are a C++20 extension"))
621 : 2 : inform (DECL_SOURCE_LOCATION (stripped_init), "declared here");
622 : 363005 : }
623 : : }
624 : :
625 : : /* Add __ to the beginning of the field name so that user code
626 : : won't find the field with name lookup. We can't just leave the name
627 : : unset because template instantiation uses the name to find
628 : : instantiated fields. */
629 : 786611 : if (id_equal (id, "_") && name_independent_cnt)
630 : : {
631 : 48 : if (*name_independent_cnt == 0)
632 : 30 : name = get_identifier ("___");
633 : : else
634 : : {
635 : : /* For 2nd and later name-independent capture use
636 : : unique names. */
637 : 18 : char buf2[5 + (HOST_BITS_PER_INT + 2) / 3];
638 : 18 : sprintf (buf2, "___.%u", *name_independent_cnt);
639 : 18 : name = get_identifier (buf2);
640 : : }
641 : 48 : name_independent_cnt[0]++;
642 : : }
643 : : else
644 : : {
645 : 786563 : buf = XALLOCAVEC (char, IDENTIFIER_LENGTH (id) + 3);
646 : 786563 : buf[1] = buf[0] = '_';
647 : 786563 : memcpy (buf + 2, IDENTIFIER_POINTER (id),
648 : 786563 : IDENTIFIER_LENGTH (id) + 1);
649 : 786563 : name = get_identifier (buf);
650 : : }
651 : :
652 : 786611 : if (variadic)
653 : : {
654 : 71 : type = make_pack_expansion (type);
655 : 71 : if (explicit_init_p)
656 : : /* With an explicit initializer 'type' is auto, which isn't really a
657 : : parameter pack in this context. We will want as many fields as we
658 : : have elements in the expansion of the initializer, so use its packs
659 : : instead. */
660 : : {
661 : 64 : PACK_EXPANSION_PARAMETER_PACKS (type)
662 : 32 : = uses_parameter_packs (initializer);
663 : 32 : PACK_EXPANSION_AUTO_P (type) = true;
664 : : }
665 : : }
666 : :
667 : : /* Make member variable. */
668 : 786611 : member = build_decl (input_location, FIELD_DECL, name, type);
669 : 786611 : DECL_VLA_CAPTURE_P (member) = vla;
670 : :
671 : 786611 : if (!explicit_init_p)
672 : : /* Normal captures are invisible to name lookup but uses are replaced
673 : : with references to the capture field; we implement this by only
674 : : really making them invisible in unevaluated context; see
675 : : qualify_lookup. For now, let's make explicitly initialized captures
676 : : always visible. */
677 : 786091 : DECL_NORMAL_CAPTURE_P (member) = true;
678 : :
679 : 786611 : if (id == this_identifier)
680 : 178680 : LAMBDA_EXPR_THIS_CAPTURE (lambda) = member;
681 : :
682 : : /* Add it to the appropriate closure class if we've started it. */
683 : 786611 : if (current_class_type
684 : 786611 : && current_class_type == LAMBDA_EXPR_CLOSURE (lambda))
685 : : {
686 : 442488 : if (COMPLETE_TYPE_P (current_class_type))
687 : 0 : internal_error ("trying to capture %qD in instantiation of "
688 : : "generic lambda", id);
689 : 442488 : finish_member_declaration (member);
690 : : }
691 : :
692 : 786611 : tree listmem = member;
693 : 786611 : if (variadic)
694 : : {
695 : 71 : listmem = make_pack_expansion (member);
696 : 71 : initializer = orig_init;
697 : : }
698 : 786611 : LAMBDA_EXPR_CAPTURE_LIST (lambda)
699 : 786611 : = tree_cons (listmem, initializer, LAMBDA_EXPR_CAPTURE_LIST (lambda));
700 : :
701 : 786611 : if (LAMBDA_EXPR_CLOSURE (lambda))
702 : 442488 : return build_capture_proxy (member, initializer);
703 : : /* For explicit captures we haven't started the function yet, so we wait
704 : : and build the proxy from cp_parser_lambda_body. */
705 : 344123 : LAMBDA_CAPTURE_EXPLICIT_P (LAMBDA_EXPR_CAPTURE_LIST (lambda)) = true;
706 : 344123 : return NULL_TREE;
707 : : }
708 : :
709 : : /* Register all the capture members on the list CAPTURES, which is the
710 : : LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
711 : :
712 : : void
713 : 1361888 : register_capture_members (tree captures)
714 : : {
715 : 1361888 : if (captures == NULL_TREE)
716 : : return;
717 : :
718 : 622831 : register_capture_members (TREE_CHAIN (captures));
719 : :
720 : 622831 : tree field = TREE_PURPOSE (captures);
721 : 622831 : if (PACK_EXPANSION_P (field))
722 : 71 : field = PACK_EXPANSION_PATTERN (field);
723 : :
724 : 622831 : finish_member_declaration (field);
725 : : }
726 : :
727 : : /* Similar to add_capture, except this works on a stack of nested lambdas.
728 : : BY_REFERENCE_P in this case is derived from the default capture mode.
729 : : Returns the capture for the lambda at the bottom of the stack. */
730 : :
731 : : tree
732 : 440211 : add_default_capture (tree lambda_stack, tree id, tree initializer)
733 : : {
734 : 440211 : bool this_capture_p = (id == this_identifier);
735 : 440211 : tree var = NULL_TREE;
736 : 440211 : tree saved_class_type = current_class_type;
737 : :
738 : 440211 : for (tree node = lambda_stack;
739 : 882723 : node;
740 : 442512 : node = TREE_CHAIN (node))
741 : : {
742 : 442512 : tree lambda = TREE_VALUE (node);
743 : :
744 : 442512 : current_class_type = LAMBDA_EXPR_CLOSURE (lambda);
745 : 442512 : if (DECL_PACK_P (initializer))
746 : 0 : initializer = make_pack_expansion (initializer);
747 : 442512 : var = add_capture (lambda,
748 : : id,
749 : : initializer,
750 : : /*by_reference_p=*/
751 : : (this_capture_p
752 : 442512 : || (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda)
753 : 393364 : == CPLD_REFERENCE)),
754 : : /*explicit_init_p=*/false, NULL);
755 : 442512 : initializer = convert_from_reference (var);
756 : :
757 : : /* Warn about deprecated implicit capture of this via [=]. */
758 : 442512 : if (cxx_dialect >= cxx20
759 : 251752 : && this_capture_p
760 : 469295 : && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) == CPLD_COPY)
761 : : {
762 : 35 : auto_diagnostic_group d;
763 : 35 : if (warning_at (LAMBDA_EXPR_LOCATION (lambda), OPT_Wdeprecated,
764 : : "implicit capture of %qE via %<[=]%> is deprecated "
765 : : "in C++20", this_identifier))
766 : 31 : inform (LAMBDA_EXPR_LOCATION (lambda), "add explicit %<this%> or "
767 : : "%<*this%> capture");
768 : 35 : }
769 : : }
770 : :
771 : 440211 : current_class_type = saved_class_type;
772 : :
773 : 440211 : return var;
774 : : }
775 : :
776 : : /* Return the capture pertaining to a use of 'this' in LAMBDA, in the
777 : : form of an INDIRECT_REF, possibly adding it through default
778 : : capturing, if ADD_CAPTURE_P is nonzero. If ADD_CAPTURE_P is negative,
779 : : try to capture but don't complain if we can't. */
780 : :
781 : : tree
782 : 683537 : lambda_expr_this_capture (tree lambda, int add_capture_p)
783 : : {
784 : 683537 : tree result;
785 : :
786 : 683537 : tree this_capture = LAMBDA_EXPR_THIS_CAPTURE (lambda);
787 : :
788 : : /* In unevaluated context this isn't an odr-use, so don't capture. */
789 : 683537 : if (cp_unevaluated_operand)
790 : 91 : add_capture_p = false;
791 : :
792 : : /* Try to default capture 'this' if we can. */
793 : 683537 : if (!this_capture)
794 : : {
795 : : tree lambda_stack = NULL_TREE;
796 : 94605 : tree init = NULL_TREE;
797 : : bool saw_complete = false;
798 : :
799 : : /* If we are in a lambda function, we can move out until we hit:
800 : : 1. a non-lambda function or NSDMI,
801 : : 2. a lambda function capturing 'this', or
802 : : 3. a non-default capturing lambda function. */
803 : : for (tree tlambda = lambda; ;)
804 : : {
805 : 94605 : if (add_capture_p
806 : 143772 : && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda) == CPLD_NONE)
807 : : /* tlambda won't let us capture 'this'. */
808 : : break;
809 : :
810 : 94589 : if (add_capture_p)
811 : 49151 : lambda_stack = tree_cons (NULL_TREE,
812 : : tlambda,
813 : : lambda_stack);
814 : :
815 : 94589 : tree closure = LAMBDA_EXPR_CLOSURE (tlambda);
816 : 94589 : if (COMPLETE_TYPE_P (closure))
817 : : /* We're instantiating a generic lambda op(), the containing
818 : : scope may be gone. */
819 : 3644 : saw_complete = true;
820 : :
821 : 94589 : tree containing_function
822 : 94589 : = decl_function_context (TYPE_NAME (closure));
823 : :
824 : 94589 : tree ex = LAMBDA_EXPR_EXTRA_SCOPE (tlambda);
825 : 94589 : if (ex && TREE_CODE (ex) == FIELD_DECL)
826 : : {
827 : : /* Lambda in an NSDMI. We don't have a function to look up
828 : : 'this' in, but we can find (or rebuild) the fake one from
829 : : inject_this_parameter. */
830 : 63 : if (!containing_function && !saw_complete)
831 : : /* If we're parsing a lambda in a non-local class,
832 : : we can find the fake 'this' in scope_chain. */
833 : 45 : init = scope_chain->x_current_class_ptr;
834 : : else
835 : : /* Otherwise it's either gone or buried in
836 : : function_context_stack, so make another. */
837 : 18 : init = build_this_parm (NULL_TREE, DECL_CONTEXT (ex),
838 : : TYPE_UNQUALIFIED);
839 : 63 : gcc_checking_assert
840 : : (init && (TREE_TYPE (TREE_TYPE (init))
841 : : == current_nonlambda_class_type ()));
842 : : break;
843 : : }
844 : :
845 : 94526 : if (containing_function == NULL_TREE)
846 : : /* We ran out of scopes; there's no 'this' to capture. */
847 : : break;
848 : :
849 : 95279 : if (!LAMBDA_FUNCTION_P (containing_function))
850 : : {
851 : : /* We found a non-lambda function.
852 : : There is no this pointer in xobj member functions. */
853 : 94007 : if (DECL_IOBJ_MEMBER_FUNCTION_P (containing_function))
854 : : /* First parameter is 'this'. */
855 : 89275 : init = DECL_ARGUMENTS (containing_function);
856 : : break;
857 : : }
858 : :
859 : 495 : tlambda
860 : 495 : = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function));
861 : :
862 : 495 : if (LAMBDA_EXPR_THIS_CAPTURE (tlambda))
863 : : {
864 : : /* An outer lambda has already captured 'this'. */
865 : : init = LAMBDA_EXPR_THIS_CAPTURE (tlambda);
866 : : break;
867 : : }
868 : : }
869 : :
870 : 89396 : if (init)
871 : : {
872 : 89356 : if (add_capture_p)
873 : 49122 : this_capture = add_default_capture (lambda_stack,
874 : : /*id=*/this_identifier,
875 : : init);
876 : : else
877 : : this_capture = init;
878 : : }
879 : : }
880 : :
881 : 683537 : if (cp_unevaluated_operand)
882 : : result = this_capture;
883 : 683446 : else if (!this_capture)
884 : : {
885 : 4760 : if (add_capture_p == 1)
886 : : {
887 : 16 : error ("%<this%> was not captured for this lambda function");
888 : 16 : result = error_mark_node;
889 : : }
890 : : else
891 : : result = NULL_TREE;
892 : : }
893 : : else
894 : : {
895 : : /* To make sure that current_class_ref is for the lambda. */
896 : 678686 : gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref))
897 : : == LAMBDA_EXPR_CLOSURE (lambda));
898 : :
899 : 678686 : result = this_capture;
900 : :
901 : : /* If 'this' is captured, each use of 'this' is transformed into an
902 : : access to the corresponding unnamed data member of the closure
903 : : type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
904 : : ensures that the transformed expression is an rvalue. ] */
905 : 678686 : result = rvalue (result);
906 : : }
907 : :
908 : 683537 : return result;
909 : : }
910 : :
911 : : /* Return the innermost LAMBDA_EXPR we're currently in, if any. */
912 : :
913 : : tree
914 : 36290640 : current_lambda_expr (void)
915 : : {
916 : 36290640 : tree type = current_class_type;
917 : 47882197 : while (type && !LAMBDA_TYPE_P (type))
918 : 4762752 : type = decl_type_context (TYPE_NAME (type));
919 : 36290640 : if (type)
920 : 2237559 : return CLASSTYPE_LAMBDA_EXPR (type);
921 : : else
922 : : return NULL_TREE;
923 : : }
924 : :
925 : : /* Return the current LAMBDA_EXPR, if this is a resolvable dummy
926 : : object. NULL otherwise.. */
927 : :
928 : : static tree
929 : 198356781 : resolvable_dummy_lambda (tree object)
930 : : {
931 : 198356781 : if (!is_dummy_object (object))
932 : : return NULL_TREE;
933 : :
934 : 13540691 : tree type = TYPE_MAIN_VARIANT (TREE_TYPE (object));
935 : 13540691 : gcc_assert (!TYPE_PTR_P (type));
936 : :
937 : 13540691 : if (type != current_class_type
938 : 11342665 : && current_class_type
939 : 16084693 : && LAMBDA_TYPE_P (current_class_type)
940 : 256361 : && lambda_function (current_class_type)
941 : 13797043 : && DERIVED_FROM_P (type, nonlambda_method_basetype()))
942 : 251051 : return CLASSTYPE_LAMBDA_EXPR (current_class_type);
943 : :
944 : : return NULL_TREE;
945 : : }
946 : :
947 : : /* We don't want to capture 'this' until we know we need it, i.e. after
948 : : overload resolution has chosen a non-static member function. At that
949 : : point we call this function to turn a dummy object into a use of the
950 : : 'this' capture. */
951 : :
952 : : tree
953 : 116464216 : maybe_resolve_dummy (tree object, bool add_capture_p)
954 : : {
955 : 116464216 : if (tree lam = resolvable_dummy_lambda (object))
956 : 232354 : if (tree cap = lambda_expr_this_capture (lam, add_capture_p))
957 : 232354 : if (cap != error_mark_node)
958 : 232348 : object = build_fold_indirect_ref (cap);
959 : :
960 : 116464216 : return object;
961 : : }
962 : :
963 : : /* When parsing a generic lambda containing an argument-dependent
964 : : member function call we defer overload resolution to instantiation
965 : : time. But we have to know now whether to capture this or not.
966 : : Do that if FNS contains any non-static fns.
967 : : The std doesn't anticipate this case, but I expect this to be the
968 : : outcome of discussion. */
969 : :
970 : : void
971 : 81892565 : maybe_generic_this_capture (tree object, tree fns)
972 : : {
973 : 81892565 : if (tree lam = resolvable_dummy_lambda (object))
974 : 18697 : if (!LAMBDA_EXPR_THIS_CAPTURE (lam))
975 : : {
976 : : /* We've not yet captured, so look at the function set of
977 : : interest. */
978 : 1169 : if (BASELINK_P (fns))
979 : 49 : fns = BASELINK_FUNCTIONS (fns);
980 : 1169 : bool id_expr = TREE_CODE (fns) == TEMPLATE_ID_EXPR;
981 : 1169 : if (id_expr)
982 : 1126 : fns = TREE_OPERAND (fns, 0);
983 : :
984 : 1178 : for (lkp_iterator iter (fns); iter; ++iter)
985 : 52 : if (((!id_expr && TREE_CODE (*iter) != USING_DECL)
986 : 1129 : || TREE_CODE (*iter) == TEMPLATE_DECL)
987 : 2353 : && DECL_IOBJ_MEMBER_FUNCTION_P (*iter))
988 : : {
989 : : /* Found a non-static member. Capture this. */
990 : 1169 : lambda_expr_this_capture (lam, /*maybe*/-1);
991 : 1169 : break;
992 : : }
993 : : }
994 : 81892565 : }
995 : :
996 : : /* Returns the innermost non-lambda function. */
997 : :
998 : : tree
999 : 47 : current_nonlambda_function (void)
1000 : : {
1001 : 47 : tree fn = current_function_decl;
1002 : 53 : while (fn && LAMBDA_FUNCTION_P (fn))
1003 : 3 : fn = decl_function_context (fn);
1004 : 47 : return fn;
1005 : : }
1006 : :
1007 : : /* Returns the method basetype of the innermost non-lambda function, including
1008 : : a hypothetical constructor if inside an NSDMI, or NULL_TREE if none. */
1009 : :
1010 : : tree
1011 : 256690 : nonlambda_method_basetype (void)
1012 : : {
1013 : 256690 : if (!current_class_ref)
1014 : : return NULL_TREE;
1015 : :
1016 : 256454 : tree type = current_class_type;
1017 : 512908 : if (!type || !LAMBDA_TYPE_P (type))
1018 : : return type;
1019 : :
1020 : 257382 : while (true)
1021 : : {
1022 : 256873 : tree lam = CLASSTYPE_LAMBDA_EXPR (type);
1023 : 256873 : tree ex = LAMBDA_EXPR_EXTRA_SCOPE (lam);
1024 : 256873 : if (ex && TREE_CODE (ex) == FIELD_DECL)
1025 : : /* Lambda in an NSDMI. */
1026 : 30 : return DECL_CONTEXT (ex);
1027 : :
1028 : 256843 : tree fn = TYPE_CONTEXT (type);
1029 : 256843 : if (!fn || TREE_CODE (fn) != FUNCTION_DECL
1030 : 513677 : || !DECL_IOBJ_MEMBER_FUNCTION_P (fn))
1031 : : /* No enclosing non-lambda method. */
1032 : : return NULL_TREE;
1033 : 252764 : if (!LAMBDA_FUNCTION_P (fn))
1034 : : /* Found an enclosing non-lambda method. */
1035 : 251599 : return TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
1036 : 509 : type = DECL_CONTEXT (fn);
1037 : 509 : }
1038 : : }
1039 : :
1040 : : /* Like current_scope, but looking through lambdas. */
1041 : :
1042 : : tree
1043 : 39925578 : current_nonlambda_scope (void)
1044 : : {
1045 : 39925578 : tree scope = current_scope ();
1046 : 40087726 : for (;;)
1047 : : {
1048 : 40249862 : if (TREE_CODE (scope) == FUNCTION_DECL
1049 : 40592622 : && LAMBDA_FUNCTION_P (scope))
1050 : : {
1051 : 162136 : scope = CP_TYPE_CONTEXT (DECL_CONTEXT (scope));
1052 : 162136 : continue;
1053 : : }
1054 : 45401680 : else if (LAMBDA_TYPE_P (scope))
1055 : : {
1056 : 12 : scope = CP_TYPE_CONTEXT (scope);
1057 : 12 : continue;
1058 : : }
1059 : 39925578 : break;
1060 : : }
1061 : 39925578 : return scope;
1062 : : }
1063 : :
1064 : : /* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with
1065 : : indicated FN and NARGS, but do not initialize the return type or any of the
1066 : : argument slots. */
1067 : :
1068 : : static tree
1069 : 18245 : prepare_op_call (tree fn, int nargs)
1070 : : {
1071 : 18245 : tree t;
1072 : :
1073 : 18245 : t = build_vl_exp (CALL_EXPR, nargs + 3);
1074 : 18245 : CALL_EXPR_FN (t) = fn;
1075 : 18245 : CALL_EXPR_STATIC_CHAIN (t) = NULL;
1076 : :
1077 : 18245 : return t;
1078 : : }
1079 : :
1080 : : /* Return true iff CALLOP is the op() for a generic lambda. */
1081 : :
1082 : : bool
1083 : 317173 : generic_lambda_fn_p (tree callop)
1084 : : {
1085 : 634346 : return (LAMBDA_FUNCTION_P (callop)
1086 : 317173 : && DECL_TEMPLATE_INFO (callop)
1087 : 604712 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (callop)));
1088 : : }
1089 : :
1090 : : /* If the closure TYPE has a static op(), also add a conversion to function
1091 : : pointer. */
1092 : :
1093 : : void
1094 : 739014 : maybe_add_lambda_conv_op (tree type)
1095 : : {
1096 : 739014 : bool nested = (cfun != NULL);
1097 : 739014 : bool nested_def = decl_function_context (TYPE_MAIN_DECL (type));
1098 : 739014 : tree callop = lambda_function (type);
1099 : 739014 : tree lam = CLASSTYPE_LAMBDA_EXPR (type);
1100 : :
1101 : 739014 : if (LAMBDA_EXPR_CAPTURE_LIST (lam) != NULL_TREE
1102 : 739014 : || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) != CPLD_NONE)
1103 : 700486 : return;
1104 : :
1105 : 184008 : if (processing_template_decl)
1106 : : return;
1107 : :
1108 : 38903 : bool const generic_lambda_p = generic_lambda_fn_p (callop);
1109 : :
1110 : 38903 : if (!generic_lambda_p && undeduced_auto_decl (callop))
1111 : : {
1112 : : /* If the op() wasn't deduced due to errors, give up. */
1113 : 28 : gcc_assert (errorcount || sorrycount);
1114 : : return;
1115 : : }
1116 : :
1117 : : /* Non-generic non-capturing lambdas only have a conversion function to
1118 : : pointer to function when the trailing requires-clause's constraints are
1119 : : satisfied. */
1120 : 38875 : if (!generic_lambda_p && !constraints_satisfied_p (callop))
1121 : : return;
1122 : :
1123 : : /* Non-template conversion operators are defined directly with build_call_a
1124 : : and using DIRECT_ARGVEC for arguments (including 'this'). Templates are
1125 : : deferred and the CALL is built in-place. In the case of a deduced return
1126 : : call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
1127 : : the return type is also built in-place. The arguments of DECLTYPE_CALL in
1128 : : the return expression may differ in flags from those in the body CALL. In
1129 : : particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
1130 : : the body CALL, but not in DECLTYPE_CALL. */
1131 : :
1132 : 38857 : vec<tree, va_gc> *direct_argvec = 0;
1133 : 38857 : tree decltype_call = 0, call = 0;
1134 : 38857 : tree optype = TREE_TYPE (callop);
1135 : 38857 : tree fn_result = TREE_TYPE (optype);
1136 : :
1137 : 38857 : tree thisarg = NULL_TREE;
1138 : 38857 : if (TREE_CODE (optype) == METHOD_TYPE)
1139 : 38724 : thisarg = build_int_cst (TREE_TYPE (DECL_ARGUMENTS (callop)), 0);
1140 : 38857 : if (generic_lambda_p)
1141 : : {
1142 : 9269 : ++processing_template_decl;
1143 : :
1144 : : /* Prepare the dependent member call for the static member function
1145 : : '_FUN' and, potentially, prepare another call to be used in a decltype
1146 : : return expression for a deduced return call op to allow for simple
1147 : : implementation of the conversion operator. */
1148 : :
1149 : 9269 : tree objfn;
1150 : 9269 : int nargs = list_length (DECL_ARGUMENTS (callop));
1151 : 9269 : if (thisarg)
1152 : : {
1153 : 9169 : tree instance = cp_build_fold_indirect_ref (thisarg);
1154 : 9169 : objfn = lookup_template_function (DECL_NAME (callop),
1155 : 9169 : DECL_TI_ARGS (callop));
1156 : 9169 : objfn = build_min (COMPONENT_REF, NULL_TREE,
1157 : : instance, objfn, NULL_TREE);
1158 : 9169 : --nargs;
1159 : 9169 : call = prepare_op_call (objfn, nargs);
1160 : : }
1161 : : else
1162 : : objfn = callop;
1163 : :
1164 : 9269 : if (type_uses_auto (fn_result))
1165 : 9076 : decltype_call = prepare_op_call (objfn, nargs);
1166 : : }
1167 : 29588 : else if (thisarg)
1168 : : {
1169 : 29555 : direct_argvec = make_tree_vector ();
1170 : 29555 : direct_argvec->quick_push (thisarg);
1171 : : }
1172 : :
1173 : : /* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to
1174 : : declare the static member function "_FUN" below. For each arg append to
1175 : : DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated
1176 : : call args (for the template case). If a parameter pack is found, expand
1177 : : it, flagging it as PACK_EXPANSION_LOCAL_P for the body call. */
1178 : :
1179 : 38857 : tree fn_args = NULL_TREE;
1180 : 38857 : {
1181 : 38857 : int ix = 0;
1182 : 38857 : tree src = FUNCTION_FIRST_USER_PARM (callop);
1183 : 38857 : tree tgt = NULL;
1184 : :
1185 : 38857 : if (!thisarg && !decltype_call)
1186 : 38857 : src = NULL_TREE;
1187 : 66859 : while (src)
1188 : : {
1189 : 28002 : tree new_node = copy_node (src);
1190 : : /* We set DECL_CONTEXT of NEW_NODE to the statfn below.
1191 : : Notice this is creating a recursive type! */
1192 : :
1193 : : /* Clear TREE_ADDRESSABLE on thunk arguments. */
1194 : 28002 : TREE_ADDRESSABLE (new_node) = 0;
1195 : :
1196 : 28002 : if (!fn_args)
1197 : 18398 : fn_args = tgt = new_node;
1198 : : else
1199 : : {
1200 : 9604 : TREE_CHAIN (tgt) = new_node;
1201 : 9604 : tgt = new_node;
1202 : : }
1203 : :
1204 : 28002 : mark_exp_read (tgt);
1205 : :
1206 : 28002 : if (generic_lambda_p)
1207 : : {
1208 : 15264 : tree a = tgt;
1209 : 15264 : if (thisarg)
1210 : : {
1211 : 15163 : if (DECL_PACK_P (tgt))
1212 : : {
1213 : 524 : a = make_pack_expansion (a);
1214 : 524 : PACK_EXPANSION_LOCAL_P (a) = true;
1215 : : }
1216 : 15163 : CALL_EXPR_ARG (call, ix) = a;
1217 : : }
1218 : :
1219 : 15264 : if (decltype_call)
1220 : : {
1221 : : /* Avoid capturing variables in this context. */
1222 : 14987 : ++cp_unevaluated_operand;
1223 : 14987 : CALL_EXPR_ARG (decltype_call, ix) = forward_parm (tgt);
1224 : 14987 : --cp_unevaluated_operand;
1225 : : }
1226 : :
1227 : 15264 : ++ix;
1228 : : }
1229 : : else
1230 : 12738 : vec_safe_push (direct_argvec, tgt);
1231 : :
1232 : 28002 : src = TREE_CHAIN (src);
1233 : : }
1234 : : }
1235 : :
1236 : 38857 : if (generic_lambda_p)
1237 : : {
1238 : 9269 : if (decltype_call)
1239 : : {
1240 : 9076 : fn_result = finish_decltype_type
1241 : 9076 : (decltype_call, /*id_expression_or_member_access_p=*/false,
1242 : : tf_warning_or_error);
1243 : : }
1244 : : }
1245 : 29588 : else if (thisarg)
1246 : : {
1247 : : /* Don't warn on deprecated or unavailable lambda declarations, unless
1248 : : the lambda is actually called. */
1249 : 29555 : auto du = make_temp_override (deprecated_state,
1250 : 29555 : UNAVAILABLE_DEPRECATED_SUPPRESS);
1251 : 29555 : call = build_call_a (callop, direct_argvec->length (),
1252 : : direct_argvec->address ());
1253 : 29555 : }
1254 : :
1255 : 38857 : if (thisarg)
1256 : : {
1257 : 38724 : CALL_FROM_THUNK_P (call) = 1;
1258 : 38724 : SET_EXPR_LOCATION (call, UNKNOWN_LOCATION);
1259 : : }
1260 : :
1261 : 38857 : tree stattype
1262 : 38857 : = build_function_type (fn_result, FUNCTION_FIRST_USER_PARMTYPE (callop));
1263 : 38857 : stattype = (cp_build_type_attribute_variant
1264 : 38857 : (stattype, TYPE_ATTRIBUTES (optype)));
1265 : 38857 : if (flag_noexcept_type
1266 : 38857 : && TYPE_NOTHROW_P (TREE_TYPE (callop)))
1267 : 43 : stattype = build_exception_variant (stattype, noexcept_true_spec);
1268 : :
1269 : 38857 : if (generic_lambda_p)
1270 : 9269 : --processing_template_decl;
1271 : :
1272 : : /* First build up the conversion op. */
1273 : :
1274 : 38857 : tree rettype = build_pointer_type (stattype);
1275 : 38857 : tree name = make_conv_op_name (rettype);
1276 : 38857 : tree thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1277 : 38857 : tree fntype = build_method_type_directly (thistype, rettype, void_list_node);
1278 : : /* DR 1722: The conversion function should be noexcept. */
1279 : 38857 : fntype = build_exception_variant (fntype, noexcept_true_spec);
1280 : 38857 : tree convfn = build_lang_decl (FUNCTION_DECL, name, fntype);
1281 : 38857 : SET_DECL_LANGUAGE (convfn, lang_cplusplus);
1282 : 38857 : tree fn = convfn;
1283 : 38857 : DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
1284 : 38857 : SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
1285 : 38857 : grokclassfn (type, fn, NO_SPECIAL);
1286 : 38857 : set_linkage_according_to_type (type, fn);
1287 : 38857 : rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
1288 : 38857 : DECL_IN_AGGR_P (fn) = 1;
1289 : 38857 : DECL_ARTIFICIAL (fn) = 1;
1290 : 38857 : DECL_NOT_REALLY_EXTERN (fn) = 1;
1291 : 38857 : DECL_DECLARED_INLINE_P (fn) = 1;
1292 : 38857 : DECL_DECLARED_CONSTEXPR_P (fn) = DECL_DECLARED_CONSTEXPR_P (callop);
1293 : 77714 : if (DECL_IMMEDIATE_FUNCTION_P (callop))
1294 : 17 : SET_DECL_IMMEDIATE_FUNCTION_P (fn);
1295 : 38857 : DECL_ARGUMENTS (fn) = build_this_parm (fn, fntype, TYPE_QUAL_CONST);
1296 : :
1297 : 38857 : if (nested_def)
1298 : 37468 : DECL_INTERFACE_KNOWN (fn) = 1;
1299 : :
1300 : 38857 : if (generic_lambda_p)
1301 : 9269 : fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
1302 : :
1303 : 38857 : add_method (type, fn, false);
1304 : :
1305 : 38857 : if (thisarg == NULL_TREE)
1306 : : {
1307 : : /* For static lambda, just return operator(). */
1308 : 133 : if (nested)
1309 : 128 : push_function_context ();
1310 : : else
1311 : : /* Still increment function_depth so that we don't GC in the
1312 : : middle of an expression. */
1313 : 5 : ++function_depth;
1314 : :
1315 : : /* Generate the body of the conversion op. */
1316 : :
1317 : 133 : start_preparsed_function (convfn, NULL_TREE,
1318 : : SF_PRE_PARSED | SF_INCLASS_INLINE);
1319 : 133 : tree body = begin_function_body ();
1320 : 133 : tree compound_stmt = begin_compound_stmt (0);
1321 : :
1322 : : /* decl_needed_p needs to see that it's used. */
1323 : 133 : TREE_USED (callop) = 1;
1324 : 133 : finish_return_stmt (decay_conversion (callop, tf_warning_or_error));
1325 : :
1326 : 133 : finish_compound_stmt (compound_stmt);
1327 : 133 : finish_function_body (body);
1328 : :
1329 : 133 : fn = finish_function (/*inline_p=*/true);
1330 : 133 : if (!generic_lambda_p)
1331 : 33 : expand_or_defer_fn (fn);
1332 : :
1333 : 133 : if (nested)
1334 : 128 : pop_function_context ();
1335 : : else
1336 : 5 : --function_depth;
1337 : 133 : return;
1338 : : }
1339 : :
1340 : : /* Generic thunk code fails for varargs; we'll complain in mark_used if
1341 : : the conversion op is used. */
1342 : 38724 : if (varargs_function_p (callop))
1343 : : {
1344 : 196 : DECL_DELETED_FN (fn) = 1;
1345 : 196 : return;
1346 : : }
1347 : :
1348 : : /* Now build up the thunk to be returned. */
1349 : :
1350 : 38528 : tree statfn = build_lang_decl (FUNCTION_DECL, fun_identifier, stattype);
1351 : 38528 : SET_DECL_LANGUAGE (statfn, lang_cplusplus);
1352 : 38528 : fn = statfn;
1353 : 38528 : DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
1354 : 38528 : grokclassfn (type, fn, NO_SPECIAL);
1355 : 38528 : set_linkage_according_to_type (type, fn);
1356 : 38528 : rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
1357 : 38528 : DECL_IN_AGGR_P (fn) = 1;
1358 : 38528 : DECL_ARTIFICIAL (fn) = 1;
1359 : 38528 : DECL_NOT_REALLY_EXTERN (fn) = 1;
1360 : 38528 : DECL_DECLARED_INLINE_P (fn) = 1;
1361 : 38528 : DECL_STATIC_FUNCTION_P (fn) = 1;
1362 : 38528 : DECL_DECLARED_CONSTEXPR_P (fn) = DECL_DECLARED_CONSTEXPR_P (callop);
1363 : 77056 : if (DECL_IMMEDIATE_FUNCTION_P (callop))
1364 : 17 : SET_DECL_IMMEDIATE_FUNCTION_P (fn);
1365 : 38528 : DECL_ARGUMENTS (fn) = fn_args;
1366 : 66246 : for (tree arg = fn_args; arg; arg = DECL_CHAIN (arg))
1367 : : {
1368 : : /* Avoid duplicate -Wshadow warnings. */
1369 : 27718 : DECL_NAME (arg) = NULL_TREE;
1370 : 27718 : DECL_CONTEXT (arg) = fn;
1371 : : }
1372 : 38528 : if (nested_def)
1373 : 37156 : DECL_INTERFACE_KNOWN (fn) = 1;
1374 : :
1375 : 38528 : if (generic_lambda_p)
1376 : 9157 : fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
1377 : :
1378 : 38528 : if (flag_sanitize & SANITIZE_NULL)
1379 : : /* Don't UBsan this function; we're deliberately calling op() with a null
1380 : : object argument. */
1381 : 35 : add_no_sanitize_value (fn, SANITIZE_UNDEFINED);
1382 : :
1383 : 38528 : add_method (type, fn, false);
1384 : :
1385 : 38528 : if (nested)
1386 : 37178 : push_function_context ();
1387 : : else
1388 : : /* Still increment function_depth so that we don't GC in the
1389 : : middle of an expression. */
1390 : 1350 : ++function_depth;
1391 : :
1392 : : /* Generate the body of the thunk. */
1393 : :
1394 : 38528 : start_preparsed_function (statfn, NULL_TREE,
1395 : : SF_PRE_PARSED | SF_INCLASS_INLINE);
1396 : 38528 : tree body = begin_function_body ();
1397 : 38528 : tree compound_stmt = begin_compound_stmt (0);
1398 : 38528 : if (!generic_lambda_p)
1399 : : {
1400 : 29371 : set_flags_from_callee (call);
1401 : 29371 : if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call)))
1402 : 437 : call = build_cplus_new (TREE_TYPE (call), call, tf_warning_or_error);
1403 : : }
1404 : 38528 : call = convert_from_reference (call);
1405 : 38528 : finish_return_stmt (call);
1406 : :
1407 : 38528 : finish_compound_stmt (compound_stmt);
1408 : 38528 : finish_function_body (body);
1409 : :
1410 : 38528 : fn = finish_function (/*inline_p=*/true);
1411 : 38528 : if (!generic_lambda_p)
1412 : 29371 : expand_or_defer_fn (fn);
1413 : :
1414 : : /* Generate the body of the conversion op. */
1415 : :
1416 : 38528 : start_preparsed_function (convfn, NULL_TREE,
1417 : : SF_PRE_PARSED | SF_INCLASS_INLINE);
1418 : 38528 : body = begin_function_body ();
1419 : 38528 : compound_stmt = begin_compound_stmt (0);
1420 : :
1421 : : /* decl_needed_p needs to see that it's used. */
1422 : 38528 : TREE_USED (statfn) = 1;
1423 : 38528 : finish_return_stmt (decay_conversion (statfn, tf_warning_or_error));
1424 : :
1425 : 38528 : finish_compound_stmt (compound_stmt);
1426 : 38528 : finish_function_body (body);
1427 : :
1428 : 38528 : fn = finish_function (/*inline_p=*/true);
1429 : 38528 : if (!generic_lambda_p)
1430 : 29371 : expand_or_defer_fn (fn);
1431 : :
1432 : 38528 : if (nested)
1433 : 37178 : pop_function_context ();
1434 : : else
1435 : 1350 : --function_depth;
1436 : : }
1437 : :
1438 : : /* True if FN is the static function "_FUN" that gets returned from the lambda
1439 : : conversion operator. */
1440 : :
1441 : : bool
1442 : 451004 : lambda_static_thunk_p (tree fn)
1443 : : {
1444 : 451004 : return (fn && TREE_CODE (fn) == FUNCTION_DECL
1445 : 451004 : && DECL_ARTIFICIAL (fn)
1446 : 39464 : && DECL_STATIC_FUNCTION_P (fn)
1447 : 525520 : && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fn)));
1448 : : }
1449 : :
1450 : : bool
1451 : 146498291 : call_from_lambda_thunk_p (tree call)
1452 : : {
1453 : 146498291 : return (CALL_FROM_THUNK_P (call)
1454 : 146498291 : && lambda_static_thunk_p (current_function_decl));
1455 : : }
1456 : :
1457 : : /* Returns true iff VAL is a lambda-related declaration which should
1458 : : be ignored by unqualified lookup. */
1459 : :
1460 : : bool
1461 : 2882913914 : is_lambda_ignored_entity (tree val)
1462 : : {
1463 : : /* Look past normal, non-VLA capture proxies. */
1464 : 2882913914 : if (is_normal_capture_proxy (val)
1465 : 2882913914 : && !variably_modified_type_p (TREE_TYPE (val), NULL_TREE))
1466 : : return true;
1467 : :
1468 : : /* Always ignore lambda fields, their names are only for debugging. */
1469 : 2880575462 : if (TREE_CODE (val) == FIELD_DECL
1470 : 2880575462 : && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val)))
1471 : : return true;
1472 : :
1473 : : /* None of the lookups that use qualify_lookup want the op() from the
1474 : : lambda; they want the one from the enclosing class. */
1475 : 2880575435 : if (tree fns = maybe_get_fns (val))
1476 : 942288319 : if (LAMBDA_FUNCTION_P (OVL_FIRST (fns)))
1477 : : return true;
1478 : :
1479 : : return false;
1480 : : }
1481 : :
1482 : : /* Lambdas that appear in variable initializer or default argument
1483 : : scope get that in their mangling, so we need to record it. Also,
1484 : : multiple lambdas in the same scope may need a mangling
1485 : : discriminator. In ABI <= 17, there is a single per-scope sequence
1486 : : number. In ABI >= 18, there are per-scope per-signature sequence
1487 : : numbers. */
1488 : : struct GTY(()) lambda_sig_count
1489 : : {
1490 : : tree fn; // The lambda fn whose sig this is.
1491 : : unsigned count;
1492 : : };
1493 : : struct GTY(()) lambda_discriminator
1494 : : {
1495 : : tree scope;
1496 : : unsigned nesting; // Inside a function, VAR_DECLs get the function
1497 : : // as scope. This counts that nesting.
1498 : : unsigned count; // The per-scope counter.
1499 : : vec<lambda_sig_count, va_gc> *discriminators; // Per-signature counters
1500 : : };
1501 : : // The current scope.
1502 : : static GTY(()) lambda_discriminator lambda_scope;
1503 : : // Stack of previous scopes.
1504 : : static GTY(()) vec<lambda_discriminator, va_gc> *lambda_scope_stack;
1505 : :
1506 : : // Push DECL as lambda extra scope, also new discriminator counters.
1507 : :
1508 : : void
1509 : 197658025 : start_lambda_scope (tree decl)
1510 : : {
1511 : 197658025 : gcc_checking_assert (decl);
1512 : 197658025 : if (current_function_decl && VAR_P (decl))
1513 : : // If we're inside a function, we ignore variable scope. Don't push.
1514 : 39892589 : lambda_scope.nesting++;
1515 : : else
1516 : : {
1517 : 157765436 : vec_safe_push (lambda_scope_stack, lambda_scope);
1518 : 157765436 : lambda_scope.scope = decl;
1519 : 157765436 : lambda_scope.nesting = 0;
1520 : 157765436 : lambda_scope.count = 0;
1521 : 157765436 : lambda_scope.discriminators = nullptr;
1522 : : }
1523 : 197658025 : }
1524 : :
1525 : : // Pop from the current lambda extra scope.
1526 : :
1527 : : void
1528 : 197657986 : finish_lambda_scope (void)
1529 : : {
1530 : 197657986 : if (!lambda_scope.nesting--)
1531 : : {
1532 : 157765397 : lambda_scope = lambda_scope_stack->last ();
1533 : 157765397 : lambda_scope_stack->pop ();
1534 : : }
1535 : 197657986 : }
1536 : :
1537 : : // Record the current lambda scope into LAMBDA
1538 : :
1539 : : void
1540 : 738663 : record_lambda_scope (tree lambda)
1541 : : {
1542 : 738663 : LAMBDA_EXPR_EXTRA_SCOPE (lambda) = lambda_scope.scope;
1543 : 738663 : if (lambda_scope.scope)
1544 : : {
1545 : 735965 : tree closure = LAMBDA_EXPR_CLOSURE (lambda);
1546 : 735965 : gcc_checking_assert (closure);
1547 : 735965 : maybe_key_decl (lambda_scope.scope, TYPE_NAME (closure));
1548 : : }
1549 : 738663 : }
1550 : :
1551 : : // Compare lambda template heads TMPL_A and TMPL_B, used for both
1552 : : // templated lambdas, and template template parameters of said lambda.
1553 : :
1554 : : static bool
1555 : 8393 : compare_lambda_template_head (tree tmpl_a, tree tmpl_b)
1556 : : {
1557 : : // We only need one level of template parms
1558 : 8393 : tree inner_a = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl_a));
1559 : 8393 : tree inner_b = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl_b));
1560 : :
1561 : : // We only compare explicit template parms, ignoring trailing
1562 : : // synthetic ones.
1563 : 8393 : int len_a = TREE_VEC_LENGTH (inner_a);
1564 : 8393 : int len_b = TREE_VEC_LENGTH (inner_b);
1565 : :
1566 : 9036 : for (int ix = 0, len = MAX (len_a, len_b); ix != len; ix++)
1567 : : {
1568 : 8434 : tree parm_a = NULL_TREE;
1569 : 8434 : if (ix < len_a)
1570 : : {
1571 : 8422 : parm_a = TREE_VEC_ELT (inner_a, ix);
1572 : 8422 : if (parm_a == error_mark_node)
1573 : : return false;
1574 : 8422 : parm_a = TREE_VALUE (parm_a);
1575 : 8422 : if (parm_a == error_mark_node)
1576 : : return false;
1577 : 8422 : if (DECL_VIRTUAL_P (parm_a))
1578 : 5220 : parm_a = NULL_TREE;
1579 : : }
1580 : :
1581 : 8434 : tree parm_b = NULL_TREE;
1582 : 8434 : if (ix < len_b)
1583 : : {
1584 : 8414 : parm_b = TREE_VEC_ELT (inner_b, ix);
1585 : 8414 : if (parm_b == error_mark_node)
1586 : : return false;
1587 : 8414 : parm_b = TREE_VALUE (parm_b);
1588 : 8414 : if (parm_b == error_mark_node)
1589 : : return false;
1590 : 8408 : if (DECL_VIRTUAL_P (parm_b))
1591 : 5154 : parm_b = NULL_TREE;
1592 : : }
1593 : :
1594 : 8428 : if (!parm_a && !parm_b)
1595 : : // we're done
1596 : : break;
1597 : :
1598 : 3303 : if (!(parm_a && parm_b))
1599 : : return false;
1600 : :
1601 : 3184 : if (TREE_CODE (parm_a) != TREE_CODE (parm_b))
1602 : : return false;
1603 : :
1604 : 3184 : if (TREE_CODE (parm_a) == PARM_DECL)
1605 : : {
1606 : 2551 : if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm_a))
1607 : 2551 : != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm_b)))
1608 : : return false;
1609 : :
1610 : 10 : if (!same_type_p (TREE_TYPE (parm_a), TREE_TYPE (parm_b)))
1611 : : return false;
1612 : : }
1613 : : else
1614 : : {
1615 : 633 : if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm_a))
1616 : 633 : != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm_b)))
1617 : : return false;
1618 : :
1619 : 633 : if (TREE_CODE (parm_a) != TEMPLATE_DECL)
1620 : 633 : gcc_checking_assert (TREE_CODE (parm_a) == TYPE_DECL);
1621 : 0 : else if (!compare_lambda_template_head (parm_a, parm_b))
1622 : : return false;
1623 : : }
1624 : : }
1625 : :
1626 : : return true;
1627 : : }
1628 : :
1629 : : // Compare lambda signatures FN_A and FN_B, they may be TEMPLATE_DECLs too.
1630 : :
1631 : : static bool
1632 : 96378 : compare_lambda_sig (tree fn_a, tree fn_b)
1633 : : {
1634 : 96378 : if (TREE_CODE (fn_a) == TEMPLATE_DECL
1635 : 8748 : && TREE_CODE (fn_b) == TEMPLATE_DECL)
1636 : : {
1637 : 8393 : if (!compare_lambda_template_head (fn_a, fn_b))
1638 : : return false;
1639 : 5727 : fn_a = DECL_TEMPLATE_RESULT (fn_a);
1640 : 5727 : fn_b = DECL_TEMPLATE_RESULT (fn_b);
1641 : : }
1642 : 87985 : else if (TREE_CODE (fn_a) == TEMPLATE_DECL
1643 : 87630 : || TREE_CODE (fn_b) == TEMPLATE_DECL)
1644 : : return false;
1645 : :
1646 : 93077 : if (fn_a == error_mark_node
1647 : 93076 : || fn_b == error_mark_node)
1648 : : return false;
1649 : :
1650 : 93076 : for (tree args_a = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn_a))),
1651 : 93076 : args_b = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn_b)));
1652 : 171424 : args_a || args_b;
1653 : 78348 : args_a = TREE_CHAIN (args_a), args_b = TREE_CHAIN (args_b))
1654 : : {
1655 : 128331 : if (!args_a || !args_b)
1656 : : return false;
1657 : : // This check also deals with differing variadicness
1658 : 128326 : if (!same_type_p (TREE_VALUE (args_a), TREE_VALUE (args_b)))
1659 : : return false;
1660 : : }
1661 : :
1662 : : return true;
1663 : : }
1664 : :
1665 : : // Record the per-scope discriminator of LAMBDA. If the extra scope
1666 : : // is empty, we must use the empty scope counter, which might not be
1667 : : // the live one.
1668 : :
1669 : : void
1670 : 739057 : record_lambda_scope_discriminator (tree lambda)
1671 : : {
1672 : 1475247 : auto *slot = (vec_safe_is_empty (lambda_scope_stack)
1673 : 736190 : || LAMBDA_EXPR_EXTRA_SCOPE (lambda)
1674 : 225 : ? &lambda_scope : lambda_scope_stack->begin ());
1675 : 739057 : LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR (lambda) = slot->count++;
1676 : 739057 : }
1677 : :
1678 : : // Record the per-scope per-signature discriminator of LAMBDA. If the
1679 : : // extra scope is empty, we must use the empty scope counter, which
1680 : : // might not be the live one.
1681 : :
1682 : : void
1683 : 739045 : record_lambda_scope_sig_discriminator (tree lambda, tree fn)
1684 : : {
1685 : 1475223 : auto *slot = (vec_safe_is_empty (lambda_scope_stack)
1686 : 736178 : || LAMBDA_EXPR_EXTRA_SCOPE (lambda)
1687 : 222 : ? &lambda_scope : lambda_scope_stack->begin ());
1688 : 739045 : gcc_checking_assert (LAMBDA_EXPR_EXTRA_SCOPE (lambda) == slot->scope);
1689 : :
1690 : : // A linear search, we're not expecting this to be a big list, and
1691 : : // this avoids needing a signature hash function.
1692 : 739045 : lambda_sig_count *sig;
1693 : 739045 : if (unsigned ix = vec_safe_length (slot->discriminators))
1694 : 143725 : for (sig = slot->discriminators->begin (); ix--; sig++)
1695 : 96378 : if (compare_lambda_sig (fn, sig->fn))
1696 : 43093 : goto found;
1697 : 695952 : {
1698 : 695952 : lambda_sig_count init = {fn, 0};
1699 : 695952 : sig = vec_safe_push (slot->discriminators, init);
1700 : : }
1701 : 739045 : found:
1702 : 739045 : LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda) = sig->count++;
1703 : 739045 : }
1704 : :
1705 : : tree
1706 : 739014 : start_lambda_function (tree fco, tree lambda_expr)
1707 : : {
1708 : : /* Let the front end know that we are going to be defining this
1709 : : function. */
1710 : 739014 : start_preparsed_function (fco,
1711 : : NULL_TREE,
1712 : : SF_PRE_PARSED | SF_INCLASS_INLINE);
1713 : :
1714 : 739014 : tree body = begin_function_body ();
1715 : :
1716 : : /* Push the proxies for any explicit captures. */
1717 : 1361843 : for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap;
1718 : 622829 : cap = TREE_CHAIN (cap))
1719 : 622829 : build_capture_proxy (TREE_PURPOSE (cap), TREE_VALUE (cap));
1720 : :
1721 : 739014 : return body;
1722 : : }
1723 : :
1724 : : /* Subroutine of prune_lambda_captures: CAP is a node in
1725 : : LAMBDA_EXPR_CAPTURE_LIST. Return the variable it captures for which we
1726 : : might optimize away the capture, or NULL_TREE if there is no such
1727 : : variable. */
1728 : :
1729 : : static tree
1730 : 195 : var_to_maybe_prune (tree cap)
1731 : : {
1732 : 195 : if (LAMBDA_CAPTURE_EXPLICIT_P (cap))
1733 : : /* Don't prune explicit captures. */
1734 : : return NULL_TREE;
1735 : :
1736 : 186 : tree mem = TREE_PURPOSE (cap);
1737 : 372 : if (!DECL_P (mem) || !DECL_NORMAL_CAPTURE_P (mem))
1738 : : /* Packs and init-captures aren't captures of constant vars. */
1739 : : return NULL_TREE;
1740 : :
1741 : 186 : tree init = TREE_VALUE (cap);
1742 : 186 : if (is_normal_capture_proxy (init))
1743 : 3 : init = DECL_CAPTURED_VARIABLE (init);
1744 : 186 : if (decl_constant_var_p (init))
1745 : : return init;
1746 : :
1747 : : return NULL_TREE;
1748 : : }
1749 : :
1750 : : /* walk_tree helper for prune_lambda_captures: Remember which capture proxies
1751 : : for constant variables are actually used in the lambda body.
1752 : :
1753 : : There will always be a DECL_EXPR for the capture proxy; remember it when we
1754 : : see it, but replace it with any other use. */
1755 : :
1756 : : static tree
1757 : 3748 : mark_const_cap_r (tree *t, int *walk_subtrees, void *data)
1758 : : {
1759 : 3748 : hash_map<tree,tree*> &const_vars = *(hash_map<tree,tree*>*)data;
1760 : :
1761 : 3748 : tree var = NULL_TREE;
1762 : 3748 : if (TREE_CODE (*t) == DECL_EXPR)
1763 : : {
1764 : 280 : tree decl = DECL_EXPR_DECL (*t);
1765 : 280 : if (is_constant_capture_proxy (decl))
1766 : : {
1767 : 106 : var = DECL_CAPTURED_VARIABLE (decl);
1768 : 106 : *walk_subtrees = 0;
1769 : : }
1770 : : }
1771 : 3468 : else if (!location_wrapper_p (*t) /* is_capture_proxy dislikes them. */
1772 : 3468 : && is_constant_capture_proxy (*t))
1773 : 6 : var = DECL_CAPTURED_VARIABLE (*t);
1774 : :
1775 : 3748 : if (var)
1776 : : {
1777 : 112 : tree *&slot = const_vars.get_or_insert (var);
1778 : 112 : if (!slot || VAR_P (*t))
1779 : 112 : slot = t;
1780 : : }
1781 : :
1782 : 3748 : return NULL_TREE;
1783 : : }
1784 : :
1785 : : /* We're at the end of processing a lambda; go back and remove any captures of
1786 : : constant variables for which we've folded away all uses. */
1787 : :
1788 : : static void
1789 : 739014 : prune_lambda_captures (tree body)
1790 : : {
1791 : 739014 : tree lam = current_lambda_expr ();
1792 : 739014 : if (!LAMBDA_EXPR_CAPTURE_OPTIMIZED (lam))
1793 : : /* No uses were optimized away. */
1794 : 738925 : return;
1795 : 125 : if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) == CPLD_NONE)
1796 : : /* No default captures, and we don't prune explicit captures. */
1797 : : return;
1798 : : /* Don't bother pruning in a template, we'll prune at instantiation time. */
1799 : 113 : if (dependent_type_p (TREE_TYPE (lam)))
1800 : : return;
1801 : :
1802 : 89 : hash_map<tree,tree*> const_vars;
1803 : :
1804 : 89 : cp_walk_tree_without_duplicates (&body, mark_const_cap_r, &const_vars);
1805 : :
1806 : 89 : tree *fieldp = &TYPE_FIELDS (LAMBDA_EXPR_CLOSURE (lam));
1807 : 284 : for (tree *capp = &LAMBDA_EXPR_CAPTURE_LIST (lam); *capp; )
1808 : : {
1809 : 195 : tree cap = *capp;
1810 : 195 : if (tree var = var_to_maybe_prune (cap))
1811 : : {
1812 : 109 : tree **use = const_vars.get (var);
1813 : 109 : if (use && TREE_CODE (**use) == DECL_EXPR)
1814 : : {
1815 : : /* All uses of this capture were folded away, leaving only the
1816 : : proxy declaration. */
1817 : :
1818 : : /* Splice the capture out of LAMBDA_EXPR_CAPTURE_LIST. */
1819 : 100 : *capp = TREE_CHAIN (cap);
1820 : :
1821 : : /* And out of TYPE_FIELDS. */
1822 : 100 : tree field = TREE_PURPOSE (cap);
1823 : 192 : while (*fieldp != field)
1824 : 92 : fieldp = &DECL_CHAIN (*fieldp);
1825 : 100 : *fieldp = DECL_CHAIN (*fieldp);
1826 : :
1827 : : /* And remove the capture proxy declaration. */
1828 : 100 : **use = void_node;
1829 : 100 : continue;
1830 : 100 : }
1831 : : }
1832 : :
1833 : 95 : capp = &TREE_CHAIN (cap);
1834 : : }
1835 : 89 : }
1836 : :
1837 : : // Record the per-scope per-signature discriminator of LAMBDA. If the
1838 : : // extra scope is empty, we must use the empty scope counter, which
1839 : : // might not be the live one.
1840 : :
1841 : : void
1842 : 739014 : finish_lambda_function (tree body)
1843 : : {
1844 : 739014 : finish_function_body (body);
1845 : :
1846 : 739014 : prune_lambda_captures (body);
1847 : :
1848 : : /* Finish the function and generate code for it if necessary. */
1849 : 739014 : tree fn = finish_function (/*inline_p=*/true);
1850 : :
1851 : : /* Only expand if the call op is not a template. */
1852 : 739014 : if (!DECL_TEMPLATE_INFO (fn))
1853 : 233649 : expand_or_defer_fn (fn);
1854 : 739014 : }
1855 : :
1856 : : #include "gt-cp-lambda.h"
|
