[Bug c++/108337] New: Misaligned memory access issues when inline assembly is used with optimization on x86_64

["eric-bugs at omnifarious dot org" <gcc-bugzilla@gcc.gnu.org>]

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

            Bug ID: 108337
           Summary: Misaligned memory access issues when inline assembly
                    is used with optimization on x86_64
           Product: gcc
           Version: 12.2.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: eric-bugs at omnifarious dot org
  Target Milestone: ---

The following code works fine when compiled this way:

g++ -std=c++20 -march=znver2 -static -O1 -nostartfiles -nostdlib -Wl,-emain
foo.cpp

but when compiled this way generates a segfault before outputting anything:

g++ -std=c++20 -march=znver2 -static -O2 -nostartfiles -nostdlib -Wl,-emain
foo.cpp


---------- foo.cpp ---------
using val_t = unsigned long;
using call_id = unsigned short;

  template<typename _Tp>
    struct remove_reference
    { typedef _Tp type; };

  template<typename _Tp>
    struct remove_reference<_Tp&>
    { typedef _Tp type; };

  template<typename _Tp>
    struct remove_reference<_Tp&&>
    { typedef _Tp type; };

  template<typename _Tp>
    [[__nodiscard__]]
    constexpr _Tp&&
    forward(typename remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); }


struct syscall_param {
   syscall_param(val_t v) noexcept : value(v) { }

   syscall_param(void *v) noexcept : value(reinterpret_cast<val_t>(v)) {
      static_assert(sizeof(void *) == sizeof(val_t));
   }

   syscall_param(void const *v) noexcept : value(reinterpret_cast<val_t>(v)) {
      static_assert(sizeof(void *) == sizeof(val_t));
   }
   val_t value;
};

inline val_t do_syscall(call_id callnum,
                           syscall_param const &p1) noexcept
{
   val_t retval;
   asm volatile (
      "syscall\n\t"
       :"=a"(retval)
       :"a"(static_cast<unsigned long>(callnum)), "D"(p1.value)
       :"%rcx", "%r11", "memory"
      );
   return retval;
}

inline val_t do_syscall(call_id callnum,
                           syscall_param const &p1,
                           syscall_param const &p2,
                           syscall_param const &p3) noexcept
{
   val_t retval;
   asm volatile (
      "syscall\n\t"
       :"=a"(retval)
       :"a"(static_cast<unsigned long>(callnum)), "D"(p1.value), "S"(p2.value),
 "d"(p3.value)
       :"%rcx", "%r11", "memory"
      );
   return retval;
}

template <typename... T>
val_t
syscall_expected(call_id callnum, T &&... args) noexcept
{
   val_t result = do_syscall(callnum, forward<T>(args)...);

   return result;
}

inline val_t write(int fd, char const *data, unsigned long size) noexcept
{
   return syscall_expected(1, fd, data, size);
}

inline void exit [[noreturn]](int status) noexcept {
   syscall_expected(231, status);
   __builtin_unreachable();
}

int main(int argc, char *argv[])
{
    int i = 0;
    char msg[] = "Hello World 0!\n";

    auto result = write(1, msg, sizeof(msg) - 1);
    i = 1;
    while (result >= 0 && i < 10) {
        msg[12] = i++ + '0';
        result = write(1, msg, sizeof(msg) - 1);
    }
    exit(result >= 0 ? 0 : 1);
}