为什么 gcc 不优化 c++ 中的协程？

Question

试过一个关于c++20协程的example（从cppreference抄过来的，应该是对的）。例子很简单，我开启了-O3优化，但是gcc并没有优化成最好的汇编代码。 （我认为在最好的汇编代码中，main 函数应该是空的，因为 main 函数实际上并没有做任何有意义的事情。） 我的问题是：

1. main函数可以优化成空吗？ （如果我们这样做就不会违反标准。）
2. 如果 1 为真，为什么 gcc 不能优化它？有没有什么方法可以将主要功能优化为空或 gcc 目前无法做到这一点？

示例代码如下：

#include <coroutine>
#include <utility>
 
template<class T>
struct task
{
    struct promise_type
    {
        auto get_return_object()
        {
            return task(std::coroutine_handle<promise_type>::from_promise(*this));
        }
        std::suspend_always initial_suspend() { return {}; }
        struct final_awaiter
        {
            bool await_ready() noexcept { return false; }
            void await_resume() noexcept {}
            std::coroutine_handle<>
                await_suspend(std::coroutine_handle<promise_type> h) noexcept
            {
                // final_awaiter::await_suspend is called when the execution of the
                // current coroutine (referred to by 'h') is about to finish.
                // If the current coroutine was resumed by another coroutine via
                // co_await get_task(), a handle to that coroutine has been stored
                // as h.promise().previous. In that case, return the handle to resume
                // the previous coroutine.
                // Otherwise, return noop_coroutine(), whose resumption does nothing.
 
                if (auto previous = h.promise().previous; previous)
                    return previous;
                else
                    return std::noop_coroutine();
            }
        };
        final_awaiter final_suspend() noexcept { return {}; }
        void unhandled_exception() { throw; }
        void return_value(T value) { result = std::move(value); }
 
        T result;
        std::coroutine_handle<> previous;
    };
 
    task(std::coroutine_handle<promise_type> h) : coro(h) {}
    task(task&& t) = delete;
    ~task() { coro.destroy(); }
 
    struct awaiter
    {
        bool await_ready() { return false; }
        T await_resume() { return std::move(coro.promise().result); }
        auto await_suspend(std::coroutine_handle<> h)
        {
            coro.promise().previous = h;
            return coro;
        }
        std::coroutine_handle<promise_type> coro;
    };
    awaiter operator co_await() { return awaiter{coro}; }
    T operator()()
    {
        coro.resume();
        return std::move(coro.promise().result);
    }
 
private:
    std::coroutine_handle<promise_type> coro;
};
 
task<int> get_random()
{
    co_return 4;
}
 
task<int> test()
{
    task<int> v = get_random();
    task<int> u = get_random();
    int x = (co_await v + co_await u);
    co_return x;
}
 
int main()
{
    task<int> t = test();
    int result = t();
}

Answer 1

1. main函数可以优化成空吗？ （如果我们这样做就不会违反标准。）

我觉得不行。 即使在这样一个微不足道的例子中它也没有：

int f() {
    return 3;
}

int main()
{
    int x = f();
}

很明显

main

真的什么都没做。但是在你的情况下，只是说，

task

可能有副作用（或者可能有副作用

int

专门针对另一个翻译单元），所以

main 中的两行代码是不正确的

可以扔掉。

2. 如果 1 为真，为什么 gcc 不能优化它？有没有什么方法可以将主要功能优化为空或 gcc 目前无法做到这一点？

如果我的观察有道理，那么第二个问题就不需要回答了。