c++, coroutines: Rework handling of throwing_cleanups [PR102051].

In the fix for PR95822 (r11-7402) we set throwing_cleanup false in the top
level of the coroutine transform code.  However, as the current PR shows,
that is not sufficient.

Any use of cxx_maybe_build_cleanup() can reset the flag, which causes the
check_return_expr () logic to try to add a guard variable and set it.

For the coroutine code, we need to handle the cleanups separately, since
the responsibility for them changes after the first resume point, which
we handle in the ramp exception processing.

Fix this by forcing the "throwing_cleanup" flag false right before the
processing of the return expression.

	PR c++/102051

gcc/cp/ChangeLog:

	* coroutines.cc
	(cp_coroutine_transform::build_ramp_function): Handle
	"throwing_cleanup" here instead of ...
	(cp_coroutine_transform::apply_transforms): ... here.

gcc/testsuite/ChangeLog:

	* g++.dg/coroutines/pr102051.C: New test.

Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>

diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
index b45efab2b517a8a064ad08b1c96ce47c9905bd9a..3991de19d65c667e13f528496fb3d06816390499 100644 (file)
--- a/gcc/cp/coroutines.cc
+++ b/gcc/cp/coroutines.cc
@@ -4990,11 +4990,16 @@ cp_coroutine_transform::build_ramp_function ()
      The expression promise.get_return_object() is used to initialize the
      glvalue result or prvalue result object of a call to a coroutine.  */
 
+  /* We must manage the cleanups ourselves, because the responsibility for
+     them changes after the initial suspend.  However, any use of
+     cxx_maybe_build_cleanup () can set the throwing_cleanup flag.  */
+  cp_function_chain->throwing_cleanup = false;
   if (void_ramp_p)
     /* We still want to call the method, even if the result is unused.  */
     r = get_ro;
   else
     {
+      /* The initial section of finish_return_expr ().  */
       bool no_warning;
       bool dangling;
       /* Without a relevant location, bad conversions in check_return_expr
@@ -5220,17 +5225,6 @@ cp_coroutine_transform::apply_transforms ()
   body_blocks = current_binding_level->blocks;
   current_binding_level->blocks = NULL_TREE;
 
-  /* If the original function has a return value with a non-trivial DTOR
-     and the body contains a var with a DTOR that might throw, the decl is
-     marked "throwing_cleanup".
-     We do not [in the ramp, which is synthesised here], use any body var
-     types with DTORs that might throw.
-     The original body is transformed into the actor function which only
-     contains void returns, and is also wrapped in a try-catch block.
-     So (a) the 'throwing_cleanup' is not correct for the ramp and (b) we do
-     not need to transfer it to the actor which only contains void returns.  */
-  cp_function_chain->throwing_cleanup = false;
-
   /* Collect information on the original function params and their use in the
      function body.  */
   analyze_fn_parms (orig_fn_decl, &param_uses);

diff --git a/gcc/testsuite/g++.dg/coroutines/pr102051.C b/gcc/testsuite/g++.dg/coroutines/pr102051.C
new file mode 100644 (file)
index 0000000..bba98b6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr102051.C
@@ -0,0 +1,16 @@
+#include <coroutine>
+
+struct Foo {
+    ~Foo() noexcept(false); // true succeeds
+    struct promise_type {
+        Foo get_return_object() { return {}; }
+        std::suspend_never initial_suspend() { return {}; }
+        void return_void() {}
+        void unhandled_exception() {}
+        std::suspend_always final_suspend() noexcept { return {}; }
+    };
+};
+
+Foo bar() {
+    co_return;
+}