From: Iain Sandoe Date: Sat, 31 Aug 2024 12:08:42 +0000 (+0100) Subject: c++, coroutines: Revise promise construction/destruction. X-Git-Tag: releases/gcc-14.3.0~65 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=5dbf5f9f4f83b0048e7c3af8fbaefb503d56928e;p=thirdparty%2Fgcc.git c++, coroutines: Revise promise construction/destruction. In examining the coroutine testcases for unexpected diagnostic output for 'Wall', I found a 'statement has no effect' warning for the promise construction in one case. In particular, the case is where the users promise type has an implicit CTOR but a user-provided DTOR. Further, the type does not actually need constructing. In very early versions of the coroutines code we used to check TYPE_NEEDS_CONSTRUCTING() to determine whether to attempt to build a constructor call for the promise. During review, it was suggested to use type_build_ctor_call () instead. This latter call checks the constructors in the type (both user-defined and implicit) and returns true, amongst other cases if any of the found CTORs are marked as deprecated. In a number of places (for example [class.copy.ctor] / 6) the standard says that some version of an implicit CTOR is deprecated when the user provides a DTOR. Thus, for this specific arrangement of promise type, type_build_ctor_call returns true, because of (for example) a deprecated implicit copy CTOR. We are not going to use any of the deprecated CTORs and thus will not see warnings from this - however, since the call returned true, we have now determined that we should attempt to build a constructor call. Note as above, the type does not actually require construction and thus one might expect either a NULL_TREE or error_mark_node in response to the build_special_member_call (). However, in practice the function returns the original instance object instead of a call or some error. When we add that as a statement it triggers the 'statement has no effect' warning. The patch here rearranges the promise construction/destruction code to allow for the case that a DTOR is required independently of a CTOR. In addition, we check that the return from build_special_member_call () has side effects before we add it as a statement. gcc/cp/ChangeLog: * coroutines.cc (cp_coroutine_transform::build_ramp_function): Separate the build of promise constructor and destructor. When evaluating the constructor, check that build_special_member_call returns an expression with side effects before adding it. Signed-off-by: Iain Sandoe (cherry picked from commit 7d1483921941d21d91f929ef0d59a9794b1946b4) --- diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc index 4b13f904ff0..e0e312265c1 100644 --- a/gcc/cp/coroutines.cc +++ b/gcc/cp/coroutines.cc @@ -5108,16 +5108,12 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer) tree p = build_class_member_access_expr (deref_fp, promise_m, NULL_TREE, false, tf_warning_or_error); - tree promise_dtor = NULL_TREE; if (type_build_ctor_call (promise_type)) { - /* Do a placement new constructor for the promise type (we never call - the new operator, just the constructor on the object in place in the - frame). + /* Construct the promise object [dcl.fct.def.coroutine] / 5.7. - First try to find a constructor with the same parameter list as the - original function (if it has params), failing that find a constructor - with no parameter list. */ + First try to find a constructor with an argument list comprised of + the parameter copies. */ if (DECL_ARGUMENTS (orig)) { @@ -5129,20 +5125,27 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer) else r = NULL_TREE; + /* If that fails then the promise constructor argument list is empty. */ if (r == NULL_TREE || r == error_mark_node) r = build_special_member_call (p, complete_ctor_identifier, NULL, promise_type, LOOKUP_NORMAL, tf_warning_or_error); - r = coro_build_cvt_void_expr_stmt (r, fn_start); - finish_expr_stmt (r); + /* If type_build_ctor_call() encounters deprecated implicit CTORs it will + return true, and therefore we will execute this code path. However, + we might well not actually require a CTOR and under those conditions + the build call above will not return a call expression, but the + original instance object. Do not attempt to add the statement unless + it has side-effects. */ + if (r && r != error_mark_node && TREE_SIDE_EFFECTS (r)) + finish_expr_stmt (r); + } - r = build_modify_expr (fn_start, coro_promise_live, boolean_type_node, - INIT_EXPR, fn_start, boolean_true_node, - boolean_type_node); + tree promise_dtor = cxx_maybe_build_cleanup (p, tf_warning_or_error);; + if (flag_exceptions && promise_dtor) + { + r = cp_build_init_expr (coro_promise_live, boolean_true_node); finish_expr_stmt (r); - - promise_dtor = cxx_maybe_build_cleanup (p, tf_warning_or_error); } /* Set up a new bind context for the GRO. */