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-2017 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"
33 #include "cp-cilkplus.h"
35 /* Constructor for a lambda expression. */
38 build_lambda_expr (void)
40 tree lambda
= make_node (LAMBDA_EXPR
);
41 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
42 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
43 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
44 LAMBDA_EXPR_PENDING_PROXIES (lambda
) = NULL
;
45 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
49 /* Create the closure object for a LAMBDA_EXPR. */
52 build_lambda_object (tree lambda_expr
)
54 /* Build aggregate constructor call.
55 - cp_parser_braced_list
56 - cp_parser_functional_cast */
57 vec
<constructor_elt
, va_gc
> *elts
= NULL
;
58 tree node
, expr
, type
;
61 if (processing_template_decl
|| lambda_expr
== error_mark_node
)
64 /* Make sure any error messages refer to the lambda-introducer. */
65 saved_loc
= input_location
;
66 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
68 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
70 node
= TREE_CHAIN (node
))
72 tree field
= TREE_PURPOSE (node
);
73 tree val
= TREE_VALUE (node
);
75 if (field
== error_mark_node
)
77 expr
= error_mark_node
;
81 if (TREE_CODE (val
) == TREE_LIST
)
82 val
= build_x_compound_expr_from_list (val
, ELK_INIT
,
88 /* Mere mortals can't copy arrays with aggregate initialization, so
89 do some magic to make it work here. */
90 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
91 val
= build_array_copy (val
);
92 else if (DECL_NORMAL_CAPTURE_P (field
)
93 && !DECL_VLA_CAPTURE_P (field
)
94 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
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."
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 val
= force_rvalue (val
, tf_warning_or_error
);
104 if (TREE_CODE (val
) == TARGET_EXPR
)
105 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
108 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
111 expr
= build_constructor (init_list_type_node
, elts
);
112 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
114 /* N2927: "[The closure] class type is not an aggregate."
115 But we briefly treat it as an aggregate to make this simpler. */
116 type
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
117 CLASSTYPE_NON_AGGREGATE (type
) = 0;
118 expr
= finish_compound_literal (type
, expr
, tf_warning_or_error
);
119 CLASSTYPE_NON_AGGREGATE (type
) = 1;
122 input_location
= saved_loc
;
126 /* Return an initialized RECORD_TYPE for LAMBDA.
127 LAMBDA must have its explicit captures already. */
130 begin_lambda_type (tree lambda
)
135 /* Unique name. This is just like an unnamed class, but we cannot use
136 make_anon_name because of certain checks against TYPE_UNNAMED_P. */
138 name
= make_lambda_name ();
140 /* Create the new RECORD_TYPE for this lambda. */
141 type
= xref_tag (/*tag_code=*/record_type
,
144 /*template_header_p=*/false);
145 if (type
== error_mark_node
)
146 return error_mark_node
;
149 /* Designate it as a struct so that we can use aggregate initialization. */
150 CLASSTYPE_DECLARED_CLASS (type
) = false;
152 /* Cross-reference the expression and the type. */
153 LAMBDA_EXPR_CLOSURE (lambda
) = type
;
154 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
156 /* In C++17, assume the closure is literal; we'll clear the flag later if
158 if (cxx_dialect
>= cxx17
)
159 CLASSTYPE_LITERAL_P (type
) = true;
161 /* Clear base types. */
162 xref_basetypes (type
, /*bases=*/NULL_TREE
);
164 /* Start the class. */
165 type
= begin_class_definition (type
);
170 /* Returns the type to use for the return type of the operator() of a
174 lambda_return_type (tree expr
)
176 if (expr
== NULL_TREE
)
177 return void_type_node
;
178 if (type_unknown_p (expr
)
179 || BRACE_ENCLOSED_INITIALIZER_P (expr
))
181 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
182 return error_mark_node
;
184 gcc_checking_assert (!type_dependent_expression_p (expr
));
185 return cv_unqualified (type_decays_to (unlowered_expr_type (expr
)));
188 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
192 lambda_function (tree lambda
)
195 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
196 type
= LAMBDA_EXPR_CLOSURE (lambda
);
199 gcc_assert (LAMBDA_TYPE_P (type
));
200 /* Don't let debug_tree cause instantiation. */
201 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
202 && !COMPLETE_OR_OPEN_TYPE_P (type
))
204 lambda
= lookup_member (type
, call_op_identifier
,
205 /*protect=*/0, /*want_type=*/false,
206 tf_warning_or_error
);
208 lambda
= STRIP_TEMPLATE (get_first_fn (lambda
));
212 /* Returns the type to use for the FIELD_DECL corresponding to the
213 capture of EXPR. EXPLICIT_INIT_P indicates whether this is a
214 C++14 init capture, and BY_REFERENCE_P indicates whether we're
215 capturing by reference. */
218 lambda_capture_field_type (tree expr
, bool explicit_init_p
,
222 bool is_this
= is_this_parameter (tree_strip_nop_conversions (expr
));
224 if (!is_this
&& type_dependent_expression_p (expr
))
226 type
= cxx_make_type (DECLTYPE_TYPE
);
227 DECLTYPE_TYPE_EXPR (type
) = expr
;
228 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
229 DECLTYPE_FOR_INIT_CAPTURE (type
) = explicit_init_p
;
230 DECLTYPE_FOR_REF_CAPTURE (type
) = by_reference_p
;
231 SET_TYPE_STRUCTURAL_EQUALITY (type
);
233 else if (!is_this
&& explicit_init_p
)
235 tree auto_node
= make_auto ();
239 /* Add the reference now, so deduction doesn't lose
240 outermost CV qualifiers of EXPR. */
241 type
= build_reference_type (type
);
242 type
= do_auto_deduction (type
, expr
, auto_node
);
246 type
= non_reference (unlowered_expr_type (expr
));
248 if (!is_this
&& by_reference_p
)
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 /* 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. */
297 insert_capture_proxy (tree var
)
299 if (is_normal_capture_proxy (var
))
301 tree cap
= DECL_CAPTURED_VARIABLE (var
);
304 gcc_assert (!is_normal_capture_proxy (cap
));
305 tree old
= retrieve_local_specialization (cap
);
307 gcc_assert (DECL_CONTEXT (old
) != DECL_CONTEXT (var
));
309 register_local_specialization (var
, cap
);
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
);
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
);
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. */
328 insert_pending_capture_proxies (void)
331 vec
<tree
, va_gc
> *proxies
;
334 if (!current_function_decl
|| !LAMBDA_FUNCTION_P (current_function_decl
))
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
)
341 tree var
= (*proxies
)[i
];
342 insert_capture_proxy (var
);
344 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam
));
345 LAMBDA_EXPR_PENDING_PROXIES (lam
) = NULL
;
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. */
354 lambda_proxy_type (tree ref
)
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
)))
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
);
370 if (DECL_PACK_P (TREE_OPERAND (ref
, 1)))
371 type
= make_pack_expansion (type
);
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
380 build_capture_proxy (tree member
, tree init
)
382 tree var
, object
, fn
, closure
, name
, lam
, type
;
384 if (PACK_EXPANSION_P (member
))
385 member
= PACK_EXPANSION_PATTERN (member
);
387 closure
= DECL_CONTEXT (member
);
388 fn
= lambda_function (closure
);
389 lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
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);
397 /* Remove the __ inserted by add_capture. */
398 name
= get_identifier (IDENTIFIER_POINTER (DECL_NAME (member
)) + 2);
400 type
= lambda_proxy_type (object
);
402 if (name
== this_identifier
&& !POINTER_TYPE_P (type
))
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
);
409 if (DECL_VLA_CAPTURE_P (member
))
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
);
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;
428 DECL_CONTEXT (var
) = fn
;
430 if (DECL_NORMAL_CAPTURE_P (member
))
432 if (DECL_VLA_CAPTURE_P (member
))
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.
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);
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
;
453 if (name
== this_identifier
)
455 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam
) == member
);
456 LAMBDA_EXPR_THIS_CAPTURE (lam
) = var
;
459 if (fn
== current_function_decl
)
460 insert_capture_proxy (var
);
462 vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam
), var
);
467 static GTY(()) tree ptr_id
;
468 static GTY(()) tree max_id
;
470 /* Return a struct containing a pointer and a length for lambda capture of
471 an array of runtime length. */
474 vla_capture_type (tree array_type
)
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
);
481 ptr_id
= get_identifier ("ptr");
482 max_id
= get_identifier ("max");
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
);
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. */
498 add_capture (tree lambda
, tree id
, tree orig_init
, bool by_reference_p
,
499 bool explicit_init_p
)
502 tree type
, member
, name
;
504 bool variadic
= false;
505 tree initializer
= orig_init
;
507 if (PACK_EXPANSION_P (initializer
))
509 initializer
= PACK_EXPANSION_PATTERN (initializer
);
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
;
522 if (array_of_runtime_bound_p (type
))
526 error ("array of runtime bound cannot be captured by copy, "
527 "only by reference");
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
);
538 else if (!dependent_type_p (type
)
539 && variably_modified_type_p (type
, NULL_TREE
))
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
;
551 type
= lambda_capture_field_type (initializer
, explicit_init_p
,
553 if (type
== error_mark_node
)
554 return error_mark_node
;
556 if (id
== this_identifier
&& !by_reference_p
)
558 gcc_assert (POINTER_TYPE_P (type
));
559 type
= TREE_TYPE (type
);
560 initializer
= cp_build_indirect_ref (initializer
, RO_NULL
,
561 tf_warning_or_error
);
564 if (dependent_type_p (type
))
566 else if (id
!= this_identifier
&& by_reference_p
)
568 if (!lvalue_p (initializer
))
570 error ("cannot capture %qE by reference", initializer
);
571 return error_mark_node
;
576 /* Capture by copy requires a complete type. */
577 type
= complete_type (type
);
578 if (!COMPLETE_TYPE_P (type
))
580 error ("capture by copy of incomplete type %qT", type
);
581 cxx_incomplete_type_inform (type
);
582 return error_mark_node
;
587 /* Add __ to the beginning of the field name so that user code
588 won't find the field with name lookup. We can't just leave the name
589 unset because template instantiation uses the name to find
590 instantiated fields. */
591 buf
= (char *) alloca (IDENTIFIER_LENGTH (id
) + 3);
592 buf
[1] = buf
[0] = '_';
593 memcpy (buf
+ 2, IDENTIFIER_POINTER (id
),
594 IDENTIFIER_LENGTH (id
) + 1);
595 name
= get_identifier (buf
);
597 /* If TREE_TYPE isn't set, we're still in the introducer, so check
599 if (!LAMBDA_EXPR_CLOSURE (lambda
))
601 if (IDENTIFIER_MARKED (name
))
603 pedwarn (input_location
, 0,
604 "already captured %qD in lambda expression", id
);
607 IDENTIFIER_MARKED (name
) = true;
611 type
= make_pack_expansion (type
);
613 /* Make member variable. */
614 member
= build_decl (input_location
, FIELD_DECL
, name
, type
);
615 DECL_VLA_CAPTURE_P (member
) = vla
;
617 if (!explicit_init_p
)
618 /* Normal captures are invisible to name lookup but uses are replaced
619 with references to the capture field; we implement this by only
620 really making them invisible in unevaluated context; see
621 qualify_lookup. For now, let's make explicitly initialized captures
623 DECL_NORMAL_CAPTURE_P (member
) = true;
625 if (id
== this_identifier
)
626 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
628 /* Add it to the appropriate closure class if we've started it. */
629 if (current_class_type
630 && current_class_type
== LAMBDA_EXPR_CLOSURE (lambda
))
632 if (COMPLETE_TYPE_P (current_class_type
))
633 internal_error ("trying to capture %qD in instantiation of "
634 "generic lambda", id
);
635 finish_member_declaration (member
);
638 tree listmem
= member
;
641 listmem
= make_pack_expansion (member
);
642 initializer
= orig_init
;
644 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
645 = tree_cons (listmem
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
647 if (LAMBDA_EXPR_CLOSURE (lambda
))
648 return build_capture_proxy (member
, initializer
);
649 /* For explicit captures we haven't started the function yet, so we wait
650 and build the proxy from cp_parser_lambda_body. */
654 /* Register all the capture members on the list CAPTURES, which is the
655 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
658 register_capture_members (tree captures
)
660 if (captures
== NULL_TREE
)
663 register_capture_members (TREE_CHAIN (captures
));
665 tree field
= TREE_PURPOSE (captures
);
666 if (PACK_EXPANSION_P (field
))
667 field
= PACK_EXPANSION_PATTERN (field
);
669 /* We set this in add_capture to avoid duplicates. */
670 IDENTIFIER_MARKED (DECL_NAME (field
)) = false;
671 finish_member_declaration (field
);
674 /* Similar to add_capture, except this works on a stack of nested lambdas.
675 BY_REFERENCE_P in this case is derived from the default capture mode.
676 Returns the capture for the lambda at the bottom of the stack. */
679 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
681 bool this_capture_p
= (id
== this_identifier
);
683 tree var
= NULL_TREE
;
685 tree saved_class_type
= current_class_type
;
689 for (node
= lambda_stack
;
691 node
= TREE_CHAIN (node
))
693 tree lambda
= TREE_VALUE (node
);
695 current_class_type
= LAMBDA_EXPR_CLOSURE (lambda
);
696 if (DECL_PACK_P (initializer
))
697 initializer
= make_pack_expansion (initializer
);
698 var
= add_capture (lambda
,
703 || (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
705 /*explicit_init_p=*/false);
706 initializer
= convert_from_reference (var
);
709 current_class_type
= saved_class_type
;
714 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the
715 form of an INDIRECT_REF, possibly adding it through default
716 capturing, if ADD_CAPTURE_P is true. */
719 lambda_expr_this_capture (tree lambda
, bool add_capture_p
)
723 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
725 /* In unevaluated context this isn't an odr-use, so don't capture. */
726 if (cp_unevaluated_operand
)
727 add_capture_p
= false;
729 /* Try to default capture 'this' if we can. */
732 || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
))
734 tree lambda_stack
= NULL_TREE
;
735 tree init
= NULL_TREE
;
737 /* If we are in a lambda function, we can move out until we hit:
738 1. a non-lambda function or NSDMI,
739 2. a lambda function capturing 'this', or
740 3. a non-default capturing lambda function. */
741 for (tree tlambda
= lambda
; ;)
743 lambda_stack
= tree_cons (NULL_TREE
,
747 if (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)
748 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)) == FIELD_DECL
)
750 /* In an NSDMI, we don't have a function to look up the decl in,
751 but the fake 'this' pointer that we're using for parsing is
753 init
= scope_chain
->x_current_class_ptr
;
755 (init
&& (TREE_TYPE (TREE_TYPE (init
))
756 == current_nonlambda_class_type ()));
760 tree closure_decl
= TYPE_NAME (LAMBDA_EXPR_CLOSURE (tlambda
));
761 tree containing_function
= decl_function_context (closure_decl
);
763 if (containing_function
== NULL_TREE
)
764 /* We ran out of scopes; there's no 'this' to capture. */
767 if (!LAMBDA_FUNCTION_P (containing_function
))
769 /* We found a non-lambda function. */
770 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
))
771 /* First parameter is 'this'. */
772 init
= DECL_ARGUMENTS (containing_function
);
777 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
779 if (LAMBDA_EXPR_THIS_CAPTURE (tlambda
))
781 /* An outer lambda has already captured 'this'. */
782 init
= LAMBDA_EXPR_THIS_CAPTURE (tlambda
);
786 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda
) == CPLD_NONE
)
787 /* An outer lambda won't let us capture 'this'. */
794 this_capture
= add_default_capture (lambda_stack
,
795 /*id=*/this_identifier
,
802 if (cp_unevaluated_operand
)
803 result
= this_capture
;
804 else if (!this_capture
)
808 error ("%<this%> was not captured for this lambda function");
809 result
= error_mark_node
;
816 /* To make sure that current_class_ref is for the lambda. */
817 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
))
818 == LAMBDA_EXPR_CLOSURE (lambda
));
820 result
= this_capture
;
822 /* If 'this' is captured, each use of 'this' is transformed into an
823 access to the corresponding unnamed data member of the closure
824 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
825 ensures that the transformed expression is an rvalue. ] */
826 result
= rvalue (result
);
832 /* Return the current LAMBDA_EXPR, if this is a resolvable dummy
833 object. NULL otherwise.. */
836 resolvable_dummy_lambda (tree object
)
838 if (!is_dummy_object (object
))
841 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (object
));
842 gcc_assert (!TYPE_PTR_P (type
));
844 if (type
!= current_class_type
845 && current_class_type
846 && LAMBDA_TYPE_P (current_class_type
)
847 && lambda_function (current_class_type
)
848 && DERIVED_FROM_P (type
, current_nonlambda_class_type ()))
849 return CLASSTYPE_LAMBDA_EXPR (current_class_type
);
854 /* We don't want to capture 'this' until we know we need it, i.e. after
855 overload resolution has chosen a non-static member function. At that
856 point we call this function to turn a dummy object into a use of the
860 maybe_resolve_dummy (tree object
, bool add_capture_p
)
862 if (tree lam
= resolvable_dummy_lambda (object
))
863 if (tree cap
= lambda_expr_this_capture (lam
, add_capture_p
))
864 if (cap
!= error_mark_node
)
865 object
= build_x_indirect_ref (EXPR_LOCATION (object
), cap
,
866 RO_NULL
, tf_warning_or_error
);
871 /* When parsing a generic lambda containing an argument-dependent
872 member function call we defer overload resolution to instantiation
873 time. But we have to know now whether to capture this or not.
874 Do that if FNS contains any non-static fns.
875 The std doesn't anticipate this case, but I expect this to be the
876 outcome of discussion. */
879 maybe_generic_this_capture (tree object
, tree fns
)
881 if (tree lam
= resolvable_dummy_lambda (object
))
882 if (!LAMBDA_EXPR_THIS_CAPTURE (lam
))
884 /* We've not yet captured, so look at the function set of
886 if (BASELINK_P (fns
))
887 fns
= BASELINK_FUNCTIONS (fns
);
888 bool id_expr
= TREE_CODE (fns
) == TEMPLATE_ID_EXPR
;
890 fns
= TREE_OPERAND (fns
, 0);
892 for (lkp_iterator
iter (fns
); iter
; ++iter
)
893 if ((!id_expr
|| TREE_CODE (*iter
) == TEMPLATE_DECL
)
894 && DECL_NONSTATIC_MEMBER_FUNCTION_P (*iter
))
896 /* Found a non-static member. Capture this. */
897 lambda_expr_this_capture (lam
, true);
903 /* Returns the innermost non-lambda function. */
906 current_nonlambda_function (void)
908 tree fn
= current_function_decl
;
909 while (fn
&& LAMBDA_FUNCTION_P (fn
))
910 fn
= decl_function_context (fn
);
914 /* Returns the method basetype of the innermost non-lambda function, or
915 NULL_TREE if none. */
918 nonlambda_method_basetype (void)
921 if (!current_class_ref
)
924 type
= current_class_type
;
925 if (!LAMBDA_TYPE_P (type
))
928 /* Find the nearest enclosing non-lambda function. */
929 fn
= TYPE_NAME (type
);
931 fn
= decl_function_context (fn
);
932 while (fn
&& LAMBDA_FUNCTION_P (fn
));
934 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
937 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
940 /* Like current_scope, but looking through lambdas. */
943 current_nonlambda_scope (void)
945 tree scope
= current_scope ();
948 if (TREE_CODE (scope
) == FUNCTION_DECL
949 && LAMBDA_FUNCTION_P (scope
))
951 scope
= CP_TYPE_CONTEXT (DECL_CONTEXT (scope
));
954 else if (LAMBDA_TYPE_P (scope
))
956 scope
= CP_TYPE_CONTEXT (scope
);
964 /* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with
965 indicated FN and NARGS, but do not initialize the return type or any of the
969 prepare_op_call (tree fn
, int nargs
)
973 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
974 CALL_EXPR_FN (t
) = fn
;
975 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
980 /* Return true iff CALLOP is the op() for a generic lambda. */
983 generic_lambda_fn_p (tree callop
)
985 return (LAMBDA_FUNCTION_P (callop
)
986 && DECL_TEMPLATE_INFO (callop
)
987 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (callop
)));
990 /* Returns true iff we need to consider default capture for an enclosing
994 need_generic_capture (void)
996 if (!processing_template_decl
)
999 tree outer_closure
= NULL_TREE
;
1000 for (tree t
= current_class_type
; t
;
1001 t
= decl_type_context (TYPE_MAIN_DECL (t
)))
1003 tree lam
= CLASSTYPE_LAMBDA_EXPR (t
);
1004 if (!lam
|| LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
) == CPLD_NONE
)
1005 /* No default capture. */
1013 else if (dependent_type_p (outer_closure
))
1014 /* The enclosing context isn't instantiated. */
1020 /* A lambda-expression...is said to implicitly capture the entity...if the
1021 compound-statement...names the entity in a potentially-evaluated
1022 expression where the enclosing full-expression depends on a generic lambda
1023 parameter declared within the reaching scope of the lambda-expression. */
1026 dependent_capture_r (tree
*tp
, int *walk_subtrees
, void *data
)
1028 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
1033 if (outer_automatic_var_p (*tp
))
1035 tree t
= process_outer_var_ref (*tp
, tf_warning_or_error
, /*force*/true);
1037 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
1038 && TREE_CODE (TREE_TYPE (*tp
)) != REFERENCE_TYPE
)
1039 t
= convert_from_reference (t
);
1043 if (pset
->add (*tp
))
1046 switch (TREE_CODE (*tp
))
1048 /* Don't walk into unevaluated context or another lambda. */
1057 /* Don't walk into statements whose subexpressions we already
1064 case RANGE_FOR_STMT
:
1068 case STATEMENT_LIST
:
1075 tree decl
= DECL_EXPR_DECL (*tp
);
1078 /* walk_tree_1 won't step in here. */
1079 cp_walk_tree (&DECL_INITIAL (decl
),
1080 dependent_capture_r
, &pset
, NULL
);
1094 do_dependent_capture (tree expr
, bool force
)
1096 if (!need_generic_capture ()
1097 || (!force
&& !instantiation_dependent_expression_p (expr
)))
1100 hash_set
<tree
> pset
;
1101 cp_walk_tree (&expr
, dependent_capture_r
, &pset
, NULL
);
1105 /* If the closure TYPE has a static op(), also add a conversion to function
1109 maybe_add_lambda_conv_op (tree type
)
1111 bool nested
= (cfun
!= NULL
);
1112 bool nested_def
= decl_function_context (TYPE_MAIN_DECL (type
));
1113 tree callop
= lambda_function (type
);
1114 tree lam
= CLASSTYPE_LAMBDA_EXPR (type
);
1116 if (LAMBDA_EXPR_CAPTURE_LIST (lam
) != NULL_TREE
1117 || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
) != CPLD_NONE
)
1120 if (processing_template_decl
)
1123 bool const generic_lambda_p
= generic_lambda_fn_p (callop
);
1125 if (!generic_lambda_p
&& DECL_INITIAL (callop
) == NULL_TREE
)
1127 /* If the op() wasn't instantiated due to errors, give up. */
1128 gcc_assert (errorcount
|| sorrycount
);
1132 /* Non-template conversion operators are defined directly with build_call_a
1133 and using DIRECT_ARGVEC for arguments (including 'this'). Templates are
1134 deferred and the CALL is built in-place. In the case of a deduced return
1135 call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
1136 the return type is also built in-place. The arguments of DECLTYPE_CALL in
1137 the return expression may differ in flags from those in the body CALL. In
1138 particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
1139 the body CALL, but not in DECLTYPE_CALL. */
1141 vec
<tree
, va_gc
> *direct_argvec
= 0;
1142 tree decltype_call
= 0, call
= 0;
1143 tree optype
= TREE_TYPE (callop
);
1144 tree fn_result
= TREE_TYPE (optype
);
1146 tree thisarg
= build_nop (TREE_TYPE (DECL_ARGUMENTS (callop
)),
1148 if (generic_lambda_p
)
1150 ++processing_template_decl
;
1152 /* Prepare the dependent member call for the static member function
1153 '_FUN' and, potentially, prepare another call to be used in a decltype
1154 return expression for a deduced return call op to allow for simple
1155 implementation of the conversion operator. */
1157 tree instance
= cp_build_indirect_ref (thisarg
, RO_NULL
,
1158 tf_warning_or_error
);
1159 tree objfn
= build_min (COMPONENT_REF
, NULL_TREE
,
1160 instance
, DECL_NAME (callop
), NULL_TREE
);
1161 int nargs
= list_length (DECL_ARGUMENTS (callop
)) - 1;
1163 call
= prepare_op_call (objfn
, nargs
);
1164 if (type_uses_auto (fn_result
))
1165 decltype_call
= prepare_op_call (objfn
, nargs
);
1169 direct_argvec
= make_tree_vector ();
1170 direct_argvec
->quick_push (thisarg
);
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. */
1179 tree fn_args
= NULL_TREE
;
1182 tree src
= DECL_CHAIN (DECL_ARGUMENTS (callop
));
1187 tree new_node
= copy_node (src
);
1190 fn_args
= tgt
= new_node
;
1193 TREE_CHAIN (tgt
) = new_node
;
1197 mark_exp_read (tgt
);
1199 if (generic_lambda_p
)
1201 /* Avoid capturing variables in this context. */
1202 ++cp_unevaluated_operand
;
1203 tree a
= forward_parm (tgt
);
1204 --cp_unevaluated_operand
;
1206 CALL_EXPR_ARG (call
, ix
) = a
;
1208 CALL_EXPR_ARG (decltype_call
, ix
) = unshare_expr (a
);
1210 if (PACK_EXPANSION_P (a
))
1211 /* Set this after unsharing so it's not in decltype_call. */
1212 PACK_EXPANSION_LOCAL_P (a
) = true;
1217 vec_safe_push (direct_argvec
, tgt
);
1219 src
= TREE_CHAIN (src
);
1224 if (generic_lambda_p
)
1228 fn_result
= finish_decltype_type
1229 (decltype_call
, /*id_expression_or_member_access_p=*/false,
1230 tf_warning_or_error
);
1234 call
= build_call_a (callop
,
1235 direct_argvec
->length (),
1236 direct_argvec
->address ());
1238 CALL_FROM_THUNK_P (call
) = 1;
1239 SET_EXPR_LOCATION (call
, UNKNOWN_LOCATION
);
1241 tree stattype
= build_function_type (fn_result
, FUNCTION_ARG_CHAIN (callop
));
1242 stattype
= (cp_build_type_attribute_variant
1243 (stattype
, TYPE_ATTRIBUTES (optype
)));
1244 if (flag_noexcept_type
1245 && TYPE_NOTHROW_P (TREE_TYPE (callop
)))
1246 stattype
= build_exception_variant (stattype
, noexcept_true_spec
);
1248 if (generic_lambda_p
)
1249 --processing_template_decl
;
1251 /* First build up the conversion op. */
1253 tree rettype
= build_pointer_type (stattype
);
1254 tree name
= make_conv_op_name (rettype
);
1255 tree thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
1256 tree fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
1257 tree convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
1259 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
1260 SET_DECL_ALIGN (fn
, MINIMUM_METHOD_BOUNDARY
);
1261 grokclassfn (type
, fn
, NO_SPECIAL
);
1262 set_linkage_according_to_type (type
, fn
);
1263 rest_of_decl_compilation (fn
, namespace_bindings_p (), at_eof
);
1264 DECL_IN_AGGR_P (fn
) = 1;
1265 DECL_ARTIFICIAL (fn
) = 1;
1266 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1267 DECL_DECLARED_INLINE_P (fn
) = 1;
1268 DECL_ARGUMENTS (fn
) = build_this_parm (fn
, fntype
, TYPE_QUAL_CONST
);
1271 DECL_INTERFACE_KNOWN (fn
) = 1;
1273 if (generic_lambda_p
)
1274 fn
= add_inherited_template_parms (fn
, DECL_TI_TEMPLATE (callop
));
1276 add_method (type
, fn
, false);
1278 /* Generic thunk code fails for varargs; we'll complain in mark_used if
1279 the conversion op is used. */
1280 if (varargs_function_p (callop
))
1282 DECL_DELETED_FN (fn
) = 1;
1286 /* Now build up the thunk to be returned. */
1288 name
= get_identifier ("_FUN");
1289 tree statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
1291 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
1292 grokclassfn (type
, fn
, NO_SPECIAL
);
1293 set_linkage_according_to_type (type
, fn
);
1294 rest_of_decl_compilation (fn
, namespace_bindings_p (), at_eof
);
1295 DECL_IN_AGGR_P (fn
) = 1;
1296 DECL_ARTIFICIAL (fn
) = 1;
1297 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1298 DECL_DECLARED_INLINE_P (fn
) = 1;
1299 DECL_STATIC_FUNCTION_P (fn
) = 1;
1300 DECL_ARGUMENTS (fn
) = fn_args
;
1301 for (tree arg
= fn_args
; arg
; arg
= DECL_CHAIN (arg
))
1303 /* Avoid duplicate -Wshadow warnings. */
1304 DECL_NAME (arg
) = NULL_TREE
;
1305 DECL_CONTEXT (arg
) = fn
;
1308 DECL_INTERFACE_KNOWN (fn
) = 1;
1310 if (generic_lambda_p
)
1311 fn
= add_inherited_template_parms (fn
, DECL_TI_TEMPLATE (callop
));
1313 if (flag_sanitize
& SANITIZE_NULL
)
1314 /* Don't UBsan this function; we're deliberately calling op() with a null
1316 add_no_sanitize_value (fn
, SANITIZE_UNDEFINED
);
1318 add_method (type
, fn
, false);
1321 push_function_context ();
1323 /* Still increment function_depth so that we don't GC in the
1324 middle of an expression. */
1327 /* Generate the body of the thunk. */
1329 start_preparsed_function (statfn
, NULL_TREE
,
1330 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1331 if (DECL_ONE_ONLY (statfn
))
1333 /* Put the thunk in the same comdat group as the call op. */
1334 cgraph_node::get_create (statfn
)->add_to_same_comdat_group
1335 (cgraph_node::get_create (callop
));
1337 tree body
= begin_function_body ();
1338 tree compound_stmt
= begin_compound_stmt (0);
1339 if (!generic_lambda_p
)
1341 set_flags_from_callee (call
);
1342 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
1343 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
1345 call
= convert_from_reference (call
);
1346 finish_return_stmt (call
);
1348 finish_compound_stmt (compound_stmt
);
1349 finish_function_body (body
);
1351 fn
= finish_function (/*inline_p=*/true);
1352 if (!generic_lambda_p
)
1353 expand_or_defer_fn (fn
);
1355 /* Generate the body of the conversion op. */
1357 start_preparsed_function (convfn
, NULL_TREE
,
1358 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1359 body
= begin_function_body ();
1360 compound_stmt
= begin_compound_stmt (0);
1362 /* decl_needed_p needs to see that it's used. */
1363 TREE_USED (statfn
) = 1;
1364 finish_return_stmt (decay_conversion (statfn
, tf_warning_or_error
));
1366 finish_compound_stmt (compound_stmt
);
1367 finish_function_body (body
);
1369 fn
= finish_function (/*inline_p=*/true);
1370 if (!generic_lambda_p
)
1371 expand_or_defer_fn (fn
);
1374 pop_function_context ();
1379 /* True if FN is the static function "_FUN" that gets returned from the lambda
1380 conversion operator. */
1383 lambda_static_thunk_p (tree fn
)
1385 return (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
1386 && DECL_ARTIFICIAL (fn
)
1387 && DECL_STATIC_FUNCTION_P (fn
)
1388 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fn
)));
1391 /* Returns true iff VAL is a lambda-related declaration which should
1392 be ignored by unqualified lookup. */
1395 is_lambda_ignored_entity (tree val
)
1397 /* Look past normal capture proxies. */
1398 if (is_normal_capture_proxy (val
))
1401 /* Always ignore lambda fields, their names are only for debugging. */
1402 if (TREE_CODE (val
) == FIELD_DECL
1403 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val
)))
1406 /* None of the lookups that use qualify_lookup want the op() from the
1407 lambda; they want the one from the enclosing class. */
1408 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
1414 /* Lambdas that appear in variable initializer or default argument scope
1415 get that in their mangling, so we need to record it. We might as well
1416 use the count for function and namespace scopes as well. */
1417 static GTY(()) tree lambda_scope
;
1418 static GTY(()) int lambda_count
;
1419 struct GTY(()) tree_int
1424 static GTY(()) vec
<tree_int
, va_gc
> *lambda_scope_stack
;
1427 start_lambda_scope (tree decl
)
1431 /* Once we're inside a function, we ignore variable scope and just push
1432 the function again so that popping works properly. */
1433 if (current_function_decl
&& TREE_CODE (decl
) == VAR_DECL
)
1434 decl
= current_function_decl
;
1435 ti
.t
= lambda_scope
;
1436 ti
.i
= lambda_count
;
1437 vec_safe_push (lambda_scope_stack
, ti
);
1438 if (lambda_scope
!= decl
)
1440 /* Don't reset the count if we're still in the same function. */
1441 lambda_scope
= decl
;
1447 record_lambda_scope (tree lambda
)
1449 LAMBDA_EXPR_EXTRA_SCOPE (lambda
) = lambda_scope
;
1450 LAMBDA_EXPR_DISCRIMINATOR (lambda
) = lambda_count
++;
1454 finish_lambda_scope (void)
1456 tree_int
*p
= &lambda_scope_stack
->last ();
1457 if (lambda_scope
!= p
->t
)
1459 lambda_scope
= p
->t
;
1460 lambda_count
= p
->i
;
1462 lambda_scope_stack
->pop ();
1466 start_lambda_function (tree fco
, tree lambda_expr
)
1468 /* Let the front end know that we are going to be defining this
1470 start_preparsed_function (fco
,
1472 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1474 tree body
= begin_function_body ();
1476 /* Push the proxies for any explicit captures. */
1477 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
); cap
;
1478 cap
= TREE_CHAIN (cap
))
1479 build_capture_proxy (TREE_PURPOSE (cap
), TREE_VALUE (cap
));
1485 finish_lambda_function (tree body
)
1487 finish_function_body (body
);
1489 /* Finish the function and generate code for it if necessary. */
1490 tree fn
= finish_function (/*inline_p=*/true);
1492 /* Only expand if the call op is not a template. */
1493 if (!DECL_TEMPLATE_INFO (fn
))
1494 expand_or_defer_fn (fn
);
1497 #include "gt-cp-lambda.h"