[lldb] [Process/FreeBSDRemote] Access FPR via RegisterInfo offsets

[mgorny]

Summary

Use offset-based method to access base x87 FPU registers, using offsets
relative to the position of 'struct FPR', as determined by the location
of first register in it (fctrl). Change m_fpr to use a fixed-size array
matching FXSAVE size (512 bytes). Add unit tests for verifying
RegisterInfo offsets and sizes against the FXSAVE layout.

[mgorny]

Rename ASSERT_FPR to ASSERT_OFF since it's a more generic offset-based assert.

[mgorny]

Update to match changes in GPR patch.

[labath]

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

563–570

what if m_gpr and m_fpr were actually a single concatenated buffer? Could we then ditch GetFPROffset and just have a single memcpy here?

[mgorny]

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

563–570

We'd need GetFPROffset() for ptrace calls then ;-). I've got an another idea ready, just need to wait for some free RAM to test it. That said, we might reach the point where combining all these diffs is easier than reviewing them separately.

[labath]

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

563–570

We'd need GetFPROffset() for ptrace calls then ;-)

To get the address of the regset buffer, right?

I'd imagine that could be handled by some function like GetFPRBuffer() (similar one exists in linux), or even GetBuffer(regset). I'd imagine that would be useful for the generic caching infrastructure as well.

[mgorny]

Rebased.

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

private:
   };
   enum {
     YMMXSaveSet,
     MaxXSaveSet = YMMXSaveSet,
   };
 
   // Private member variables.
   std::array<uint8_t, sizeof(struct reg)> m_gpr;
-#if defined(__x86_64__)
-  struct fpreg m_fpr;
-#else
-  struct xmmreg m_fpr;
-#endif
+  std::array<uint8_t, 512> m_fpr; // FXSAVE
   struct dbreg m_dbr;
   std::vector<uint8_t> m_xsave;
   std::array<uint32_t, MaxXSaveSet + 1> m_xsave_offsets;
 
   llvm::Optional<enum RegSetKind> GetSetForNativeRegNum(int reg_num) const;
   int GetDR(int num) const;
 
   Status ReadRegisterSet(uint32_t set);
   Status WriteRegisterSet(uint32_t set);
+
+  size_t GetFPROffset() 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

if (HostInfo::GetArchitecture().GetAddressByteSize() == 4) {
     return new RegisterContextFreeBSD_x86_64(target_arch);
   }
 }
 
 NativeRegisterContextFreeBSD_x86_64::NativeRegisterContextFreeBSD_x86_64(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
     : NativeRegisterContextRegisterInfo(
           native_thread, CreateRegisterInfoInterface(target_arch)),
-      m_fpr(), m_dbr() {
+      m_dbr() {
   assert(m_gpr.size() == GetRegisterInfoInterface().GetGPRSize());
 }
 
 // CONSIDER after local and llgs debugging are merged, register set support can
 // be moved into a base x86-64 class with IsRegisterSetAvailable made virtual.
 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) {
case llvm::Triple::x86_64:
     return &g_reg_sets_x86_64[set_index];
   default:
     llvm_unreachable("Unhandled target architecture.");
   }
 }
 
 static constexpr int RegNumX86ToX86_64(int regnum) {
   switch (regnum) {
-  case lldb_fctrl_i386:
-    return lldb_fctrl_x86_64;
-  case lldb_fstat_i386:
-    return lldb_fstat_x86_64;
-  case lldb_ftag_i386:
-    return lldb_ftag_x86_64;
-  case lldb_fop_i386:
-    return lldb_fop_x86_64;
-  case lldb_fiseg_i386:
-    return lldb_fiseg_x86_64;
-  case lldb_fioff_i386:
-    return lldb_fioff_x86_64;
-  case lldb_foseg_i386:
-    return lldb_foseg_x86_64;
-  case lldb_fooff_i386:
-    return lldb_fooff_x86_64;
-  case lldb_mxcsr_i386:
-    return lldb_mxcsr_x86_64;
-  case lldb_mxcsrmask_i386:
-    return lldb_mxcsrmask_x86_64;
-  case lldb_st0_i386:
-  case lldb_st1_i386:
-  case lldb_st2_i386:
-  case lldb_st3_i386:
-  case lldb_st4_i386:
-  case lldb_st5_i386:
-  case lldb_st6_i386:
-  case lldb_st7_i386:
-    return lldb_st0_x86_64 + regnum - lldb_st0_i386;
-  case lldb_mm0_i386:
-  case lldb_mm1_i386:
-  case lldb_mm2_i386:
-  case lldb_mm3_i386:
-  case lldb_mm4_i386:
-  case lldb_mm5_i386:
-  case lldb_mm6_i386:
-  case lldb_mm7_i386:
-    return lldb_mm0_x86_64 + regnum - lldb_mm0_i386;
-  case lldb_xmm0_i386:
-  case lldb_xmm1_i386:
-  case lldb_xmm2_i386:
-  case lldb_xmm3_i386:
-  case lldb_xmm4_i386:
-  case lldb_xmm5_i386:
-  case lldb_xmm6_i386:
-  case lldb_xmm7_i386:
-    return lldb_xmm0_x86_64 + regnum - lldb_xmm0_i386;
   case lldb_ymm0_i386:
   case lldb_ymm1_i386:
   case lldb_ymm2_i386:
   case lldb_ymm3_i386:
   case lldb_ymm4_i386:
   case lldb_ymm5_i386:
   case lldb_ymm6_i386:
   case lldb_ymm7_i386:

 Status NativeRegisterContextFreeBSD_x86_64::ReadRegisterSet(uint32_t set) {
   switch (set) {
   case GPRegSet:
     return NativeProcessFreeBSD::PtraceWrapper(PT_GETREGS, m_thread.GetID(),
                                                m_gpr.data());
   case FPRegSet:
 #if defined(__x86_64__)
     return NativeProcessFreeBSD::PtraceWrapper(PT_GETFPREGS, m_thread.GetID(),
-                                               &m_fpr);
+                                               m_fpr.data());
 #else
     return NativeProcessFreeBSD::PtraceWrapper(PT_GETXMMREGS, m_thread.GetID(),
-                                               &m_fpr);
+                                               m_fpr.data());
 #endif
   case DBRegSet:
     return NativeProcessFreeBSD::PtraceWrapper(PT_GETDBREGS, m_thread.GetID(),
                                                &m_dbr);
   case XSaveRegSet: {
     struct ptrace_xstate_info info;
     Status ret = NativeProcessFreeBSD::PtraceWrapper(
         PT_GETXSTATE_INFO, GetProcessPid(), &info, sizeof(info));

 Status NativeRegisterContextFreeBSD_x86_64::WriteRegisterSet(uint32_t set) {
   switch (set) {
   case GPRegSet:
     return NativeProcessFreeBSD::PtraceWrapper(PT_SETREGS, m_thread.GetID(),
                                                m_gpr.data());
   case FPRegSet:
 #if defined(__x86_64__)
     return NativeProcessFreeBSD::PtraceWrapper(PT_SETFPREGS, m_thread.GetID(),
-                                               &m_fpr);
+                                               m_fpr.data());
 #else
     return NativeProcessFreeBSD::PtraceWrapper(PT_SETXMMREGS, m_thread.GetID(),
-                                               &m_fpr);
+                                               m_fpr.data());
 #endif
   case DBRegSet:
     return NativeProcessFreeBSD::PtraceWrapper(PT_SETDBREGS, m_thread.GetID(),
                                                &m_dbr);
   case XSaveRegSet:
     // ReadRegisterSet() must always be called before WriteRegisterSet().
     assert(m_xsave.size() > 0);
     return NativeProcessFreeBSD::PtraceWrapper(PT_SETXSTATE, GetProcessPid(),
if (error.Fail())
     return error;
 
   switch (set) {
   case GPRegSet:
     reg_value.SetBytes(m_gpr.data() + reg_info->byte_offset,
                        reg_info->byte_size, endian::InlHostByteOrder());
     return error;
   case FPRegSet:
+    reg_value.SetBytes(m_fpr.data() + reg_info->byte_offset - GetFPROffset(),
+                       reg_info->byte_size, endian::InlHostByteOrder());
+    return error;
   case XSaveRegSet:
   case DBRegSet:
     // legacy logic
     break;
   }
 
   switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86_64:
     break;
   case llvm::Triple::x86:
     reg = RegNumX86ToX86_64(reg);
     break;
   default:
     llvm_unreachable("Unhandled target architecture.");
   }
 
   switch (reg) {
-#if defined(__x86_64__)
-// the 32-bit field carries more detail, so we don't have to reinvent
-// the wheel
-#define FPR_ENV(x) ((struct envxmm32 *)m_fpr.fpr_env)->x
-#else
-#define FPR_ENV(x) ((struct envxmm *)m_fpr.xmm_env)->x
-#endif
-  case lldb_fctrl_x86_64:
-    reg_value = (uint16_t)FPR_ENV(en_cw);
-    break;
-  case lldb_fstat_x86_64:
-    reg_value = (uint16_t)FPR_ENV(en_sw);
-    break;
-  case lldb_ftag_x86_64:
-    reg_value = (uint16_t)FPR_ENV(en_tw);
-    break;
-  case lldb_fop_x86_64:
-    reg_value = (uint16_t)FPR_ENV(en_opcode);
-    break;
-  case lldb_fiseg_x86_64:
-    reg_value = (uint32_t)FPR_ENV(en_fcs);
-    break;
-  case lldb_fioff_x86_64:
-    reg_value = (uint32_t)FPR_ENV(en_fip);
-    break;
-  case lldb_foseg_x86_64:
-    reg_value = (uint32_t)FPR_ENV(en_fos);
-    break;
-  case lldb_fooff_x86_64:
-    reg_value = (uint32_t)FPR_ENV(en_foo);
-    break;
-  case lldb_mxcsr_x86_64:
-    reg_value = (uint32_t)FPR_ENV(en_mxcsr);
-    break;
-  case lldb_mxcsrmask_x86_64:
-    reg_value = (uint32_t)FPR_ENV(en_mxcsr_mask);
-    break;
-  case lldb_st0_x86_64:
-  case lldb_st1_x86_64:
-  case lldb_st2_x86_64:
-  case lldb_st3_x86_64:
-  case lldb_st4_x86_64:
-  case lldb_st5_x86_64:
-  case lldb_st6_x86_64:
-  case lldb_st7_x86_64:
-#if defined(__x86_64__)
-    reg_value.SetBytes(&m_fpr.fpr_acc[reg - lldb_st0_x86_64],
-                       reg_info->byte_size, endian::InlHostByteOrder());
-#else
-    reg_value.SetBytes(&m_fpr.xmm_acc[reg - lldb_st0_x86_64],
-                       reg_info->byte_size, endian::InlHostByteOrder());
-#endif
-    break;
-  case lldb_mm0_x86_64:
-  case lldb_mm1_x86_64:
-  case lldb_mm2_x86_64:
-  case lldb_mm3_x86_64:
-  case lldb_mm4_x86_64:
-  case lldb_mm5_x86_64:
-  case lldb_mm6_x86_64:
-  case lldb_mm7_x86_64:
-#if defined(__x86_64__)
-    reg_value.SetBytes(&m_fpr.fpr_acc[reg - lldb_mm0_x86_64],
-                       reg_info->byte_size, endian::InlHostByteOrder());
-#else
-    reg_value.SetBytes(&m_fpr.xmm_acc[reg - lldb_mm0_x86_64],
-                       reg_info->byte_size, endian::InlHostByteOrder());
-#endif
-    break;
-  case lldb_xmm0_x86_64:
-  case lldb_xmm1_x86_64:
-  case lldb_xmm2_x86_64:
-  case lldb_xmm3_x86_64:
-  case lldb_xmm4_x86_64:
-  case lldb_xmm5_x86_64:
-  case lldb_xmm6_x86_64:
-  case lldb_xmm7_x86_64:
-  case lldb_xmm8_x86_64:
-  case lldb_xmm9_x86_64:
-  case lldb_xmm10_x86_64:
-  case lldb_xmm11_x86_64:
-  case lldb_xmm12_x86_64:
-  case lldb_xmm13_x86_64:
-  case lldb_xmm14_x86_64:
-  case lldb_xmm15_x86_64:
-#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:
Status NativeRegisterContextFreeBSD_x86_64::WriteRegister(
 
   enum RegSetKind set = opt_set.getValue();
   error = ReadRegisterSet(set);
   if (error.Fail())
     return error;
 
   switch (set) {
   case GPRegSet:
     ::memcpy(m_gpr.data() + reg_info->byte_offset, reg_value.GetBytes(),
              reg_value.GetByteSize());
     return WriteRegisterSet(set);
   case FPRegSet:
+    ::memcpy(m_fpr.data() + reg_info->byte_offset - GetFPROffset(),
+             reg_value.GetBytes(), reg_value.GetByteSize());
+    return WriteRegisterSet(set);
   case XSaveRegSet:
   case DBRegSet:
     // legacy logic
     break;
   }
 
   switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86_64:
     break;
   case llvm::Triple::x86:
     reg = RegNumX86ToX86_64(reg);
     break;
   default:
     llvm_unreachable("Unhandled target architecture.");
   }
 
   switch (reg) {
-  case lldb_fctrl_x86_64:
-    FPR_ENV(en_cw) = reg_value.GetAsUInt16();
-    break;
-  case lldb_fstat_x86_64:
-    FPR_ENV(en_sw) = reg_value.GetAsUInt16();
-    break;
-  case lldb_ftag_x86_64:
-    FPR_ENV(en_tw) = reg_value.GetAsUInt16();
-    break;
-  case lldb_fop_x86_64:
-    FPR_ENV(en_opcode) = reg_value.GetAsUInt16();
-    break;
-  case lldb_fiseg_x86_64:
-    FPR_ENV(en_fcs) = reg_value.GetAsUInt32();
-    break;
-  case lldb_fioff_x86_64:
-    FPR_ENV(en_fip) = reg_value.GetAsUInt32();
-    break;
-  case lldb_foseg_x86_64:
-    FPR_ENV(en_fos) = reg_value.GetAsUInt32();
-    break;
-  case lldb_fooff_x86_64:
-    FPR_ENV(en_foo) = reg_value.GetAsUInt32();
-    break;
-  case lldb_mxcsr_x86_64:
-    FPR_ENV(en_mxcsr) = reg_value.GetAsUInt32();
-    break;
-  case lldb_mxcsrmask_x86_64:
-    FPR_ENV(en_mxcsr_mask) = reg_value.GetAsUInt32();
-    break;
-  case lldb_st0_x86_64:
-  case lldb_st1_x86_64:
-  case lldb_st2_x86_64:
-  case lldb_st3_x86_64:
-  case lldb_st4_x86_64:
-  case lldb_st5_x86_64:
-  case lldb_st6_x86_64:
-  case lldb_st7_x86_64:
-#if defined(__x86_64__)
-    ::memcpy(&m_fpr.fpr_acc[reg - lldb_st0_x86_64], reg_value.GetBytes(),
-             reg_value.GetByteSize());
-#else
-    ::memcpy(&m_fpr.xmm_acc[reg - lldb_st0_x86_64], reg_value.GetBytes(),
-             reg_value.GetByteSize());
-#endif
-    break;
-  case lldb_mm0_x86_64:
-  case lldb_mm1_x86_64:
-  case lldb_mm2_x86_64:
-  case lldb_mm3_x86_64:
-  case lldb_mm4_x86_64:
-  case lldb_mm5_x86_64:
-  case lldb_mm6_x86_64:
-  case lldb_mm7_x86_64:
-#if defined(__x86_64__)
-    ::memcpy(&m_fpr.fpr_acc[reg - lldb_mm0_x86_64], reg_value.GetBytes(),
-             reg_value.GetByteSize());
-#else
-    ::memcpy(&m_fpr.xmm_acc[reg - lldb_mm0_x86_64], reg_value.GetBytes(),
-             reg_value.GetByteSize());
-#endif
-    break;
-  case lldb_xmm0_x86_64:
-  case lldb_xmm1_x86_64:
-  case lldb_xmm2_x86_64:
-  case lldb_xmm3_x86_64:
-  case lldb_xmm4_x86_64:
-  case lldb_xmm5_x86_64:
-  case lldb_xmm6_x86_64:
-  case lldb_xmm7_x86_64:
-  case lldb_xmm8_x86_64:
-  case lldb_xmm9_x86_64:
-  case lldb_xmm10_x86_64:
-  case lldb_xmm11_x86_64:
-  case lldb_xmm12_x86_64:
-  case lldb_xmm13_x86_64:
-  case lldb_xmm14_x86_64:
-  case lldb_xmm15_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:
if ((r_source.m_dbr.dr[7] & 0xFF) == 0)
       return llvm::Error::success();
 
     m_dbr = r_source.m_dbr;
     res = WriteRegisterSet(DBRegSet);
   }
   return res.ToError();
 }
 
+size_t NativeRegisterContextFreeBSD_x86_64::GetFPROffset() const {
+  int regno;
+  switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
+  case llvm::Triple::x86:
+    regno = lldb_fctrl_i386;
+    break;
+  case llvm::Triple::x86_64:
+    regno = lldb_fctrl_x86_64;
+    break;
+  default:
+    llvm_unreachable("Unhandled target architecture.");
+  }
+
+  return GetRegisterInfoInterface().GetRegisterInfo()[regno].byte_offset;
+}
+
 #endif // defined(__x86_64__)

lldb/unittests/Process/FreeBSD/RegisterContextFreeBSDTests.cpp

 #include "RegisterContextFreeBSD_x86_64.h"
 #endif
 
 using namespace lldb_private;
 
 #define ASSERT_REG(regname, offset, size)                                      \
   {                                                                            \
     const RegisterInfo *reg_info = &reg_ctx.GetRegisterInfo()[lldb_##regname]; \
-    EXPECT_EQ(reg_info->byte_offset, offset);                                  \
-    EXPECT_EQ(reg_info->byte_size, size);                                      \
+    EXPECT_EQ(reg_info->byte_offset, static_cast<size_t>(offset));             \
+    EXPECT_EQ(reg_info->byte_size, static_cast<size_t>(size));                 \
   }
 
+#define ASSERT_FPR(regname, offset, size)                                      \
+  ASSERT_REG(regname, offset + fpr_offset, size)
+
 #if defined(__x86_64__)
 
 #define ASSERT_GPR_X86_64(regname)                                             \
   ASSERT_REG(regname##_x86_64, offsetof(reg, r_##regname),                     \
              sizeof(reg::r_##regname))
 
 TEST(RegisterContextFreeBSDTest, x86_64) {
   ArchSpec arch{"x86_64-unknown-freebsd12.2"};
TEST(RegisterContextFreeBSDTest, x86_64) {
   ASSERT_GPR_X86_64(gs);
   ASSERT_GPR_X86_64(es);
   ASSERT_GPR_X86_64(ds);
   ASSERT_GPR_X86_64(rip);
   ASSERT_GPR_X86_64(cs);
   ASSERT_GPR_X86_64(rflags);
   ASSERT_GPR_X86_64(rsp);
   ASSERT_GPR_X86_64(ss);
+
+  // fctrl is the first FPR field, it is used to determine offset of the whole
+  // FPR struct
+  size_t fpr_offset = reg_ctx.GetRegisterInfo()[lldb_fctrl_x86_64].byte_offset;
+
+  // assert against FXSAVE struct
+  ASSERT_FPR(fctrl_x86_64, 0x00, 2);
+  ASSERT_FPR(fstat_x86_64, 0x02, 2);
+  // TODO: This is a known bug, abridged ftag should is 8 bits in length.
+  ASSERT_FPR(ftag_x86_64, 0x04, 2);
+  ASSERT_FPR(fop_x86_64, 0x06, 2);
+  // NB: Technically fiseg/foseg are 16-bit long and the higher 16 bits
+  // are reserved.  However, we use them to access/recombine 64-bit FIP/FDP.
+  ASSERT_FPR(fioff_x86_64, 0x08, 4);
+  ASSERT_FPR(fiseg_x86_64, 0x0C, 4);
+  ASSERT_FPR(fooff_x86_64, 0x10, 4);
+  ASSERT_FPR(foseg_x86_64, 0x14, 4);
+  ASSERT_FPR(mxcsr_x86_64, 0x18, 4);
+  ASSERT_FPR(mxcsrmask_x86_64, 0x1C, 4);
+  ASSERT_FPR(st0_x86_64, 0x20, 10);
+  ASSERT_FPR(st1_x86_64, 0x30, 10);
+  ASSERT_FPR(st2_x86_64, 0x40, 10);
+  ASSERT_FPR(st3_x86_64, 0x50, 10);
+  ASSERT_FPR(st4_x86_64, 0x60, 10);
+  ASSERT_FPR(st5_x86_64, 0x70, 10);
+  ASSERT_FPR(st6_x86_64, 0x80, 10);
+  ASSERT_FPR(st7_x86_64, 0x90, 10);
+  ASSERT_FPR(mm0_x86_64, 0x20, 8);
+  ASSERT_FPR(mm1_x86_64, 0x30, 8);
+  ASSERT_FPR(mm2_x86_64, 0x40, 8);
+  ASSERT_FPR(mm3_x86_64, 0x50, 8);
+  ASSERT_FPR(mm4_x86_64, 0x60, 8);
+  ASSERT_FPR(mm5_x86_64, 0x70, 8);
+  ASSERT_FPR(mm6_x86_64, 0x80, 8);
+  ASSERT_FPR(mm7_x86_64, 0x90, 8);
+  ASSERT_FPR(xmm0_x86_64, 0xA0, 16);
+  ASSERT_FPR(xmm1_x86_64, 0xB0, 16);
+  ASSERT_FPR(xmm2_x86_64, 0xC0, 16);
+  ASSERT_FPR(xmm3_x86_64, 0xD0, 16);
+  ASSERT_FPR(xmm4_x86_64, 0xE0, 16);
+  ASSERT_FPR(xmm5_x86_64, 0xF0, 16);
+  ASSERT_FPR(xmm6_x86_64, 0x100, 16);
+  ASSERT_FPR(xmm7_x86_64, 0x110, 16);
+  ASSERT_FPR(xmm8_x86_64, 0x120, 16);
+  ASSERT_FPR(xmm9_x86_64, 0x130, 16);
+  ASSERT_FPR(xmm10_x86_64, 0x140, 16);
+  ASSERT_FPR(xmm11_x86_64, 0x150, 16);
+  ASSERT_FPR(xmm12_x86_64, 0x160, 16);
+  ASSERT_FPR(xmm13_x86_64, 0x170, 16);
+  ASSERT_FPR(xmm14_x86_64, 0x180, 16);
+  ASSERT_FPR(xmm15_x86_64, 0x190, 16);
 }
 #endif
 
 #if defined(__i386__) || defined(__x86_64__)
 
 #if defined(__i386__)
 #define reg32 reg
 #endif
TEST(RegisterContextFreeBSDTest, i386) {
   ASSERT_GPR_I386(ecx);
   ASSERT_GPR_I386(eax);
   ASSERT_GPR_I386(eip);
   ASSERT_GPR_I386(cs);
   ASSERT_GPR_I386(eflags);
   ASSERT_GPR_I386(esp);
   ASSERT_GPR_I386(ss);
   ASSERT_GPR_I386(gs);
+
+  // fctrl is the first FPR field, it is used to determine offset of the whole
+  // FPR struct
+  size_t fpr_offset = reg_ctx.GetRegisterInfo()[lldb_fctrl_i386].byte_offset;
+
+  // assert against FXSAVE struct
+  ASSERT_FPR(fctrl_i386, 0x00, 2);
+  ASSERT_FPR(fstat_i386, 0x02, 2);
+  // TODO: This is a known bug, abridged ftag should is 8 bits in length.
+  ASSERT_FPR(ftag_i386, 0x04, 2);
+  ASSERT_FPR(fop_i386, 0x06, 2);
+  // NB: Technically fiseg/foseg are 16-bit long and the higher 16 bits
+  // are reserved.  However, we use them to access/recombine 64-bit FIP/FDP.
+  ASSERT_FPR(fioff_i386, 0x08, 4);
+  ASSERT_FPR(fiseg_i386, 0x0C, 4);
+  ASSERT_FPR(fooff_i386, 0x10, 4);
+  ASSERT_FPR(foseg_i386, 0x14, 4);
+  ASSERT_FPR(mxcsr_i386, 0x18, 4);
+  ASSERT_FPR(mxcsrmask_i386, 0x1C, 4);
+  ASSERT_FPR(st0_i386, 0x20, 10);
+  ASSERT_FPR(st1_i386, 0x30, 10);
+  ASSERT_FPR(st2_i386, 0x40, 10);
+  ASSERT_FPR(st3_i386, 0x50, 10);
+  ASSERT_FPR(st4_i386, 0x60, 10);
+  ASSERT_FPR(st5_i386, 0x70, 10);
+  ASSERT_FPR(st6_i386, 0x80, 10);
+  ASSERT_FPR(st7_i386, 0x90, 10);
+  ASSERT_FPR(mm0_i386, 0x20, 8);
+  ASSERT_FPR(mm1_i386, 0x30, 8);
+  ASSERT_FPR(mm2_i386, 0x40, 8);
+  ASSERT_FPR(mm3_i386, 0x50, 8);
+  ASSERT_FPR(mm4_i386, 0x60, 8);
+  ASSERT_FPR(mm5_i386, 0x70, 8);
+  ASSERT_FPR(mm6_i386, 0x80, 8);
+  ASSERT_FPR(mm7_i386, 0x90, 8);
+  ASSERT_FPR(xmm0_i386, 0xA0, 16);
+  ASSERT_FPR(xmm1_i386, 0xB0, 16);
+  ASSERT_FPR(xmm2_i386, 0xC0, 16);
+  ASSERT_FPR(xmm3_i386, 0xD0, 16);
+  ASSERT_FPR(xmm4_i386, 0xE0, 16);
+  ASSERT_FPR(xmm5_i386, 0xF0, 16);
+  ASSERT_FPR(xmm6_i386, 0x100, 16);
+  ASSERT_FPR(xmm7_i386, 0x110, 16);
 }
 #endif