+2010-03-23 Jason Merrill <jason@redhat.com>
+
+ Make lambda conversion op and op() non-static.
+ * semantics.c (maybe_add_lambda_conv_op): Make non-static.
+ Also add the thunk function returned by the conversion op.
+ Mark the conversion deleted if the op() is variadic.
+ * decl2.c (mark_used): Give helpful message about deleted conversion.
+ * parser.c (cp_parser_lambda_declarator_opt): Don't make op() static.
+ * semantics.c (finish_this_expr): Adjust.
+ * mangle.c (write_closure_type_name): Adjust.
+ * decl.c (grok_op_properties): Don't allow it.
+ * call.c (build_user_type_conversion_1): No static conversion ops.
+ (build_op_call): Or op().
+
+ * decl2.c (change_return_type): Fix 'this' quals.
+
2010-03-22 Jason Merrill <jason@redhat.com>
PR c++/43333
for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
{
tree fn = OVL_CURRENT (fns);
- tree first = first_arg;
if (DECL_NONCONVERTING_P (fn)
&& (flags & LOOKUP_ONLYCONVERTING))
continue;
- /* Lambdas have a static conversion op. */
- if (DECL_STATIC_FUNCTION_P (fn))
- first = NULL_TREE;
-
/* [over.match.funcs] For conversion functions, the function
is considered to be a member of the class of the implicit
object argument for the purpose of defining the type of
if (TREE_CODE (fn) == TEMPLATE_DECL)
cand = add_template_candidate (&candidates, fn, fromtype,
NULL_TREE,
- first, NULL, totype,
+ first_arg, NULL, totype,
TYPE_BINFO (fromtype),
conversion_path,
flags,
DEDUCE_CONV);
else
cand = add_function_candidate (&candidates, fn, fromtype,
- first, NULL,
+ first_arg, NULL,
TYPE_BINFO (fromtype),
conversion_path,
flags);
{
tree fn = OVL_CURRENT (fns);
- tree lfirst = first_mem_arg;
- if (DECL_STATIC_FUNCTION_P (fn))
- lfirst = NULL_TREE;
-
if (TREE_CODE (fn) == TEMPLATE_DECL)
add_template_candidate (&candidates, fn, base, NULL_TREE,
- lfirst, *args, NULL_TREE,
+ first_mem_arg, *args, NULL_TREE,
TYPE_BINFO (type),
TYPE_BINFO (type),
LOOKUP_NORMAL, DEDUCE_CALL);
else
add_function_candidate
- (&candidates, fn, base, lfirst, *args, TYPE_BINFO (type),
+ (&candidates, fn, base, first_mem_arg, *args, TYPE_BINFO (type),
TYPE_BINFO (type), LOOKUP_NORMAL);
}
}
- /* Rather than mess with handling static conversion ops here, just don't
- look at conversions in lambdas. */
- if (LAMBDA_TYPE_P (type))
- convs = NULL_TREE;
- else
- convs = lookup_conversions (type, /*lookup_template_convs_p=*/true);
+ convs = lookup_conversions (type, /*lookup_template_convs_p=*/true);
for (; convs; convs = TREE_CHAIN (convs))
{
|| operator_code == ARRAY_REF
|| operator_code == NOP_EXPR)
{
- if (class_type && LAMBDA_TYPE_P (class_type))
- /* Lambdas can have static op() and conv ops. */;
- else
- {
- error ("%qD must be a nonstatic member function", decl);
- return false;
- }
+ error ("%qD must be a nonstatic member function", decl);
+ return false;
}
else
{
if (TREE_CODE (fntype) == FUNCTION_TYPE)
newtype = build_function_type (new_ret, args);
else
- newtype = build_method_type_directly (TYPE_METHOD_BASETYPE (fntype),
- new_ret, TREE_CHAIN (args));
+ newtype = build_method_type_directly
+ (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
+ new_ret, TREE_CHAIN (args));
if (raises)
newtype = build_exception_variant (newtype, raises);
if (attrs)
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_DELETED_FN (decl))
{
+ if (DECL_ARTIFICIAL (decl))
+ {
+ if (DECL_OVERLOADED_OPERATOR_P (decl) == TYPE_EXPR
+ && LAMBDA_TYPE_P (DECL_CONTEXT (decl)))
+ {
+ /* We mark a lambda conversion op as deleted if we can't
+ generate it properly; see maybe_add_lambda_conv_op. */
+ sorry ("converting lambda which uses %<...%> to "
+ "function pointer");
+ return;
+ }
+ }
error ("deleted function %q+D", decl);
error ("used here");
return;
MANGLE_TRACE_TREE ("closure-type-name", type);
write_string ("Ul");
- write_method_parms (parms, DECL_NONSTATIC_MEMBER_FUNCTION_P (fn), fn);
+ write_method_parms (parms, /*method_p=*/1, fn);
write_char ('E');
write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
}
declarator = make_id_declarator (NULL_TREE, ansi_opname (CALL_EXPR),
sfk_none);
- quals = TYPE_UNQUALIFIED;
- if (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr) == NULL_TREE
- && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_NONE)
- {
- /* A lambda with no captures has a static op() and a conversion op
- to function type. */
- if (LAMBDA_EXPR_MUTABLE_P (lambda_expr))
- error ("lambda expression with no captures declared mutable");
- return_type_specs.storage_class = sc_static;
- }
- else if (!LAMBDA_EXPR_MUTABLE_P (lambda_expr))
- quals = TYPE_QUAL_CONST;
+ quals = (LAMBDA_EXPR_MUTABLE_P (lambda_expr)
+ ? TYPE_UNQUALIFIED : TYPE_QUAL_CONST);
declarator = make_call_declarator (declarator, param_list, quals,
exception_spec,
/*late_return_type=*/NULL_TREE);
{
tree result;
- /* In a lambda expression, 'this' refers to the captured 'this'. */
- if (current_function_decl
- && LAMBDA_FUNCTION_P (current_function_decl))
- result = (lambda_expr_this_capture
- (CLASSTYPE_LAMBDA_EXPR (current_class_type)));
- else if (current_class_ptr)
- result = current_class_ptr;
+ if (current_class_ptr)
+ {
+ tree type = TREE_TYPE (current_class_ref);
+
+ /* In a lambda expression, 'this' refers to the captured 'this'. */
+ if (LAMBDA_TYPE_P (type))
+ result = lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type));
+ else
+ result = current_class_ptr;
+
+ }
else if (current_function_decl
&& DECL_STATIC_FUNCTION_P (current_function_decl))
{
bool nested = (current_function_decl != NULL_TREE);
tree callop = lambda_function (type);
tree rettype, name, fntype, fn, body, compound_stmt;
+ tree thistype, stattype, statfn, convfn, call, arg;
+ VEC (tree, gc) *argvec;
- if (!DECL_STATIC_FUNCTION_P (callop))
+ if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type)) != NULL_TREE)
return;
- rettype = build_pointer_type (TREE_TYPE (callop));
+ stattype = build_function_type (TREE_TYPE (TREE_TYPE (callop)),
+ FUNCTION_ARG_CHAIN (callop));
+
+ /* First build up the conversion op. */
+
+ rettype = build_pointer_type (stattype);
name = mangle_conv_op_name_for_type (rettype);
- fntype = build_function_type (rettype, void_list_node);
- fn = build_lang_decl (FUNCTION_DECL, name, fntype);
+ thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST);
+ fntype = build_method_type_directly (thistype, rettype, void_list_node);
+ fn = convfn = build_lang_decl (FUNCTION_DECL, name, fntype);
DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
DECL_ARTIFICIAL (fn) = 1;
DECL_NOT_REALLY_EXTERN (fn) = 1;
DECL_DECLARED_INLINE_P (fn) = 1;
+ DECL_ARGUMENTS (fn) = build_this_parm (fntype, TYPE_QUAL_CONST);
+ if (nested)
+ DECL_INTERFACE_KNOWN (fn) = 1;
+
+ add_method (type, fn, NULL_TREE);
+
+ /* 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. */
+
+ name = get_identifier ("_FUN");
+ fn = statfn = build_lang_decl (FUNCTION_DECL, name, stattype);
+ DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
+ if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
+ && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
+ DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
+ grokclassfn (type, fn, NO_SPECIAL);
+ set_linkage_according_to_type (type, fn);
+ rest_of_decl_compilation (fn, toplevel_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_ARGUMENTS (fn) = copy_list (TREE_CHAIN (DECL_ARGUMENTS (callop)));
+ for (arg = DECL_ARGUMENTS (fn); arg; arg = TREE_CHAIN (arg))
+ DECL_CONTEXT (arg) = fn;
if (nested)
DECL_INTERFACE_KNOWN (fn) = 1;
if (nested)
push_function_context ();
- start_preparsed_function (fn, NULL_TREE,
+
+ /* Generate the body of the thunk. */
+
+ start_preparsed_function (statfn, NULL_TREE,
+ SF_PRE_PARSED | SF_INCLASS_INLINE);
+ if (DECL_ONE_ONLY (statfn))
+ {
+ /* Put the thunk in the same comdat group as the call op. */
+ struct cgraph_node *callop_node, *thunk_node;
+ DECL_COMDAT_GROUP (statfn) = DECL_COMDAT_GROUP (callop);
+ callop_node = cgraph_node (callop);
+ thunk_node = cgraph_node (statfn);
+ gcc_assert (callop_node->same_comdat_group == NULL);
+ gcc_assert (thunk_node->same_comdat_group == NULL);
+ callop_node->same_comdat_group = thunk_node;
+ thunk_node->same_comdat_group = callop_node;
+ }
+ body = begin_function_body ();
+ compound_stmt = begin_compound_stmt (0);
+
+ arg = build1 (NOP_EXPR, TREE_TYPE (DECL_ARGUMENTS (callop)), void_zero_node);
+ argvec = make_tree_vector ();
+ VEC_quick_push (tree, argvec, arg);
+ for (arg = DECL_ARGUMENTS (statfn); arg; arg = TREE_CHAIN (arg))
+ VEC_safe_push (tree, gc, argvec, arg);
+ call = build_cxx_call (callop, VEC_length (tree, argvec),
+ VEC_address (tree, argvec));
+ CALL_FROM_THUNK_P (call) = 1;
+ finish_return_stmt (call);
+
+ finish_compound_stmt (compound_stmt);
+ finish_function_body (body);
+
+ expand_or_defer_fn (finish_function (2));
+
+ /* 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);
- finish_return_stmt (decay_conversion (callop));
+ finish_return_stmt (decay_conversion (statfn));
finish_compound_stmt (compound_stmt);
finish_function_body (body);
expand_or_defer_fn (finish_function (2));
+
if (nested)
pop_function_context ();
}
+2010-03-23 Jason Merrill <jason@redhat.com>
+
+ * g++.dg/cpp0x/lambda/lambda-const-neg.C: Adjust for non-static op().
+ * g++.dg/cpp0x/lambda/lambda-conv.C: Likewise.
+ * g++.dg/cpp0x/lambda/lambda-mangle.C: Likewise.
+ * g++.dg/cpp0x/lambda/lambda-non-const.C: Likewise.
+ * g++.dg/cpp0x/lambda/lambda-conv2.C: New.
+ * g++.dg/cpp0x/lambda/lambda-conv3.C: New.
+
2010-03-23 Mike Stump <mikestump@comcast.net>
PR target/33120
int main() {
call([] () -> void {});
- call([] () mutable -> void {}); // { dg-message "" "declared mutable" }
+ call([] () mutable -> void {});
int i = -1;
call([&i] () -> void { i = 0; });
-// Test for conversion from stateless lambda to function pointer, which is
-// not yet part of the draft but hopefully will be after the March 2010
-// meeting.
+// Test for conversion from stateless lambda to function pointer.
// { dg-options -std=c++0x }
-// { dg-final { scan-assembler "weak\[^\n\r\]*_?_ZZ1fvENUlvE_cvPFvvEEv" { target { ! { *-*-darwin* *-*-mingw* *-*-cygwin } } } } }
+// { dg-final { scan-assembler "weak\[^\n\r\]*_?_ZZ1fvENKUlvE_cvPFvvEEv" { target { ! { *-*-darwin* *-*-mingw* *-*-cygwin } } } } }
inline void f()
{
--- /dev/null
+// Test for conversion from stateless lambda to function pointer.
+
+// { dg-options -std=c++0x }
+// { dg-do run }
+
+typedef int (*pfn)(int);
+
+int main()
+{
+ pfn p = [](int i) { return i-42; };
+ return p (42);
+}
--- /dev/null
+// Conversion to a function pointer uses a generic thunk, which doesn't
+// work properly for variadics. Make sure that we can still use the lambda
+// normally.
+
+// { dg-options -std=c++0x }
+
+void f()
+{
+ auto l = [](...){};
+ void (*p1)(...) = l; // { dg-bogus "sorry" "" { xfail *-*-* } }
+ l(); // OK
+}
// The closure type is encoded as Z1giEUlvE_.
// The call operator of that type is _ZZ1giENKUlvE_clEv.
-// { dg-final { scan-assembler "_ZZ1giENUlvE_clEv" } }
-// { dg-final { scan-assembler "weak\[^\n\r\]*_?_ZZ1giENUlvE_clEv" { target { ! { *-*-darwin* *-*-mingw* *-*-cygwin } } } } }
+// { dg-final { scan-assembler "_ZZ1giENKUlvE_clEv" } }
+// { dg-final { scan-assembler "weak\[^\n\r\]*_?_ZZ1giENKUlvE_clEv" { target { ! { *-*-darwin* *-*-mingw* *-*-cygwin } } } } }
algo([=]{return n+bef();});
// The captured entities do not participate in <lambda-sig>
void f(int =
// Type: ZN1S1fEiiEd0_UlvE_
// Operator: _ZZN1S1fEiiEd0_NKUlvE_clEv
-// { dg-final { scan-assembler "_ZZN1S1fEiiEd0_NUlvE_clEv" } }
-// { dg-final { scan-assembler "weak\[^\n\r\]*_?_ZZN1S1fEiiEd0_NUlvE_clEv" { target { ! { *-*-darwin* *-*-mingw* *-*-cygwin } } } } }
+// { dg-final { scan-assembler "_ZZN1S1fEiiEd0_NKUlvE_clEv" } }
+// { dg-final { scan-assembler "weak\[^\n\r\]*_?_ZZN1S1fEiiEd0_NKUlvE_clEv" { target { ! { *-*-darwin* *-*-mingw* *-*-cygwin } } } } }
[]{return 1;}()
// Type: ZN1S1fEiiEd0_UlvE0_
// Operator: _ZZN1S1fEiiEd0_NKUlvE0_clEv
-// { dg-final { scan-assembler "_ZZN1S1fEiiEd0_NUlvE0_clEv" } }
+// { dg-final { scan-assembler "_ZZN1S1fEiiEd0_NKUlvE0_clEv" } }
+ []{return 2;}(),
int =
// Type: ZN1S1fEiiEd_UlvE_
// Operator: _ZZN1S1fEiiEd_NKUlvE_clEv
-// { dg-final { scan-assembler "_ZZN1S1fEiiEd_NUlvE_clEv" } }
+// { dg-final { scan-assembler "_ZZN1S1fEiiEd_NKUlvE_clEv" } }
[]{return 3;}());
};
template int R<int>::x;
// Type of lambda in intializer of R<int>::x: N1RIiE1xMUlvE_E
// Corresponding operator(): _ZNK1RIiE1xMUlvE_clEv
-// { dg-final { scan-assembler "_ZN1RIiE1xMUlvE_clEv" } }
-// { dg-final { scan-assembler "weak\[^\n\r\]*_?_ZN1RIiE1xMUlvE_clEv" { target { ! { *-*-mingw* *-*-cygwin } } } } }
+// { dg-final { scan-assembler "_ZNK1RIiE1xMUlvE_clEv" } }
+// { dg-final { scan-assembler "weak\[^\n\r\]*_?_ZNK1RIiE1xMUlvE_clEv" { target { ! { *-*-mingw* *-*-cygwin } } } } }
void bar()
{
}
// lambdas used in non-template, non-class body initializers are internal.
-// { dg-final { scan-assembler-not "weak\[^\n\r\]*_ZNUlv" } }
+// { dg-final { scan-assembler-not "weak\[^\n\r\]*_ZNKUlv" } }
// { dg-final { scan-assembler-not "weak\[^\n\r\]*variable" } }
int variable = []{return 1;}();
int main() {
call([] () -> void {});
+ call([] () mutable -> void {});
int i = -1;
call([i] () mutable -> void { i = 0; });
OSDN Git Service
