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.
6 Copyright (C) 1998-2018 Free Software Foundation, Inc.
8 This file is part of GCC.
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)
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.
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/>. */
26 #include "coretypes.h"
28 #include "stringpool.h"
30 #include "tree-iterator.h"
34 /* Constructor for a lambda expression. */
37 build_lambda_expr (void)
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;
48 /* Create the closure object for a LAMBDA_EXPR. */
51 build_lambda_object (tree lambda_expr
)
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
;
60 if (processing_template_decl
|| lambda_expr
== error_mark_node
)
63 /* Make sure any error messages refer to the lambda-introducer. */
64 saved_loc
= input_location
;
65 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
67 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
69 node
= TREE_CHAIN (node
))
71 tree field
= TREE_PURPOSE (node
);
72 tree val
= TREE_VALUE (node
);
74 if (field
== error_mark_node
)
76 expr
= error_mark_node
;
80 if (TREE_CODE (val
) == TREE_LIST
)
81 val
= build_x_compound_expr_from_list (val
, ELK_INIT
,
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
)
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."
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;
107 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
110 expr
= build_constructor (init_list_type_node
, elts
);
111 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
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;
121 input_location
= saved_loc
;
125 /* Return an initialized RECORD_TYPE for LAMBDA.
126 LAMBDA must have its explicit captures already. */
129 begin_lambda_type (tree lambda
)
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. */
137 name
= make_lambda_name ();
139 /* Create the new RECORD_TYPE for this lambda. */
140 type
= xref_tag (/*tag_code=*/record_type
,
143 /*template_header_p=*/false);
144 if (type
== error_mark_node
)
145 return error_mark_node
;
148 /* Designate it as a struct so that we can use aggregate initialization. */
149 CLASSTYPE_DECLARED_CLASS (type
) = false;
151 /* Cross-reference the expression and the type. */
152 LAMBDA_EXPR_CLOSURE (lambda
) = type
;
153 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
155 /* In C++17, assume the closure is literal; we'll clear the flag later if
157 if (cxx_dialect
>= cxx17
)
158 CLASSTYPE_LITERAL_P (type
) = true;
160 /* Clear base types. */
161 xref_basetypes (type
, /*bases=*/NULL_TREE
);
163 /* Start the class. */
164 type
= begin_class_definition (type
);
169 /* Returns the type to use for the return type of the operator() of a
173 lambda_return_type (tree expr
)
175 if (expr
== NULL_TREE
)
176 return void_type_node
;
177 if (type_unknown_p (expr
)
178 || BRACE_ENCLOSED_INITIALIZER_P (expr
))
180 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
181 return error_mark_node
;
183 gcc_checking_assert (!type_dependent_expression_p (expr
));
184 return cv_unqualified (type_decays_to (unlowered_expr_type (expr
)));
187 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
191 lambda_function (tree lambda
)
194 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
195 type
= LAMBDA_EXPR_CLOSURE (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
))
203 lambda
= lookup_member (type
, call_op_identifier
,
204 /*protect=*/0, /*want_type=*/false,
205 tf_warning_or_error
);
207 lambda
= STRIP_TEMPLATE (get_first_fn (lambda
));
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. */
217 lambda_capture_field_type (tree expr
, bool explicit_init_p
,
221 bool is_this
= is_this_parameter (tree_strip_nop_conversions (expr
));
223 if (!is_this
&& type_dependent_expression_p (expr
))
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
);
232 else if (!is_this
&& explicit_init_p
)
234 tree auto_node
= make_auto ();
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
);
245 type
= non_reference (unlowered_expr_type (expr
));
248 && (by_reference_p
|| TREE_CODE (type
) == FUNCTION_TYPE
))
249 type
= build_reference_type (type
);
255 /* Returns true iff DECL is a lambda capture proxy variable created by
256 build_capture_proxy. */
259 is_capture_proxy (tree decl
)
262 && DECL_HAS_VALUE_EXPR_P (decl
)
263 && !DECL_ANON_UNION_VAR_P (decl
)
264 && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl
)));
267 /* Returns true iff DECL is a capture proxy for a normal capture
268 (i.e. without explicit initializer). */
271 is_normal_capture_proxy (tree decl
)
273 if (!is_capture_proxy (decl
))
274 /* It's not a capture proxy. */
277 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
281 /* It is a capture proxy, is it a normal capture? */
282 tree val
= DECL_VALUE_EXPR (decl
);
283 if (val
== error_mark_node
)
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
);
293 /* Returns true iff DECL is a capture proxy for which we can use
294 DECL_CAPTURED_VARIABLE. In effect, this is a normal proxy other than a
295 nested capture of a function parameter pack. */
298 is_capture_proxy_with_ref (tree var
)
300 return (is_normal_capture_proxy (var
) && DECL_LANG_SPECIFIC (var
)
301 && DECL_CAPTURED_VARIABLE (var
));
304 /* VAR is a capture proxy created by build_capture_proxy; add it to the
305 current function, which is the operator() for the appropriate lambda. */
308 insert_capture_proxy (tree var
)
310 if (is_capture_proxy_with_ref (var
))
312 tree cap
= DECL_CAPTURED_VARIABLE (var
);
315 gcc_assert (!is_normal_capture_proxy (cap
));
316 tree old
= retrieve_local_specialization (cap
);
318 gcc_assert (DECL_CONTEXT (old
) != DECL_CONTEXT (var
));
320 register_local_specialization (var
, cap
);
323 /* Put the capture proxy in the extra body block so that it won't clash
324 with a later local variable. */
325 pushdecl_outermost_localscope (var
);
327 /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
328 var
= build_stmt (DECL_SOURCE_LOCATION (var
), DECL_EXPR
, var
);
329 tree stmt_list
= (*stmt_list_stack
)[1];
330 gcc_assert (stmt_list
);
331 append_to_statement_list_force (var
, &stmt_list
);
334 /* We've just finished processing a lambda; if the containing scope is also
335 a lambda, insert any capture proxies that were created while processing
336 the nested lambda. */
339 insert_pending_capture_proxies (void)
342 vec
<tree
, va_gc
> *proxies
;
345 if (!current_function_decl
|| !LAMBDA_FUNCTION_P (current_function_decl
))
348 lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
349 proxies
= LAMBDA_EXPR_PENDING_PROXIES (lam
);
350 for (i
= 0; i
< vec_safe_length (proxies
); ++i
)
352 tree var
= (*proxies
)[i
];
353 insert_capture_proxy (var
);
355 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam
));
356 LAMBDA_EXPR_PENDING_PROXIES (lam
) = NULL
;
359 /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
360 return the type we want the proxy to have: the type of the field itself,
361 with added const-qualification if the lambda isn't mutable and the
362 capture is by value. */
365 lambda_proxy_type (tree ref
)
368 if (ref
== error_mark_node
)
369 return error_mark_node
;
370 if (REFERENCE_REF_P (ref
))
371 ref
= TREE_OPERAND (ref
, 0);
372 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
373 type
= TREE_TYPE (ref
);
374 if (!type
|| WILDCARD_TYPE_P (non_reference (type
)))
376 type
= cxx_make_type (DECLTYPE_TYPE
);
377 DECLTYPE_TYPE_EXPR (type
) = ref
;
378 DECLTYPE_FOR_LAMBDA_PROXY (type
) = true;
379 SET_TYPE_STRUCTURAL_EQUALITY (type
);
381 if (DECL_PACK_P (TREE_OPERAND (ref
, 1)))
382 type
= make_pack_expansion (type
);
386 /* MEMBER is a capture field in a lambda closure class. Now that we're
387 inside the operator(), build a placeholder var for future lookups and
391 build_capture_proxy (tree member
, tree init
)
393 tree var
, object
, fn
, closure
, name
, lam
, type
;
395 if (PACK_EXPANSION_P (member
))
396 member
= PACK_EXPANSION_PATTERN (member
);
398 closure
= DECL_CONTEXT (member
);
399 fn
= lambda_function (closure
);
400 lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
402 /* The proxy variable forwards to the capture field. */
403 object
= build_fold_indirect_ref (DECL_ARGUMENTS (fn
));
404 object
= finish_non_static_data_member (member
, object
, NULL_TREE
);
405 if (REFERENCE_REF_P (object
))
406 object
= TREE_OPERAND (object
, 0);
408 /* Remove the __ inserted by add_capture. */
409 name
= get_identifier (IDENTIFIER_POINTER (DECL_NAME (member
)) + 2);
411 type
= lambda_proxy_type (object
);
413 if (name
== this_identifier
&& !POINTER_TYPE_P (type
))
415 type
= build_pointer_type (type
);
416 type
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
417 object
= build_fold_addr_expr_with_type (object
, type
);
420 if (DECL_VLA_CAPTURE_P (member
))
422 /* Rebuild the VLA type from the pointer and maxindex. */
423 tree field
= next_initializable_field (TYPE_FIELDS (type
));
424 tree ptr
= build_simple_component_ref (object
, field
);
425 field
= next_initializable_field (DECL_CHAIN (field
));
426 tree max
= build_simple_component_ref (object
, field
);
427 type
= build_cplus_array_type (TREE_TYPE (TREE_TYPE (ptr
)),
428 build_index_type (max
));
429 type
= build_reference_type (type
);
430 REFERENCE_VLA_OK (type
) = true;
431 object
= convert (type
, ptr
);
434 var
= build_decl (input_location
, VAR_DECL
, name
, type
);
435 SET_DECL_VALUE_EXPR (var
, object
);
436 DECL_HAS_VALUE_EXPR_P (var
) = 1;
437 DECL_ARTIFICIAL (var
) = 1;
439 DECL_CONTEXT (var
) = fn
;
441 if (DECL_NORMAL_CAPTURE_P (member
))
443 if (DECL_VLA_CAPTURE_P (member
))
445 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
446 init
= TREE_OPERAND (init
, 0); // Strip ADDR_EXPR.
447 init
= TREE_OPERAND (init
, 0); // Strip ARRAY_REF.
451 if (PACK_EXPANSION_P (init
))
452 init
= PACK_EXPANSION_PATTERN (init
);
453 if (INDIRECT_REF_P (init
))
454 init
= TREE_OPERAND (init
, 0);
458 gcc_assert (VAR_P (init
) || TREE_CODE (init
) == PARM_DECL
);
459 while (is_normal_capture_proxy (init
))
460 init
= DECL_CAPTURED_VARIABLE (init
);
461 retrofit_lang_decl (var
);
462 DECL_CAPTURED_VARIABLE (var
) = init
;
465 if (name
== this_identifier
)
467 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam
) == member
);
468 LAMBDA_EXPR_THIS_CAPTURE (lam
) = var
;
471 if (fn
== current_function_decl
)
472 insert_capture_proxy (var
);
474 vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam
), var
);
479 static GTY(()) tree ptr_id
;
480 static GTY(()) tree max_id
;
482 /* Return a struct containing a pointer and a length for lambda capture of
483 an array of runtime length. */
486 vla_capture_type (tree array_type
)
488 tree type
= xref_tag (record_type
, make_anon_name (), ts_current
, false);
489 xref_basetypes (type
, NULL_TREE
);
490 type
= begin_class_definition (type
);
493 ptr_id
= get_identifier ("ptr");
494 max_id
= get_identifier ("max");
496 tree ptrtype
= build_pointer_type (TREE_TYPE (array_type
));
497 tree field
= build_decl (input_location
, FIELD_DECL
, ptr_id
, ptrtype
);
498 finish_member_declaration (field
);
499 field
= build_decl (input_location
, FIELD_DECL
, max_id
, sizetype
);
500 finish_member_declaration (field
);
501 return finish_struct (type
, NULL_TREE
);
504 /* From an ID and INITIALIZER, create a capture (by reference if
505 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
506 and return it. If ID is `this', BY_REFERENCE_P says whether
507 `*this' is captured by reference. */
510 add_capture (tree lambda
, tree id
, tree orig_init
, bool by_reference_p
,
511 bool explicit_init_p
)
514 tree type
, member
, name
;
516 bool variadic
= false;
517 tree initializer
= orig_init
;
519 if (PACK_EXPANSION_P (initializer
))
521 initializer
= PACK_EXPANSION_PATTERN (initializer
);
525 if (TREE_CODE (initializer
) == TREE_LIST
526 /* A pack expansion might end up with multiple elements. */
527 && !PACK_EXPANSION_P (TREE_VALUE (initializer
)))
528 initializer
= build_x_compound_expr_from_list (initializer
, ELK_INIT
,
529 tf_warning_or_error
);
530 type
= TREE_TYPE (initializer
);
531 if (type
== error_mark_node
)
532 return error_mark_node
;
534 if (array_of_runtime_bound_p (type
))
538 error ("array of runtime bound cannot be captured by copy, "
539 "only by reference");
541 /* For a VLA, we capture the address of the first element and the
542 maximum index, and then reconstruct the VLA for the proxy. */
543 tree elt
= cp_build_array_ref (input_location
, initializer
,
544 integer_zero_node
, tf_warning_or_error
);
545 initializer
= build_constructor_va (init_list_type_node
, 2,
546 NULL_TREE
, build_address (elt
),
547 NULL_TREE
, array_type_nelts (type
));
548 type
= vla_capture_type (type
);
550 else if (!dependent_type_p (type
)
551 && variably_modified_type_p (type
, NULL_TREE
))
553 error ("capture of variable-size type %qT that is not an N3639 array "
554 "of runtime bound", type
);
555 if (TREE_CODE (type
) == ARRAY_TYPE
556 && variably_modified_type_p (TREE_TYPE (type
), NULL_TREE
))
557 inform (input_location
, "because the array element type %qT has "
558 "variable size", TREE_TYPE (type
));
559 type
= error_mark_node
;
563 type
= lambda_capture_field_type (initializer
, explicit_init_p
,
565 if (type
== error_mark_node
)
566 return error_mark_node
;
568 if (id
== this_identifier
&& !by_reference_p
)
570 gcc_assert (POINTER_TYPE_P (type
));
571 type
= TREE_TYPE (type
);
572 initializer
= cp_build_fold_indirect_ref (initializer
);
575 if (dependent_type_p (type
))
577 else if (id
!= this_identifier
&& by_reference_p
)
579 if (!lvalue_p (initializer
))
581 error ("cannot capture %qE by reference", initializer
);
582 return error_mark_node
;
587 /* Capture by copy requires a complete type. */
588 type
= complete_type (type
);
589 if (!COMPLETE_TYPE_P (type
))
591 error ("capture by copy of incomplete type %qT", type
);
592 cxx_incomplete_type_inform (type
);
593 return error_mark_node
;
598 /* Add __ to the beginning of the field name so that user code
599 won't find the field with name lookup. We can't just leave the name
600 unset because template instantiation uses the name to find
601 instantiated fields. */
602 buf
= (char *) alloca (IDENTIFIER_LENGTH (id
) + 3);
603 buf
[1] = buf
[0] = '_';
604 memcpy (buf
+ 2, IDENTIFIER_POINTER (id
),
605 IDENTIFIER_LENGTH (id
) + 1);
606 name
= get_identifier (buf
);
608 /* If TREE_TYPE isn't set, we're still in the introducer, so check
610 if (!LAMBDA_EXPR_CLOSURE (lambda
))
612 if (IDENTIFIER_MARKED (name
))
614 pedwarn (input_location
, 0,
615 "already captured %qD in lambda expression", id
);
618 IDENTIFIER_MARKED (name
) = true;
622 type
= make_pack_expansion (type
);
624 /* Make member variable. */
625 member
= build_decl (input_location
, FIELD_DECL
, name
, type
);
626 DECL_VLA_CAPTURE_P (member
) = vla
;
628 if (!explicit_init_p
)
629 /* Normal captures are invisible to name lookup but uses are replaced
630 with references to the capture field; we implement this by only
631 really making them invisible in unevaluated context; see
632 qualify_lookup. For now, let's make explicitly initialized captures
634 DECL_NORMAL_CAPTURE_P (member
) = true;
636 if (id
== this_identifier
)
637 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
639 /* Add it to the appropriate closure class if we've started it. */
640 if (current_class_type
641 && current_class_type
== LAMBDA_EXPR_CLOSURE (lambda
))
643 if (COMPLETE_TYPE_P (current_class_type
))
644 internal_error ("trying to capture %qD in instantiation of "
645 "generic lambda", id
);
646 finish_member_declaration (member
);
649 tree listmem
= member
;
652 listmem
= make_pack_expansion (member
);
653 initializer
= orig_init
;
655 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
656 = tree_cons (listmem
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
658 if (LAMBDA_EXPR_CLOSURE (lambda
))
659 return build_capture_proxy (member
, initializer
);
660 /* For explicit captures we haven't started the function yet, so we wait
661 and build the proxy from cp_parser_lambda_body. */
665 /* Register all the capture members on the list CAPTURES, which is the
666 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
669 register_capture_members (tree captures
)
671 if (captures
== NULL_TREE
)
674 register_capture_members (TREE_CHAIN (captures
));
676 tree field
= TREE_PURPOSE (captures
);
677 if (PACK_EXPANSION_P (field
))
678 field
= PACK_EXPANSION_PATTERN (field
);
680 /* We set this in add_capture to avoid duplicates. */
681 IDENTIFIER_MARKED (DECL_NAME (field
)) = false;
682 finish_member_declaration (field
);
685 /* Similar to add_capture, except this works on a stack of nested lambdas.
686 BY_REFERENCE_P in this case is derived from the default capture mode.
687 Returns the capture for the lambda at the bottom of the stack. */
690 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
692 bool this_capture_p
= (id
== this_identifier
);
694 tree var
= NULL_TREE
;
696 tree saved_class_type
= current_class_type
;
700 for (node
= lambda_stack
;
702 node
= TREE_CHAIN (node
))
704 tree lambda
= TREE_VALUE (node
);
706 current_class_type
= LAMBDA_EXPR_CLOSURE (lambda
);
707 if (DECL_PACK_P (initializer
))
708 initializer
= make_pack_expansion (initializer
);
709 var
= add_capture (lambda
,
714 || (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
716 /*explicit_init_p=*/false);
717 initializer
= convert_from_reference (var
);
720 current_class_type
= saved_class_type
;
725 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the
726 form of an INDIRECT_REF, possibly adding it through default
727 capturing, if ADD_CAPTURE_P is true. */
730 lambda_expr_this_capture (tree lambda
, bool add_capture_p
)
734 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
736 /* In unevaluated context this isn't an odr-use, so don't capture. */
737 if (cp_unevaluated_operand
)
738 add_capture_p
= false;
740 /* Try to default capture 'this' if we can. */
743 || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
))
745 tree lambda_stack
= NULL_TREE
;
746 tree init
= NULL_TREE
;
748 /* If we are in a lambda function, we can move out until we hit:
749 1. a non-lambda function or NSDMI,
750 2. a lambda function capturing 'this', or
751 3. a non-default capturing lambda function. */
752 for (tree tlambda
= lambda
; ;)
754 lambda_stack
= tree_cons (NULL_TREE
,
758 if (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)
759 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)) == FIELD_DECL
)
761 /* In an NSDMI, we don't have a function to look up the decl in,
762 but the fake 'this' pointer that we're using for parsing is
764 init
= scope_chain
->x_current_class_ptr
;
766 (init
&& (TREE_TYPE (TREE_TYPE (init
))
767 == current_nonlambda_class_type ()));
771 tree closure_decl
= TYPE_NAME (LAMBDA_EXPR_CLOSURE (tlambda
));
772 tree containing_function
= decl_function_context (closure_decl
);
774 if (containing_function
== NULL_TREE
)
775 /* We ran out of scopes; there's no 'this' to capture. */
778 if (!LAMBDA_FUNCTION_P (containing_function
))
780 /* We found a non-lambda function. */
781 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
))
782 /* First parameter is 'this'. */
783 init
= DECL_ARGUMENTS (containing_function
);
788 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
790 if (LAMBDA_EXPR_THIS_CAPTURE (tlambda
))
792 /* An outer lambda has already captured 'this'. */
793 init
= LAMBDA_EXPR_THIS_CAPTURE (tlambda
);
797 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda
) == CPLD_NONE
)
798 /* An outer lambda won't let us capture 'this'. */
805 this_capture
= add_default_capture (lambda_stack
,
806 /*id=*/this_identifier
,
813 if (cp_unevaluated_operand
)
814 result
= this_capture
;
815 else if (!this_capture
)
819 error ("%<this%> was not captured for this lambda function");
820 result
= error_mark_node
;
827 /* To make sure that current_class_ref is for the lambda. */
828 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
))
829 == LAMBDA_EXPR_CLOSURE (lambda
));
831 result
= this_capture
;
833 /* If 'this' is captured, each use of 'this' is transformed into an
834 access to the corresponding unnamed data member of the closure
835 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
836 ensures that the transformed expression is an rvalue. ] */
837 result
= rvalue (result
);
843 /* Return the current LAMBDA_EXPR, if this is a resolvable dummy
844 object. NULL otherwise.. */
847 resolvable_dummy_lambda (tree object
)
849 if (!is_dummy_object (object
))
852 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (object
));
853 gcc_assert (!TYPE_PTR_P (type
));
855 if (type
!= current_class_type
856 && current_class_type
857 && LAMBDA_TYPE_P (current_class_type
)
858 && lambda_function (current_class_type
)
859 && DERIVED_FROM_P (type
, current_nonlambda_class_type ()))
860 return CLASSTYPE_LAMBDA_EXPR (current_class_type
);
865 /* We don't want to capture 'this' until we know we need it, i.e. after
866 overload resolution has chosen a non-static member function. At that
867 point we call this function to turn a dummy object into a use of the
871 maybe_resolve_dummy (tree object
, bool add_capture_p
)
873 if (tree lam
= resolvable_dummy_lambda (object
))
874 if (tree cap
= lambda_expr_this_capture (lam
, add_capture_p
))
875 if (cap
!= error_mark_node
)
876 object
= build_fold_indirect_ref (cap
);
881 /* When parsing a generic lambda containing an argument-dependent
882 member function call we defer overload resolution to instantiation
883 time. But we have to know now whether to capture this or not.
884 Do that if FNS contains any non-static fns.
885 The std doesn't anticipate this case, but I expect this to be the
886 outcome of discussion. */
889 maybe_generic_this_capture (tree object
, tree fns
)
891 if (tree lam
= resolvable_dummy_lambda (object
))
892 if (!LAMBDA_EXPR_THIS_CAPTURE (lam
))
894 /* We've not yet captured, so look at the function set of
896 if (BASELINK_P (fns
))
897 fns
= BASELINK_FUNCTIONS (fns
);
898 bool id_expr
= TREE_CODE (fns
) == TEMPLATE_ID_EXPR
;
900 fns
= TREE_OPERAND (fns
, 0);
902 for (lkp_iterator
iter (fns
); iter
; ++iter
)
903 if ((!id_expr
|| TREE_CODE (*iter
) == TEMPLATE_DECL
)
904 && DECL_NONSTATIC_MEMBER_FUNCTION_P (*iter
))
906 /* Found a non-static member. Capture this. */
907 lambda_expr_this_capture (lam
, true);
913 /* Returns the innermost non-lambda function. */
916 current_nonlambda_function (void)
918 tree fn
= current_function_decl
;
919 while (fn
&& LAMBDA_FUNCTION_P (fn
))
920 fn
= decl_function_context (fn
);
924 /* Returns the method basetype of the innermost non-lambda function, or
925 NULL_TREE if none. */
928 nonlambda_method_basetype (void)
931 if (!current_class_ref
)
934 type
= current_class_type
;
935 if (!type
|| !LAMBDA_TYPE_P (type
))
938 /* Find the nearest enclosing non-lambda function. */
939 fn
= TYPE_NAME (type
);
941 fn
= decl_function_context (fn
);
942 while (fn
&& LAMBDA_FUNCTION_P (fn
));
944 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
947 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
950 /* Like current_scope, but looking through lambdas. */
953 current_nonlambda_scope (void)
955 tree scope
= current_scope ();
958 if (TREE_CODE (scope
) == FUNCTION_DECL
959 && LAMBDA_FUNCTION_P (scope
))
961 scope
= CP_TYPE_CONTEXT (DECL_CONTEXT (scope
));
964 else if (LAMBDA_TYPE_P (scope
))
966 scope
= CP_TYPE_CONTEXT (scope
);
974 /* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with
975 indicated FN and NARGS, but do not initialize the return type or any of the
979 prepare_op_call (tree fn
, int nargs
)
983 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
984 CALL_EXPR_FN (t
) = fn
;
985 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
990 /* Return true iff CALLOP is the op() for a generic lambda. */
993 generic_lambda_fn_p (tree callop
)
995 return (LAMBDA_FUNCTION_P (callop
)
996 && DECL_TEMPLATE_INFO (callop
)
997 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (callop
)));
1000 /* If the closure TYPE has a static op(), also add a conversion to function
1004 maybe_add_lambda_conv_op (tree type
)
1006 bool nested
= (cfun
!= NULL
);
1007 bool nested_def
= decl_function_context (TYPE_MAIN_DECL (type
));
1008 tree callop
= lambda_function (type
);
1009 tree lam
= CLASSTYPE_LAMBDA_EXPR (type
);
1011 if (LAMBDA_EXPR_CAPTURE_LIST (lam
) != NULL_TREE
1012 || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
) != CPLD_NONE
)
1015 if (processing_template_decl
)
1018 bool const generic_lambda_p
= generic_lambda_fn_p (callop
);
1020 if (!generic_lambda_p
&& DECL_INITIAL (callop
) == NULL_TREE
)
1022 /* If the op() wasn't instantiated due to errors, give up. */
1023 gcc_assert (errorcount
|| sorrycount
);
1027 /* Non-template conversion operators are defined directly with build_call_a
1028 and using DIRECT_ARGVEC for arguments (including 'this'). Templates are
1029 deferred and the CALL is built in-place. In the case of a deduced return
1030 call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
1031 the return type is also built in-place. The arguments of DECLTYPE_CALL in
1032 the return expression may differ in flags from those in the body CALL. In
1033 particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
1034 the body CALL, but not in DECLTYPE_CALL. */
1036 vec
<tree
, va_gc
> *direct_argvec
= 0;
1037 tree decltype_call
= 0, call
= 0;
1038 tree optype
= TREE_TYPE (callop
);
1039 tree fn_result
= TREE_TYPE (optype
);
1041 tree thisarg
= build_nop (TREE_TYPE (DECL_ARGUMENTS (callop
)),
1043 if (generic_lambda_p
)
1045 ++processing_template_decl
;
1047 /* Prepare the dependent member call for the static member function
1048 '_FUN' and, potentially, prepare another call to be used in a decltype
1049 return expression for a deduced return call op to allow for simple
1050 implementation of the conversion operator. */
1052 tree instance
= cp_build_fold_indirect_ref (thisarg
);
1053 tree objfn
= build_min (COMPONENT_REF
, NULL_TREE
,
1054 instance
, DECL_NAME (callop
), NULL_TREE
);
1055 int nargs
= list_length (DECL_ARGUMENTS (callop
)) - 1;
1057 call
= prepare_op_call (objfn
, nargs
);
1058 if (type_uses_auto (fn_result
))
1059 decltype_call
= prepare_op_call (objfn
, nargs
);
1063 direct_argvec
= make_tree_vector ();
1064 direct_argvec
->quick_push (thisarg
);
1067 /* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to
1068 declare the static member function "_FUN" below. For each arg append to
1069 DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated
1070 call args (for the template case). If a parameter pack is found, expand
1071 it, flagging it as PACK_EXPANSION_LOCAL_P for the body call. */
1073 tree fn_args
= NULL_TREE
;
1076 tree src
= DECL_CHAIN (DECL_ARGUMENTS (callop
));
1081 tree new_node
= copy_node (src
);
1084 fn_args
= tgt
= new_node
;
1087 TREE_CHAIN (tgt
) = new_node
;
1091 mark_exp_read (tgt
);
1093 if (generic_lambda_p
)
1095 /* Avoid capturing variables in this context. */
1096 ++cp_unevaluated_operand
;
1097 tree a
= forward_parm (tgt
);
1098 --cp_unevaluated_operand
;
1100 CALL_EXPR_ARG (call
, ix
) = a
;
1102 CALL_EXPR_ARG (decltype_call
, ix
) = unshare_expr (a
);
1104 if (PACK_EXPANSION_P (a
))
1105 /* Set this after unsharing so it's not in decltype_call. */
1106 PACK_EXPANSION_LOCAL_P (a
) = true;
1111 vec_safe_push (direct_argvec
, tgt
);
1113 src
= TREE_CHAIN (src
);
1117 if (generic_lambda_p
)
1121 fn_result
= finish_decltype_type
1122 (decltype_call
, /*id_expression_or_member_access_p=*/false,
1123 tf_warning_or_error
);
1127 call
= build_call_a (callop
,
1128 direct_argvec
->length (),
1129 direct_argvec
->address ());
1131 CALL_FROM_THUNK_P (call
) = 1;
1132 SET_EXPR_LOCATION (call
, UNKNOWN_LOCATION
);
1134 tree stattype
= build_function_type (fn_result
, FUNCTION_ARG_CHAIN (callop
));
1135 stattype
= (cp_build_type_attribute_variant
1136 (stattype
, TYPE_ATTRIBUTES (optype
)));
1137 if (flag_noexcept_type
1138 && TYPE_NOTHROW_P (TREE_TYPE (callop
)))
1139 stattype
= build_exception_variant (stattype
, noexcept_true_spec
);
1141 if (generic_lambda_p
)
1142 --processing_template_decl
;
1144 /* First build up the conversion op. */
1146 tree rettype
= build_pointer_type (stattype
);
1147 tree name
= make_conv_op_name (rettype
);
1148 tree thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
1149 tree fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
1150 tree convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
1152 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
1153 SET_DECL_ALIGN (fn
, MINIMUM_METHOD_BOUNDARY
);
1154 grokclassfn (type
, fn
, NO_SPECIAL
);
1155 set_linkage_according_to_type (type
, fn
);
1156 rest_of_decl_compilation (fn
, namespace_bindings_p (), at_eof
);
1157 DECL_IN_AGGR_P (fn
) = 1;
1158 DECL_ARTIFICIAL (fn
) = 1;
1159 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1160 DECL_DECLARED_INLINE_P (fn
) = 1;
1161 DECL_ARGUMENTS (fn
) = build_this_parm (fn
, fntype
, TYPE_QUAL_CONST
);
1164 DECL_INTERFACE_KNOWN (fn
) = 1;
1166 if (generic_lambda_p
)
1167 fn
= add_inherited_template_parms (fn
, DECL_TI_TEMPLATE (callop
));
1169 add_method (type
, fn
, false);
1171 /* Generic thunk code fails for varargs; we'll complain in mark_used if
1172 the conversion op is used. */
1173 if (varargs_function_p (callop
))
1175 DECL_DELETED_FN (fn
) = 1;
1179 /* Now build up the thunk to be returned. */
1181 name
= get_identifier ("_FUN");
1182 tree statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
1184 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
1185 grokclassfn (type
, fn
, NO_SPECIAL
);
1186 set_linkage_according_to_type (type
, fn
);
1187 rest_of_decl_compilation (fn
, namespace_bindings_p (), at_eof
);
1188 DECL_IN_AGGR_P (fn
) = 1;
1189 DECL_ARTIFICIAL (fn
) = 1;
1190 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1191 DECL_DECLARED_INLINE_P (fn
) = 1;
1192 DECL_STATIC_FUNCTION_P (fn
) = 1;
1193 DECL_ARGUMENTS (fn
) = fn_args
;
1194 for (tree arg
= fn_args
; arg
; arg
= DECL_CHAIN (arg
))
1196 /* Avoid duplicate -Wshadow warnings. */
1197 DECL_NAME (arg
) = NULL_TREE
;
1198 DECL_CONTEXT (arg
) = fn
;
1201 DECL_INTERFACE_KNOWN (fn
) = 1;
1203 if (generic_lambda_p
)
1204 fn
= add_inherited_template_parms (fn
, DECL_TI_TEMPLATE (callop
));
1206 if (flag_sanitize
& SANITIZE_NULL
)
1207 /* Don't UBsan this function; we're deliberately calling op() with a null
1209 add_no_sanitize_value (fn
, SANITIZE_UNDEFINED
);
1211 add_method (type
, fn
, false);
1214 push_function_context ();
1216 /* Still increment function_depth so that we don't GC in the
1217 middle of an expression. */
1220 /* Generate the body of the thunk. */
1222 start_preparsed_function (statfn
, NULL_TREE
,
1223 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1224 if (DECL_ONE_ONLY (statfn
))
1226 /* Put the thunk in the same comdat group as the call op. */
1227 cgraph_node::get_create (statfn
)->add_to_same_comdat_group
1228 (cgraph_node::get_create (callop
));
1230 tree body
= begin_function_body ();
1231 tree compound_stmt
= begin_compound_stmt (0);
1232 if (!generic_lambda_p
)
1234 set_flags_from_callee (call
);
1235 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
1236 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
1238 call
= convert_from_reference (call
);
1239 finish_return_stmt (call
);
1241 finish_compound_stmt (compound_stmt
);
1242 finish_function_body (body
);
1244 fn
= finish_function (/*inline_p=*/true);
1245 if (!generic_lambda_p
)
1246 expand_or_defer_fn (fn
);
1248 /* Generate the body of the conversion op. */
1250 start_preparsed_function (convfn
, NULL_TREE
,
1251 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1252 body
= begin_function_body ();
1253 compound_stmt
= begin_compound_stmt (0);
1255 /* decl_needed_p needs to see that it's used. */
1256 TREE_USED (statfn
) = 1;
1257 finish_return_stmt (decay_conversion (statfn
, tf_warning_or_error
));
1259 finish_compound_stmt (compound_stmt
);
1260 finish_function_body (body
);
1262 fn
= finish_function (/*inline_p=*/true);
1263 if (!generic_lambda_p
)
1264 expand_or_defer_fn (fn
);
1267 pop_function_context ();
1272 /* True if FN is the static function "_FUN" that gets returned from the lambda
1273 conversion operator. */
1276 lambda_static_thunk_p (tree fn
)
1278 return (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
1279 && DECL_ARTIFICIAL (fn
)
1280 && DECL_STATIC_FUNCTION_P (fn
)
1281 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fn
)));
1284 /* Returns true iff VAL is a lambda-related declaration which should
1285 be ignored by unqualified lookup. */
1288 is_lambda_ignored_entity (tree val
)
1290 /* Look past normal capture proxies. */
1291 if (is_normal_capture_proxy (val
))
1294 /* Always ignore lambda fields, their names are only for debugging. */
1295 if (TREE_CODE (val
) == FIELD_DECL
1296 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val
)))
1299 /* None of the lookups that use qualify_lookup want the op() from the
1300 lambda; they want the one from the enclosing class. */
1301 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
1307 /* Lambdas that appear in variable initializer or default argument scope
1308 get that in their mangling, so we need to record it. We might as well
1309 use the count for function and namespace scopes as well. */
1310 static GTY(()) tree lambda_scope
;
1311 static GTY(()) int lambda_count
;
1312 struct GTY(()) tree_int
1317 static GTY(()) vec
<tree_int
, va_gc
> *lambda_scope_stack
;
1320 start_lambda_scope (tree decl
)
1324 /* Once we're inside a function, we ignore variable scope and just push
1325 the function again so that popping works properly. */
1326 if (current_function_decl
&& TREE_CODE (decl
) == VAR_DECL
)
1327 decl
= current_function_decl
;
1328 ti
.t
= lambda_scope
;
1329 ti
.i
= lambda_count
;
1330 vec_safe_push (lambda_scope_stack
, ti
);
1331 if (lambda_scope
!= decl
)
1333 /* Don't reset the count if we're still in the same function. */
1334 lambda_scope
= decl
;
1340 record_lambda_scope (tree lambda
)
1342 LAMBDA_EXPR_EXTRA_SCOPE (lambda
) = lambda_scope
;
1343 LAMBDA_EXPR_DISCRIMINATOR (lambda
) = lambda_count
++;
1347 finish_lambda_scope (void)
1349 tree_int
*p
= &lambda_scope_stack
->last ();
1350 if (lambda_scope
!= p
->t
)
1352 lambda_scope
= p
->t
;
1353 lambda_count
= p
->i
;
1355 lambda_scope_stack
->pop ();
1359 start_lambda_function (tree fco
, tree lambda_expr
)
1361 /* Let the front end know that we are going to be defining this
1363 start_preparsed_function (fco
,
1365 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1367 tree body
= begin_function_body ();
1369 /* Push the proxies for any explicit captures. */
1370 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
); cap
;
1371 cap
= TREE_CHAIN (cap
))
1372 build_capture_proxy (TREE_PURPOSE (cap
), TREE_VALUE (cap
));
1378 finish_lambda_function (tree body
)
1380 finish_function_body (body
);
1382 /* Finish the function and generate code for it if necessary. */
1383 tree fn
= finish_function (/*inline_p=*/true);
1385 /* Only expand if the call op is not a template. */
1386 if (!DECL_TEMPLATE_INFO (fn
))
1387 expand_or_defer_fn (fn
);
1390 #include "gt-cp-lambda.h"