diff options
Diffstat (limited to 'gcc/cp/lambda.cc')
| -rw-r--r-- | gcc/cp/lambda.cc | 1583 |
1 files changed, 1583 insertions, 0 deletions
diff --git a/gcc/cp/lambda.cc b/gcc/cp/lambda.cc new file mode 100644 index 0000000..4cc3a47 --- /dev/null +++ b/gcc/cp/lambda.cc @@ -0,0 +1,1583 @@ +/* Perform the semantic phase of lambda parsing, i.e., the process of + building tree structure, checking semantic consistency, and + building RTL. These routines are used both during actual parsing + and during the instantiation of template functions. + + Copyright (C) 1998-2022 Free Software Foundation, Inc. + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + GCC is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "cp-tree.h" +#include "stringpool.h" +#include "cgraph.h" +#include "tree-iterator.h" +#include "toplev.h" +#include "gimplify.h" +#include "target.h" + +/* Constructor for a lambda expression. */ + +tree +build_lambda_expr (void) +{ + tree lambda = make_node (LAMBDA_EXPR); + LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) = CPLD_NONE; + LAMBDA_EXPR_CAPTURE_LIST (lambda) = NULL_TREE; + LAMBDA_EXPR_THIS_CAPTURE (lambda) = NULL_TREE; + LAMBDA_EXPR_REGEN_INFO (lambda) = NULL_TREE; + LAMBDA_EXPR_PENDING_PROXIES (lambda) = NULL; + LAMBDA_EXPR_MUTABLE_P (lambda) = false; + return lambda; +} + +/* Create the closure object for a LAMBDA_EXPR. */ + +tree +build_lambda_object (tree lambda_expr) +{ + /* Build aggregate constructor call. + - cp_parser_braced_list + - cp_parser_functional_cast */ + vec<constructor_elt, va_gc> *elts = NULL; + tree node, expr, type; + + if (processing_template_decl || lambda_expr == error_mark_node) + return lambda_expr; + + /* Make sure any error messages refer to the lambda-introducer. */ + location_t loc = LAMBDA_EXPR_LOCATION (lambda_expr); + iloc_sentinel il (loc); + + for (node = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); + node; + node = TREE_CHAIN (node)) + { + tree field = TREE_PURPOSE (node); + tree val = TREE_VALUE (node); + + if (field == error_mark_node) + { + expr = error_mark_node; + goto out; + } + + if (TREE_CODE (val) == TREE_LIST) + val = build_x_compound_expr_from_list (val, ELK_INIT, + tf_warning_or_error); + + if (DECL_P (val)) + mark_used (val); + + /* Mere mortals can't copy arrays with aggregate initialization, so + do some magic to make it work here. */ + if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE) + val = build_array_copy (val); + else if (DECL_NORMAL_CAPTURE_P (field) + && !DECL_VLA_CAPTURE_P (field) + && !TYPE_REF_P (TREE_TYPE (field))) + { + /* "the entities that are captured by copy are used to + direct-initialize each corresponding non-static data + member of the resulting closure object." + + There's normally no way to express direct-initialization + from an element of a CONSTRUCTOR, so we build up a special + TARGET_EXPR to bypass the usual copy-initialization. */ + val = force_rvalue (val, tf_warning_or_error); + if (TREE_CODE (val) == TARGET_EXPR) + TARGET_EXPR_DIRECT_INIT_P (val) = true; + } + + CONSTRUCTOR_APPEND_ELT (elts, DECL_NAME (field), val); + } + + expr = build_constructor (init_list_type_node, elts); + CONSTRUCTOR_IS_DIRECT_INIT (expr) = 1; + + /* N2927: "[The closure] class type is not an aggregate." + But we briefly treat it as an aggregate to make this simpler. */ + type = LAMBDA_EXPR_CLOSURE (lambda_expr); + CLASSTYPE_NON_AGGREGATE (type) = 0; + expr = finish_compound_literal (type, expr, tf_warning_or_error); + protected_set_expr_location (expr, loc); + CLASSTYPE_NON_AGGREGATE (type) = 1; + + out: + return expr; +} + +/* Return an initialized RECORD_TYPE for LAMBDA. + LAMBDA must have its explicit captures already. */ + +tree +begin_lambda_type (tree lambda) +{ + /* Lambda names are nearly but not quite anonymous. */ + tree name = make_anon_name (); + IDENTIFIER_LAMBDA_P (name) = true; + + /* Create the new RECORD_TYPE for this lambda. */ + tree type = xref_tag (/*tag_code=*/record_type, name); + if (type == error_mark_node) + return error_mark_node; + + /* Designate it as a struct so that we can use aggregate initialization. */ + CLASSTYPE_DECLARED_CLASS (type) = false; + + /* Cross-reference the expression and the type. */ + LAMBDA_EXPR_CLOSURE (lambda) = type; + CLASSTYPE_LAMBDA_EXPR (type) = lambda; + + /* In C++17, assume the closure is literal; we'll clear the flag later if + necessary. */ + if (cxx_dialect >= cxx17) + CLASSTYPE_LITERAL_P (type) = true; + + /* Clear base types. */ + xref_basetypes (type, /*bases=*/NULL_TREE); + + /* Start the class. */ + type = begin_class_definition (type); + + return type; +} + +/* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the + closure type. */ + +tree +lambda_function (tree lambda) +{ + tree type; + if (TREE_CODE (lambda) == LAMBDA_EXPR) + type = LAMBDA_EXPR_CLOSURE (lambda); + else + type = lambda; + gcc_assert (LAMBDA_TYPE_P (type)); + /* Don't let debug_tree cause instantiation. */ + if (CLASSTYPE_TEMPLATE_INSTANTIATION (type) + && !COMPLETE_OR_OPEN_TYPE_P (type)) + return NULL_TREE; + lambda = lookup_member (type, call_op_identifier, + /*protect=*/0, /*want_type=*/false, + tf_warning_or_error); + if (lambda) + lambda = STRIP_TEMPLATE (get_first_fn (lambda)); + return lambda; +} + +/* Returns the type to use for the FIELD_DECL corresponding to the + capture of EXPR. EXPLICIT_INIT_P indicates whether this is a + C++14 init capture, and BY_REFERENCE_P indicates whether we're + capturing by reference. */ + +tree +lambda_capture_field_type (tree expr, bool explicit_init_p, + bool by_reference_p) +{ + tree type; + bool is_this = is_this_parameter (tree_strip_nop_conversions (expr)); + + if (is_this) + type = TREE_TYPE (expr); + else if (explicit_init_p) + { + tree auto_node = make_auto (); + + type = auto_node; + if (by_reference_p) + /* Add the reference now, so deduction doesn't lose + outermost CV qualifiers of EXPR. */ + type = build_reference_type (type); + if (uses_parameter_packs (expr)) + /* Stick with 'auto' even if the type could be deduced. */; + else + type = do_auto_deduction (type, expr, auto_node); + } + else if (type_dependent_expression_p (expr)) + { + type = cxx_make_type (DECLTYPE_TYPE); + DECLTYPE_TYPE_EXPR (type) = expr; + DECLTYPE_FOR_LAMBDA_CAPTURE (type) = true; + DECLTYPE_FOR_REF_CAPTURE (type) = by_reference_p; + SET_TYPE_STRUCTURAL_EQUALITY (type); + } + else + { + STRIP_ANY_LOCATION_WRAPPER (expr); + + if (!by_reference_p && is_capture_proxy (expr)) + { + /* When capturing by-value another capture proxy from an enclosing + lambda, consider the type of the corresponding field instead, + as the proxy may be additionally const-qualifed if the enclosing + lambda is non-mutable (PR94376). */ + gcc_assert (TREE_CODE (DECL_VALUE_EXPR (expr)) == COMPONENT_REF); + expr = TREE_OPERAND (DECL_VALUE_EXPR (expr), 1); + } + + type = non_reference (unlowered_expr_type (expr)); + + if (by_reference_p || TREE_CODE (type) == FUNCTION_TYPE) + type = build_reference_type (type); + } + + return type; +} + +/* Returns true iff DECL is a lambda capture proxy variable created by + build_capture_proxy. */ + +bool +is_capture_proxy (tree decl) +{ + /* Location wrappers should be stripped or otherwise handled by the + caller before using this predicate. */ + gcc_checking_assert (!location_wrapper_p (decl)); + + return (VAR_P (decl) + && DECL_HAS_VALUE_EXPR_P (decl) + && !DECL_ANON_UNION_VAR_P (decl) + && !DECL_DECOMPOSITION_P (decl) + && !DECL_FNAME_P (decl) + && !(DECL_ARTIFICIAL (decl) + && DECL_LANG_SPECIFIC (decl) + && DECL_OMP_PRIVATIZED_MEMBER (decl)) + && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl))); +} + +/* Returns true iff DECL is a capture proxy for a normal capture + (i.e. without explicit initializer). */ + +bool +is_normal_capture_proxy (tree decl) +{ + if (!is_capture_proxy (decl)) + /* It's not a capture proxy. */ + return false; + + return (DECL_LANG_SPECIFIC (decl) + && DECL_CAPTURED_VARIABLE (decl)); +} + +/* Returns true iff DECL is a capture proxy for a normal capture + of a constant variable. */ + +bool +is_constant_capture_proxy (tree decl) +{ + if (is_normal_capture_proxy (decl)) + return decl_constant_var_p (DECL_CAPTURED_VARIABLE (decl)); + return false; +} + +/* VAR is a capture proxy created by build_capture_proxy; add it to the + current function, which is the operator() for the appropriate lambda. */ + +void +insert_capture_proxy (tree var) +{ + if (is_normal_capture_proxy (var)) + { + tree cap = DECL_CAPTURED_VARIABLE (var); + if (CHECKING_P) + { + gcc_assert (!is_normal_capture_proxy (cap)); + tree old = retrieve_local_specialization (cap); + if (old) + gcc_assert (DECL_CONTEXT (old) != DECL_CONTEXT (var)); + } + register_local_specialization (var, cap); + } + + /* Put the capture proxy in the extra body block so that it won't clash + with a later local variable. */ + pushdecl_outermost_localscope (var); + + /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */ + var = build_stmt (DECL_SOURCE_LOCATION (var), DECL_EXPR, var); + tree stmt_list = (*stmt_list_stack)[1]; + gcc_assert (stmt_list); + append_to_statement_list_force (var, &stmt_list); +} + +/* We've just finished processing a lambda; if the containing scope is also + a lambda, insert any capture proxies that were created while processing + the nested lambda. */ + +void +insert_pending_capture_proxies (void) +{ + tree lam; + vec<tree, va_gc> *proxies; + unsigned i; + + if (!current_function_decl || !LAMBDA_FUNCTION_P (current_function_decl)) + return; + + lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl)); + proxies = LAMBDA_EXPR_PENDING_PROXIES (lam); + for (i = 0; i < vec_safe_length (proxies); ++i) + { + tree var = (*proxies)[i]; + insert_capture_proxy (var); + } + release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam)); + LAMBDA_EXPR_PENDING_PROXIES (lam) = NULL; +} + +/* Given REF, a COMPONENT_REF designating a field in the lambda closure, + return the type we want the proxy to have: the type of the field itself, + with added const-qualification if the lambda isn't mutable and the + capture is by value. */ + +tree +lambda_proxy_type (tree ref) +{ + tree type; + if (ref == error_mark_node) + return error_mark_node; + if (REFERENCE_REF_P (ref)) + ref = TREE_OPERAND (ref, 0); + gcc_assert (TREE_CODE (ref) == COMPONENT_REF); + type = TREE_TYPE (ref); + if (!type || WILDCARD_TYPE_P (non_reference (type))) + { + type = cxx_make_type (DECLTYPE_TYPE); + DECLTYPE_TYPE_EXPR (type) = ref; + DECLTYPE_FOR_LAMBDA_PROXY (type) = true; + SET_TYPE_STRUCTURAL_EQUALITY (type); + } + if (DECL_PACK_P (TREE_OPERAND (ref, 1))) + type = make_pack_expansion (type); + return type; +} + +/* MEMBER is a capture field in a lambda closure class. Now that we're + inside the operator(), build a placeholder var for future lookups and + debugging. */ + +static tree +build_capture_proxy (tree member, tree init) +{ + tree var, object, fn, closure, name, lam, type; + + if (PACK_EXPANSION_P (member)) + member = PACK_EXPANSION_PATTERN (member); + + closure = DECL_CONTEXT (member); + fn = lambda_function (closure); + lam = CLASSTYPE_LAMBDA_EXPR (closure); + + /* The proxy variable forwards to the capture field. */ + object = build_fold_indirect_ref (DECL_ARGUMENTS (fn)); + object = finish_non_static_data_member (member, object, NULL_TREE); + if (REFERENCE_REF_P (object)) + object = TREE_OPERAND (object, 0); + + /* Remove the __ inserted by add_capture. */ + name = get_identifier (IDENTIFIER_POINTER (DECL_NAME (member)) + 2); + + type = lambda_proxy_type (object); + + if (name == this_identifier && !INDIRECT_TYPE_P (type)) + { + type = build_pointer_type (type); + type = cp_build_qualified_type (type, TYPE_QUAL_CONST); + object = build_fold_addr_expr_with_type (object, type); + } + + if (DECL_VLA_CAPTURE_P (member)) + { + /* Rebuild the VLA type from the pointer and maxindex. */ + tree field = next_initializable_field (TYPE_FIELDS (type)); + tree ptr = build_simple_component_ref (object, field); + field = next_initializable_field (DECL_CHAIN (field)); + tree max = build_simple_component_ref (object, field); + type = build_cplus_array_type (TREE_TYPE (TREE_TYPE (ptr)), + build_index_type (max)); + type = build_reference_type (type); + object = convert (type, ptr); + } + + complete_type (type); + + var = build_decl (input_location, VAR_DECL, name, type); + SET_DECL_VALUE_EXPR (var, object); + DECL_HAS_VALUE_EXPR_P (var) = 1; + DECL_ARTIFICIAL (var) = 1; + TREE_USED (var) = 1; + DECL_CONTEXT (var) = fn; + + if (DECL_NORMAL_CAPTURE_P (member)) + { + if (DECL_VLA_CAPTURE_P (member)) + { + init = CONSTRUCTOR_ELT (init, 0)->value; + init = TREE_OPERAND (init, 0); // Strip ADDR_EXPR. + init = TREE_OPERAND (init, 0); // Strip ARRAY_REF. + } + else + { + if (PACK_EXPANSION_P (init)) + init = PACK_EXPANSION_PATTERN (init); + } + + if (INDIRECT_REF_P (init)) + init = TREE_OPERAND (init, 0); + STRIP_NOPS (init); + + gcc_assert (VAR_P (init) || TREE_CODE (init) == PARM_DECL); + while (is_normal_capture_proxy (init)) + init = DECL_CAPTURED_VARIABLE (init); + retrofit_lang_decl (var); + DECL_CAPTURED_VARIABLE (var) = init; + } + + if (name == this_identifier) + { + gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam) == member); + LAMBDA_EXPR_THIS_CAPTURE (lam) = var; + } + + if (fn == current_function_decl) + insert_capture_proxy (var); + else + vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam), var); + + return var; +} + +static GTY(()) tree ptr_id; +static GTY(()) tree max_id; + +/* Return a struct containing a pointer and a length for lambda capture of + an array of runtime length. */ + +static tree +vla_capture_type (tree array_type) +{ + tree type = xref_tag (record_type, make_anon_name ()); + xref_basetypes (type, NULL_TREE); + type = begin_class_definition (type); + if (!ptr_id) + { + ptr_id = get_identifier ("ptr"); + max_id = get_identifier ("max"); + } + tree ptrtype = build_pointer_type (TREE_TYPE (array_type)); + tree field = build_decl (input_location, FIELD_DECL, ptr_id, ptrtype); + finish_member_declaration (field); + field = build_decl (input_location, FIELD_DECL, max_id, sizetype); + finish_member_declaration (field); + return finish_struct (type, NULL_TREE); +} + +/* From an ID and INITIALIZER, create a capture (by reference if + BY_REFERENCE_P is true), add it to the capture-list for LAMBDA, + and return it. If ID is `this', BY_REFERENCE_P says whether + `*this' is captured by reference. */ + +tree +add_capture (tree lambda, tree id, tree orig_init, bool by_reference_p, + bool explicit_init_p) +{ + char *buf; + tree type, member, name; + bool vla = false; + bool variadic = false; + tree initializer = orig_init; + + if (PACK_EXPANSION_P (initializer)) + { + initializer = PACK_EXPANSION_PATTERN (initializer); + variadic = true; + } + + if (TREE_CODE (initializer) == TREE_LIST + /* A pack expansion might end up with multiple elements. */ + && !PACK_EXPANSION_P (TREE_VALUE (initializer))) + initializer = build_x_compound_expr_from_list (initializer, ELK_INIT, + tf_warning_or_error); + type = TREE_TYPE (initializer); + if (type == error_mark_node) + return error_mark_node; + + if (!dependent_type_p (type) && array_of_runtime_bound_p (type)) + { + vla = true; + if (!by_reference_p) + error ("array of runtime bound cannot be captured by copy, " + "only by reference"); + + /* For a VLA, we capture the address of the first element and the + maximum index, and then reconstruct the VLA for the proxy. */ + tree elt = cp_build_array_ref (input_location, initializer, + integer_zero_node, tf_warning_or_error); + initializer = build_constructor_va (init_list_type_node, 2, + NULL_TREE, build_address (elt), + NULL_TREE, array_type_nelts (type)); + type = vla_capture_type (type); + } + else if (!dependent_type_p (type) + && variably_modified_type_p (type, NULL_TREE)) + { + sorry ("capture of variably-modified type %qT that is not an N3639 array " + "of runtime bound", type); + if (TREE_CODE (type) == ARRAY_TYPE + && variably_modified_type_p (TREE_TYPE (type), NULL_TREE)) + inform (input_location, "because the array element type %qT has " + "variable size", TREE_TYPE (type)); + return error_mark_node; + } + else + { + type = lambda_capture_field_type (initializer, explicit_init_p, + by_reference_p); + if (type == error_mark_node) + return error_mark_node; + + if (id == this_identifier && !by_reference_p) + { + gcc_assert (INDIRECT_TYPE_P (type)); + type = TREE_TYPE (type); + initializer = cp_build_fold_indirect_ref (initializer); + } + + if (dependent_type_p (type)) + ; + else if (id != this_identifier && by_reference_p) + { + if (!lvalue_p (initializer)) + { + error ("cannot capture %qE by reference", initializer); + return error_mark_node; + } + } + else + { + /* Capture by copy requires a complete type. */ + type = complete_type (type); + if (!COMPLETE_TYPE_P (type)) + { + error ("capture by copy of incomplete type %qT", type); + cxx_incomplete_type_inform (type); + return error_mark_node; + } + else if (!verify_type_context (input_location, + TCTX_CAPTURE_BY_COPY, type)) + return error_mark_node; + } + } + + /* Add __ to the beginning of the field name so that user code + won't find the field with name lookup. We can't just leave the name + unset because template instantiation uses the name to find + instantiated fields. */ + buf = (char *) alloca (IDENTIFIER_LENGTH (id) + 3); + buf[1] = buf[0] = '_'; + memcpy (buf + 2, IDENTIFIER_POINTER (id), + IDENTIFIER_LENGTH (id) + 1); + name = get_identifier (buf); + + if (variadic) + { + type = make_pack_expansion (type); + if (explicit_init_p) + /* With an explicit initializer 'type' is auto, which isn't really a + parameter pack in this context. We will want as many fields as we + have elements in the expansion of the initializer, so use its packs + instead. */ + { + PACK_EXPANSION_PARAMETER_PACKS (type) + = uses_parameter_packs (initializer); + PACK_EXPANSION_AUTO_P (type) = true; + } + } + + /* Make member variable. */ + member = build_decl (input_location, FIELD_DECL, name, type); + DECL_VLA_CAPTURE_P (member) = vla; + + if (!explicit_init_p) + /* Normal captures are invisible to name lookup but uses are replaced + with references to the capture field; we implement this by only + really making them invisible in unevaluated context; see + qualify_lookup. For now, let's make explicitly initialized captures + always visible. */ + DECL_NORMAL_CAPTURE_P (member) = true; + + if (id == this_identifier) + LAMBDA_EXPR_THIS_CAPTURE (lambda) = member; + + /* Add it to the appropriate closure class if we've started it. */ + if (current_class_type + && current_class_type == LAMBDA_EXPR_CLOSURE (lambda)) + { + if (COMPLETE_TYPE_P (current_class_type)) + internal_error ("trying to capture %qD in instantiation of " + "generic lambda", id); + finish_member_declaration (member); + } + + tree listmem = member; + if (variadic) + { + listmem = make_pack_expansion (member); + initializer = orig_init; + } + LAMBDA_EXPR_CAPTURE_LIST (lambda) + = tree_cons (listmem, initializer, LAMBDA_EXPR_CAPTURE_LIST (lambda)); + + if (LAMBDA_EXPR_CLOSURE (lambda)) + return build_capture_proxy (member, initializer); + /* For explicit captures we haven't started the function yet, so we wait + and build the proxy from cp_parser_lambda_body. */ + LAMBDA_CAPTURE_EXPLICIT_P (LAMBDA_EXPR_CAPTURE_LIST (lambda)) = true; + return NULL_TREE; +} + +/* Register all the capture members on the list CAPTURES, which is the + LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */ + +void +register_capture_members (tree captures) +{ + if (captures == NULL_TREE) + return; + + register_capture_members (TREE_CHAIN (captures)); + + tree field = TREE_PURPOSE (captures); + if (PACK_EXPANSION_P (field)) + field = PACK_EXPANSION_PATTERN (field); + + finish_member_declaration (field); +} + +/* Similar to add_capture, except this works on a stack of nested lambdas. + BY_REFERENCE_P in this case is derived from the default capture mode. + Returns the capture for the lambda at the bottom of the stack. */ + +tree +add_default_capture (tree lambda_stack, tree id, tree initializer) +{ + bool this_capture_p = (id == this_identifier); + tree var = NULL_TREE; + tree saved_class_type = current_class_type; + + for (tree node = lambda_stack; + node; + node = TREE_CHAIN (node)) + { + tree lambda = TREE_VALUE (node); + + current_class_type = LAMBDA_EXPR_CLOSURE (lambda); + if (DECL_PACK_P (initializer)) + initializer = make_pack_expansion (initializer); + var = add_capture (lambda, + id, + initializer, + /*by_reference_p=*/ + (this_capture_p + || (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) + == CPLD_REFERENCE)), + /*explicit_init_p=*/false); + initializer = convert_from_reference (var); + + /* Warn about deprecated implicit capture of this via [=]. */ + if (cxx_dialect >= cxx20 + && this_capture_p + && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) == CPLD_COPY) + { + if (warning_at (LAMBDA_EXPR_LOCATION (lambda), OPT_Wdeprecated, + "implicit capture of %qE via %<[=]%> is deprecated " + "in C++20", this_identifier)) + inform (LAMBDA_EXPR_LOCATION (lambda), "add explicit %<this%> or " + "%<*this%> capture"); + } + } + + current_class_type = saved_class_type; + + return var; +} + +/* Return the capture pertaining to a use of 'this' in LAMBDA, in the + form of an INDIRECT_REF, possibly adding it through default + capturing, if ADD_CAPTURE_P is nonzero. If ADD_CAPTURE_P is negative, + try to capture but don't complain if we can't. */ + +tree +lambda_expr_this_capture (tree lambda, int add_capture_p) +{ + tree result; + + tree this_capture = LAMBDA_EXPR_THIS_CAPTURE (lambda); + + /* In unevaluated context this isn't an odr-use, so don't capture. */ + if (cp_unevaluated_operand) + add_capture_p = false; + + /* Try to default capture 'this' if we can. */ + if (!this_capture) + { + tree lambda_stack = NULL_TREE; + tree init = NULL_TREE; + + /* If we are in a lambda function, we can move out until we hit: + 1. a non-lambda function or NSDMI, + 2. a lambda function capturing 'this', or + 3. a non-default capturing lambda function. */ + for (tree tlambda = lambda; ;) + { + if (add_capture_p + && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda) == CPLD_NONE) + /* tlambda won't let us capture 'this'. */ + break; + + if (add_capture_p) + lambda_stack = tree_cons (NULL_TREE, + tlambda, + lambda_stack); + + tree closure = LAMBDA_EXPR_CLOSURE (tlambda); + tree containing_function + = decl_function_context (TYPE_NAME (closure)); + + tree ex = LAMBDA_EXPR_EXTRA_SCOPE (tlambda); + if (ex && TREE_CODE (ex) == FIELD_DECL) + { + /* Lambda in an NSDMI. We don't have a function to look up + 'this' in, but we can find (or rebuild) the fake one from + inject_this_parameter. */ + if (!containing_function && !COMPLETE_TYPE_P (closure)) + /* If we're parsing a lambda in a non-local class, + we can find the fake 'this' in scope_chain. */ + init = scope_chain->x_current_class_ptr; + else + /* Otherwise it's either gone or buried in + function_context_stack, so make another. */ + init = build_this_parm (NULL_TREE, DECL_CONTEXT (ex), + TYPE_UNQUALIFIED); + gcc_checking_assert + (init && (TREE_TYPE (TREE_TYPE (init)) + == current_nonlambda_class_type ())); + break; + } + + if (containing_function == NULL_TREE) + /* We ran out of scopes; there's no 'this' to capture. */ + break; + + if (!LAMBDA_FUNCTION_P (containing_function)) + { + /* We found a non-lambda function. */ + if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function)) + /* First parameter is 'this'. */ + init = DECL_ARGUMENTS (containing_function); + break; + } + + tlambda + = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function)); + + if (LAMBDA_EXPR_THIS_CAPTURE (tlambda)) + { + /* An outer lambda has already captured 'this'. */ + init = LAMBDA_EXPR_THIS_CAPTURE (tlambda); + break; + } + } + + if (init) + { + if (add_capture_p) + this_capture = add_default_capture (lambda_stack, + /*id=*/this_identifier, + init); + else + this_capture = init; + } + } + + if (cp_unevaluated_operand) + result = this_capture; + else if (!this_capture) + { + if (add_capture_p == 1) + { + error ("%<this%> was not captured for this lambda function"); + result = error_mark_node; + } + else + result = NULL_TREE; + } + else + { + /* To make sure that current_class_ref is for the lambda. */ + gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)) + == LAMBDA_EXPR_CLOSURE (lambda)); + + result = this_capture; + + /* If 'this' is captured, each use of 'this' is transformed into an + access to the corresponding unnamed data member of the closure + type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast + ensures that the transformed expression is an rvalue. ] */ + result = rvalue (result); + } + + return result; +} + +/* Return the innermost LAMBDA_EXPR we're currently in, if any. */ + +tree +current_lambda_expr (void) +{ + tree type = current_class_type; + while (type && !LAMBDA_TYPE_P (type)) + type = decl_type_context (TYPE_NAME (type)); + if (type) + return CLASSTYPE_LAMBDA_EXPR (type); + else + return NULL_TREE; +} + +/* Return the current LAMBDA_EXPR, if this is a resolvable dummy + object. NULL otherwise.. */ + +static tree +resolvable_dummy_lambda (tree object) +{ + if (!is_dummy_object (object)) + return NULL_TREE; + + tree type = TYPE_MAIN_VARIANT (TREE_TYPE (object)); + gcc_assert (!TYPE_PTR_P (type)); + + if (type != current_class_type + && current_class_type + && LAMBDA_TYPE_P (current_class_type) + && lambda_function (current_class_type) + && DERIVED_FROM_P (type, nonlambda_method_basetype())) + return CLASSTYPE_LAMBDA_EXPR (current_class_type); + + return NULL_TREE; +} + +/* We don't want to capture 'this' until we know we need it, i.e. after + overload resolution has chosen a non-static member function. At that + point we call this function to turn a dummy object into a use of the + 'this' capture. */ + +tree +maybe_resolve_dummy (tree object, bool add_capture_p) +{ + if (tree lam = resolvable_dummy_lambda (object)) + if (tree cap = lambda_expr_this_capture (lam, add_capture_p)) + if (cap != error_mark_node) + object = build_fold_indirect_ref (cap); + + return object; +} + +/* When parsing a generic lambda containing an argument-dependent + member function call we defer overload resolution to instantiation + time. But we have to know now whether to capture this or not. + Do that if FNS contains any non-static fns. + The std doesn't anticipate this case, but I expect this to be the + outcome of discussion. */ + +void +maybe_generic_this_capture (tree object, tree fns) +{ + if (tree lam = resolvable_dummy_lambda (object)) + if (!LAMBDA_EXPR_THIS_CAPTURE (lam)) + { + /* We've not yet captured, so look at the function set of + interest. */ + if (BASELINK_P (fns)) + fns = BASELINK_FUNCTIONS (fns); + bool id_expr = TREE_CODE (fns) == TEMPLATE_ID_EXPR; + if (id_expr) + fns = TREE_OPERAND (fns, 0); + + for (lkp_iterator iter (fns); iter; ++iter) + if (((!id_expr && TREE_CODE (*iter) != USING_DECL) + || TREE_CODE (*iter) == TEMPLATE_DECL) + && DECL_NONSTATIC_MEMBER_FUNCTION_P (*iter)) + { + /* Found a non-static member. Capture this. */ + lambda_expr_this_capture (lam, /*maybe*/-1); + break; + } + } +} + +/* Returns the innermost non-lambda function. */ + +tree +current_nonlambda_function (void) +{ + tree fn = current_function_decl; + while (fn && LAMBDA_FUNCTION_P (fn)) + fn = decl_function_context (fn); + return fn; +} + +/* Returns the method basetype of the innermost non-lambda function, including + a hypothetical constructor if inside an NSDMI, or NULL_TREE if none. */ + +tree +nonlambda_method_basetype (void) +{ + if (!current_class_ref) + return NULL_TREE; + + tree type = current_class_type; + if (!type || !LAMBDA_TYPE_P (type)) + return type; + + while (true) + { + tree lam = CLASSTYPE_LAMBDA_EXPR (type); + tree ex = LAMBDA_EXPR_EXTRA_SCOPE (lam); + if (ex && TREE_CODE (ex) == FIELD_DECL) + /* Lambda in an NSDMI. */ + return DECL_CONTEXT (ex); + + tree fn = TYPE_CONTEXT (type); + if (!fn || TREE_CODE (fn) != FUNCTION_DECL + || !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) + /* No enclosing non-lambda method. */ + return NULL_TREE; + if (!LAMBDA_FUNCTION_P (fn)) + /* Found an enclosing non-lambda method. */ + return TYPE_METHOD_BASETYPE (TREE_TYPE (fn)); + type = DECL_CONTEXT (fn); + } +} + +/* Like current_scope, but looking through lambdas. */ + +tree +current_nonlambda_scope (void) +{ + tree scope = current_scope (); + for (;;) + { + if (TREE_CODE (scope) == FUNCTION_DECL + && LAMBDA_FUNCTION_P (scope)) + { + scope = CP_TYPE_CONTEXT (DECL_CONTEXT (scope)); + continue; + } + else if (LAMBDA_TYPE_P (scope)) + { + scope = CP_TYPE_CONTEXT (scope); + continue; + } + break; + } + return scope; +} + +/* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with + indicated FN and NARGS, but do not initialize the return type or any of the + argument slots. */ + +static tree +prepare_op_call (tree fn, int nargs) +{ + tree t; + + t = build_vl_exp (CALL_EXPR, nargs + 3); + CALL_EXPR_FN (t) = fn; + CALL_EXPR_STATIC_CHAIN (t) = NULL; + + return t; +} + +/* Return true iff CALLOP is the op() for a generic lambda. */ + +bool +generic_lambda_fn_p (tree callop) +{ + return (LAMBDA_FUNCTION_P (callop) + && DECL_TEMPLATE_INFO (callop) + && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (callop))); +} + +/* If the closure TYPE has a static op(), also add a conversion to function + pointer. */ + +void +maybe_add_lambda_conv_op (tree type) +{ + bool nested = (cfun != NULL); + bool nested_def = decl_function_context (TYPE_MAIN_DECL (type)); + tree callop = lambda_function (type); + tree lam = CLASSTYPE_LAMBDA_EXPR (type); + + if (LAMBDA_EXPR_CAPTURE_LIST (lam) != NULL_TREE + || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) != CPLD_NONE) + return; + + if (processing_template_decl) + return; + + bool const generic_lambda_p = generic_lambda_fn_p (callop); + + if (!generic_lambda_p && undeduced_auto_decl (callop)) + { + /* If the op() wasn't deduced due to errors, give up. */ + gcc_assert (errorcount || sorrycount); + return; + } + + /* Non-generic non-capturing lambdas only have a conversion function to + pointer to function when the trailing requires-clause's constraints are + satisfied. */ + if (!generic_lambda_p && !constraints_satisfied_p (callop)) + return; + + /* Non-template conversion operators are defined directly with build_call_a + and using DIRECT_ARGVEC for arguments (including 'this'). Templates are + deferred and the CALL is built in-place. In the case of a deduced return + call op, the decltype expression, DECLTYPE_CALL, used as a substitute for + the return type is also built in-place. The arguments of DECLTYPE_CALL in + the return expression may differ in flags from those in the body CALL. In + particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in + the body CALL, but not in DECLTYPE_CALL. */ + + vec<tree, va_gc> *direct_argvec = 0; + tree decltype_call = 0, call = 0; + tree optype = TREE_TYPE (callop); + tree fn_result = TREE_TYPE (optype); + + tree thisarg = build_int_cst (TREE_TYPE (DECL_ARGUMENTS (callop)), 0); + if (generic_lambda_p) + { + ++processing_template_decl; + + /* Prepare the dependent member call for the static member function + '_FUN' and, potentially, prepare another call to be used in a decltype + return expression for a deduced return call op to allow for simple + implementation of the conversion operator. */ + + tree instance = cp_build_fold_indirect_ref (thisarg); + tree objfn = lookup_template_function (DECL_NAME (callop), + DECL_TI_ARGS (callop)); + objfn = build_min (COMPONENT_REF, NULL_TREE, + instance, objfn, NULL_TREE); + int nargs = list_length (DECL_ARGUMENTS (callop)) - 1; + + call = prepare_op_call (objfn, nargs); + if (type_uses_auto (fn_result)) + decltype_call = prepare_op_call (objfn, nargs); + } + else + { + direct_argvec = make_tree_vector (); + direct_argvec->quick_push (thisarg); + } + + /* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to + declare the static member function "_FUN" below. For each arg append to + DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated + call args (for the template case). If a parameter pack is found, expand + it, flagging it as PACK_EXPANSION_LOCAL_P for the body call. */ + + tree fn_args = NULL_TREE; + { + int ix = 0; + tree src = DECL_CHAIN (DECL_ARGUMENTS (callop)); + tree tgt = NULL; + + while (src) + { + tree new_node = copy_node (src); + /* We set DECL_CONTEXT of NEW_NODE to the statfn below. + Notice this is creating a recursive type! */ + + /* Clear TREE_ADDRESSABLE on thunk arguments. */ + TREE_ADDRESSABLE (new_node) = 0; + + if (!fn_args) + fn_args = tgt = new_node; + else + { + TREE_CHAIN (tgt) = new_node; + tgt = new_node; + } + + mark_exp_read (tgt); + + if (generic_lambda_p) + { + tree a = tgt; + if (DECL_PACK_P (tgt)) + { + a = make_pack_expansion (a); + PACK_EXPANSION_LOCAL_P (a) = true; + } + CALL_EXPR_ARG (call, ix) = a; + + if (decltype_call) + { + /* Avoid capturing variables in this context. */ + ++cp_unevaluated_operand; + CALL_EXPR_ARG (decltype_call, ix) = forward_parm (tgt); + --cp_unevaluated_operand; + } + + ++ix; + } + else + vec_safe_push (direct_argvec, tgt); + + src = TREE_CHAIN (src); + } + } + + if (generic_lambda_p) + { + if (decltype_call) + { + fn_result = finish_decltype_type + (decltype_call, /*id_expression_or_member_access_p=*/false, + tf_warning_or_error); + } + } + else + call = build_call_a (callop, + direct_argvec->length (), + direct_argvec->address ()); + + CALL_FROM_THUNK_P (call) = 1; + SET_EXPR_LOCATION (call, UNKNOWN_LOCATION); + + tree stattype = build_function_type (fn_result, FUNCTION_ARG_CHAIN (callop)); + stattype = (cp_build_type_attribute_variant + (stattype, TYPE_ATTRIBUTES (optype))); + if (flag_noexcept_type + && TYPE_NOTHROW_P (TREE_TYPE (callop))) + stattype = build_exception_variant (stattype, noexcept_true_spec); + + if (generic_lambda_p) + --processing_template_decl; + + /* First build up the conversion op. */ + + tree rettype = build_pointer_type (stattype); + tree name = make_conv_op_name (rettype); + tree thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST); + tree fntype = build_method_type_directly (thistype, rettype, void_list_node); + /* DR 1722: The conversion function should be noexcept. */ + fntype = build_exception_variant (fntype, noexcept_true_spec); + tree convfn = build_lang_decl (FUNCTION_DECL, name, fntype); + SET_DECL_LANGUAGE (convfn, lang_cplusplus); + tree fn = convfn; + DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop); + SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY); + grokclassfn (type, fn, NO_SPECIAL); + set_linkage_according_to_type (type, fn); + rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof); + DECL_IN_AGGR_P (fn) = 1; + DECL_ARTIFICIAL (fn) = 1; + DECL_NOT_REALLY_EXTERN (fn) = 1; + DECL_DECLARED_INLINE_P (fn) = 1; + DECL_DECLARED_CONSTEXPR_P (fn) = DECL_DECLARED_CONSTEXPR_P (callop); + if (DECL_IMMEDIATE_FUNCTION_P (callop)) + SET_DECL_IMMEDIATE_FUNCTION_P (fn); + DECL_ARGUMENTS (fn) = build_this_parm (fn, fntype, TYPE_QUAL_CONST); + + if (nested_def) + DECL_INTERFACE_KNOWN (fn) = 1; + + if (generic_lambda_p) + fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop)); + + add_method (type, fn, false); + + /* Generic thunk code fails for varargs; we'll complain in mark_used if + the conversion op is used. */ + if (varargs_function_p (callop)) + { + DECL_DELETED_FN (fn) = 1; + return; + } + + /* Now build up the thunk to be returned. */ + + tree statfn = build_lang_decl (FUNCTION_DECL, fun_identifier, stattype); + SET_DECL_LANGUAGE (statfn, lang_cplusplus); + fn = statfn; + DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop); + grokclassfn (type, fn, NO_SPECIAL); + set_linkage_according_to_type (type, fn); + rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof); + DECL_IN_AGGR_P (fn) = 1; + DECL_ARTIFICIAL (fn) = 1; + DECL_NOT_REALLY_EXTERN (fn) = 1; + DECL_DECLARED_INLINE_P (fn) = 1; + DECL_STATIC_FUNCTION_P (fn) = 1; + DECL_DECLARED_CONSTEXPR_P (fn) = DECL_DECLARED_CONSTEXPR_P (callop); + if (DECL_IMMEDIATE_FUNCTION_P (callop)) + SET_DECL_IMMEDIATE_FUNCTION_P (fn); + DECL_ARGUMENTS (fn) = fn_args; + for (tree arg = fn_args; arg; arg = DECL_CHAIN (arg)) + { + /* Avoid duplicate -Wshadow warnings. */ + DECL_NAME (arg) = NULL_TREE; + DECL_CONTEXT (arg) = fn; + } + if (nested_def) + DECL_INTERFACE_KNOWN (fn) = 1; + + if (generic_lambda_p) + fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop)); + + if (flag_sanitize & SANITIZE_NULL) + /* Don't UBsan this function; we're deliberately calling op() with a null + object argument. */ + add_no_sanitize_value (fn, SANITIZE_UNDEFINED); + + add_method (type, fn, false); + + if (nested) + push_function_context (); + else + /* Still increment function_depth so that we don't GC in the + middle of an expression. */ + ++function_depth; + + /* Generate the body of the thunk. */ + + start_preparsed_function (statfn, NULL_TREE, + SF_PRE_PARSED | SF_INCLASS_INLINE); + tree body = begin_function_body (); + tree compound_stmt = begin_compound_stmt (0); + if (!generic_lambda_p) + { + set_flags_from_callee (call); + if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call))) + call = build_cplus_new (TREE_TYPE (call), call, tf_warning_or_error); + } + call = convert_from_reference (call); + finish_return_stmt (call); + + finish_compound_stmt (compound_stmt); + finish_function_body (body); + + fn = finish_function (/*inline_p=*/true); + if (!generic_lambda_p) + expand_or_defer_fn (fn); + + /* Generate the body of the conversion op. */ + + start_preparsed_function (convfn, NULL_TREE, + SF_PRE_PARSED | SF_INCLASS_INLINE); + body = begin_function_body (); + compound_stmt = begin_compound_stmt (0); + + /* decl_needed_p needs to see that it's used. */ + TREE_USED (statfn) = 1; + finish_return_stmt (decay_conversion (statfn, tf_warning_or_error)); + + finish_compound_stmt (compound_stmt); + finish_function_body (body); + + fn = finish_function (/*inline_p=*/true); + if (!generic_lambda_p) + expand_or_defer_fn (fn); + + if (nested) + pop_function_context (); + else + --function_depth; +} + +/* True if FN is the static function "_FUN" that gets returned from the lambda + conversion operator. */ + +bool +lambda_static_thunk_p (tree fn) +{ + return (fn && TREE_CODE (fn) == FUNCTION_DECL + && DECL_ARTIFICIAL (fn) + && DECL_STATIC_FUNCTION_P (fn) + && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fn))); +} + +bool +call_from_lambda_thunk_p (tree call) +{ + return (CALL_FROM_THUNK_P (call) + && lambda_static_thunk_p (current_function_decl)); +} + +/* Returns true iff VAL is a lambda-related declaration which should + be ignored by unqualified lookup. */ + +bool +is_lambda_ignored_entity (tree val) +{ + /* Look past normal, non-VLA capture proxies. */ + if (is_normal_capture_proxy (val) + && !variably_modified_type_p (TREE_TYPE (val), NULL_TREE)) + return true; + + /* Always ignore lambda fields, their names are only for debugging. */ + if (TREE_CODE (val) == FIELD_DECL + && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val))) + return true; + + /* None of the lookups that use qualify_lookup want the op() from the + lambda; they want the one from the enclosing class. */ + if (tree fns = maybe_get_fns (val)) + if (LAMBDA_FUNCTION_P (OVL_FIRST (fns))) + return true; + + return false; +} + +/* Lambdas that appear in variable initializer or default argument scope + get that in their mangling, so we need to record it. We might as well + use the count for function and namespace scopes as well. */ +static GTY(()) tree lambda_scope; +static GTY(()) int lambda_count; +struct GTY(()) tree_int +{ + tree t; + int i; +}; +static GTY(()) vec<tree_int, va_gc> *lambda_scope_stack; + +void +start_lambda_scope (tree decl) +{ + tree_int ti; + gcc_assert (decl); + /* Once we're inside a function, we ignore variable scope and just push + the function again so that popping works properly. */ + if (current_function_decl && TREE_CODE (decl) == VAR_DECL) + decl = current_function_decl; + ti.t = lambda_scope; + ti.i = lambda_count; + vec_safe_push (lambda_scope_stack, ti); + if (lambda_scope != decl) + { + /* Don't reset the count if we're still in the same function. */ + lambda_scope = decl; + lambda_count = 0; + } +} + +void +record_lambda_scope (tree lambda) +{ + LAMBDA_EXPR_EXTRA_SCOPE (lambda) = lambda_scope; + LAMBDA_EXPR_DISCRIMINATOR (lambda) = lambda_count++; + if (lambda_scope) + { + tree closure = LAMBDA_EXPR_CLOSURE (lambda); + gcc_checking_assert (closure); + maybe_attach_decl (lambda_scope, TYPE_NAME (closure)); + } +} + +/* This lambda is an instantiation of a lambda in a template default argument + that got no LAMBDA_EXPR_EXTRA_SCOPE, so this shouldn't either. But we do + need to use and increment the global count to avoid collisions. */ + +void +record_null_lambda_scope (tree lambda) +{ + if (vec_safe_is_empty (lambda_scope_stack)) + record_lambda_scope (lambda); + else + { + tree_int *p = lambda_scope_stack->begin(); + LAMBDA_EXPR_EXTRA_SCOPE (lambda) = p->t; + LAMBDA_EXPR_DISCRIMINATOR (lambda) = p->i++; + } + gcc_assert (LAMBDA_EXPR_EXTRA_SCOPE (lambda) == NULL_TREE); +} + +void +finish_lambda_scope (void) +{ + tree_int *p = &lambda_scope_stack->last (); + if (lambda_scope != p->t) + { + lambda_scope = p->t; + lambda_count = p->i; + } + lambda_scope_stack->pop (); +} + +tree +start_lambda_function (tree fco, tree lambda_expr) +{ + /* Let the front end know that we are going to be defining this + function. */ + start_preparsed_function (fco, + NULL_TREE, + SF_PRE_PARSED | SF_INCLASS_INLINE); + + tree body = begin_function_body (); + + /* Push the proxies for any explicit captures. */ + for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap; + cap = TREE_CHAIN (cap)) + build_capture_proxy (TREE_PURPOSE (cap), TREE_VALUE (cap)); + + return body; +} + +/* Subroutine of prune_lambda_captures: CAP is a node in + LAMBDA_EXPR_CAPTURE_LIST. Return the variable it captures for which we + might optimize away the capture, or NULL_TREE if there is no such + variable. */ + +static tree +var_to_maybe_prune (tree cap) +{ + if (LAMBDA_CAPTURE_EXPLICIT_P (cap)) + /* Don't prune explicit captures. */ + return NULL_TREE; + + tree mem = TREE_PURPOSE (cap); + if (!DECL_P (mem) || !DECL_NORMAL_CAPTURE_P (mem)) + /* Packs and init-captures aren't captures of constant vars. */ + return NULL_TREE; + + tree init = TREE_VALUE (cap); + if (is_normal_capture_proxy (init)) + init = DECL_CAPTURED_VARIABLE (init); + if (decl_constant_var_p (init)) + return init; + + return NULL_TREE; +} + +/* walk_tree helper for prune_lambda_captures: Remember which capture proxies + for constant variables are actually used in the lambda body. + + There will always be a DECL_EXPR for the capture proxy; remember it when we + see it, but replace it with any other use. */ + +static tree +mark_const_cap_r (tree *t, int *walk_subtrees, void *data) +{ + hash_map<tree,tree*> &const_vars = *(hash_map<tree,tree*>*)data; + + tree var = NULL_TREE; + if (TREE_CODE (*t) == DECL_EXPR) + { + tree decl = DECL_EXPR_DECL (*t); + if (is_constant_capture_proxy (decl)) + { + var = DECL_CAPTURED_VARIABLE (decl); + *walk_subtrees = 0; + } + } + else if (!location_wrapper_p (*t) /* is_capture_proxy dislikes them. */ + && is_constant_capture_proxy (*t)) + var = DECL_CAPTURED_VARIABLE (*t); + + if (var) + { + tree *&slot = const_vars.get_or_insert (var); + if (!slot || VAR_P (*t)) + slot = t; + } + + return NULL_TREE; +} + +/* We're at the end of processing a lambda; go back and remove any captures of + constant variables for which we've folded away all uses. */ + +static void +prune_lambda_captures (tree body) +{ + tree lam = current_lambda_expr (); + if (!LAMBDA_EXPR_CAPTURE_OPTIMIZED (lam)) + /* No uses were optimized away. */ + return; + if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) == CPLD_NONE) + /* No default captures, and we don't prune explicit captures. */ + return; + + hash_map<tree,tree*> const_vars; + + cp_walk_tree_without_duplicates (&body, mark_const_cap_r, &const_vars); + + tree *fieldp = &TYPE_FIELDS (LAMBDA_EXPR_CLOSURE (lam)); + for (tree *capp = &LAMBDA_EXPR_CAPTURE_LIST (lam); *capp; ) + { + tree cap = *capp; + if (tree var = var_to_maybe_prune (cap)) + { + tree **use = const_vars.get (var); + if (use && TREE_CODE (**use) == DECL_EXPR) + { + /* All uses of this capture were folded away, leaving only the + proxy declaration. */ + + /* Splice the capture out of LAMBDA_EXPR_CAPTURE_LIST. */ + *capp = TREE_CHAIN (cap); + + /* And out of TYPE_FIELDS. */ + tree field = TREE_PURPOSE (cap); + while (*fieldp != field) + fieldp = &DECL_CHAIN (*fieldp); + *fieldp = DECL_CHAIN (*fieldp); + + /* And remove the capture proxy declaration. */ + **use = void_node; + continue; + } + } + + capp = &TREE_CHAIN (cap); + } +} + +void +finish_lambda_function (tree body) +{ + finish_function_body (body); + + prune_lambda_captures (body); + + /* Finish the function and generate code for it if necessary. */ + tree fn = finish_function (/*inline_p=*/true); + + /* Only expand if the call op is not a template. */ + if (!DECL_TEMPLATE_INFO (fn)) + expand_or_defer_fn (fn); +} + +#include "gt-cp-lambda.h" |