elf-core: Convert remaining register context to use register set maps

[labath]

Summary

In D39681, we started using a map instead passing a long list of
register sets to the ppc64le register context. However, existing
register sets were still using the old method.

This converts remaining register contexts to use the register set map.
While doing this, I realized that using OS-specific keys for the map was
not a good idea, as sometimes we have a register context shared between
two OSs (e.g. linux and freebsd share the arm/arm64 register contexts).
Therefore, I create a new enum to represent register sets in an
OS-independent manner (the enum contains the generic GPR and FPR values,
but the rest of the values are likely to be architecture-specific).

This saves a bit of code now, but the real impact I see here is that it
can potentially pave the way for reduction of the number of register
context classes (for example RegisterContextPOSIXCore_arm and
RegisterContextPOSIXCore_arm64 are identical except that we initialize
them with a different RegisterInfoInterface object).

[krytarowski]

Looks reasonable!

I'm just thinking whether change code like CoreRegset::PPC_VMX to CoreRegset::PPC::VMX. I'm planning to add CoreRegset::X86_64::XSAVE in future.

[alexandreyy]

Looks good to me!

[labath]

In D40133#927655, @krytarowski wrote:

I'm just thinking whether change code like CoreRegset::PPC_VMX to CoreRegset::PPC::VMX. I'm planning to add CoreRegset::X86_64::XSAVE in future.

That's an interesting idea, but I don't see how would that be possible -- enum values can't have nested names. I suppose we could fake that by making CoreRegset and CoreRegset::X86_64 namespaces, but then the name of the enum type would have to be something different (CoreRegset::Type?). I am not sure if that's worth the trouble.

I don't think we will have that many register sets, so it's probably fine to have flat namespaces for arch/regset combinations.

[clayborg]

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

58 ↗

(On Diff #123189)

Seems weird to have PPC_VMX and PPC_VSX define in a CoreRegSet? Do these need to be specific for each arch? Why is everyone trying to use these?

[labath]

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

58 ↗

(On Diff #123189)

This enum represents all possible register sets that we can find in the elf core files. Not all register contexts are expected to use all of them -- each register context just plucks out those that he knows about (if they were present in the core file).

The enum (and the corresponding map) are intended as a replacement for the list of member variable register sets in the ThreadData struct. vregset (and the previous ppc64 patch was about to add one more) is already quite architecture-specific.

While I do think that this is an improvement over the list-of-members solution, I am also not entirely happy with having these arch-specific sets in the enum.

The alternative I thought of just now is to have a a plain vector instead of a map for register set data. Then, at the generic level, we will just be dealing with "register set 0", "register set 1", etc.. and when we consult the RegisterInfoInterface class, it will tell us that "register set 0" is in fact GPR, register set 2 is VMX, etc.

What do you think?

[clayborg]

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

58 ↗

(On Diff #123189)

I like the vector idea a bit better and I like the idea of the RegisterInfoInterface telling us that "register set at index 0" is GPR, etc.

[labath]

I am going to come back to this later, with a slightly different approach, but first I need to do another cleanup elsewhere.

[labath]

This is a slight deviation from the initial approach. What I've done here is
that I've kept the register set indices in an os-specific form. I've done this
because it enables the parsing code in ProcessElfCore to be
architecture-agnostic -- it can just deal with OS specifics, and can just shove
any note it does not recognise to the side. These will be then parsed in the
corresponding register contexts, which can only deal with architecture
specifics, and ignore OS details, as the translation of os-specific note types
is provided by a separate lookup table.

This way, adding an register set, which is already supported on other OSes, to a
new OS, should in most cases be as simple as adding a new entry into the
register set description map.

lldb/trunk/source/Plugins/Process/elf-core/CMakeLists.txt

 include_directories(../Utility)
 
 add_lldb_library(lldbPluginProcessElfCore PLUGIN
   ProcessElfCore.cpp
   ThreadElfCore.cpp
   RegisterContextPOSIXCore_arm.cpp
   RegisterContextPOSIXCore_arm64.cpp
   RegisterContextPOSIXCore_mips64.cpp
   RegisterContextPOSIXCore_powerpc.cpp
   RegisterContextPOSIXCore_ppc64le.cpp
   RegisterContextPOSIXCore_s390x.cpp
   RegisterContextPOSIXCore_x86_64.cpp
+  RegisterUtilities.cpp
 
   LINK_LIBS
     lldbCore
     lldbTarget
     lldbPluginDynamicLoaderPosixDYLD
     lldbPluginObjectFileELF
     lldbPluginProcessUtility
   LINK_COMPONENTS
     BinaryFormat
     Support
   )

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

 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/ObjectFile/ELF/ELFHeader.h"
-#include "Plugins/Process/elf-core/elf-core-enums.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 
 struct ThreadData;
 
 class ProcessElfCore : public lldb_private::Process {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------

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

 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Threading.h"
 
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
-
-// Project includes
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "ProcessElfCore.h"
 #include "ThreadElfCore.h"
-#include "elf-core-enums.h"
 
 using namespace lldb_private;
 
 ConstString ProcessElfCore::GetPluginNameStatic() {
   static ConstString g_name("elf-core");
   return g_name;
 }
 
if ((note.info.n_type == FREEBSD::NT_PRSTATUS && have_prstatus) ||
       have_prpsinfo = false;
     }
 
     switch (note.info.n_type) {
     case FREEBSD::NT_PRSTATUS:
       have_prstatus = true;
       ParseFreeBSDPrStatus(thread_data, note.data, GetArchitecture());
       break;
-    case FREEBSD::NT_FPREGSET:
-      thread_data.fpregset = note.data;
-      break;
-    case FREEBSD::NT_PPC_VMX:
-      thread_data.vregset = note.data;
-      break;
     case FREEBSD::NT_PRPSINFO:
       have_prpsinfo = true;
       break;
     case FREEBSD::NT_THRMISC: {
       lldb::offset_t offset = 0;
       thread_data.name = note.data.GetCStr(&offset, 20);
       break;
     }
     case FREEBSD::NT_PROCSTAT_AUXV:
       // FIXME: FreeBSD sticks an int at the beginning of the note
       m_auxv = DataExtractor(note.data, 4, note.data.GetByteSize() - 4);
       break;
     default:
+      thread_data.notes.push_back(note);
       break;
     }
   }
   if (!have_prstatus) {
     return llvm::make_error<llvm::StringError>(
         "Could not find NT_PRSTATUS note in core file.",
         llvm::inconvertibleErrorCode());
   }
   m_thread_data.push_back(thread_data);
   return llvm::Error::success();
 }
 
 llvm::Error ProcessElfCore::parseNetBSDNotes(llvm::ArrayRef<CoreNote> notes) {
   ThreadData thread_data;
   for (const auto &note : notes) {
     // NetBSD per-thread information is stored in notes named
     // "NetBSD-CORE@nnn" so match on the initial part of the string.
     if (!llvm::StringRef(note.info.n_name).startswith("NetBSD-CORE"))
       continue;
 
-    if (note.info.n_type == NETBSD::NT_PROCINFO) {
+    switch (note.info.n_type) {
+    case NETBSD::NT_PROCINFO:
       ParseNetBSDProcInfo(thread_data, note.data);
-      continue;
-    }
-    if (note.info.n_type == NETBSD::NT_AUXV) {
+      break;
+    case NETBSD::NT_AUXV:
       m_auxv = note.data;
-      continue;
-    }
+      break;
 
-    if (GetArchitecture().GetMachine() == llvm::Triple::x86_64) {
-      switch (note.info.n_type) {
-      case NETBSD::NT_AMD64_REGS:
+      if (GetArchitecture().GetMachine() == llvm::Triple::x86_64)
         thread_data.gpregset = note.data;
-        break;
-      case NETBSD::NT_AMD64_FPREGS:
-        thread_data.fpregset = note.data;
-        break;
-      }
-    }
-  }
+    default:
+      thread_data.notes.push_back(note);
   if (thread_data.gpregset.GetByteSize() == 0) {
     return llvm::make_error<llvm::StringError>(
         "Could not find general purpose registers note in core file.",
         llvm::inconvertibleErrorCode());
   }
   m_thread_data.push_back(thread_data);
   return llvm::Error::success();
 }
case OPENBSD::NT_PROCINFO:
       ParseOpenBSDProcInfo(thread_data, note.data);
       break;
     case OPENBSD::NT_AUXV:
       m_auxv = note.data;
       break;
     case OPENBSD::NT_REGS:
       thread_data.gpregset = note.data;
       break;
-    case OPENBSD::NT_FPREGS:
-      thread_data.fpregset = note.data;
+    default:
+      thread_data.notes.push_back(note);
       break;
     }
   }
   if (thread_data.gpregset.GetByteSize() == 0) {
     return llvm::make_error<llvm::StringError>(
         "Could not find general purpose registers note in core file.",
         llvm::inconvertibleErrorCode());
   }
case LINUX::NT_PRSTATUS: {
       Status status = prstatus.Parse(note.data, arch);
       if (status.Fail())
         return status.ToError();
       thread_data.prstatus_sig = prstatus.pr_cursig;
       thread_data.tid = prstatus.pr_pid;
       uint32_t header_size = ELFLinuxPrStatus::GetSize(arch);
       size_t len = note.data.GetByteSize() - header_size;
       thread_data.gpregset = DataExtractor(note.data, header_size, len);
-      if (arch.GetCore() == ArchSpec::eCore_ppc64le_generic)
-        thread_data.regsets.try_emplace(note.info.n_type, thread_data.gpregset);
       break;
     }
     case LINUX::NT_PRPSINFO: {
       have_prpsinfo = true;
       ELFLinuxPrPsInfo prpsinfo;
       Status status = prpsinfo.Parse(note.data, arch);
       if (status.Fail())
         return status.ToError();
case LINUX::NT_FILE: {
         if (path && path[0])
           m_nt_file_entries[i].path.SetCString(path);
       }
       break;
     }
     case LINUX::NT_AUXV:
       m_auxv = note.data;
       break;
-    case LINUX::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 || arch.IsMIPS())
-        thread_data.fpregset = note.data;
-      else if (arch.GetCore() == ArchSpec::eCore_ppc64le_generic) {
-        thread_data.regsets.insert(std::make_pair(note.info.n_type, note.data));
-      }
-      break;
-    case LINUX::NT_PPC_VMX:
-    case LINUX::NT_PPC_VSX:
-      if (arch.GetCore() == ArchSpec::eCore_ppc64le_generic)
-        thread_data.regsets.insert(std::make_pair(note.info.n_type, note.data));
-      break;
-    case LINUX::NT_PRXFPREG:
-      thread_data.fpregset = note.data;
+    default:
+      thread_data.notes.push_back(note);
       break;
     }
   }
   // Add last entry in the note section
   if (have_prstatus)
     m_thread_data.push_back(thread_data);
   return llvm::Error::success();
 }

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

 //===-- RegisterContextPOSIXCore_arm.h --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegisterContextCorePOSIX_arm_h_
 #define liblldb_RegisterContextCorePOSIX_arm_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 
 class RegisterContextCorePOSIX_arm : public RegisterContextPOSIX_arm {
 public:
   RegisterContextCorePOSIX_arm(
       lldb_private::Thread &thread,
       lldb_private::RegisterInfoInterface *register_info,
       const lldb_private::DataExtractor &gpregset,
-      const lldb_private::DataExtractor &fpregset);
+      llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   ~RegisterContextCorePOSIX_arm() 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;

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

 
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_arm::RegisterContextCorePOSIX_arm(
     Thread &thread, RegisterInfoInterface *register_info,
-    const DataExtractor &gpregset, const DataExtractor &fpregset)
+    const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_arm(thread, 0, register_info) {
   m_gpr_buffer.reset(
       new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_arm::~RegisterContextCorePOSIX_arm() {}

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

 //===-- RegisterContextPOSIXCore_arm64.h ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegisterContextCorePOSIX_arm64_h_
 #define liblldb_RegisterContextCorePOSIX_arm64_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 
 class RegisterContextCorePOSIX_arm64 : public RegisterContextPOSIX_arm64 {
 public:
   RegisterContextCorePOSIX_arm64(
       lldb_private::Thread &thread,
       lldb_private::RegisterInfoInterface *register_info,
       const lldb_private::DataExtractor &gpregset,
-      const lldb_private::DataExtractor &fpregset);
+      llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   ~RegisterContextCorePOSIX_arm64() 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;

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

 //===-- RegisterContextPOSIXCore_arm64.cpp ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_arm64.h"
-
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_arm64::RegisterContextCorePOSIX_arm64(
     Thread &thread, RegisterInfoInterface *register_info,
-    const DataExtractor &gpregset, const DataExtractor &fpregset)
+    const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_arm64(thread, 0, register_info) {
   m_gpr_buffer.reset(
       new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_arm64::~RegisterContextCorePOSIX_arm64() {}

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

 //===-- RegisterContextPOSIXCore_mips64.h -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegisterContextCorePOSIX_mips64_h_
 #define liblldb_RegisterContextCorePOSIX_mips64_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "Plugins/Process/Utility/RegisterContextPOSIX_mips64.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 
 class RegisterContextCorePOSIX_mips64 : public RegisterContextPOSIX_mips64 {
 public:
   RegisterContextCorePOSIX_mips64(
       lldb_private::Thread &thread,
       lldb_private::RegisterInfoInterface *register_info,
       const lldb_private::DataExtractor &gpregset,
-      const lldb_private::DataExtractor &fpregset);
+      llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   ~RegisterContextCorePOSIX_mips64() 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;

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

 
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_mips64::RegisterContextCorePOSIX_mips64(
     Thread &thread, RegisterInfoInterface *register_info,
-    const DataExtractor &gpregset, const DataExtractor &fpregset)
+    const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_mips64(thread, 0, register_info) {
   m_gpr_buffer.reset(
       new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
+
+  DataExtractor fpregset = getRegset(
+      notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
   m_fpr_buffer.reset(
       new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize()));
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_mips64::~RegisterContextCorePOSIX_mips64() {}
 

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

 //===-- RegisterContextPOSIXCore_powerpc.h ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegisterContextCorePOSIX_powerpc_h_
 #define liblldb_RegisterContextCorePOSIX_powerpc_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Utility/DataExtractor.h"
 
 class RegisterContextCorePOSIX_powerpc : public RegisterContextPOSIX_powerpc {
 public:
   RegisterContextCorePOSIX_powerpc(
       lldb_private::Thread &thread,
       lldb_private::RegisterInfoInterface *register_info,
       const lldb_private::DataExtractor &gpregset,
-      const lldb_private::DataExtractor &fpregset,
-      const lldb_private::DataExtractor &vregset);
+      llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   ~RegisterContextCorePOSIX_powerpc() 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;

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

 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_powerpc::RegisterContextCorePOSIX_powerpc(
     Thread &thread, RegisterInfoInterface *register_info,
-    const DataExtractor &gpregset, const DataExtractor &fpregset,
-    const DataExtractor &vregset)
+    const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_powerpc(thread, 0, register_info) {
   m_gpr_buffer.reset(
       new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
+
+  ArchSpec arch = register_info->GetTargetArchitecture();
+  DataExtractor fpregset = getRegset(notes, arch.GetTriple(), FPR_Desc);
   m_fpr_buffer.reset(
       new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize()));
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
+
+  DataExtractor vregset = getRegset(notes, arch.GetTriple(), PPC_VMX_Desc);
   m_vec_buffer.reset(
       new DataBufferHeap(vregset.GetDataStart(), vregset.GetByteSize()));
   m_vec.SetData(m_vec_buffer);
   m_vec.SetByteOrder(vregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_powerpc::~RegisterContextCorePOSIX_powerpc() {}
 

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

 //===-- RegisterContextPOSIXCore_ppc64le.h ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegisterContextCorePOSIX_ppc64le_h_
 #define liblldb_RegisterContextCorePOSIX_ppc64le_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "llvm/ADT/DenseMap.h"
 
 class RegisterContextCorePOSIX_ppc64le : public RegisterContextPOSIX_ppc64le {
 public:
   RegisterContextCorePOSIX_ppc64le(
       lldb_private::Thread &thread,
       lldb_private::RegisterInfoInterface *register_info,
-      const llvm::DenseMap<uint32_t, lldb_private::DataExtractor> &regsets);
+      const lldb_private::DataExtractor &gpregset,
+      llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   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;
 
 protected:

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

 //===-- RegisterContextPOSIXCore_ppc64le.cpp --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_ppc64le.h"
 
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 
 #include "Plugins/Process/Utility/lldb-ppc64le-register-enums.h"
-#include "elf-core-enums.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_ppc64le::RegisterContextCorePOSIX_ppc64le(
     Thread &thread, RegisterInfoInterface *register_info,
-    const llvm::DenseMap<uint32_t, lldb_private::DataExtractor> &regsets)
+    const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_ppc64le(thread, 0, register_info) {
-  DataExtractor gpregset = regsets.lookup(LINUX::NT_PRSTATUS);
   m_gpr_buffer.reset(
       new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 
-  DataExtractor fpregset = regsets.lookup(LINUX::NT_FPREGSET);
+  ArchSpec arch = register_info->GetTargetArchitecture();
+  DataExtractor fpregset = getRegset(notes, arch.GetTriple(), FPR_Desc);
   m_fpr_buffer.reset(
       new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize()));
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 
-  DataExtractor vmxregset = regsets.lookup(LINUX::NT_PPC_VMX);
+  DataExtractor vmxregset = getRegset(notes, arch.GetTriple(), PPC_VMX_Desc);
   m_vmx_buffer.reset(
       new DataBufferHeap(vmxregset.GetDataStart(), vmxregset.GetByteSize()));
   m_vmx.SetData(m_vmx_buffer);
   m_vmx.SetByteOrder(vmxregset.GetByteOrder());
 
-  DataExtractor vsxregset = regsets.lookup(LINUX::NT_PPC_VSX);
+  DataExtractor vsxregset = getRegset(notes, arch.GetTriple(), PPC_VSX_Desc);
   m_vsx_buffer.reset(
       new DataBufferHeap(vsxregset.GetDataStart(), vsxregset.GetByteSize()));
   m_vsx.SetData(m_vsx_buffer);
   m_vsx.SetByteOrder(vsxregset.GetByteOrder());
 }
 
 size_t RegisterContextCorePOSIX_ppc64le::GetFPRSize() const {
   return k_num_fpr_registers_ppc64le * sizeof(uint64_t);

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

 //===-- RegisterContextPOSIXCore_s390x.h ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegisterContextCorePOSIX_s390x_h_
 #define liblldb_RegisterContextCorePOSIX_s390x_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "Plugins/Process/Utility/RegisterContextPOSIX_s390x.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Utility/DataExtractor.h"
 
 class RegisterContextCorePOSIX_s390x : public RegisterContextPOSIX_s390x {
 public:
   RegisterContextCorePOSIX_s390x(
       lldb_private::Thread &thread,
       lldb_private::RegisterInfoInterface *register_info,
       const lldb_private::DataExtractor &gpregset,
-      const lldb_private::DataExtractor &fpregset);
+      llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   ~RegisterContextCorePOSIX_s390x() 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;

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

 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_s390x::RegisterContextCorePOSIX_s390x(
     Thread &thread, RegisterInfoInterface *register_info,
-    const DataExtractor &gpregset, const DataExtractor &fpregset)
+    const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_s390x(thread, 0, register_info) {
   m_gpr_buffer.reset(
       new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 
+  DataExtractor fpregset = getRegset(
+      notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
   m_fpr_buffer.reset(
       new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize()));
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_s390x::~RegisterContextCorePOSIX_s390x() {}
 

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

 //===-- RegisterContextPOSIXCore_x86_64.h -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegisterContextCorePOSIX_x86_64_h_
 #define liblldb_RegisterContextCorePOSIX_x86_64_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "Plugins/Process/Utility/RegisterContextPOSIX_x86.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.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);
+      llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   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;

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

 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataExtractor.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_x86_64::RegisterContextCorePOSIX_x86_64(
     Thread &thread, RegisterInfoInterface *register_info,
-    const DataExtractor &gpregset, const DataExtractor &fpregset)
+    const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_x86(thread, 0, register_info) {
   size_t size, len;
 
   size = GetGPRSize();
   m_gpregset.reset(new uint8_t[size]);
   len =
       gpregset.ExtractBytes(0, size, lldb::eByteOrderLittle, m_gpregset.get());
   if (len != size)
     m_gpregset.reset();
 
+  DataExtractor fpregset = getRegset(
+      notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
   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();
 }
 

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

+//===-- RegisterUtilities.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_REGISTERUTILITIES_H
+#define LLDB_REGISTERUTILITIES_H
+
+#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
+#include "lldb/Utility/DataExtractor.h"
+
+namespace lldb_private {
+/// Core files PT_NOTE segment descriptor types
+
+namespace FREEBSD {
+enum {
+  NT_PRSTATUS = 1,
+  NT_FPREGSET,
+  NT_PRPSINFO,
+  NT_THRMISC = 7,
+  NT_PROCSTAT_AUXV = 16,
+  NT_PPC_VMX = 0x100
+};
+}
+
+namespace NETBSD {
+enum { NT_PROCINFO = 1, NT_AUXV, NT_AMD64_REGS = 33, NT_AMD64_FPREGS = 35 };
+}
+
+namespace OPENBSD {
+enum {
+  NT_PROCINFO = 10,
+  NT_AUXV = 11,
+  NT_REGS = 20,
+  NT_FPREGS = 21,
+};
+}
+
+namespace LINUX {
+enum {
+  NT_PRSTATUS = 1,
+  NT_FPREGSET,
+  NT_PRPSINFO,
+  NT_TASKSTRUCT,
+  NT_PLATFORM,
+  NT_AUXV,
+  NT_FILE = 0x46494c45,
+  NT_SIGINFO = 0x53494749,
+  NT_PPC_VMX = 0x100,
+  NT_PPC_VSX = 0x102,
+  NT_PRXFPREG = 0x46e62b7f,
+};
+}
+
+struct CoreNote {
+  ELFNote info;
+  DataExtractor data;
+};
+
+// A structure describing how to find a register set in a core file from a given
+// OS.
+struct RegsetDesc {
+  // OS to which this entry applies to. Must not be UnknownOS.
+  llvm::Triple::OSType OS;
+
+  // Architecture to which this entry applies to. Can be UnknownArch, in which
+  // case it applies to all architectures of a given OS.
+  llvm::Triple::ArchType Arch;
+
+  // The note type under which the register set can be found.
+  uint32_t Note;
+};
+
+// Returns the register set in Notes which corresponds to the specified Triple
+// according to the list of register set descriptions in RegsetDescs. The list
+// is scanned linearly, so you can use a more specific entry (e.g. linux-i386)
+// to override a more general entry (e.g. general linux), as long as you place
+// it earlier in the list. If a register set is not found, it returns an empty
+// DataExtractor.
+DataExtractor getRegset(llvm::ArrayRef<CoreNote> Notes,
+                        const llvm::Triple &Triple,
+                        llvm::ArrayRef<RegsetDesc> RegsetDescs);
+
+constexpr RegsetDesc FPR_Desc[] = {
+    {llvm::Triple::FreeBSD, llvm::Triple::UnknownArch, FREEBSD::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
+    {llvm::Triple::Linux, llvm::Triple::x86, LINUX::NT_PRXFPREG},
+    {llvm::Triple::Linux, llvm::Triple::UnknownArch, LINUX::NT_FPREGSET},
+    {llvm::Triple::NetBSD, llvm::Triple::x86_64, NETBSD::NT_AMD64_FPREGS},
+    {llvm::Triple::OpenBSD, llvm::Triple::UnknownArch, OPENBSD::NT_FPREGS},
+};
+
+constexpr RegsetDesc PPC_VMX_Desc[] = {
+    {llvm::Triple::FreeBSD, llvm::Triple::UnknownArch, FREEBSD::NT_PPC_VMX},
+    {llvm::Triple::Linux, llvm::Triple::UnknownArch, LINUX::NT_PPC_VMX},
+};
+
+constexpr RegsetDesc PPC_VSX_Desc[] = {
+    {llvm::Triple::Linux, llvm::Triple::UnknownArch, LINUX::NT_PPC_VSX},
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef LLDB_REGISTERUTILITIES_H

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

+//===-- RegisterUtilities.cpp -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
+#include "llvm/ADT/STLExtras.h"
+
+using namespace lldb_private;
+
+static llvm::Optional<uint32_t>
+getNoteType(const llvm::Triple &Triple,
+            llvm::ArrayRef<RegsetDesc> RegsetDescs) {
+  for (const auto &Entry : RegsetDescs) {
+    if (Entry.OS != Triple.getOS())
+      continue;
+    if (Entry.Arch != llvm::Triple::UnknownArch &&
+        Entry.Arch != Triple.getArch())
+      continue;
+    return Entry.Note;
+  }
+  return llvm::None;
+}
+
+DataExtractor lldb_private::getRegset(llvm::ArrayRef<CoreNote> Notes,
+                                      const llvm::Triple &Triple,
+                                      llvm::ArrayRef<RegsetDesc> RegsetDescs) {
+  auto TypeOr = getNoteType(Triple, RegsetDescs);
+  if (!TypeOr)
+    return DataExtractor();
+  uint32_t Type = *TypeOr;
+  auto Iter = llvm::find_if(
+      Notes, [Type](const CoreNote &Note) { return Note.info.n_type == Type; });
+  return Iter == Notes.end() ? DataExtractor() : Iter->data;
+}

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

 //===-- ThreadElfCore.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ThreadElfCore_h_
 #define liblldb_ThreadElfCore_h_
 
-// C Includes
-// C++ Includes
-#include <string>
-
-// Other libraries and framework includes
-// Project includes
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "llvm/ADT/DenseMap.h"
+#include <string>
 
 struct compat_timeval {
   alignas(8) uint64_t tv_sec;
   alignas(8) uint64_t tv_usec;
 };
 
 // PRSTATUS structure's size differs based on architecture.
 // This is the layout in the x86-64 arch.
struct ELFLinuxPrPsInfo {
   static size_t GetSize(const lldb_private::ArchSpec &arch);
 };
 
 static_assert(sizeof(ELFLinuxPrPsInfo) == 136,
               "sizeof ELFLinuxPrPsInfo is not correct!");
 
 struct ThreadData {
   lldb_private::DataExtractor gpregset;
-  lldb_private::DataExtractor fpregset;
-  lldb_private::DataExtractor vregset;
-  llvm::DenseMap<uint32_t, lldb_private::DataExtractor> regsets;
+  std::vector<lldb_private::CoreNote> notes;
   lldb::tid_t tid;
   int signo = 0;
   int prstatus_sig = 0;
   std::string name;
 };
 
 class ThreadElfCore : public lldb_private::Thread {
 public:
protected:
   // Member variables.
   //------------------------------------------------------------------
   std::string m_thread_name;
   lldb::RegisterContextSP m_thread_reg_ctx_sp;
 
   int m_signo;
 
   lldb_private::DataExtractor m_gpregset_data;
-  lldb_private::DataExtractor m_fpregset_data;
-  lldb_private::DataExtractor m_vregset_data;
-  llvm::DenseMap<uint32_t, lldb_private::DataExtractor> m_regsets_data;
+  std::vector<lldb_private::CoreNote> m_notes;
 
   bool CalculateStopInfo() override;
 };
 
 #endif // liblldb_ThreadElfCore_h_

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

 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Construct a Thread object with given data
 //----------------------------------------------------------------------
 ThreadElfCore::ThreadElfCore(Process &process, const ThreadData &td)
     : Thread(process, td.tid), m_thread_name(td.name), m_thread_reg_ctx_sp(),
-      m_signo(td.signo), m_gpregset_data(td.gpregset),
-      m_fpregset_data(td.fpregset), m_vregset_data(td.vregset),
-      m_regsets_data(td.regsets) {}
+      m_signo(td.signo), m_gpregset_data(td.gpregset), m_notes(td.notes) {}
 
 ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
 
 void ThreadElfCore::RefreshStateAfterStop() {
   GetRegisterContext()->InvalidateIfNeeded(false);
 }
 
 void ThreadElfCore::ClearStackFrames() {
if (!reg_interface) {
         log->Printf("elf-core::%s:: Architecture(%d) or OS(%d) not supported",
                     __FUNCTION__, arch.GetMachine(), arch.GetTriple().getOS());
       assert(false && "Architecture or OS not supported");
     }
 
     switch (arch.GetMachine()) {
     case llvm::Triple::aarch64:
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_arm64(
-          *this, reg_interface, m_gpregset_data, m_fpregset_data));
+          *this, reg_interface, m_gpregset_data, m_notes));
       break;
     case llvm::Triple::arm:
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_arm(
-          *this, reg_interface, m_gpregset_data, m_fpregset_data));
+          *this, reg_interface, m_gpregset_data, m_notes));
       break;
     case llvm::Triple::mipsel:
     case llvm::Triple::mips:
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_mips64(
-         *this, reg_interface, m_gpregset_data, m_fpregset_data));
+          *this, reg_interface, m_gpregset_data, m_notes));
       break;
     case llvm::Triple::mips64:
     case llvm::Triple::mips64el:
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_mips64(
-          *this, reg_interface, m_gpregset_data, m_fpregset_data));
+          *this, reg_interface, m_gpregset_data, m_notes));
       break;
     case llvm::Triple::ppc:
     case llvm::Triple::ppc64:
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_powerpc(
-          *this, reg_interface, m_gpregset_data, m_fpregset_data,
-          m_vregset_data));
+          *this, reg_interface, m_gpregset_data, m_notes));
       break;
     case llvm::Triple::ppc64le:
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_ppc64le(
-          *this, reg_interface, m_regsets_data));
+          *this, reg_interface, m_gpregset_data, m_notes));
       break;
     case llvm::Triple::systemz:
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_s390x(
-          *this, reg_interface, m_gpregset_data, m_fpregset_data));
+          *this, reg_interface, m_gpregset_data, m_notes));
       break;
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
-          *this, reg_interface, m_gpregset_data, m_fpregset_data));
+          *this, reg_interface, m_gpregset_data, m_notes));
       break;
     default:
       break;
     }
 
     reg_ctx_sp = m_thread_reg_ctx_sp;
   } else if (m_unwinder_ap.get()) {
     reg_ctx_sp = m_unwinder_ap->CreateRegisterContextForFrame(frame);

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

-//===-- elf-core-enums.h ----------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLDB_ELF_CORE_ENUMS_H
-#define LLDB_ELF_CORE_ENUMS_H
-
-#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
-#include "lldb/Utility/DataExtractor.h"
-
-namespace lldb_private {
-/// Core files PT_NOTE segment descriptor types
-
-namespace FREEBSD {
-enum {
-  NT_PRSTATUS = 1,
-  NT_FPREGSET,
-  NT_PRPSINFO,
-  NT_THRMISC = 7,
-  NT_PROCSTAT_AUXV = 16,
-  NT_PPC_VMX = 0x100
-};
-}
-
-namespace NETBSD {
-enum { NT_PROCINFO = 1, NT_AUXV, NT_AMD64_REGS = 33, NT_AMD64_FPREGS = 35 };
-}
-
-namespace OPENBSD {
-enum {
-  NT_PROCINFO = 10,
-  NT_AUXV = 11,
-  NT_REGS = 20,
-  NT_FPREGS = 21,
-};
-}
-
-namespace LINUX {
-enum {
-  NT_PRSTATUS = 1,
-  NT_FPREGSET,
-  NT_PRPSINFO,
-  NT_TASKSTRUCT,
-  NT_PLATFORM,
-  NT_AUXV,
-  NT_FILE = 0x46494c45,
-  NT_SIGINFO = 0x53494749,
-  NT_PPC_VMX = 0x100,
-  NT_PPC_VSX = 0x102,
-  NT_PRXFPREG = 0x46e62b7f,
-};
-}
-
-struct CoreNote {
-  ELFNote info;
-  DataExtractor data;
-};
-
-} // namespace lldb_private
-
-#endif // #ifndef LLDB_ELF_CORE_ENUMS_H

lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.cpp

 #include "ProcessMinidump.h"
 
 #include "RegisterContextMinidump_x86_32.h"
 #include "RegisterContextMinidump_x86_64.h"
 
 // Other libraries and framework includes
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
-
 #include "Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.h"
+#include "Plugins/Process/elf-core/RegisterUtilities.h"
 
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 
if (concrete_frame_idx == 0) {
     RegisterInfoInterface *reg_interface = nullptr;
 
     // TODO write other register contexts and add them here
     switch (arch.GetMachine()) {
     case llvm::Triple::x86: {
       reg_interface = new RegisterContextLinux_i386(arch);
       lldb::DataBufferSP buf =
           ConvertMinidumpContext_x86_32(m_gpregset_data, reg_interface);
-      DataExtractor gpregs(buf, lldb::eByteOrderLittle, 4);
-      DataExtractor fpregs;
+      DataExtractor gpregset(buf, lldb::eByteOrderLittle, 4);
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
-          *this, reg_interface, gpregs, fpregs));
+          *this, reg_interface, gpregset, {}));
       break;
     }
     case llvm::Triple::x86_64: {
       reg_interface = new RegisterContextLinux_x86_64(arch);
       lldb::DataBufferSP buf =
           ConvertMinidumpContext_x86_64(m_gpregset_data, reg_interface);
-      DataExtractor gpregs(buf, lldb::eByteOrderLittle, 8);
-      DataExtractor fpregs;
+      DataExtractor gpregset(buf, lldb::eByteOrderLittle, 8);
       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
-          *this, reg_interface, gpregs, fpregs));
+          *this, reg_interface, gpregset, {}));
       break;
     }
     default:
       break;
     }
 
     if (!reg_interface) {
       if (log)