[lldb] [Process/FreeBSDRemote] Check for regset support early [WIP]

[mgorny]

Summary

@labath, I'm trying to copy the logic from Linux here but for some reason unsupported regsets are now reported as 'unknown' instead of not all. Any clue what I'm doing wrong?

[mgorny]

Hmm, if I add GetUserRegisterCount() override, then registers start disappearing. Except that wrong registers disappear.

[labath]

My guess is that this is because of the extra debug registers that you're exposing. You'll notice that Get(User)RegisterSetCount returns just a number, and this means that it is not really possible to selectively disable register sets -- all you can do is disable the ones that come last.

We ran into a similar problem on arm with @omjavaid.

For the time being, we may be able to work around this by making the debug registers come earlier in the list (after ensuring they work on linux). Or we could hide them on BSDs as well...

[omjavaid]

In D91422#2396697, @labath wrote:

My guess is that this is because of the extra debug registers that you're exposing. You'll notice that Get(User)RegisterSetCount returns just a number, and this means that it is not really possible to selectively disable register sets -- all you can do is disable the ones that come last.

We ran into a similar problem on arm with @omjavaid.

For the time being, we may be able to work around this by making the debug registers come earlier in the list (after ensuring they work on linux). Or we could hide them on BSDs as well...

Register sets are stored in statically which means we have to honor the order as @labath pointed out. Ideally register sets array should be a dynamic list with all currently available registerset inserted in the list.

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

public:
   // executable.
   static NativeRegisterContextFreeBSD *
   CreateHostNativeRegisterContextFreeBSD(const ArchSpec &target_arch,
                                          NativeThreadProtocol &native_thread);
   virtual llvm::Error
   CopyHardwareWatchpointsFrom(NativeRegisterContextFreeBSD &source) = 0;
 
 protected:
-  virtual NativeProcessFreeBSD &GetProcess();
-  virtual ::pid_t GetProcessPid();
+  virtual NativeProcessFreeBSD &GetProcess() const;
+  virtual ::pid_t GetProcessPid() const;
 };
 
 } // namespace process_freebsd
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextFreeBSD_h

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

 using namespace lldb_private;
 using namespace lldb_private::process_freebsd;
 
 // clang-format off
 #include <sys/types.h>
 #include <sys/ptrace.h>
 // clang-format on
 
-NativeProcessFreeBSD &NativeRegisterContextFreeBSD::GetProcess() {
+NativeProcessFreeBSD &NativeRegisterContextFreeBSD::GetProcess() const {
   return static_cast<NativeProcessFreeBSD &>(m_thread.GetProcess());
 }
 
-::pid_t NativeRegisterContextFreeBSD::GetProcessPid() {
+::pid_t NativeRegisterContextFreeBSD::GetProcessPid() const {
   return GetProcess().GetID();
 }

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

private:
 
   uint8_t *GetOffsetRegSetData(uint32_t set, size_t reg_offset);
 
   struct YMMSplitPtr {
     void *xmm;
     void *ymm_hi;
   };
   llvm::Optional<YMMSplitPtr> GetYMMSplitReg(uint32_t reg);
+  bool IsRegisterSetAvailable(uint32_t set_index) const;
 };
 
 } // 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

for (int i: {FPRegSet, DBRegSet})
     m_regset_offsets[i] = GetRegisterInfoInterface()
                               .GetRegisterInfo()[first_regnos[i]]
                               .byte_offset;
 }
 
 uint32_t NativeRegisterContextFreeBSD_x86_64::GetRegisterSetCount() const {
   uint32_t sets = 0;
   for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index) {
-    if (GetSetForNativeRegNum(set_index))
+    if (IsRegisterSetAvailable(set_index))
       ++sets;
   }
 
   return sets;
 }
 
 const RegisterSet *
 NativeRegisterContextFreeBSD_x86_64::GetRegisterSet(uint32_t set_index) const {
+  if (!IsRegisterSetAvailable(set_index))
+    return nullptr;
+
   switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86:
     return &g_reg_sets_i386[set_index];
   case llvm::Triple::x86_64:
     return &g_reg_sets_x86_64[set_index];
   default:
     llvm_unreachable("Unhandled target architecture.");
   }
NativeRegisterContextFreeBSD_x86_64::GetYMMSplitReg(uint32_t reg) {
   }
 
   auto *fpreg = reinterpret_cast<struct savexmm_ymm *>(m_xsave.data());
   auto *ymmreg = reinterpret_cast<struct ymmacc *>(m_xsave.data() + offset);
 
   return YMMSplitPtr{&fpreg->sv_xmm[reg_index], &ymmreg[reg_index]};
 }
 
+bool NativeRegisterContextFreeBSD_x86_64::IsRegisterSetAvailable(
+    uint32_t set_index) const {
+  switch (static_cast<RegSetKind>(set_index)) {
+  case GPRegSet:
+  case FPRegSet:
+  case DBRegSet:
+    return true;
+  case YMMRegSet: {
+    struct ptrace_xstate_info info;
+    Status ret = NativeProcessFreeBSD::PtraceWrapper(
+        PT_GETXSTATE_INFO, GetProcessPid(), &info, sizeof(info));
+    if (!ret.Success())
+      return false;
+
+    assert(info.xsave_mask & XFEATURE_ENABLED_X87);
+    assert(info.xsave_mask & XFEATURE_ENABLED_SSE);
+    return !!(info.xsave_mask & XFEATURE_ENABLED_YMM_HI128);
+  }
+  case MPXRegSet:
+    return false;
+  }
+  llvm_unreachable("Unknown register set");
+}
+
 #endif // defined(__x86_64__)