协程的参数在调用期间覆盖 promise_type

如何解决协程的参数在调用期间覆盖 promise_type

以下测试程序：

#include <coroutine>
#include <iostream>
#include <optional>

//#define FIX1
//#define FIX2
//#define FIX3


struct final_awaiter
{
    std::coroutine_handle<> continuation;

    bool await_ready() const noexcept { return false; }

    std::coroutine_handle<> await_suspend(std::coroutine_handle<> h) const noexcept
    {
        std::cout << "resuming continuation=" << continuation.address() << std::endl;
        return continuation ? continuation : std::noop_coroutine();
    }

    void await_resume() const noexcept {}
};


struct schedule
{};

// test...
std::coroutine_handle<> inner_coro;

struct schedule_awaiter
{
    bool await_ready() const noexcept { return false; }

    void await_suspend(std::coroutine_handle<> h) const noexcept
    {
        std::cout << "'scheduling' inner_coro h=" << h.address() << std::endl;
        inner_coro = h;
    }
    void await_resume() const noexcept { std::cout << "schedule resumed " << std::endl; }
};


template<typename PromiseType>
struct task_awaiter
{
    std::coroutine_handle<PromiseType> handle;

    bool await_ready() const noexcept
    {
        const bool ready = handle.promise().value.has_value();

        std::cout << "[task,h=" << handle.address()
                  << "] await_ready(),value=" << handle.promise().value.value_or(-1)
                  << ",ready=" << (ready ? "YES <<<<< ????? " : "no") << std::endl;
        return ready;
    }

    void await_suspend(std::coroutine_handle<> h) const noexcept
    {
        std::cout << "[task,h=" << handle.address()
                  << "] await_suspend(),saving continuation=" << h.address() << std::endl;
        handle.promise().continuation = h;
    }

    auto await_resume() const noexcept
    {
        std::cout << "[task,h=" << handle.address()
                  << "] await_resume(),returnnig value == " << *handle.promise().value
                  << std::endl;
        return std::move(*(handle.promise().value));
    }
};


struct task
{
    struct promise_type
    {
#ifdef FIX1
        std::coroutine_handle<> continuation; // works (1)
        std::optional<int> value;
#else
        std::optional<int> value;
        std::coroutine_handle<> continuation; // segfaults (1)
#endif

#ifdef FIX3
        promise_type() = default;
        explicit promise_type(int) {} // works (3)
#endif

        task get_return_object()
        {
            return task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }

        std::suspend_never initial_suspend() const noexcept { return {}; }

        auto final_suspend() const noexcept { return final_awaiter{continuation}; }

        void return_value(int val) noexcept
        {
            std::cout << "return_value,val=" << val << std::endl;
            value = val;
        }

        [[noreturn]] void unhandled_exception() { std::terminate(); }

        // await schedule
        auto await_transform(schedule) const noexcept { return schedule_awaiter{}; }

        // await task
        auto await_transform(const task& t) const noexcept
        {
            return task_awaiter{t.handle};
        }
    };


    explicit task(std::coroutine_handle<promise_type> handle)
        : handle(handle)
    {}

    task(task&& other) noexcept
        : handle(std::exchange(other.handle,nullptr))
    {}

    ~task()
    {
        std::cout << "~task,h=" << handle.address() << std::endl;
        if (handle) { handle.destroy(); }
    }

    int get() const
    {
        if (handle) { return *handle.promise().value; }
        throw std::logic_error("get(): moved from task");
    }

    std::coroutine_handle<promise_type> handle;
};


// ---

#ifdef FIX2
task inner() // works (2)
#else
task inner(int r) // segfaults (2)
#endif
{
    std::cout << ">> inner 1" << std::endl;
    co_await schedule{};
    std::cout << ">> inner 2" << std::endl;
    co_return 10; // co_return r;
}


task outer()
{
    std::cout << "> outer 1" << std::endl;

#ifdef FIX2
    auto t = inner(); // works (2)
#else
    auto t = inner(5); // segfaults (2)
#endif

    std::cout << "> outer 2" << std::endl;
    auto r = co_await t;
    std::cout << "> outer 3" << std::endl;
    co_return r;
}


int main()
{
    auto result = outer();

    std::cout << "...manually resuming h=" << inner_coro.address() << std::endl;
    inner_coro.resume();

    std::cout << "result = " << result.get() << std::endl;
}

在 MSVC 中按预期工作：

> outer 1
>> inner 1
'scheduling' inner_coro h=000001A5F5DF1DD0
> outer 2
[task,h=000001A5F5DF1DD0] await_ready(),value=-1,ready=no
[task,h=000001A5F5DF1DD0] await_suspend(),saving continuation=000001A5F5DF0C40
...manually resuming h=000001A5F5DF1DD0
schedule resumed
>> inner 2
return_value,val=10
resuming continuation=000001A5F5DF0C40
[task,h=000001A5F5DF1DD0] await_resume(),returnnig value == 10
> outer 3
return_value,val=10
~task,h=000001A5F5DF1DD0
resuming continuation=0000000000000000
result = 10
~task,h=000001A5F5DF0C40

但是 gcc 中的段错误 (godbolt)：

> outer 1
>> inner 1
'scheduling' inner_coro h=0x18c354e1770
> outer 2
[task,h=0x18c354e1770] await_ready(),value=5,ready=YES <<<<< ?????
[task,h=0x18c354e1770] await_resume(),returnnig value == 5
> outer 3
return_value,val=5
~task,h=0x18c354e1770
resuming continuation=0
...manually resuming h=0x18c354e1770
Segmentation fault

似乎 task::promise_type::value 被 inner() 的参数 (5) 覆盖，因此“内部”协程没有按预期挂起而是结束/被销毁，然后发生段错误（手动）resume() 调用。是程序有bug还是gcc有bug？

取消注释 FIX1、FIX2 或 FIX3“修复”了段错误...