[lldb] [Process/FreeBSDRemote] Support YMM reg via PT_*XSTATE

[mgorny]

Summary

Add a framework for reading/writing extended register sets via
PT_GETXSTATE/PT_GETXSTATE_INFO/PT_SETXSTATE, and use it to support
YMM0..YMM15. The code is prepared to handle arbitrary XSAVE extensions,
including correct offset handling.

This fixes Shell/Register/*ymm* tests.

[mgorny]

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

479

@labath, is this a safe assumption to make? Generally, if ReadRegisterSet() is not called, m_xsave will be zero-sized.

[krytarowski]

+ @bsdjhb John, could you have a look?

[mgorny]

Remove accidental reformatting.

[labath]

I assume this fixes some of the tests we have already, but it would be good to mention that in the description.

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

479

Interesting question. I don't really have an answer to that. Somebody obviously should fill out m_xsave before calling this function, but maybe it doesn't have to be ReadRegisterSet()? What will happen if the client sends a G packet before reading any registers?

That said, I'm not particularly troubled by this assertion. I wouldn't be surprised if we already had code making that assumption without even realizing it.

[emaste]

Looks OK

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

448–449

I wonder if these should be an error rather than assertion?

[mgorny]

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

448–449

I suppose the question is if they ever happen in real use. If they do, we should probably handle them gracefully. Otherwise, assertion should be sufficient.

[mgorny]

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

448–449

I can actually answer the first question myself. According to Intel's manual, it is impossible to disable x87 bit. IIRC attempt to unset it on XCR0 will raise some fault.

The second question is basically whether under any circumstances can FreeBSD kernel disable SSE on XCR0 (this code is only used on systems supporting XSAVE).

[emaste]

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

448–449

I guess my point is that having these bits unset would indicate a kernel issue or bug, or maybe hardware issue, but never indicate an error or invalid operation in lldb itself.

Either way I think there is no practical impact, it's not actually going to happen.

[krytarowski]

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

448–449

If we assert on this code we more trigger software bug in lldb rather than a hardware specifics.

[mgorny]

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

448–449

I think that's roughly the purpose assertions serve. If something is terribly broken, it will blow up on the developers but it will be optimized away in normal work.

479

Actually, I didn't realize WriteRegisterSet() is local to the plugin. In this case, I can easily verify it's never called like this, so I'll just update the comment and leave the assert so that we don't break it in the future.

[mgorny]

Updated the comment above assertion, and indicated fixed tests in the description.

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.h

 #include <sys/types.h>
 #include <machine/reg.h>
 // clang-format on
 
 #include "Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
 
+#define LLDB_INVALID_XSAVE_OFFSET UINT32_MAX
+
 namespace lldb_private {
 namespace process_freebsd {
 
 class NativeProcessFreeBSD;
 
 class NativeRegisterContextFreeBSD_x86_64
     : public NativeRegisterContextFreeBSD {
 public:
public:
 
   uint32_t NumSupportedHardwareWatchpoints() override;
 
   Status
   CopyHardwareWatchpointsFrom(NativeRegisterContextFreeBSD &source) override;
 
 private:
   // Private member types.
-  enum { GPRegSet, FPRegSet, DBRegSet };
+  enum { GPRegSet, FPRegSet, XSaveRegSet, DBRegSet };
+  enum {
+    YMMXSaveSet,
+    MaxXSaveSet = YMMXSaveSet,
+  };
 
   // Private member variables.
   struct reg m_gpr;
 #if defined(__x86_64__)
   struct fpreg m_fpr;
 #else
   struct xmmreg m_fpr;
 #endif
   struct dbreg m_dbr;
+  std::vector<uint8_t> m_xsave;
+  std::array<uint32_t, MaxXSaveSet + 1> m_xsave_offsets;
 
   int GetSetForNativeRegNum(int reg_num) const;
   int GetDR(int num) const;
 
   Status ReadRegisterSet(uint32_t set);
   Status WriteRegisterSet(uint32_t set);
 };
 
 } // namespace process_freebsd
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextFreeBSD_x86_64_h
 
 #endif // defined(__x86_64__)

lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp

 //===-- NativeRegisterContextFreeBSD_x86_64.cpp ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__i386__) || defined(__x86_64__)
 
 #include "NativeRegisterContextFreeBSD_x86_64.h"
 
+// clang-format off
 #include <machine/fpu.h>
+#include <x86/specialreg.h>
+#include <cpuid.h>
+// clang-format on
 
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
+#include "NativeProcessFreeBSD.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
 
 using namespace lldb_private;
 using namespace lldb_private::process_freebsd;
 
 // Private namespace.
 
int NativeRegisterContextFreeBSD_x86_64::GetSetForNativeRegNum(
 
   switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86:
     if (reg_num >= k_first_gpr_i386 && reg_num <= k_last_gpr_i386)
       return GPRegSet;
     if (reg_num >= k_first_fpr_i386 && reg_num <= k_last_fpr_i386)
       return FPRegSet;
     if (reg_num >= k_first_avx_i386 && reg_num <= k_last_avx_i386)
-      return -1; // AVX
+      return XSaveRegSet; // AVX
     if (reg_num >= k_first_mpxr_i386 && reg_num <= k_last_mpxr_i386)
       return -1; // MPXR
     if (reg_num >= k_first_mpxc_i386 && reg_num <= k_last_mpxc_i386)
       return -1; // MPXC
     if (reg_num >= k_first_dbr_i386 && reg_num <= k_last_dbr_i386)
       return DBRegSet; // DBR
     break;
   case llvm::Triple::x86_64:
     if (reg_num >= k_first_gpr_x86_64 && reg_num <= k_last_gpr_x86_64)
       return GPRegSet;
     if (reg_num >= k_first_fpr_x86_64 && reg_num <= k_last_fpr_x86_64)
       return FPRegSet;
     if (reg_num >= k_first_avx_x86_64 && reg_num <= k_last_avx_x86_64)
-      return -1; // AVX
+      return XSaveRegSet; // AVX
     if (reg_num >= k_first_mpxr_x86_64 && reg_num <= k_last_mpxr_x86_64)
       return -1; // MPXR
     if (reg_num >= k_first_mpxc_x86_64 && reg_num <= k_last_mpxc_x86_64)
       return -1; // MPXC
     if (reg_num >= k_first_dbr_x86_64 && reg_num <= k_last_dbr_x86_64)
       return DBRegSet; // DBR
     break;
   default:
Status NativeRegisterContextFreeBSD_x86_64::ReadRegisterSet(uint32_t set) {
   case FPRegSet:
 #if defined(__x86_64__)
     return DoRegisterSet(PT_GETFPREGS, &m_fpr);
 #else
     return DoRegisterSet(PT_GETXMMREGS, &m_fpr);
 #endif
   case DBRegSet:
     return DoRegisterSet(PT_GETDBREGS, &m_dbr);
+  case XSaveRegSet: {
+    struct ptrace_xstate_info info;
+    Status ret = NativeProcessFreeBSD::PtraceWrapper(
+        PT_GETXSTATE_INFO, GetProcessPid(), &info, sizeof(info));
+    if (!ret.Success())
+      return ret;
+
+    assert(info.xsave_mask & XFEATURE_ENABLED_X87);
+    assert(info.xsave_mask & XFEATURE_ENABLED_SSE);
+
+    m_xsave_offsets[YMMXSaveSet] = LLDB_INVALID_XSAVE_OFFSET;
+    if (info.xsave_mask & XFEATURE_ENABLED_YMM_HI128) {
+      uint32_t eax, ecx, edx;
+      __get_cpuid_count(0x0D, 2, &eax, &m_xsave_offsets[YMMXSaveSet], &ecx,
+                        &edx);
+    }
+
+    m_xsave.resize(info.xsave_len);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETXSTATE, GetProcessPid(),
+                                               m_xsave.data(), m_xsave.size());
+  }
   }
   llvm_unreachable("NativeRegisterContextFreeBSD_x86_64::ReadRegisterSet");
 }
 
 Status NativeRegisterContextFreeBSD_x86_64::WriteRegisterSet(uint32_t set) {
   switch (set) {
   case GPRegSet:
     return DoRegisterSet(PT_SETREGS, &m_gpr);
   case FPRegSet:
 #if defined(__x86_64__)
     return DoRegisterSet(PT_SETFPREGS, &m_fpr);
 #else
     return DoRegisterSet(PT_SETXMMREGS, &m_fpr);
 #endif
   case DBRegSet:
     return DoRegisterSet(PT_SETDBREGS, &m_dbr);
+  case XSaveRegSet:
+    // ReadRegisterSet() must always be called before WriteRegisterSet().
+    assert(m_xsave.size() > 0);
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETXSTATE, GetProcessPid(),
+                                               m_xsave.data(), m_xsave.size());
   }
   llvm_unreachable("NativeRegisterContextFreeBSD_x86_64::WriteRegisterSet");
 }
 
 Status
 NativeRegisterContextFreeBSD_x86_64::ReadRegister(const RegisterInfo *reg_info,
                                                   RegisterValue &reg_value) {
   Status error;

 #if defined(__x86_64__)
     reg_value.SetBytes(&m_fpr.fpr_xacc[reg - lldb_xmm0_x86_64],
                        reg_info->byte_size, endian::InlHostByteOrder());
 #else
     reg_value.SetBytes(&m_fpr.xmm_reg[reg - lldb_xmm0_x86_64],
                        reg_info->byte_size, endian::InlHostByteOrder());
 #endif
     break;
+  case lldb_ymm0_x86_64:
+  case lldb_ymm1_x86_64:
+  case lldb_ymm2_x86_64:
+  case lldb_ymm3_x86_64:
+  case lldb_ymm4_x86_64:
+  case lldb_ymm5_x86_64:
+  case lldb_ymm6_x86_64:
+  case lldb_ymm7_x86_64:
+  case lldb_ymm8_x86_64:
+  case lldb_ymm9_x86_64:
+  case lldb_ymm10_x86_64:
+  case lldb_ymm11_x86_64:
+  case lldb_ymm12_x86_64:
+  case lldb_ymm13_x86_64:
+  case lldb_ymm14_x86_64:
+  case lldb_ymm15_x86_64: {
+    uint32_t offset = m_xsave_offsets[YMMXSaveSet];
+    if (offset == LLDB_INVALID_XSAVE_OFFSET) {
+      error.SetErrorStringWithFormat(
+          "register \"%s\" not supported by CPU/kernel", reg_info->name);
+    } else {
+      uint32_t reg_index = reg - lldb_ymm0_x86_64;
+      auto *fpreg = reinterpret_cast<struct savexmm_ymm *>(m_xsave.data());
+      auto *ymmreg = reinterpret_cast<struct ymmacc *>(m_xsave.data() + offset);
+
+      YMMReg ymm =
+          XStateToYMM(reinterpret_cast<void *>(&fpreg->sv_xmm[reg_index]),
+                      reinterpret_cast<void *>(&ymmreg[reg_index]));
+      reg_value.SetBytes(ymm.bytes, reg_info->byte_size,
+                         endian::InlHostByteOrder());
+    }
+    break;
+  }
   case lldb_dr0_x86_64:
   case lldb_dr1_x86_64:
   case lldb_dr2_x86_64:
   case lldb_dr3_x86_64:
   case lldb_dr4_x86_64:
   case lldb_dr5_x86_64:
   case lldb_dr6_x86_64:
   case lldb_dr7_x86_64:

 #if defined(__x86_64__)
     ::memcpy(&m_fpr.fpr_xacc[reg - lldb_xmm0_x86_64], reg_value.GetBytes(),
              reg_value.GetByteSize());
 #else
     ::memcpy(&m_fpr.xmm_reg[reg - lldb_xmm0_x86_64], reg_value.GetBytes(),
              reg_value.GetByteSize());
 #endif
     break;
+  case lldb_ymm0_x86_64:
+  case lldb_ymm1_x86_64:
+  case lldb_ymm2_x86_64:
+  case lldb_ymm3_x86_64:
+  case lldb_ymm4_x86_64:
+  case lldb_ymm5_x86_64:
+  case lldb_ymm6_x86_64:
+  case lldb_ymm7_x86_64:
+  case lldb_ymm8_x86_64:
+  case lldb_ymm9_x86_64:
+  case lldb_ymm10_x86_64:
+  case lldb_ymm11_x86_64:
+  case lldb_ymm12_x86_64:
+  case lldb_ymm13_x86_64:
+  case lldb_ymm14_x86_64:
+  case lldb_ymm15_x86_64: {
+    uint32_t offset = m_xsave_offsets[YMMXSaveSet];
+    if (offset == LLDB_INVALID_XSAVE_OFFSET) {
+      error.SetErrorStringWithFormat(
+          "register \"%s\" not supported by CPU/kernel", reg_info->name);
+    } else {
+      uint32_t reg_index = reg - lldb_ymm0_x86_64;
+      auto *fpreg = reinterpret_cast<struct savexmm_ymm *>(m_xsave.data());
+      auto *ymmreg = reinterpret_cast<struct ymmacc *>(m_xsave.data() + offset);
+
+      YMMReg ymm;
+      ::memcpy(ymm.bytes, reg_value.GetBytes(), reg_value.GetByteSize());
+      YMMToXState(ymm, reinterpret_cast<void *>(&fpreg->sv_xmm[reg_index]),
+                  reinterpret_cast<void *>(&ymmreg[reg_index]));
+    }
+    break;
+  }
   case lldb_dr0_x86_64:
   case lldb_dr1_x86_64:
   case lldb_dr2_x86_64:
   case lldb_dr3_x86_64:
   case lldb_dr4_x86_64:
   case lldb_dr5_x86_64:
   case lldb_dr6_x86_64:
   case lldb_dr7_x86_64: