avoid symmetric transfer on GCC

Author: ericniebler

examples/CMakeLists.txt

@@ -32,6 +32,8 @@ function(def_example example)
         PRIVATE STDEXEC::stdexec
                 stdexec_executable_flags
                 $<TARGET_NAME_IF_EXISTS:TBB::tbb>)
+    target_compile_options(${target} INTERFACE
+        $<$<CXX_COMPILER_ID:GNU>:-Wno-maybe-uninitialized>) # warnings being emitted from stdlib headers, why?
 endfunction()
 
 set(stdexec_examples

include/stdexec/__detail/__as_awaitable.hpp

@@ -33,7 +33,6 @@
 #include <functional>  // for std::identity
 #include <system_error>
 #include <thread>
-#include <variant>
 
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
@@ -307,8 +306,7 @@ namespace STDEXEC
       }
 
       constexpr auto
-      await_suspend([[maybe_unused]] __std::coroutine_handle<_Promise> __hcoro) noexcept  //
-        -> __std::coroutine_handle<>
+      await_suspend([[maybe_unused]] __std::coroutine_handle<_Promise> __hcoro) noexcept -> bool
       {
         STDEXEC_ASSERT(this->__continuation_ == __hcoro);
 
@@ -330,14 +328,14 @@ namespace STDEXEC
           // The operation completed inline with set_value or set_error, so we can just
           // resume the current coroutine. await_resume will either return the value or
           // throw as appropriate.
-          return __hcoro;
+          return false;
         }
         else
         {
           // If __ready_ was still false when executing the CAS, then the operation did not
           // complete inline. The continuation will be resumed when the operation
           // completes, so we return a noop_coroutine to suspend the current coroutine.
-          return __std::noop_coroutine();
+          return true;
         }
       }
 
@@ -363,7 +361,7 @@ namespace STDEXEC
       {}
 
       auto await_suspend([[maybe_unused]] __std::coroutine_handle<_Promise> __hcoro)
-        -> __std::coroutine_handle<>
+        -> STDEXEC_PP_IF(STDEXEC_GCC(), bool, __std::coroutine_handle<>)
       {
         STDEXEC_ASSERT(this->__continuation_ == __hcoro);
         {
@@ -379,14 +377,16 @@ namespace STDEXEC
           // unhandled_stopped() on the promise to propagate the stop signal. That will
           // result in the coroutine being torn down, so beware. We then resume the
           // returned coroutine handle (which may be a noop_coroutine).
-          return __hcoro.promise().unhandled_stopped();
+          return STDEXEC_PP_IF(STDEXEC_GCC(),
+                               (__hcoro.promise().unhandled_stopped().resume(), true),
+                               __hcoro.promise().unhandled_stopped());
         }
         else
         {
           // The operation completed with set_value or set_error, so we can just resume
           // the current coroutine. await_resume will either return the value or throw as
           // appropriate.
-          return __hcoro;
+          return STDEXEC_PP_IF(STDEXEC_GCC(), false, __hcoro);
         }
       }
 

include/stdexec/__detail/__task.hpp

@@ -252,11 +252,17 @@ namespace STDEXEC
       return __attrs{};
     }
 
+#if !STDEXEC_GCC()
+    // This transforms a task into an __awaiter that can perform symmetric transfer when
+    // co_awaited. It is disabled on GCC due to
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94794, which causes unbounded stack
+    // growth.
     template <class _ParentPromise>
     constexpr auto as_awaitable(_ParentPromise& __parent) && noexcept
     {
       return __awaiter<_ParentPromise>(static_cast<task&&>(*this), __parent);
     }
+#endif
 
    private:
     using __on_stopped_t   = __forward_stop_request<stop_source_type>;

test/stdexec/types/test_task.cpp

@@ -244,9 +244,6 @@ namespace
     CHECK(i == 42);
   }
 
-#  if !STDEXEC_GCC() || (STDEXEC_GCC_VERSION >= 13'00 && defined(__OPTIMIZE__))
-  // This test is disabled on GCC due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94794
-
   auto sync() -> ex::task<int>
   {
     co_return 42;
@@ -281,8 +278,6 @@ namespace
     CHECK(i == 84'000'042);
   }
 
-#  endif
-
   // FUTURE TODO: add support so that `co_await sndr` can return a reference.
   // auto test_task_awaits_just_ref_sender() -> ex::task<void> {
   //   int value = 42;