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-2017 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
20You should have received a copy of the GNU General Public License
21along 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
34/* Constructor for a lambda expression. */
35
36tree
37build_lambda_expr (void)
38{
39 tree lambda = make_node (LAMBDA_EXPR);
40 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) = CPLD_NONE;
41 LAMBDA_EXPR_CAPTURE_LIST (lambda) = NULL_TREE;
42 LAMBDA_EXPR_THIS_CAPTURE (lambda) = NULL_TREE;
43 LAMBDA_EXPR_PENDING_PROXIES (lambda) = NULL;
44 LAMBDA_EXPR_MUTABLE_P (lambda) = false;
45 return lambda;
46}
47
48/* Create the closure object for a LAMBDA_EXPR. */
49
50tree
51build_lambda_object (tree lambda_expr)
52{
53 /* Build aggregate constructor call.
54 - cp_parser_braced_list
55 - cp_parser_functional_cast */
56 vec<constructor_elt, va_gc> *elts = NULL;
57 tree node, expr, type;
58 location_t saved_loc;
59
60 if (processing_template_decl || lambda_expr == error_mark_node)
61 return lambda_expr;
62
63 /* Make sure any error messages refer to the lambda-introducer. */
64 saved_loc = input_location;
65 input_location = LAMBDA_EXPR_LOCATION (lambda_expr);
66
67 for (node = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr);
68 node;
69 node = TREE_CHAIN (node))
70 {
71 tree field = TREE_PURPOSE (node);
72 tree val = TREE_VALUE (node);
73
74 if (field == error_mark_node)
75 {
76 expr = error_mark_node;
77 goto out;
78 }
79
80 if (TREE_CODE (val) == TREE_LIST)
81 val = build_x_compound_expr_from_list (val, ELK_INIT,
82 tf_warning_or_error);
83
84 if (DECL_P (val))
85 mark_used (val);
86
87 /* Mere mortals can't copy arrays with aggregate initialization, so
88 do some magic to make it work here. */
89 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE)
90 val = build_array_copy (val);
91 else if (DECL_NORMAL_CAPTURE_P (field)
92 && !DECL_VLA_CAPTURE_P (field)
93 && TREE_CODE (TREE_TYPE (field)) != REFERENCE_TYPE)
94 {
95 /* "the entities that are captured by copy are used to
96 direct-initialize each corresponding non-static data
97 member of the resulting closure object."
98
99 There's normally no way to express direct-initialization
100 from an element of a CONSTRUCTOR, so we build up a special
101 TARGET_EXPR to bypass the usual copy-initialization. */
102 val = force_rvalue (val, tf_warning_or_error);
103 if (TREE_CODE (val) == TARGET_EXPR)
104 TARGET_EXPR_DIRECT_INIT_P (val) = true;
105 }
106
107 CONSTRUCTOR_APPEND_ELT (elts, DECL_NAME (field), val);
108 }
109
110 expr = build_constructor (init_list_type_node, elts);
111 CONSTRUCTOR_IS_DIRECT_INIT (expr) = 1;
112
113 /* N2927: "[The closure] class type is not an aggregate."
114 But we briefly treat it as an aggregate to make this simpler. */
115 type = LAMBDA_EXPR_CLOSURE (lambda_expr);
116 CLASSTYPE_NON_AGGREGATE (type) = 0;
117 expr = finish_compound_literal (type, expr, tf_warning_or_error);
118 CLASSTYPE_NON_AGGREGATE (type) = 1;
119
120 out:
121 input_location = saved_loc;
122 return expr;
123}
124
125/* Return an initialized RECORD_TYPE for LAMBDA.
126 LAMBDA must have its explicit captures already. */
127
128tree
129begin_lambda_type (tree lambda)
130{
131 tree type;
132
133 {
134 /* Unique name. This is just like an unnamed class, but we cannot use
135 make_anon_name because of certain checks against TYPE_UNNAMED_P. */
136 tree name;
137 name = make_lambda_name ();
138
139 /* Create the new RECORD_TYPE for this lambda. */
140 type = xref_tag (/*tag_code=*/record_type,
141 name,
142 /*scope=*/ts_lambda,
143 /*template_header_p=*/false);
144 if (type == error_mark_node)
145 return error_mark_node;
146 }
147
148 /* Designate it as a struct so that we can use aggregate initialization. */
149 CLASSTYPE_DECLARED_CLASS (type) = false;
150
151 /* Cross-reference the expression and the type. */
152 LAMBDA_EXPR_CLOSURE (lambda) = type;
153 CLASSTYPE_LAMBDA_EXPR (type) = lambda;
154
155 /* In C++17, assume the closure is literal; we'll clear the flag later if
156 necessary. */
157 if (cxx_dialect >= cxx17)
158 CLASSTYPE_LITERAL_P (type) = true;
159
160 /* Clear base types. */
161 xref_basetypes (type, /*bases=*/NULL_TREE);
162
163 /* Start the class. */
164 type = begin_class_definition (type);
165
166 return type;
167}
168
169/* Returns the type to use for the return type of the operator() of a
170 closure class. */
171
172tree
173lambda_return_type (tree expr)
174{
175 if (expr == NULL_TREE)
176 return void_type_node;
177 if (type_unknown_p (expr)
178 || BRACE_ENCLOSED_INITIALIZER_P (expr))
179 {
180 cxx_incomplete_type_error (expr, TREE_TYPE (expr));
181 return error_mark_node;
182 }
183 gcc_checking_assert (!type_dependent_expression_p (expr));
184 return cv_unqualified (type_decays_to (unlowered_expr_type (expr)));
185}
186
187/* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
188 closure type. */
189
190tree
191lambda_function (tree lambda)
192{
193 tree type;
194 if (TREE_CODE (lambda) == LAMBDA_EXPR)
195 type = LAMBDA_EXPR_CLOSURE (lambda);
196 else
197 type = lambda;
198 gcc_assert (LAMBDA_TYPE_P (type));
199 /* Don't let debug_tree cause instantiation. */
200 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
201 && !COMPLETE_OR_OPEN_TYPE_P (type))
202 return NULL_TREE;
203 lambda = lookup_member (type, call_op_identifier,
204 /*protect=*/0, /*want_type=*/false,
205 tf_warning_or_error);
206 if (lambda)
207 lambda = STRIP_TEMPLATE (get_first_fn (lambda));
208 return lambda;
209}
210
211/* Returns the type to use for the FIELD_DECL corresponding to the
212 capture of EXPR. EXPLICIT_INIT_P indicates whether this is a
213 C++14 init capture, and BY_REFERENCE_P indicates whether we're
214 capturing by reference. */
215
216tree
217lambda_capture_field_type (tree expr, bool explicit_init_p,
218 bool by_reference_p)
219{
220 tree type;
221 bool is_this = is_this_parameter (tree_strip_nop_conversions (expr));
222
223 if (!is_this && type_dependent_expression_p (expr))
224 {
225 type = cxx_make_type (DECLTYPE_TYPE);
226 DECLTYPE_TYPE_EXPR (type) = expr;
227 DECLTYPE_FOR_LAMBDA_CAPTURE (type) = true;
228 DECLTYPE_FOR_INIT_CAPTURE (type) = explicit_init_p;
229 DECLTYPE_FOR_REF_CAPTURE (type) = by_reference_p;
230 SET_TYPE_STRUCTURAL_EQUALITY (type);
231 }
232 else if (!is_this && explicit_init_p)
233 {
234 tree auto_node = make_auto ();
235
236 type = auto_node;
237 if (by_reference_p)
238 /* Add the reference now, so deduction doesn't lose
239 outermost CV qualifiers of EXPR. */
240 type = build_reference_type (type);
241 type = do_auto_deduction (type, expr, auto_node);
242 }
243 else
244 {
245 type = non_reference (unlowered_expr_type (expr));
246
247 if (!is_this
248 && (by_reference_p || TREE_CODE (type) == FUNCTION_TYPE))
249 type = build_reference_type (type);
250 }
251
252 return type;
253}
254
255/* Returns true iff DECL is a lambda capture proxy variable created by
256 build_capture_proxy. */
257
258bool
259is_capture_proxy (tree decl)
260{
261 return (VAR_P (decl)
262 && DECL_HAS_VALUE_EXPR_P (decl)
263 && !DECL_ANON_UNION_VAR_P (decl)
264 && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl)));
265}
266
267/* Returns true iff DECL is a capture proxy for a normal capture
268 (i.e. without explicit initializer). */
269
270bool
271is_normal_capture_proxy (tree decl)
272{
273 if (!is_capture_proxy (decl))
274 /* It's not a capture proxy. */
275 return false;
276
277 if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
278 /* VLA capture. */
279 return true;
280
281 /* It is a capture proxy, is it a normal capture? */
282 tree val = DECL_VALUE_EXPR (decl);
283 if (val == error_mark_node)
284 return true;
285
286 if (TREE_CODE (val) == ADDR_EXPR)
287 val = TREE_OPERAND (val, 0);
288 gcc_assert (TREE_CODE (val) == COMPONENT_REF);
289 val = TREE_OPERAND (val, 1);
290 return DECL_NORMAL_CAPTURE_P (val);
291}
292
293/* VAR is a capture proxy created by build_capture_proxy; add it to the
294 current function, which is the operator() for the appropriate lambda. */
295
296void
297insert_capture_proxy (tree var)
298{
299 if (is_normal_capture_proxy (var))
300 {
301 tree cap = DECL_CAPTURED_VARIABLE (var);
302 if (CHECKING_P)
303 {
304 gcc_assert (!is_normal_capture_proxy (cap));
305 tree old = retrieve_local_specialization (cap);
306 if (old)
307 gcc_assert (DECL_CONTEXT (old) != DECL_CONTEXT (var));
308 }
309 register_local_specialization (var, cap);
310 }
311
312 /* Put the capture proxy in the extra body block so that it won't clash
313 with a later local variable. */
314 pushdecl_outermost_localscope (var);
315
316 /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
317 var = build_stmt (DECL_SOURCE_LOCATION (var), DECL_EXPR, var);
318 tree stmt_list = (*stmt_list_stack)[1];
319 gcc_assert (stmt_list);
320 append_to_statement_list_force (var, &stmt_list);
321}
322
323/* We've just finished processing a lambda; if the containing scope is also
324 a lambda, insert any capture proxies that were created while processing
325 the nested lambda. */
326
327void
328insert_pending_capture_proxies (void)
329{
330 tree lam;
331 vec<tree, va_gc> *proxies;
332 unsigned i;
333
334 if (!current_function_decl || !LAMBDA_FUNCTION_P (current_function_decl))
335 return;
336
337 lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl));
338 proxies = LAMBDA_EXPR_PENDING_PROXIES (lam);
339 for (i = 0; i < vec_safe_length (proxies); ++i)
340 {
341 tree var = (*proxies)[i];
342 insert_capture_proxy (var);
343 }
344 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam));
345 LAMBDA_EXPR_PENDING_PROXIES (lam) = NULL;
346}
347
348/* Given REF, a COMPONENT_REF designating a field in the lambda closure,
349 return the type we want the proxy to have: the type of the field itself,
350 with added const-qualification if the lambda isn't mutable and the
351 capture is by value. */
352
353tree
354lambda_proxy_type (tree ref)
355{
356 tree type;
357 if (ref == error_mark_node)
358 return error_mark_node;
359 if (REFERENCE_REF_P (ref))
360 ref = TREE_OPERAND (ref, 0);
361 gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
362 type = TREE_TYPE (ref);
363 if (!type || WILDCARD_TYPE_P (non_reference (type)))
364 {
365 type = cxx_make_type (DECLTYPE_TYPE);
366 DECLTYPE_TYPE_EXPR (type) = ref;
367 DECLTYPE_FOR_LAMBDA_PROXY (type) = true;
368 SET_TYPE_STRUCTURAL_EQUALITY (type);
369 }
370 if (DECL_PACK_P (TREE_OPERAND (ref, 1)))
371 type = make_pack_expansion (type);
372 return type;
373}
374
375/* MEMBER is a capture field in a lambda closure class. Now that we're
376 inside the operator(), build a placeholder var for future lookups and
377 debugging. */
378
379tree
380build_capture_proxy (tree member, tree init)
381{
382 tree var, object, fn, closure, name, lam, type;
383
384 if (PACK_EXPANSION_P (member))
385 member = PACK_EXPANSION_PATTERN (member);
386
387 closure = DECL_CONTEXT (member);
388 fn = lambda_function (closure);
389 lam = CLASSTYPE_LAMBDA_EXPR (closure);
390
391 /* The proxy variable forwards to the capture field. */
392 object = build_fold_indirect_ref (DECL_ARGUMENTS (fn));
393 object = finish_non_static_data_member (member, object, NULL_TREE);
394 if (REFERENCE_REF_P (object))
395 object = TREE_OPERAND (object, 0);
396
397 /* Remove the __ inserted by add_capture. */
398 name = get_identifier (IDENTIFIER_POINTER (DECL_NAME (member)) + 2);
399
400 type = lambda_proxy_type (object);
401
402 if (name == this_identifier && !POINTER_TYPE_P (type))
403 {
404 type = build_pointer_type (type);
405 type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
406 object = build_fold_addr_expr_with_type (object, type);
407 }
408
409 if (DECL_VLA_CAPTURE_P (member))
410 {
411 /* Rebuild the VLA type from the pointer and maxindex. */
412 tree field = next_initializable_field (TYPE_FIELDS (type));
413 tree ptr = build_simple_component_ref (object, field);
414 field = next_initializable_field (DECL_CHAIN (field));
415 tree max = build_simple_component_ref (object, field);
416 type = build_cplus_array_type (TREE_TYPE (TREE_TYPE (ptr)),
417 build_index_type (max));
418 type = build_reference_type (type);
419 REFERENCE_VLA_OK (type) = true;
420 object = convert (type, ptr);
421 }
422
423 var = build_decl (input_location, VAR_DECL, name, type);
424 SET_DECL_VALUE_EXPR (var, object);
425 DECL_HAS_VALUE_EXPR_P (var) = 1;
426 DECL_ARTIFICIAL (var) = 1;
427 TREE_USED (var) = 1;
428 DECL_CONTEXT (var) = fn;
429
430 if (DECL_NORMAL_CAPTURE_P (member))
431 {
432 if (DECL_VLA_CAPTURE_P (member))
433 {
434 init = CONSTRUCTOR_ELT (init, 0)->value;
435 init = TREE_OPERAND (init, 0); // Strip ADDR_EXPR.
436 init = TREE_OPERAND (init, 0); // Strip ARRAY_REF.
437 }
438 else
439 {
440 if (PACK_EXPANSION_P (init))
441 init = PACK_EXPANSION_PATTERN (init);
442 if (TREE_CODE (init) == INDIRECT_REF)
443 init = TREE_OPERAND (init, 0);
444 STRIP_NOPS (init);
445 }
446 gcc_assert (VAR_P (init) || TREE_CODE (init) == PARM_DECL);
447 while (is_normal_capture_proxy (init))
448 init = DECL_CAPTURED_VARIABLE (init);
449 retrofit_lang_decl (var);
450 DECL_CAPTURED_VARIABLE (var) = init;
451 }
452
453 if (name == this_identifier)
454 {
455 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam) == member);
456 LAMBDA_EXPR_THIS_CAPTURE (lam) = var;
457 }
458
459 if (fn == current_function_decl)
460 insert_capture_proxy (var);
461 else
462 vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam), var);
463
464 return var;
465}
466
467static GTY(()) tree ptr_id;
468static GTY(()) tree max_id;
469
470/* Return a struct containing a pointer and a length for lambda capture of
471 an array of runtime length. */
472
473static tree
474vla_capture_type (tree array_type)
475{
476 tree type = xref_tag (record_type, make_anon_name (), ts_current, false);
477 xref_basetypes (type, NULL_TREE);
478 type = begin_class_definition (type);
479 if (!ptr_id)
480 {
481 ptr_id = get_identifier ("ptr");
482 max_id = get_identifier ("max");
483 }
484 tree ptrtype = build_pointer_type (TREE_TYPE (array_type));
485 tree field = build_decl (input_location, FIELD_DECL, ptr_id, ptrtype);
486 finish_member_declaration (field);
487 field = build_decl (input_location, FIELD_DECL, max_id, sizetype);
488 finish_member_declaration (field);
489 return finish_struct (type, NULL_TREE);
490}
491
492/* From an ID and INITIALIZER, create a capture (by reference if
493 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
494 and return it. If ID is `this', BY_REFERENCE_P says whether
495 `*this' is captured by reference. */
496
497tree
498add_capture (tree lambda, tree id, tree orig_init, bool by_reference_p,
499 bool explicit_init_p)
500{
501 char *buf;
502 tree type, member, name;
503 bool vla = false;
504 bool variadic = false;
505 tree initializer = orig_init;
506
507 if (PACK_EXPANSION_P (initializer))
508 {
509 initializer = PACK_EXPANSION_PATTERN (initializer);
510 variadic = true;
511 }
512
513 if (TREE_CODE (initializer) == TREE_LIST
514 /* A pack expansion might end up with multiple elements. */
515 && !PACK_EXPANSION_P (TREE_VALUE (initializer)))
516 initializer = build_x_compound_expr_from_list (initializer, ELK_INIT,
517 tf_warning_or_error);
518 type = TREE_TYPE (initializer);
519 if (type == error_mark_node)
520 return error_mark_node;
521
522 if (array_of_runtime_bound_p (type))
523 {
524 vla = true;
525 if (!by_reference_p)
526 error ("array of runtime bound cannot be captured by copy, "
527 "only by reference");
528
529 /* For a VLA, we capture the address of the first element and the
530 maximum index, and then reconstruct the VLA for the proxy. */
531 tree elt = cp_build_array_ref (input_location, initializer,
532 integer_zero_node, tf_warning_or_error);
533 initializer = build_constructor_va (init_list_type_node, 2,
534 NULL_TREE, build_address (elt),
535 NULL_TREE, array_type_nelts (type));
536 type = vla_capture_type (type);
537 }
538 else if (!dependent_type_p (type)
539 && variably_modified_type_p (type, NULL_TREE))
540 {
541 error ("capture of variable-size type %qT that is not an N3639 array "
542 "of runtime bound", type);
543 if (TREE_CODE (type) == ARRAY_TYPE
544 && variably_modified_type_p (TREE_TYPE (type), NULL_TREE))
545 inform (input_location, "because the array element type %qT has "
546 "variable size", TREE_TYPE (type));
547 type = error_mark_node;
548 }
549 else
550 {
551 type = lambda_capture_field_type (initializer, explicit_init_p,
552 by_reference_p);
553 if (type == error_mark_node)
554 return error_mark_node;
555
556 if (id == this_identifier && !by_reference_p)
557 {
558 gcc_assert (POINTER_TYPE_P (type));
559 type = TREE_TYPE (type);
560 initializer = cp_build_fold_indirect_ref (initializer);
561 }
562
563 if (dependent_type_p (type))
564 ;
565 else if (id != this_identifier && by_reference_p)
566 {
567 if (!lvalue_p (initializer))
568 {
569 error ("cannot capture %qE by reference", initializer);
570 return error_mark_node;
571 }
572 }
573 else
574 {
575 /* Capture by copy requires a complete type. */
576 type = complete_type (type);
577 if (!COMPLETE_TYPE_P (type))
578 {
579 error ("capture by copy of incomplete type %qT", type);
580 cxx_incomplete_type_inform (type);
581 return error_mark_node;
582 }
583 }
584 }
585
586 /* Add __ to the beginning of the field name so that user code
587 won't find the field with name lookup. We can't just leave the name
588 unset because template instantiation uses the name to find
589 instantiated fields. */
590 buf = (char *) alloca (IDENTIFIER_LENGTH (id) + 3);
591 buf[1] = buf[0] = '_';
592 memcpy (buf + 2, IDENTIFIER_POINTER (id),
593 IDENTIFIER_LENGTH (id) + 1);
594 name = get_identifier (buf);
595
596 /* If TREE_TYPE isn't set, we're still in the introducer, so check
597 for duplicates. */
598 if (!LAMBDA_EXPR_CLOSURE (lambda))
599 {
600 if (IDENTIFIER_MARKED (name))
601 {
602 pedwarn (input_location, 0,
603 "already captured %qD in lambda expression", id);
604 return NULL_TREE;
605 }
606 IDENTIFIER_MARKED (name) = true;
607 }
608
609 if (variadic)
610 type = make_pack_expansion (type);
611
612 /* Make member variable. */
613 member = build_decl (input_location, FIELD_DECL, name, type);
614 DECL_VLA_CAPTURE_P (member) = vla;
615
616 if (!explicit_init_p)
617 /* Normal captures are invisible to name lookup but uses are replaced
618 with references to the capture field; we implement this by only
619 really making them invisible in unevaluated context; see
620 qualify_lookup. For now, let's make explicitly initialized captures
621 always visible. */
622 DECL_NORMAL_CAPTURE_P (member) = true;
623
624 if (id == this_identifier)
625 LAMBDA_EXPR_THIS_CAPTURE (lambda) = member;
626
627 /* Add it to the appropriate closure class if we've started it. */
628 if (current_class_type
629 && current_class_type == LAMBDA_EXPR_CLOSURE (lambda))
630 {
631 if (COMPLETE_TYPE_P (current_class_type))
632 internal_error ("trying to capture %qD in instantiation of "
633 "generic lambda", id);
634 finish_member_declaration (member);
635 }
636
637 tree listmem = member;
638 if (variadic)
639 {
640 listmem = make_pack_expansion (member);
641 initializer = orig_init;
642 }
643 LAMBDA_EXPR_CAPTURE_LIST (lambda)
644 = tree_cons (listmem, initializer, LAMBDA_EXPR_CAPTURE_LIST (lambda));
645
646 if (LAMBDA_EXPR_CLOSURE (lambda))
647 return build_capture_proxy (member, initializer);
648 /* For explicit captures we haven't started the function yet, so we wait
649 and build the proxy from cp_parser_lambda_body. */
650 return NULL_TREE;
651}
652
653/* Register all the capture members on the list CAPTURES, which is the
654 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
655
656void
657register_capture_members (tree captures)
658{
659 if (captures == NULL_TREE)
660 return;
661
662 register_capture_members (TREE_CHAIN (captures));
663
664 tree field = TREE_PURPOSE (captures);
665 if (PACK_EXPANSION_P (field))
666 field = PACK_EXPANSION_PATTERN (field);
667
668 /* We set this in add_capture to avoid duplicates. */
669 IDENTIFIER_MARKED (DECL_NAME (field)) = false;
670 finish_member_declaration (field);
671}
672
673/* Similar to add_capture, except this works on a stack of nested lambdas.
674 BY_REFERENCE_P in this case is derived from the default capture mode.
675 Returns the capture for the lambda at the bottom of the stack. */
676
677tree
678add_default_capture (tree lambda_stack, tree id, tree initializer)
679{
680 bool this_capture_p = (id == this_identifier);
681
682 tree var = NULL_TREE;
683
684 tree saved_class_type = current_class_type;
685
686 tree node;
687
688 for (node = lambda_stack;
689 node;
690 node = TREE_CHAIN (node))
691 {
692 tree lambda = TREE_VALUE (node);
693
694 current_class_type = LAMBDA_EXPR_CLOSURE (lambda);
695 if (DECL_PACK_P (initializer))
696 initializer = make_pack_expansion (initializer);
697 var = add_capture (lambda,
698 id,
699 initializer,
700 /*by_reference_p=*/
701 (this_capture_p
702 || (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda)
703 == CPLD_REFERENCE)),
704 /*explicit_init_p=*/false);
705 initializer = convert_from_reference (var);
706 }
707
708 current_class_type = saved_class_type;
709
710 return var;
711}
712
713/* Return the capture pertaining to a use of 'this' in LAMBDA, in the
714 form of an INDIRECT_REF, possibly adding it through default
715 capturing, if ADD_CAPTURE_P is true. */
716
717tree
718lambda_expr_this_capture (tree lambda, bool add_capture_p)
719{
720 tree result;
721
722 tree this_capture = LAMBDA_EXPR_THIS_CAPTURE (lambda);
723
724 /* In unevaluated context this isn't an odr-use, so don't capture. */
725 if (cp_unevaluated_operand)
726 add_capture_p = false;
727
728 /* Try to default capture 'this' if we can. */
729 if (!this_capture
730 && (!add_capture_p
731 || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) != CPLD_NONE))
732 {
733 tree lambda_stack = NULL_TREE;
734 tree init = NULL_TREE;
735
736 /* If we are in a lambda function, we can move out until we hit:
737 1. a non-lambda function or NSDMI,
738 2. a lambda function capturing 'this', or
739 3. a non-default capturing lambda function. */
740 for (tree tlambda = lambda; ;)
741 {
742 lambda_stack = tree_cons (NULL_TREE,
743 tlambda,
744 lambda_stack);
745
746 if (LAMBDA_EXPR_EXTRA_SCOPE (tlambda)
747 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (tlambda)) == FIELD_DECL)
748 {
749 /* In an NSDMI, we don't have a function to look up the decl in,
750 but the fake 'this' pointer that we're using for parsing is
751 in scope_chain. */
752 init = scope_chain->x_current_class_ptr;
753 gcc_checking_assert
754 (init && (TREE_TYPE (TREE_TYPE (init))
755 == current_nonlambda_class_type ()));
756 break;
757 }
758
759 tree closure_decl = TYPE_NAME (LAMBDA_EXPR_CLOSURE (tlambda));
760 tree containing_function = decl_function_context (closure_decl);
761
762 if (containing_function == NULL_TREE)
763 /* We ran out of scopes; there's no 'this' to capture. */
764 break;
765
766 if (!LAMBDA_FUNCTION_P (containing_function))
767 {
768 /* We found a non-lambda function. */
769 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function))
770 /* First parameter is 'this'. */
771 init = DECL_ARGUMENTS (containing_function);
772 break;
773 }
774
775 tlambda
776 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function));
777
778 if (LAMBDA_EXPR_THIS_CAPTURE (tlambda))
779 {
780 /* An outer lambda has already captured 'this'. */
781 init = LAMBDA_EXPR_THIS_CAPTURE (tlambda);
782 break;
783 }
784
785 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda) == CPLD_NONE)
786 /* An outer lambda won't let us capture 'this'. */
787 break;
788 }
789
790 if (init)
791 {
792 if (add_capture_p)
793 this_capture = add_default_capture (lambda_stack,
794 /*id=*/this_identifier,
795 init);
796 else
797 this_capture = init;
798 }
799 }
800
801 if (cp_unevaluated_operand)
802 result = this_capture;
803 else if (!this_capture)
804 {
805 if (add_capture_p)
806 {
807 error ("%<this%> was not captured for this lambda function");
808 result = error_mark_node;
809 }
810 else
811 result = NULL_TREE;
812 }
813 else
814 {
815 /* To make sure that current_class_ref is for the lambda. */
816 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref))
817 == LAMBDA_EXPR_CLOSURE (lambda));
818
819 result = this_capture;
820
821 /* If 'this' is captured, each use of 'this' is transformed into an
822 access to the corresponding unnamed data member of the closure
823 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
824 ensures that the transformed expression is an rvalue. ] */
825 result = rvalue (result);
826 }
827
828 return result;
829}
830
831/* Return the current LAMBDA_EXPR, if this is a resolvable dummy
832 object. NULL otherwise.. */
833
834static tree
835resolvable_dummy_lambda (tree object)
836{
837 if (!is_dummy_object (object))
838 return NULL_TREE;
839
840 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (object));
841 gcc_assert (!TYPE_PTR_P (type));
842
843 if (type != current_class_type
844 && current_class_type
845 && LAMBDA_TYPE_P (current_class_type)
846 && lambda_function (current_class_type)
847 && DERIVED_FROM_P (type, current_nonlambda_class_type ()))
848 return CLASSTYPE_LAMBDA_EXPR (current_class_type);
849
850 return NULL_TREE;
851}
852
853/* We don't want to capture 'this' until we know we need it, i.e. after
854 overload resolution has chosen a non-static member function. At that
855 point we call this function to turn a dummy object into a use of the
856 'this' capture. */
857
858tree
859maybe_resolve_dummy (tree object, bool add_capture_p)
860{
861 if (tree lam = resolvable_dummy_lambda (object))
862 if (tree cap = lambda_expr_this_capture (lam, add_capture_p))
863 if (cap != error_mark_node)
864 object = build_fold_indirect_ref (cap);
865
866 return object;
867}
868
869/* When parsing a generic lambda containing an argument-dependent
870 member function call we defer overload resolution to instantiation
871 time. But we have to know now whether to capture this or not.
872 Do that if FNS contains any non-static fns.
873 The std doesn't anticipate this case, but I expect this to be the
874 outcome of discussion. */
875
876void
877maybe_generic_this_capture (tree object, tree fns)
878{
879 if (tree lam = resolvable_dummy_lambda (object))
880 if (!LAMBDA_EXPR_THIS_CAPTURE (lam))
881 {
882 /* We've not yet captured, so look at the function set of
883 interest. */
884 if (BASELINK_P (fns))
885 fns = BASELINK_FUNCTIONS (fns);
886 bool id_expr = TREE_CODE (fns) == TEMPLATE_ID_EXPR;
887 if (id_expr)
888 fns = TREE_OPERAND (fns, 0);
889
890 for (lkp_iterator iter (fns); iter; ++iter)
891 if ((!id_expr || TREE_CODE (*iter) == TEMPLATE_DECL)
892 && DECL_NONSTATIC_MEMBER_FUNCTION_P (*iter))
893 {
894 /* Found a non-static member. Capture this. */
895 lambda_expr_this_capture (lam, true);
896 break;
897 }
898 }
899}
900
901/* Returns the innermost non-lambda function. */
902
903tree
904current_nonlambda_function (void)
905{
906 tree fn = current_function_decl;
907 while (fn && LAMBDA_FUNCTION_P (fn))
908 fn = decl_function_context (fn);
909 return fn;
910}
911
912/* Returns the method basetype of the innermost non-lambda function, or
913 NULL_TREE if none. */
914
915tree
916nonlambda_method_basetype (void)
917{
918 tree fn, type;
919 if (!current_class_ref)
920 return NULL_TREE;
921
922 type = current_class_type;
923 if (!type || !LAMBDA_TYPE_P (type))
924 return type;
925
926 /* Find the nearest enclosing non-lambda function. */
927 fn = TYPE_NAME (type);
928 do
929 fn = decl_function_context (fn);
930 while (fn && LAMBDA_FUNCTION_P (fn));
931
932 if (!fn || !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
933 return NULL_TREE;
934
935 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
936}
937
938/* Like current_scope, but looking through lambdas. */
939
940tree
941current_nonlambda_scope (void)
942{
943 tree scope = current_scope ();
944 for (;;)
945 {
946 if (TREE_CODE (scope) == FUNCTION_DECL
947 && LAMBDA_FUNCTION_P (scope))
948 {
949 scope = CP_TYPE_CONTEXT (DECL_CONTEXT (scope));
950 continue;
951 }
952 else if (LAMBDA_TYPE_P (scope))
953 {
954 scope = CP_TYPE_CONTEXT (scope);
955 continue;
956 }
957 break;
958 }
959 return scope;
960}
961
962/* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with
963 indicated FN and NARGS, but do not initialize the return type or any of the
964 argument slots. */
965
966static tree
967prepare_op_call (tree fn, int nargs)
968{
969 tree t;
970
971 t = build_vl_exp (CALL_EXPR, nargs + 3);
972 CALL_EXPR_FN (t) = fn;
973 CALL_EXPR_STATIC_CHAIN (t) = NULL;
974
975 return t;
976}
977
978/* Return true iff CALLOP is the op() for a generic lambda. */
979
980bool
981generic_lambda_fn_p (tree callop)
982{
983 return (LAMBDA_FUNCTION_P (callop)
984 && DECL_TEMPLATE_INFO (callop)
985 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (callop)));
986}
987
988/* If the closure TYPE has a static op(), also add a conversion to function
989 pointer. */
990
991void
992maybe_add_lambda_conv_op (tree type)
993{
994 bool nested = (cfun != NULL);
995 bool nested_def = decl_function_context (TYPE_MAIN_DECL (type));
996 tree callop = lambda_function (type);
997 tree lam = CLASSTYPE_LAMBDA_EXPR (type);
998
999 if (LAMBDA_EXPR_CAPTURE_LIST (lam) != NULL_TREE
1000 || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) != CPLD_NONE)
1001 return;
1002
1003 if (processing_template_decl)
1004 return;
1005
1006 bool const generic_lambda_p = generic_lambda_fn_p (callop);
1007
1008 if (!generic_lambda_p && DECL_INITIAL (callop) == NULL_TREE)
1009 {
1010 /* If the op() wasn't instantiated due to errors, give up. */
1011 gcc_assert (errorcount || sorrycount);
1012 return;
1013 }
1014
1015 /* Non-template conversion operators are defined directly with build_call_a
1016 and using DIRECT_ARGVEC for arguments (including 'this'). Templates are
1017 deferred and the CALL is built in-place. In the case of a deduced return
1018 call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
1019 the return type is also built in-place. The arguments of DECLTYPE_CALL in
1020 the return expression may differ in flags from those in the body CALL. In
1021 particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
1022 the body CALL, but not in DECLTYPE_CALL. */
1023
1024 vec<tree, va_gc> *direct_argvec = 0;
1025 tree decltype_call = 0, call = 0;
1026 tree optype = TREE_TYPE (callop);
1027 tree fn_result = TREE_TYPE (optype);
1028
1029 tree thisarg = build_nop (TREE_TYPE (DECL_ARGUMENTS (callop)),
1030 null_pointer_node);
1031 if (generic_lambda_p)
1032 {
1033 ++processing_template_decl;
1034
1035 /* Prepare the dependent member call for the static member function
1036 '_FUN' and, potentially, prepare another call to be used in a decltype
1037 return expression for a deduced return call op to allow for simple
1038 implementation of the conversion operator. */
1039
1040 tree instance = cp_build_fold_indirect_ref (thisarg);
1041 tree objfn = build_min (COMPONENT_REF, NULL_TREE,
1042 instance, DECL_NAME (callop), NULL_TREE);
1043 int nargs = list_length (DECL_ARGUMENTS (callop)) - 1;
1044
1045 call = prepare_op_call (objfn, nargs);
1046 if (type_uses_auto (fn_result))
1047 decltype_call = prepare_op_call (objfn, nargs);
1048 }
1049 else
1050 {
1051 direct_argvec = make_tree_vector ();
1052 direct_argvec->quick_push (thisarg);
1053 }
1054
1055 /* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to
1056 declare the static member function "_FUN" below. For each arg append to
1057 DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated
1058 call args (for the template case). If a parameter pack is found, expand
1059 it, flagging it as PACK_EXPANSION_LOCAL_P for the body call. */
1060
1061 tree fn_args = NULL_TREE;
1062 {
1063 int ix = 0;
1064 tree src = DECL_CHAIN (DECL_ARGUMENTS (callop));
1065 tree tgt = NULL;
1066
1067 while (src)
1068 {
1069 tree new_node = copy_node (src);
1070
1071 if (!fn_args)
1072 fn_args = tgt = new_node;
1073 else
1074 {
1075 TREE_CHAIN (tgt) = new_node;
1076 tgt = new_node;
1077 }
1078
1079 mark_exp_read (tgt);
1080
1081 if (generic_lambda_p)
1082 {
1083 /* Avoid capturing variables in this context. */
1084 ++cp_unevaluated_operand;
1085 tree a = forward_parm (tgt);
1086 --cp_unevaluated_operand;
1087
1088 CALL_EXPR_ARG (call, ix) = a;
1089 if (decltype_call)
1090 CALL_EXPR_ARG (decltype_call, ix) = unshare_expr (a);
1091
1092 if (PACK_EXPANSION_P (a))
1093 /* Set this after unsharing so it's not in decltype_call. */
1094 PACK_EXPANSION_LOCAL_P (a) = true;
1095
1096 ++ix;
1097 }
1098 else
1099 vec_safe_push (direct_argvec, tgt);
1100
1101 src = TREE_CHAIN (src);
1102 }
1103 }
1104
1105 if (generic_lambda_p)
1106 {
1107 if (decltype_call)
1108 {
1109 fn_result = finish_decltype_type
1110 (decltype_call, /*id_expression_or_member_access_p=*/false,
1111 tf_warning_or_error);
1112 }
1113 }
1114 else
1115 call = build_call_a (callop,
1116 direct_argvec->length (),
1117 direct_argvec->address ());
1118
1119 CALL_FROM_THUNK_P (call) = 1;
1120 SET_EXPR_LOCATION (call, UNKNOWN_LOCATION);
1121
1122 tree stattype = build_function_type (fn_result, FUNCTION_ARG_CHAIN (callop));
1123 stattype = (cp_build_type_attribute_variant
1124 (stattype, TYPE_ATTRIBUTES (optype)));
1125 if (flag_noexcept_type
1126 && TYPE_NOTHROW_P (TREE_TYPE (callop)))
1127 stattype = build_exception_variant (stattype, noexcept_true_spec);
1128
1129 if (generic_lambda_p)
1130 --processing_template_decl;
1131
1132 /* First build up the conversion op. */
1133
1134 tree rettype = build_pointer_type (stattype);
1135 tree name = make_conv_op_name (rettype);
1136 tree thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1137 tree fntype = build_method_type_directly (thistype, rettype, void_list_node);
1138 tree convfn = build_lang_decl (FUNCTION_DECL, name, fntype);
1139 tree fn = convfn;
1140 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
1141 SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
1142 grokclassfn (type, fn, NO_SPECIAL);
1143 set_linkage_according_to_type (type, fn);
1144 rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
1145 DECL_IN_AGGR_P (fn) = 1;
1146 DECL_ARTIFICIAL (fn) = 1;
1147 DECL_NOT_REALLY_EXTERN (fn) = 1;
1148 DECL_DECLARED_INLINE_P (fn) = 1;
1149 DECL_ARGUMENTS (fn) = build_this_parm (fn, fntype, TYPE_QUAL_CONST);
1150
1151 if (nested_def)
1152 DECL_INTERFACE_KNOWN (fn) = 1;
1153
1154 if (generic_lambda_p)
1155 fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
1156
1157 add_method (type, fn, false);
1158
1159 /* Generic thunk code fails for varargs; we'll complain in mark_used if
1160 the conversion op is used. */
1161 if (varargs_function_p (callop))
1162 {
1163 DECL_DELETED_FN (fn) = 1;
1164 return;
1165 }
1166
1167 /* Now build up the thunk to be returned. */
1168
1169 name = get_identifier ("_FUN");
1170 tree statfn = build_lang_decl (FUNCTION_DECL, name, stattype);
1171 fn = statfn;
1172 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
1173 grokclassfn (type, fn, NO_SPECIAL);
1174 set_linkage_according_to_type (type, fn);
1175 rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
1176 DECL_IN_AGGR_P (fn) = 1;
1177 DECL_ARTIFICIAL (fn) = 1;
1178 DECL_NOT_REALLY_EXTERN (fn) = 1;
1179 DECL_DECLARED_INLINE_P (fn) = 1;
1180 DECL_STATIC_FUNCTION_P (fn) = 1;
1181 DECL_ARGUMENTS (fn) = fn_args;
1182 for (tree arg = fn_args; arg; arg = DECL_CHAIN (arg))
1183 {
1184 /* Avoid duplicate -Wshadow warnings. */
1185 DECL_NAME (arg) = NULL_TREE;
1186 DECL_CONTEXT (arg) = fn;
1187 }
1188 if (nested_def)
1189 DECL_INTERFACE_KNOWN (fn) = 1;
1190
1191 if (generic_lambda_p)
1192 fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
1193
1194 if (flag_sanitize & SANITIZE_NULL)
1195 /* Don't UBsan this function; we're deliberately calling op() with a null
1196 object argument. */
1197 add_no_sanitize_value (fn, SANITIZE_UNDEFINED);
1198
1199 add_method (type, fn, false);
1200
1201 if (nested)
1202 push_function_context ();
1203 else
1204 /* Still increment function_depth so that we don't GC in the
1205 middle of an expression. */
1206 ++function_depth;
1207
1208 /* Generate the body of the thunk. */
1209
1210 start_preparsed_function (statfn, NULL_TREE,
1211 SF_PRE_PARSED | SF_INCLASS_INLINE);
1212 if (DECL_ONE_ONLY (statfn))
1213 {
1214 /* Put the thunk in the same comdat group as the call op. */
1215 cgraph_node::get_create (statfn)->add_to_same_comdat_group
1216 (cgraph_node::get_create (callop));
1217 }
1218 tree body = begin_function_body ();
1219 tree compound_stmt = begin_compound_stmt (0);
1220 if (!generic_lambda_p)
1221 {
1222 set_flags_from_callee (call);
1223 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call)))
1224 call = build_cplus_new (TREE_TYPE (call), call, tf_warning_or_error);
1225 }
1226 call = convert_from_reference (call);
1227 finish_return_stmt (call);
1228
1229 finish_compound_stmt (compound_stmt);
1230 finish_function_body (body);
1231
1232 fn = finish_function (/*inline_p=*/true);
1233 if (!generic_lambda_p)
1234 expand_or_defer_fn (fn);
1235
1236 /* Generate the body of the conversion op. */
1237
1238 start_preparsed_function (convfn, NULL_TREE,
1239 SF_PRE_PARSED | SF_INCLASS_INLINE);
1240 body = begin_function_body ();
1241 compound_stmt = begin_compound_stmt (0);
1242
1243 /* decl_needed_p needs to see that it's used. */
1244 TREE_USED (statfn) = 1;
1245 finish_return_stmt (decay_conversion (statfn, tf_warning_or_error));
1246
1247 finish_compound_stmt (compound_stmt);
1248 finish_function_body (body);
1249
1250 fn = finish_function (/*inline_p=*/true);
1251 if (!generic_lambda_p)
1252 expand_or_defer_fn (fn);
1253
1254 if (nested)
1255 pop_function_context ();
1256 else
1257 --function_depth;
1258}
1259
1260/* True if FN is the static function "_FUN" that gets returned from the lambda
1261 conversion operator. */
1262
1263bool
1264lambda_static_thunk_p (tree fn)
1265{
1266 return (fn && TREE_CODE (fn) == FUNCTION_DECL
1267 && DECL_ARTIFICIAL (fn)
1268 && DECL_STATIC_FUNCTION_P (fn)
1269 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fn)));
1270}
1271
1272/* Returns true iff VAL is a lambda-related declaration which should
1273 be ignored by unqualified lookup. */
1274
1275bool
1276is_lambda_ignored_entity (tree val)
1277{
1278 /* Look past normal capture proxies. */
1279 if (is_normal_capture_proxy (val))
1280 return true;
1281
1282 /* Always ignore lambda fields, their names are only for debugging. */
1283 if (TREE_CODE (val) == FIELD_DECL
1284 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val)))
1285 return true;
1286
1287 /* None of the lookups that use qualify_lookup want the op() from the
1288 lambda; they want the one from the enclosing class. */
1289 if (TREE_CODE (val) == FUNCTION_DECL && LAMBDA_FUNCTION_P (val))
1290 return true;
1291
1292 return false;
1293}
1294
1295/* Lambdas that appear in variable initializer or default argument scope
1296 get that in their mangling, so we need to record it. We might as well
1297 use the count for function and namespace scopes as well. */
1298static GTY(()) tree lambda_scope;
1299static GTY(()) int lambda_count;
1300struct GTY(()) tree_int
1301{
1302 tree t;
1303 int i;
1304};
1305static GTY(()) vec<tree_int, va_gc> *lambda_scope_stack;
1306
1307void
1308start_lambda_scope (tree decl)
1309{
1310 tree_int ti;
1311 gcc_assert (decl);
1312 /* Once we're inside a function, we ignore variable scope and just push
1313 the function again so that popping works properly. */
1314 if (current_function_decl && TREE_CODE (decl) == VAR_DECL)
1315 decl = current_function_decl;
1316 ti.t = lambda_scope;
1317 ti.i = lambda_count;
1318 vec_safe_push (lambda_scope_stack, ti);
1319 if (lambda_scope != decl)
1320 {
1321 /* Don't reset the count if we're still in the same function. */
1322 lambda_scope = decl;
1323 lambda_count = 0;
1324 }
1325}
1326
1327void
1328record_lambda_scope (tree lambda)
1329{
1330 LAMBDA_EXPR_EXTRA_SCOPE (lambda) = lambda_scope;
1331 LAMBDA_EXPR_DISCRIMINATOR (lambda) = lambda_count++;
1332}
1333
1334void
1335finish_lambda_scope (void)
1336{
1337 tree_int *p = &lambda_scope_stack->last ();
1338 if (lambda_scope != p->t)
1339 {
1340 lambda_scope = p->t;
1341 lambda_count = p->i;
1342 }
1343 lambda_scope_stack->pop ();
1344}
1345
1346tree
1347start_lambda_function (tree fco, tree lambda_expr)
1348{
1349 /* Let the front end know that we are going to be defining this
1350 function. */
1351 start_preparsed_function (fco,
1352 NULL_TREE,
1353 SF_PRE_PARSED | SF_INCLASS_INLINE);
1354
1355 tree body = begin_function_body ();
1356
1357 /* Push the proxies for any explicit captures. */
1358 for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap;
1359 cap = TREE_CHAIN (cap))
1360 build_capture_proxy (TREE_PURPOSE (cap), TREE_VALUE (cap));
1361
1362 return body;
1363}
1364
1365void
1366finish_lambda_function (tree body)
1367{
1368 finish_function_body (body);
1369
1370 /* Finish the function and generate code for it if necessary. */
1371 tree fn = finish_function (/*inline_p=*/true);
1372
1373 /* Only expand if the call op is not a template. */
1374 if (!DECL_TEMPLATE_INFO (fn))
1375 expand_or_defer_fn (fn);
1376}
1377
1378#include "gt-cp-lambda.h"
1379