Fix GCC builds

ispeters · ispeters · commit e8baca691d17 · 2026-04-01T13:50:27.000-07:00
It turns out that GCC needs `5 * sizeof(void*)` space for the inlined
coroutine frame where Clang only needs `4 * sizeof(void*)`; I haven't
figured out why, yet, but this diff reserves more space when compiling
with GCC.

It also seems to me there's a GCC bug being tickled in the previous
commit that prevents direct initialization of the stored awaiter and/or
awaitable from the result of `_get_awaitable` and/or `__get_awaiter`,
respectively, when the result is immovable. I think this is a failure to
implement C++17's mandatory copy elision, but I'm not sure. I've worked
around it with unions and in-place `new`. I also added test cases to
cover the immovable awaiter/awaitable cases.
diff --git a/include/stdexec/__detail/__connect_awaitable.hpp b/include/stdexec/__detail/__connect_awaitable.hpp
@@ -38,7 +38,10 @@ namespace STDEXEC
   // __connect_await
   namespace __connect_await
   {
-    static constexpr std::size_t __storage_size  = 4 * sizeof(void*) - 1;
+    // four pointers' worth of space when compiling with Clang or MSVC; five with GCC
+    static constexpr std::size_t __num_pointers  = 4 * (STDEXEC_CLANG() + STDEXEC_MSVC())
+                                                 + 5 * STDEXEC_GCC();
+    static constexpr std::size_t __storage_size  = __num_pointers * sizeof(void*) - 1;
     static constexpr std::size_t __storage_align = __STDCPP_DEFAULT_NEW_ALIGNMENT__;
 
     // clang-format off
@@ -123,14 +126,36 @@ namespace STDEXEC
       {
         __state(_Awaitable&& __source, __std::coroutine_handle<_Promise> __coro)
           noexcept(__is_nothrow)
-          : __awaitable_(__get_awaitable(static_cast<_Awaitable&&>(__source), __coro.promise()))
-          , __awaiter_(__get_awaiter(static_cast<__awaitable_t&&>(__awaitable_)))
-        {}
+        {
+          // GCC doesn't like initializing __awaitable_ or __awaiter_ in the member initializer
+          // clause when the result of __get_awaitable or __get_awaiter is immovable; it *seems*
+          // like direct initialization of a member with the result of a function ought to trigger
+          // C++17's mandatory copy elision, and both Clang and MSVC accept that code, but using
+          // a union with in-place new works around the issue.
+          new (static_cast<void*>(std::addressof(__awaitable_)))
+            __awaitable_t(__get_awaitable(static_cast<_Awaitable&&>(__source), __coro.promise()));
+          new (static_cast<void*>(std::addressof(__awaiter_)))
+            __awaiter_t(__get_awaiter(static_cast<__awaitable_t&&>(__awaitable_)));
+        }
 
-        [[no_unique_address]]
-        __awaitable_t __awaitable_;
-        [[no_unique_address]]
-        __awaiter_t __awaiter_;
+        ~__state()
+        {
+          // make sure to destroy in the reverse order of construction
+          std::destroy_at(std::addressof(__awaiter_));
+          std::destroy_at(std::addressof(__awaitable_));
+        }
+
+        union
+        {
+          [[no_unique_address]]
+          __awaitable_t __awaitable_;
+        };
+
+        union
+        {
+          [[no_unique_address]]
+          __awaiter_t __awaiter_;
+        };
       };
 
       [[no_unique_address]]
@@ -146,9 +171,9 @@ namespace STDEXEC
       explicit __awaitable_state(_A&& __awaitable)
         noexcept(__nothrow_constructible_from<_Awaitable, _A>)
         : __source_awaitable_(static_cast<_A&&>(__awaitable))
-      {}
+      { }
 
-      ~__awaitable_state() {}
+      ~__awaitable_state() { }
 
       constexpr void construct(__std::coroutine_handle<_Promise> __coro) noexcept(__is_nothrow)
       {
@@ -178,17 +203,32 @@ namespace STDEXEC
       {
         __state(_Awaitable&& __source, __std::coroutine_handle<_Promise> __coro)
           noexcept(__is_nothrow)
-          : __awaiter_(__get_awaiter(static_cast<_Awaitable&&>(__source)))
         {
+          // GCC doesn't like initializing __awaiter_ in the member initializer clause when the
+          // result of __get_awaiter is immovable; it *seems* like direct initialization of a
+          // member with the result of a function ought to trigger C++17's mandatory copy elision,
+          // and both Clang and MSVC accept that code, but using a union with in-place new works
+          // around the issue.
+          new (static_cast<void*>(std::addressof(__awaiter_)))
+            __awaiter_t(__get_awaiter(static_cast<_Awaitable&&>(__source)));
+
           [[maybe_unused]]
           auto&& __awaitable = __get_awaitable(static_cast<_Awaitable&&>(__source),
                                                __coro.promise());
 
           STDEXEC_ASSERT(std::addressof(__awaitable) == std::addressof(__source));
         }
 
-        [[no_unique_address]]
-        __awaiter_t __awaiter_;
+        ~__state()
+        {
+          std::destroy_at(std::addressof(__awaiter_));
+        }
+
+        union
+        {
+          [[no_unique_address]]
+          __awaiter_t __awaiter_;
+        };
       };
 
       [[no_unique_address]]
@@ -204,9 +244,9 @@ namespace STDEXEC
       explicit __awaitable_state(_A&& __awaitable)
         noexcept(__nothrow_constructible_from<_Awaitable, _A>)
         : __source_awaitable_(static_cast<_A&&>(__awaitable))
-      {}
+      { }
 
-      ~__awaitable_state() {}
+      ~__awaitable_state() { }
 
       constexpr void construct(__std::coroutine_handle<_Promise> __coro) noexcept(__is_nothrow)
       {
@@ -236,15 +276,29 @@ namespace STDEXEC
       {
         __state(_Awaitable&& __source, __std::coroutine_handle<_Promise> __coro)
           noexcept(__is_nothrow)
-          : __awaiter_(__get_awaitable(static_cast<_Awaitable&&>(__source), __coro.promise()))
         {
+          // GCC doesn't like initializing __awaiter_ in the member initializer clause when the
+          // result of __get_awaitable is immovable; it *seems* like direct initialization of a
+          // member with the result of a function ought to trigger C++17's mandatory copy elision,
+          // and both Clang and MSVC accept that code, but using a union with in-place new works
+          // around the issue.
+          new (static_cast<void*>(std::addressof(__awaiter_)))
+            __awaiter_t(__get_awaitable(static_cast<_Awaitable&&>(__source), __coro.promise()));
+
           [[maybe_unused]]
           auto&& __awaiter = __get_awaiter(static_cast<__awaiter_t&&>(__awaiter_));
           STDEXEC_ASSERT(std::addressof(__awaiter) == std::addressof(__awaiter_));
         }
 
-        [[no_unique_address]]
-        __awaiter_t __awaiter_;
+        ~__state()
+        {
+          std::destroy_at(std::addressof(__awaiter_));
+        }
+
+        [[no_unique_address]] union
+        {
+          __awaiter_t __awaiter_;
+        };
       };
 
       [[no_unique_address]]
@@ -260,9 +314,9 @@ namespace STDEXEC
       explicit __awaitable_state(_A&& __awaitable)
         noexcept(__nothrow_constructible_from<_Awaitable, _A>)
         : __source_awaitable_(static_cast<_A&&>(__awaitable))
-      {}
+      { }
 
-      ~__awaitable_state() {}
+      ~__awaitable_state() { }
 
       constexpr void construct(__std::coroutine_handle<_Promise> __coro) noexcept(__is_nothrow)
       {
@@ -292,7 +346,7 @@ namespace STDEXEC
       explicit __awaitable_state(_A&& __awaitable)
         noexcept(__nothrow_constructible_from<_Awaitable, _A>)
         : __awaiter_(static_cast<_A&&>(__awaitable))
-      {}
+      { }
 
       static constexpr void construct(__std::coroutine_handle<_Promise>) noexcept
       {
@@ -459,7 +513,7 @@ namespace STDEXEC
         noexcept(__nothrow_move_constructible<_Awaitable>)
         : __rcvr_(static_cast<_Receiver&&>(__rcvr))
         , __awaiter_(static_cast<_Awaitable&&>(__awaitable))
-      {}
+      { }
 
       __opstate(__opstate&&) = delete;
 
@@ -611,15 +665,15 @@ namespace STDEXEC
   {
     template <class, class>
     struct __promise
-    {};
+    { };
 
     template <class>
     struct __with_await_transform
-    {};
+    { };
   }  // namespace __connect_await
 
   struct __connect_awaitable_t
-  {};
+  { };
 
 #endif
 
diff --git a/test/stdexec/cpos/test_cpo_connect_awaitable.cpp b/test/stdexec/cpos/test_cpo_connect_awaitable.cpp
@@ -33,11 +33,11 @@ namespace
    public:
     explicit constexpr ready_awaitable(T&& t) noexcept
       : t_(std::move(t))
-    {}
+    { }
 
     explicit constexpr ready_awaitable(T const & t)
       : t_(t)
-    {}
+    { }
 
     static constexpr bool await_ready() noexcept
     {
@@ -76,7 +76,7 @@ namespace
       FAIL_CHECK("this awaitable should never suspend");
     }
 
-    static constexpr void await_resume() noexcept {}
+    static constexpr void await_resume() noexcept { }
 
     ready_awaitable& base() noexcept
     {
@@ -91,7 +91,7 @@ namespace
 
     explicit constexpr awaitable_ref(Awaitable& awaitable) noexcept
       : awaitable_(&awaitable)
-    {}
+    { }
 
     constexpr auto await_ready() const noexcept(noexcept(awaitable_->await_ready()))
       requires requires(Awaitable& a) {
@@ -192,7 +192,7 @@ namespace
     explicit constexpr conditionally_suspending_awaitable(bool suspend, U&&... u) noexcept
       : suspending_awaitable<T>(std::forward<U>(u)...)
       , suspend_(suspend)
-    {}
+    { }
 
     constexpr bool await_suspend(std::coroutine_handle<> coro) noexcept
     {
@@ -236,20 +236,20 @@ namespace
     }
   };
 
-  template <class Awaitable>
+  template <class Awaitable, template <class> class Wrapper = std::type_identity_t>
   struct with_as_awaitable
   {
     template <class... T>
       requires std::constructible_from<Awaitable, T...>
     explicit(sizeof...(T) == 1) with_as_awaitable(T&&... t)
       noexcept(std::is_nothrow_constructible_v<Awaitable, T...>)
       : awaitable_(std::forward<T>(t)...)
-    {}
+    { }
 
     template <class Promise>
-    awaitable_ref<Awaitable> as_awaitable(Promise&) noexcept
+    Wrapper<awaitable_ref<Awaitable>> as_awaitable(Promise&) noexcept
     {
-      return awaitable_ref(awaitable_);
+      return Wrapper<awaitable_ref<Awaitable>>(awaitable_);
     }
 
     auto& base() noexcept
@@ -261,19 +261,19 @@ namespace
     Awaitable awaitable_;
   };
 
-  template <class Awaitable>
+  template <class Awaitable, template <class> class Wrapper = std::type_identity_t>
   struct with_member_co_await
   {
     template <class... T>
       requires std::constructible_from<Awaitable, T...>
     explicit(sizeof...(T) == 1) with_member_co_await(T&&... t)
       noexcept(std::is_nothrow_constructible_v<Awaitable, T...>)
       : awaitable_(std::forward<T>(t)...)
-    {}
+    { }
 
-    constexpr awaitable_ref<Awaitable> operator co_await() noexcept
+    constexpr Wrapper<awaitable_ref<Awaitable>> operator co_await() noexcept
     {
-      return awaitable_ref(awaitable_);
+      return Wrapper<awaitable_ref<Awaitable>>(awaitable_);
     }
 
     auto& base() noexcept
@@ -285,15 +285,15 @@ namespace
     Awaitable awaitable_;
   };
 
-  template <class Awaitable>
+  template <class Awaitable, template <class> class Wrapper = std::type_identity_t>
   struct with_friend_co_await
   {
     template <class... T>
       requires std::constructible_from<Awaitable, T...>
     explicit(sizeof...(T) == 1) with_friend_co_await(T&&... t)
       noexcept(std::is_nothrow_constructible_v<Awaitable, T...>)
       : awaitable_(std::forward<T>(t)...)
-    {}
+    { }
 
     auto& base() noexcept
     {
@@ -305,9 +305,9 @@ namespace
 
     template <class Self>
       requires std::same_as<std::remove_cvref_t<Self>, with_friend_co_await>
-    friend constexpr awaitable_ref<Awaitable> operator co_await(Self&& self) noexcept
+    friend constexpr Wrapper<awaitable_ref<Awaitable>> operator co_await(Self&& self) noexcept
     {
-      return awaitable_ref(self.awaitable_);
+      return Wrapper<awaitable_ref<Awaitable>>(self.awaitable_);
     }
   };
 
@@ -700,12 +700,65 @@ namespace
       return coro.promise().unhandled_stopped();
     }
 
-    static constexpr void await_resume() noexcept {}
+    static constexpr void await_resume() noexcept { }
   };
 
   TEST_CASE("promise().unhandled_stopped() invokes set_stopped", "[cpo][cpo_connect_awaitable]")
   {
     auto op = ex::connect(stop_on_suspend{}, expect_stopped_receiver{});
     op.start();
   }
+
+  template <class Awaitable>
+  struct as_immovable : Awaitable
+  {
+    using Awaitable::Awaitable;
+
+    as_immovable(as_immovable&&) = delete;
+
+    as_immovable& base() noexcept
+    {
+      return *this;
+    }
+  };
+
+  TEST_CASE("can connect and start immovable awaiters", "[cpo][cpo_connect_awaitable]")
+  {
+    {
+      // .as_awaitable(promise) returns an immovable value
+      auto op = ex::connect(with_as_awaitable<ready_awaitable<void>, as_immovable>{},
+                            expect_void_receiver{});
+      op.start();
+    }
+    {
+      // .operator co_await() returns an immovable value
+      auto op = ex::connect(with_member_co_await<ready_awaitable<void>, as_immovable>{},
+                            expect_void_receiver{});
+      op.start();
+    }
+    {
+      // operator co_await(awaitable) returns an immovable value
+      auto op = ex::connect(with_friend_co_await<ready_awaitable<void>, as_immovable>{},
+                            expect_void_receiver{});
+      op.start();
+    }
+    {
+      // both .as_awaitable(promise) and .as_awaitable(promise).operator co_await() return
+      // immovable values
+      auto op =
+        ex::connect(with_as_awaitable<with_member_co_await<ready_awaitable<void>, as_immovable>,
+                                      as_immovable>{},
+                    expect_void_receiver{});
+      op.start();
+    }
+    {
+      // both .as_awaitable(promise) and operator co_await(as_awaitable(promise)) return
+      // immovable values
+      auto op =
+        ex::connect(with_as_awaitable<with_friend_co_await<ready_awaitable<void>, as_immovable>,
+                                      as_immovable>{},
+                    expect_void_receiver{});
+      op.start();
+    }
+  }
 }  // namespace
