ELF core: Adding parsing of the floating-point and SSE registers on x86 32/64 bit elf core files

[dvlahovski]

Summary

The floating-point and SSE registers could be present in the elf-core
file in the note NT_FPREGSET for 64 bit ones, and in the note
NT_PRXFPREG for 32 bit ones.

The entire note is a binary blob matching the layout of the x87 save
area that gets generated by the FXSAVE instruction (see Intel developers
manual for more information).

This CL mainly modifies the RegisterRead function in
RegisterContextPOSIXCore_x86_64 for it to return the correct data both
for GPR and FPR/SSE registers, and return false (meaning "this register
is not available") for other registers.

I added a test to TestElfCore.py that tests reading FPR/SSE registers
both from a 32 and 64 bit elf-core file and I have inluded the source
which I used to generate the core files.

I tried to also add support for the AVX registers, because this info could
also be present in the elf-core file (note NT_X86_XSTATE - that is the result of
the newer XSAVE instruction). Parsing the contents from the file is
easy. The problem is that the ymm registers are split into two halves
and they are in different places in the note. For making this work one
would either make a "hacky" approach, because there won't be
any other way with the current state of the register contexts - they
assume that "this register is of size N and at offset M" and
don't have the notion of discontinuos registers.

[emaste]

We need to make sure this does not regress FreeBSD core handling -- I will test as soon as I can, and add FXSAVE parsing for FreeBSD. I'll use fpr_sse.cpp to generate FreeBSD core files as well (although note that we get ~2.5MB cores with default configuration, so tweaking malloc options will be necessary).

Please document how the core files were created (e.g. compiler invocation), perhaps as a comment in the source file.

packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/TestLinuxCore.py

107 ↗

(On Diff #76918)

Curious, why are these skipped only on windows?

[labath]

I was very successful in creating tiny core files by avoiding linking with the standard library (you don't really need a full libc to crash :P ).
I think this file should use the same approach as well (see the other core files in this directory, and the make-core.sh script).

Ed, maybe you could start by tweaking that script to work on FreeBSD as well? Depending on how similar it ends up, we may want to keep it here (and rename the folder to just "elf-core", or we can create a separate "freebsd-core" folder instead...

[emaste]

Good point. D26315 has the change to add FreeBSD support to make-core.sh -- just avoiding /bin/bash, and the core file handler check.

I think we should be able to rename this directory to elf-core, and rename the individual cores to e.g. linux-i386.core, etc.

[labath]

In D26300#587333, @emaste wrote:

Good point. D26315 has the change to add FreeBSD support to make-core.sh -- just avoiding /bin/bash, and the core file handler check.

Great. I am glad the _start thingy works the same way on FreeBSD as well. I think this approach has a lot of potential. We probably don't want to check in zillions of core files, even if they are tiny, but it should enable us to do at least a basic smoke test of our changes on OS/hardware combinations we don't have access to.

I think we should be able to rename this directory to elf-core, and rename the individual cores to e.g. linux-i386.core, etc.

I'll get to that on Monday, if you don't beat me to it. :)

[labath]

I've renamed to folder into elf-core and put "linux" into the individual file names. I did not rename TestLinuxCore.py as I am still not sure what to do about it -- if we end up having a lot of these tests, we may want a separate TestFreeBSDCore.py, with the common code refactored into a base class.

I think you should be able to add a basic freebsd core file test, based on the existing main.c. We'll refactor this change after that (PS: Dimitar's internship is over, so I may end up taking this over).

packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/TestLinuxCore.py

107 ↗

(On Diff #76918)

My guess would be that we fail to select the correct platform instance when opening the core there, so we end up trying to debug a linux core file with PlatformWindows, or something like that. I'll need to look into that at some point.

[dvlahovski]

I will generate the core files with the make-core.sh script and update the revision today or tomorrow.

packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/TestLinuxCore.py

107 ↗

(On Diff #76918)

To be honest, I copied this from the other ELF core tests without investigating why they skip windows.

[dvlahovski]

Generated the core files with make-core.sh

[labath]

Looks great. Ed, do you want to give this a try run?

packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/TestLinuxCore.py

113 ↗

(On Diff #77477)

Please add "linux" to the core file names. We'll probably have freebsd versions of these as well..

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.h

49 ↗

(On Diff #77477)

Could you use a unique_ptr instead? The data doesn't seem to be shared with anyone...

[dvlahovski]

Use unique_ptr instead of shared_ptr

[emaste]

I applied this change on top of my WIP D26617 (which adds a FreeBSD core test). LLDB builds and my new test passes, so no objections from me. Once it's in I'll see about porting the new SSE test to FreeBSD too.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/TestLinuxCore.py

def test_two_cores_same_pid(self):
             altframe.FindVariable("F").GetValueAsUnsigned(), 256, error)
         self.assertTrue(error.Success())
         self.assertEqual(F, "_start")
 
         # without destroying this process, run the test which opens another core file with the
         # same pid
         self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_regions)
 
+    @skipIf(oslist=['windows'])
+    @skipIf(triple='^mips')
+    def test_FPR_SSE(self):
+        # check x86_64 core file
+        target = self.dbg.CreateTarget(None)
+        self.assertTrue(target, VALID_TARGET)
+        process = target.LoadCore("linux-fpr_sse_x86_64.core")
+
+        values = {}
+        values["fctrl"] = "0x037f"
+        values["fstat"] = "0x0000"
+        values["ftag"] = "0xff"
+        values["fop"] = "0x0000"
+        values["fiseg"] = "0x00000000"
+        values["fioff"] = "0x0040011e"
+        values["foseg"] = "0x00000000"
+        values["fooff"] = "0x00000000"
+        values["mxcsr"] = "0x00001f80"
+        values["mxcsrmask"] = "0x0000ffff"
+        values["st0"] = "{0x99 0xf7 0xcf 0xfb 0x84 0x9a 0x20 0x9a 0xfd 0x3f}"
+        values["st1"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x80 0xff 0x3f}"
+        values["st2"] = "{0xfe 0x8a 0x1b 0xcd 0x4b 0x78 0x9a 0xd4 0x00 0x40}"
+        values["st3"] = "{0xac 0x79 0xcf 0xd1 0xf7 0x17 0x72 0xb1 0xfe 0x3f}"
+        values["st4"] = "{0xbc 0xf0 0x17 0x5c 0x29 0x3b 0xaa 0xb8 0xff 0x3f}"
+        values["st5"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x80 0xff 0x3f}"
+        values["st6"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
+        values["st7"] = "{0x35 0xc2 0x68 0x21 0xa2 0xda 0x0f 0xc9 0x00 0x40}"
+        values["xmm0"] = "{0x29 0x31 0x64 0x46 0x29 0x31 0x64 0x46 0x29 0x31 0x64 0x46 0x29 0x31 0x64 0x46}"
+        values["xmm1"] = "{0x9c 0xed 0x86 0x64 0x9c 0xed 0x86 0x64 0x9c 0xed 0x86 0x64 0x9c 0xed 0x86 0x64}"
+        values["xmm2"] = "{0x07 0xc2 0x1f 0xd7 0x07 0xc2 0x1f 0xd7 0x07 0xc2 0x1f 0xd7 0x07 0xc2 0x1f 0xd7}"
+        values["xmm3"] = "{0xa2 0x20 0x48 0x25 0xa2 0x20 0x48 0x25 0xa2 0x20 0x48 0x25 0xa2 0x20 0x48 0x25}"
+        values["xmm4"] = "{0xeb 0x5a 0xa8 0xc4 0xeb 0x5a 0xa8 0xc4 0xeb 0x5a 0xa8 0xc4 0xeb 0x5a 0xa8 0xc4}"
+        values["xmm5"] = "{0x49 0x41 0x20 0x0b 0x49 0x41 0x20 0x0b 0x49 0x41 0x20 0x0b 0x49 0x41 0x20 0x0b}"
+        values["xmm6"] = "{0xf8 0xf1 0x8b 0x4f 0xf8 0xf1 0x8b 0x4f 0xf8 0xf1 0x8b 0x4f 0xf8 0xf1 0x8b 0x4f}"
+        values["xmm7"] = "{0x13 0xf1 0x30 0xcd 0x13 0xf1 0x30 0xcd 0x13 0xf1 0x30 0xcd 0x13 0xf1 0x30 0xcd}"
+
+        for regname, value in values.iteritems():
+            self.expect("register read {}".format(regname), substrs=["{} = {}".format(regname, value)])
+
+
+        # now check i386 core file
+        target = self.dbg.CreateTarget(None)
+        self.assertTrue(target, VALID_TARGET)
+        process = target.LoadCore("linux-fpr_sse_i386.core")
+
+        values["fioff"] = "0x080480cc"
+
+        for regname, value in values.iteritems():
+            self.expect("register read {}".format(regname), substrs=["{} = {}".format(regname, value)])
+
     def check_memory_regions(self, process, region_count):
         region_list = process.GetMemoryRegions()
         self.assertEqual(region_list.GetSize(), region_count)
 
         region = lldb.SBMemoryRegionInfo()
 
         # Check we have the right number of regions.
         self.assertEqual(region_list.GetSize(), region_count)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/fpr_sse.cpp

+// fpr_sse_x86_64.core was generated with:
+// ./make-core.sh fpr_sse.cpp
+//
+// fpr_sse_i386.core was generated with:
+//   export CFLAGS=-m32
+//   ./make-core.sh fpr_sse.cpp
+
+void _start(void) {
+  __asm__("fldpi;"
+          "fldz;"
+          "fld1;"
+          "fldl2e;"
+          "fldln2;"
+          "fldl2t;"
+          "fld1;"
+          "fldlg2;");
+
+  unsigned int values[8] = {
+      0x46643129, 0x6486ed9c, 0xd71fc207, 0x254820a2,
+      0xc4a85aeb, 0x0b204149, 0x4f8bf1f8, 0xcd30f113,
+  };
+
+  __asm__("vbroadcastss %0, %%xmm0;"
+          "vbroadcastss %1, %%xmm1;"
+          "vbroadcastss %2, %%xmm2;"
+          "vbroadcastss %3, %%xmm3;"
+          "vbroadcastss %4, %%xmm4;"
+          "vbroadcastss %5, %%xmm5;"
+          "vbroadcastss %6, %%xmm6;"
+          "vbroadcastss %7, %%xmm7;"
+
+          ::"m"(values[0]),
+          "m"(values[1]), "m"(values[2]), "m"(values[3]), "m"(values[4]),
+          "m"(values[5]), "m"(values[6]), "m"(values[7]));
+
+  volatile int *a = 0;
+  *a = 0;
+}

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_i386.h

 #include "RegisterInfoInterface.h"
 
 class RegisterContextLinux_i386 : public lldb_private::RegisterInfoInterface {
 public:
   RegisterContextLinux_i386(const lldb_private::ArchSpec &target_arch);
 
   size_t GetGPRSize() const override;
 
+  size_t GetFXSAVEOffset() const override;
+
   const lldb_private::RegisterInfo *GetRegisterInfo() const override;
 
   uint32_t GetRegisterCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   const std::vector<lldb_private::RegisterInfo> *
   GetDynamicRegisterInfoP() const override;
 
 private:
   std::vector<lldb_private::RegisterInfo> d_register_infos;
 };
 
 #endif

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_i386.cpp

RegisterInfo orig_ax = {"orig_eax",
                           nullptr,
                           nullptr,
                           0};
   d_register_infos.push_back(orig_ax);
 }
 
 size_t RegisterContextLinux_i386::GetGPRSize() const { return sizeof(GPR); }
 
+size_t RegisterContextLinux_i386::GetFXSAVEOffset() const {
+  return (LLVM_EXTENSION offsetof(UserArea, i387));
+}
+
 const RegisterInfo *RegisterContextLinux_i386::GetRegisterInfo() const {
   switch (m_target_arch.GetMachine()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     return g_register_infos_i386;
   default:
     assert(false && "Unhandled target architecture.");
     return NULL;

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_x86_64.h

 #include "RegisterInfoInterface.h"
 
 class RegisterContextLinux_x86_64 : public lldb_private::RegisterInfoInterface {
 public:
   RegisterContextLinux_x86_64(const lldb_private::ArchSpec &target_arch);
 
   size_t GetGPRSize() const override;
 
+  size_t GetFXSAVEOffset() const override;
+
   const lldb_private::RegisterInfo *GetRegisterInfo() const override;
 
   uint32_t GetRegisterCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   const std::vector<lldb_private::RegisterInfo> *
   GetDynamicRegisterInfoP() const override;

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_x86_64.cpp

RegisterInfo orig_ax = {"orig_rax",
                           nullptr,
                           nullptr,
                           0};
   d_register_infos.push_back(orig_ax);
 }
 
 size_t RegisterContextLinux_x86_64::GetGPRSize() const { return sizeof(GPR); }
 
+size_t RegisterContextLinux_x86_64::GetFXSAVEOffset() const {
+  return (LLVM_EXTENSION offsetof(UserArea, fpr) +
+          LLVM_EXTENSION offsetof(FPR, xstate));
+}
+
 const std::vector<lldb_private::RegisterInfo> *
 RegisterContextLinux_x86_64::GetDynamicRegisterInfoP() const {
   return &d_register_infos;
 }
 
 const RegisterInfo *RegisterContextLinux_x86_64::GetRegisterInfo() const {
   return m_register_info_p;
 }
 
 uint32_t RegisterContextLinux_x86_64::GetRegisterCount() const {
   return m_register_info_count;
 }
 
 uint32_t RegisterContextLinux_x86_64::GetUserRegisterCount() const {
   return m_user_register_count;
 }

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h

public:
   void Invalidate();
 
   void InvalidateAllRegisters() override;
 
   size_t GetRegisterCount() override;
 
   virtual size_t GetGPRSize();
 
+  virtual size_t GetFXSAVEOffset();
+
   virtual unsigned GetRegisterSize(unsigned reg);
 
   virtual unsigned GetRegisterOffset(unsigned reg);
 
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
   size_t GetRegisterSetCount() override;
 

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp

if (GetFPRType() == eXSAVE)
     return num_registers + m_reg_info.num_avx_registers;
   return num_registers;
 }
 
 size_t RegisterContextPOSIX_x86::GetGPRSize() {
   return m_register_info_ap->GetGPRSize();
 }
 
+size_t RegisterContextPOSIX_x86::GetFXSAVEOffset() {
+  return m_register_info_ap->GetFXSAVEOffset();
+}
+
 const RegisterInfo *RegisterContextPOSIX_x86::GetRegisterInfo() {
   // Commonly, this method is overridden and g_register_infos is copied and
   // specialized.
   // So, use GetRegisterInfo() rather than g_register_infos in this scope.
   return m_register_info_ap->GetRegisterInfo();
 }
 
 const RegisterInfo *

lldb/trunk/source/Plugins/Process/Utility/RegisterInfoInterface.h

 class RegisterInfoInterface {
 public:
   RegisterInfoInterface(const lldb_private::ArchSpec &target_arch)
       : m_target_arch(target_arch) {}
   virtual ~RegisterInfoInterface() {}
 
   virtual size_t GetGPRSize() const = 0;
 
+  virtual size_t GetFXSAVEOffset() const { return 0; }
+
   virtual const lldb_private::RegisterInfo *GetRegisterInfo() const = 0;
 
   // Returns the number of registers including the user registers and the
   // lldb internal registers also
   virtual uint32_t GetRegisterCount() const = 0;
 
   // Returns the number of the user registers (excluding the registers
   // kept for lldb internal use only). Subclasses should override it if

lldb/trunk/source/Plugins/Process/elf-core/ProcessElfCore.cpp

 /// Core files PT_NOTE segment descriptor types
 enum {
   NT_PRSTATUS = 1,
   NT_FPREGSET,
   NT_PRPSINFO,
   NT_TASKSTRUCT,
   NT_PLATFORM,
   NT_AUXV,
-  NT_FILE = 0x46494c45
+  NT_FILE = 0x46494c45,
+  NT_PRXFPREG = 0x46e62b7f,
 };
 
 namespace FREEBSD {
 
 enum {
   NT_PRSTATUS = 1,
   NT_FPREGSET,
   NT_PRPSINFO,
if (note.n_name == "FreeBSD") {
           return error;
         thread_data->signo = prstatus.pr_cursig;
         thread_data->tid = prstatus.pr_pid;
         header_size = ELFLinuxPrStatus::GetSize(arch);
         len = note_data.GetByteSize() - header_size;
         thread_data->gpregset = DataExtractor(note_data, header_size, len);
         break;
       case NT_FPREGSET:
+        // In a i386 core file NT_FPREGSET is present, but it's not the result
+        // of the FXSAVE instruction like in 64 bit files.
+        // The result from FXSAVE is in NT_PRXFPREG for i386 core files
+        if (arch.GetCore() == ArchSpec::eCore_x86_64_x86_64)
           thread_data->fpregset = note_data;
         break;
       case NT_PRPSINFO:
         have_prpsinfo = true;
         error = prpsinfo.Parse(note_data, arch);
         if (error.Fail())
           return error;
         thread_data->name = prpsinfo.pr_fname;
         SetID(prpsinfo.pr_pid);
if (note.n_name == "FreeBSD") {
           const char *path = note_data.GetCStr(&offset);
           if (path && path[0])
             m_nt_file_entries[i].path.SetCString(path);
         }
       } break;
       default:
         break;
       }
+    } else if (note.n_name == "LINUX") {
+      switch (note.n_type) {
+      case NT_PRXFPREG:
+        thread_data->fpregset = note_data;
+      }
     }
 
     offset += note_size;
   }
   // Add last entry in the note section
   if (thread_data && thread_data->gpregset.GetByteSize() > 0) {
     m_thread_data.push_back(*thread_data);
   }

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.h

 class RegisterContextCorePOSIX_x86_64 : public RegisterContextPOSIX_x86 {
 public:
   RegisterContextCorePOSIX_x86_64(
       lldb_private::Thread &thread,
       lldb_private::RegisterInfoInterface *register_info,
       const lldb_private::DataExtractor &gpregset,
       const lldb_private::DataExtractor &fpregset);
 
-  ~RegisterContextCorePOSIX_x86_64() override;
-
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
                      const lldb_private::RegisterValue &value) override;
 
   bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   bool HardwareSingleStep(bool enable) override;
 
 protected:
   bool ReadGPR() override;
 
   bool ReadFPR() override;
 
   bool WriteGPR() override;
 
   bool WriteFPR() override;
 
 private:
-  uint8_t *m_gpregset;
+  std::unique_ptr<uint8_t[]> m_gpregset;
+  std::unique_ptr<uint8_t[]> m_fpregset;
 };
 
 #endif // liblldb_RegisterContextCorePOSIX_x86_64_h_

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.cpp

 
 RegisterContextCorePOSIX_x86_64::RegisterContextCorePOSIX_x86_64(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, const DataExtractor &fpregset)
     : RegisterContextPOSIX_x86(thread, 0, register_info) {
   size_t size, len;
 
   size = GetGPRSize();
-  m_gpregset = new uint8_t[size];
-  len = gpregset.ExtractBytes(0, size, lldb::eByteOrderLittle, m_gpregset);
-  assert(len == size);
+  m_gpregset.reset(new uint8_t[size]);
+  len =
+      gpregset.ExtractBytes(0, size, lldb::eByteOrderLittle, m_gpregset.get());
+  if (len != size)
+    m_gpregset.reset();
+
+  size = sizeof(FXSAVE);
+  m_fpregset.reset(new uint8_t[size]);
+  len =
+      fpregset.ExtractBytes(0, size, lldb::eByteOrderLittle, m_fpregset.get());
+  if (len != size)
+    m_fpregset.reset();
 }
 
-RegisterContextCorePOSIX_x86_64::~RegisterContextCorePOSIX_x86_64() {
-  delete[] m_gpregset;
+bool RegisterContextCorePOSIX_x86_64::ReadGPR() {
+  return m_gpregset != nullptr;
 }
 
-bool RegisterContextCorePOSIX_x86_64::ReadGPR() { return m_gpregset != NULL; }
-
-bool RegisterContextCorePOSIX_x86_64::ReadFPR() { return false; }
+bool RegisterContextCorePOSIX_x86_64::ReadFPR() {
+  return m_fpregset != nullptr;
+}
 
 bool RegisterContextCorePOSIX_x86_64::WriteGPR() {
   assert(0);
   return false;
 }
 
 bool RegisterContextCorePOSIX_x86_64::WriteFPR() {
   assert(0);
   return false;
 }
 
 bool RegisterContextCorePOSIX_x86_64::ReadRegister(const RegisterInfo *reg_info,
                                                    RegisterValue &value) {
-  switch (reg_info->byte_size) {
-  case 4:
-    value = *(uint32_t *)(m_gpregset + reg_info->byte_offset);
-    return true;
-  case 8:
-    value = *(uint64_t *)(m_gpregset + reg_info->byte_offset);
-    return true;
-  }
+  const uint8_t *src;
+  size_t offset;
+  const size_t fxsave_offset = reg_info->byte_offset - GetFXSAVEOffset();
+  // make the offset relative to the beginning of the FXSAVE structure
+  // because this is the data that we have (not the entire UserArea)
+
+  if (m_gpregset && reg_info->byte_offset < GetGPRSize()) {
+    src = m_gpregset.get();
+    offset = reg_info->byte_offset;
+  } else if (m_fpregset && fxsave_offset < sizeof(FXSAVE)) {
+    src = m_fpregset.get();
+    offset = fxsave_offset;
+  } else {
     return false;
   }
 
+  Error error;
+  value.SetFromMemoryData(reg_info, src + offset, reg_info->byte_size,
+                          lldb::eByteOrderLittle, error);
+
+  return error.Success();
+}
+
 bool RegisterContextCorePOSIX_x86_64::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_x86_64::WriteRegister(
     const RegisterInfo *reg_info, const RegisterValue &value) {
   return false;