[Bug libstdc++/109631] New: Simple std::optional types returned on stack, not registers

[david at westcontrol dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109631

            Bug ID: 109631
           Summary: Simple std::optional types returned on stack, not
                    registers
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libstdc++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: david at westcontrol dot com
  Target Milestone: ---

A std::optional<T> is fundamentally like a std::pair<T, bool>, but with nice
access features, type safety, etc.  But for simple functions it is
significantly less efficient, because in gcc it is returned on the stack even
when T fits in a single register.

<https://godbolt.org/z/6hx6vxaG7>

On targets such as x86-64 and AARCH64, simple structs and pairs that fit in two
registers, are returned in two registers - there is no need for the caller to
reserve stack space and pass a hidden pointer to the callee function.  On clang
with its standard library, this also applies to std::optional<T> for suitable
types T such as "int", but on gcc and its standard C++ library, the stack is
used for returning the std::optional<int>.  Since both clang and gcc follow the
same calling conventions, this must (I believe) be a result of different
implementations of std::optional<> in the C++ libraries.

(I note that code for std::pair<bool, T> is more efficient here than using
std::pair<T, bool>.  But perhaps the details of std::optional<> require that
the contained element comes first.)



#include <optional>
#include <utility>

using A = std::optional<int>;
using B = std::pair<int, bool>;
using C = std::pair<bool, int>;

A foo_A(int x) {
    return x;
}

B foo_b(int x) {
    B y { x, true };
    return y;
}

C foo_c(int x) {
    C y { true, x };
    return y;
}